comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"THREETHREETHREE: Minting is not active" | // SPDX-License-Identifier: UNLICENSED
/// @title THREETHREETHREE
/// @author M1LL1P3D3
/// @notice MAKE THE MAGIC YOU WANT TO SEE IN THE WORLD! ✦✦✦
/// @dev This contract is constructed for use with the FIRSTTHREAD receipt contract.
pragma solidity ^0.8.17;
import "solmate/tokens/ERC1155.sol";
import "solmate/auth/Owned.sol";
import "solmate/utils/ReentrancyGuard.sol";
contract THREETHREETHREE is ERC1155, Owned, ReentrancyGuard {
string public name = "THREETHREETHREE";
string public symbol = "333";
string private _uri;
/// @dev Global per token supply cap, dualy a mint cap as once the supply decreases more tokens can't be minted.
uint public constant MAX_SUPPLY_PER_TOKEN = 111;
/// @dev The address of the receipt contract which may call burn functions in order to issue receipts.
address public receiptContract;
/// @dev Struct to hold the definition of a token.
struct Token {
/// @dev Name of token consumed by receipt contract for onchain receipt generation.
string name;
/// @dev The current supply of the token, initialized to 0 and incremented by mint functions.
uint currentSupply;
/// @dev The price of a single token represented in wei.
uint etherPrice;
/// @dev Whether the token is active or not, initialized to false and set to true by an admin function.
bool mintActive;
}
/// @dev Mapping of uint token IDs to token definitions.
mapping(uint => Token) public tokens;
/// @dev Initializes token definitions with names, and ether prices.
constructor() Owned(msg.sender) {
}
/// @notice Modifier restricting burn function access to the receipt contract.
/// @dev Checks that the address calling the burn function is a contract and not a user wallet by comparing the msg.sender to the tx.origin.
modifier onlyReceiptContract() {
}
/// @notice Mint an amount of up to the remaing supply of a single token.
/// @param id The ID of the token to mint.
/// @param amount The amount of tokens to mint.
function mintSingle(
uint id,
uint amount
) public payable nonReentrant {
require(<FILL_ME>)
require(msg.value == amount * tokens[id].etherPrice, "THREETHREETHREE: msg.value is incorrect for the tokens being minted");
require(tokens[id].currentSupply + amount <= MAX_SUPPLY_PER_TOKEN, "THREETHREETHREE: Max supply reached of the token being minted");
_mint(msg.sender, id, amount, "");
tokens[id].currentSupply += amount;
}
/// @notice Mint an amount of up to the remaining supply of multiple tokens.
/// @param ids The IDs of the tokens to mint.
/// @param amounts The amounts of tokens to mint.
function mintBatch(
uint[] memory ids,
uint[] memory amounts
) external payable nonReentrant {
}
/// @notice Burn an amount of a single token as receipt contract.
/// @param from The address to burn tokens from.
/// @param id The ID of the token to burn.
/// @param amount The amount of tokens to burn.
function burnSingle(
address from,
uint id,
uint amount
) external onlyReceiptContract {
}
/// @notice Burn multiple amounts of multiple tokens as receipt contract.
/// @param from The address to burn tokens from.
/// @param ids The IDs of the tokens to burn.
/// @param amounts The amounts of tokens to burn.
function burnBatch(
address from,
uint[] memory ids,
uint[] memory amounts
) external onlyReceiptContract {
}
/// @notice Get the URI of a token.
function uri(uint256) public view virtual override returns (string memory) {
}
/// @notice Owner can flip the minting status of a token.
/// @param id The ID of the token to flip the minting status of.
function flipTokenMintActive(
uint id
) external onlyOwner {
}
/// @notice Owner can set the name of a token.
/// @param id The ID of the token to set the name of.
/// @param _name The name to set the token to.
function setTokenName(
uint id,
string calldata _name
) external onlyOwner {
}
/// @notice Owner can set the URI of a token.
/// @param newuri The URI to set for the contract.
function setURI(
string memory newuri
) external onlyOwner {
}
/// @notice Owner can set the receipt contract address.
/// @param _receiptContract The address of the receipt contract.
function setReceiptContract(
address _receiptContract
) external onlyOwner {
}
/// @notice Owner can withdraw all ether from contract
function withdrawEther() external onlyOwner {
}
}
| tokens[id].mintActive,"THREETHREETHREE: Minting is not active" | 270,811 | tokens[id].mintActive |
"THREETHREETHREE: Max supply reached of the token being minted" | // SPDX-License-Identifier: UNLICENSED
/// @title THREETHREETHREE
/// @author M1LL1P3D3
/// @notice MAKE THE MAGIC YOU WANT TO SEE IN THE WORLD! ✦✦✦
/// @dev This contract is constructed for use with the FIRSTTHREAD receipt contract.
pragma solidity ^0.8.17;
import "solmate/tokens/ERC1155.sol";
import "solmate/auth/Owned.sol";
import "solmate/utils/ReentrancyGuard.sol";
contract THREETHREETHREE is ERC1155, Owned, ReentrancyGuard {
string public name = "THREETHREETHREE";
string public symbol = "333";
string private _uri;
/// @dev Global per token supply cap, dualy a mint cap as once the supply decreases more tokens can't be minted.
uint public constant MAX_SUPPLY_PER_TOKEN = 111;
/// @dev The address of the receipt contract which may call burn functions in order to issue receipts.
address public receiptContract;
/// @dev Struct to hold the definition of a token.
struct Token {
/// @dev Name of token consumed by receipt contract for onchain receipt generation.
string name;
/// @dev The current supply of the token, initialized to 0 and incremented by mint functions.
uint currentSupply;
/// @dev The price of a single token represented in wei.
uint etherPrice;
/// @dev Whether the token is active or not, initialized to false and set to true by an admin function.
bool mintActive;
}
/// @dev Mapping of uint token IDs to token definitions.
mapping(uint => Token) public tokens;
/// @dev Initializes token definitions with names, and ether prices.
constructor() Owned(msg.sender) {
}
/// @notice Modifier restricting burn function access to the receipt contract.
/// @dev Checks that the address calling the burn function is a contract and not a user wallet by comparing the msg.sender to the tx.origin.
modifier onlyReceiptContract() {
}
/// @notice Mint an amount of up to the remaing supply of a single token.
/// @param id The ID of the token to mint.
/// @param amount The amount of tokens to mint.
function mintSingle(
uint id,
uint amount
) public payable nonReentrant {
require(tokens[id].mintActive, "THREETHREETHREE: Minting is not active");
require(msg.value == amount * tokens[id].etherPrice, "THREETHREETHREE: msg.value is incorrect for the tokens being minted");
require(<FILL_ME>)
_mint(msg.sender, id, amount, "");
tokens[id].currentSupply += amount;
}
/// @notice Mint an amount of up to the remaining supply of multiple tokens.
/// @param ids The IDs of the tokens to mint.
/// @param amounts The amounts of tokens to mint.
function mintBatch(
uint[] memory ids,
uint[] memory amounts
) external payable nonReentrant {
}
/// @notice Burn an amount of a single token as receipt contract.
/// @param from The address to burn tokens from.
/// @param id The ID of the token to burn.
/// @param amount The amount of tokens to burn.
function burnSingle(
address from,
uint id,
uint amount
) external onlyReceiptContract {
}
/// @notice Burn multiple amounts of multiple tokens as receipt contract.
/// @param from The address to burn tokens from.
/// @param ids The IDs of the tokens to burn.
/// @param amounts The amounts of tokens to burn.
function burnBatch(
address from,
uint[] memory ids,
uint[] memory amounts
) external onlyReceiptContract {
}
/// @notice Get the URI of a token.
function uri(uint256) public view virtual override returns (string memory) {
}
/// @notice Owner can flip the minting status of a token.
/// @param id The ID of the token to flip the minting status of.
function flipTokenMintActive(
uint id
) external onlyOwner {
}
/// @notice Owner can set the name of a token.
/// @param id The ID of the token to set the name of.
/// @param _name The name to set the token to.
function setTokenName(
uint id,
string calldata _name
) external onlyOwner {
}
/// @notice Owner can set the URI of a token.
/// @param newuri The URI to set for the contract.
function setURI(
string memory newuri
) external onlyOwner {
}
/// @notice Owner can set the receipt contract address.
/// @param _receiptContract The address of the receipt contract.
function setReceiptContract(
address _receiptContract
) external onlyOwner {
}
/// @notice Owner can withdraw all ether from contract
function withdrawEther() external onlyOwner {
}
}
| tokens[id].currentSupply+amount<=MAX_SUPPLY_PER_TOKEN,"THREETHREETHREE: Max supply reached of the token being minted" | 270,811 | tokens[id].currentSupply+amount<=MAX_SUPPLY_PER_TOKEN |
"THREETHREETHREE: Minting is not active" | // SPDX-License-Identifier: UNLICENSED
/// @title THREETHREETHREE
/// @author M1LL1P3D3
/// @notice MAKE THE MAGIC YOU WANT TO SEE IN THE WORLD! ✦✦✦
/// @dev This contract is constructed for use with the FIRSTTHREAD receipt contract.
pragma solidity ^0.8.17;
import "solmate/tokens/ERC1155.sol";
import "solmate/auth/Owned.sol";
import "solmate/utils/ReentrancyGuard.sol";
contract THREETHREETHREE is ERC1155, Owned, ReentrancyGuard {
string public name = "THREETHREETHREE";
string public symbol = "333";
string private _uri;
/// @dev Global per token supply cap, dualy a mint cap as once the supply decreases more tokens can't be minted.
uint public constant MAX_SUPPLY_PER_TOKEN = 111;
/// @dev The address of the receipt contract which may call burn functions in order to issue receipts.
address public receiptContract;
/// @dev Struct to hold the definition of a token.
struct Token {
/// @dev Name of token consumed by receipt contract for onchain receipt generation.
string name;
/// @dev The current supply of the token, initialized to 0 and incremented by mint functions.
uint currentSupply;
/// @dev The price of a single token represented in wei.
uint etherPrice;
/// @dev Whether the token is active or not, initialized to false and set to true by an admin function.
bool mintActive;
}
/// @dev Mapping of uint token IDs to token definitions.
mapping(uint => Token) public tokens;
/// @dev Initializes token definitions with names, and ether prices.
constructor() Owned(msg.sender) {
}
/// @notice Modifier restricting burn function access to the receipt contract.
/// @dev Checks that the address calling the burn function is a contract and not a user wallet by comparing the msg.sender to the tx.origin.
modifier onlyReceiptContract() {
}
/// @notice Mint an amount of up to the remaing supply of a single token.
/// @param id The ID of the token to mint.
/// @param amount The amount of tokens to mint.
function mintSingle(
uint id,
uint amount
) public payable nonReentrant {
}
/// @notice Mint an amount of up to the remaining supply of multiple tokens.
/// @param ids The IDs of the tokens to mint.
/// @param amounts The amounts of tokens to mint.
function mintBatch(
uint[] memory ids,
uint[] memory amounts
) external payable nonReentrant {
require(ids.length == amounts.length, "THREETHREETHREE: IDs and amounts arrays must be the same length");
uint totalEtherPrice;
for (uint i = 0; i < ids.length; i++) {
require(<FILL_ME>)
require(tokens[ids[i]].currentSupply + amounts[i] <= MAX_SUPPLY_PER_TOKEN, "THREETHREETHREE: Max supply reached of the token being minted");
totalEtherPrice += amounts[i] * tokens[ids[i]].etherPrice;
}
require(msg.value == totalEtherPrice, "THREETHREETHREE: msg.value is incorrect for the tokens being minted");
_batchMint(msg.sender, ids, amounts, "");
for (uint i = 0; i < ids.length; i++) {
tokens[ids[i]].currentSupply += amounts[i];
}
}
/// @notice Burn an amount of a single token as receipt contract.
/// @param from The address to burn tokens from.
/// @param id The ID of the token to burn.
/// @param amount The amount of tokens to burn.
function burnSingle(
address from,
uint id,
uint amount
) external onlyReceiptContract {
}
/// @notice Burn multiple amounts of multiple tokens as receipt contract.
/// @param from The address to burn tokens from.
/// @param ids The IDs of the tokens to burn.
/// @param amounts The amounts of tokens to burn.
function burnBatch(
address from,
uint[] memory ids,
uint[] memory amounts
) external onlyReceiptContract {
}
/// @notice Get the URI of a token.
function uri(uint256) public view virtual override returns (string memory) {
}
/// @notice Owner can flip the minting status of a token.
/// @param id The ID of the token to flip the minting status of.
function flipTokenMintActive(
uint id
) external onlyOwner {
}
/// @notice Owner can set the name of a token.
/// @param id The ID of the token to set the name of.
/// @param _name The name to set the token to.
function setTokenName(
uint id,
string calldata _name
) external onlyOwner {
}
/// @notice Owner can set the URI of a token.
/// @param newuri The URI to set for the contract.
function setURI(
string memory newuri
) external onlyOwner {
}
/// @notice Owner can set the receipt contract address.
/// @param _receiptContract The address of the receipt contract.
function setReceiptContract(
address _receiptContract
) external onlyOwner {
}
/// @notice Owner can withdraw all ether from contract
function withdrawEther() external onlyOwner {
}
}
| tokens[ids[i]].mintActive,"THREETHREETHREE: Minting is not active" | 270,811 | tokens[ids[i]].mintActive |
"THREETHREETHREE: Max supply reached of the token being minted" | // SPDX-License-Identifier: UNLICENSED
/// @title THREETHREETHREE
/// @author M1LL1P3D3
/// @notice MAKE THE MAGIC YOU WANT TO SEE IN THE WORLD! ✦✦✦
/// @dev This contract is constructed for use with the FIRSTTHREAD receipt contract.
pragma solidity ^0.8.17;
import "solmate/tokens/ERC1155.sol";
import "solmate/auth/Owned.sol";
import "solmate/utils/ReentrancyGuard.sol";
contract THREETHREETHREE is ERC1155, Owned, ReentrancyGuard {
string public name = "THREETHREETHREE";
string public symbol = "333";
string private _uri;
/// @dev Global per token supply cap, dualy a mint cap as once the supply decreases more tokens can't be minted.
uint public constant MAX_SUPPLY_PER_TOKEN = 111;
/// @dev The address of the receipt contract which may call burn functions in order to issue receipts.
address public receiptContract;
/// @dev Struct to hold the definition of a token.
struct Token {
/// @dev Name of token consumed by receipt contract for onchain receipt generation.
string name;
/// @dev The current supply of the token, initialized to 0 and incremented by mint functions.
uint currentSupply;
/// @dev The price of a single token represented in wei.
uint etherPrice;
/// @dev Whether the token is active or not, initialized to false and set to true by an admin function.
bool mintActive;
}
/// @dev Mapping of uint token IDs to token definitions.
mapping(uint => Token) public tokens;
/// @dev Initializes token definitions with names, and ether prices.
constructor() Owned(msg.sender) {
}
/// @notice Modifier restricting burn function access to the receipt contract.
/// @dev Checks that the address calling the burn function is a contract and not a user wallet by comparing the msg.sender to the tx.origin.
modifier onlyReceiptContract() {
}
/// @notice Mint an amount of up to the remaing supply of a single token.
/// @param id The ID of the token to mint.
/// @param amount The amount of tokens to mint.
function mintSingle(
uint id,
uint amount
) public payable nonReentrant {
}
/// @notice Mint an amount of up to the remaining supply of multiple tokens.
/// @param ids The IDs of the tokens to mint.
/// @param amounts The amounts of tokens to mint.
function mintBatch(
uint[] memory ids,
uint[] memory amounts
) external payable nonReentrant {
require(ids.length == amounts.length, "THREETHREETHREE: IDs and amounts arrays must be the same length");
uint totalEtherPrice;
for (uint i = 0; i < ids.length; i++) {
require(tokens[ids[i]].mintActive, "THREETHREETHREE: Minting is not active");
require(<FILL_ME>)
totalEtherPrice += amounts[i] * tokens[ids[i]].etherPrice;
}
require(msg.value == totalEtherPrice, "THREETHREETHREE: msg.value is incorrect for the tokens being minted");
_batchMint(msg.sender, ids, amounts, "");
for (uint i = 0; i < ids.length; i++) {
tokens[ids[i]].currentSupply += amounts[i];
}
}
/// @notice Burn an amount of a single token as receipt contract.
/// @param from The address to burn tokens from.
/// @param id The ID of the token to burn.
/// @param amount The amount of tokens to burn.
function burnSingle(
address from,
uint id,
uint amount
) external onlyReceiptContract {
}
/// @notice Burn multiple amounts of multiple tokens as receipt contract.
/// @param from The address to burn tokens from.
/// @param ids The IDs of the tokens to burn.
/// @param amounts The amounts of tokens to burn.
function burnBatch(
address from,
uint[] memory ids,
uint[] memory amounts
) external onlyReceiptContract {
}
/// @notice Get the URI of a token.
function uri(uint256) public view virtual override returns (string memory) {
}
/// @notice Owner can flip the minting status of a token.
/// @param id The ID of the token to flip the minting status of.
function flipTokenMintActive(
uint id
) external onlyOwner {
}
/// @notice Owner can set the name of a token.
/// @param id The ID of the token to set the name of.
/// @param _name The name to set the token to.
function setTokenName(
uint id,
string calldata _name
) external onlyOwner {
}
/// @notice Owner can set the URI of a token.
/// @param newuri The URI to set for the contract.
function setURI(
string memory newuri
) external onlyOwner {
}
/// @notice Owner can set the receipt contract address.
/// @param _receiptContract The address of the receipt contract.
function setReceiptContract(
address _receiptContract
) external onlyOwner {
}
/// @notice Owner can withdraw all ether from contract
function withdrawEther() external onlyOwner {
}
}
| tokens[ids[i]].currentSupply+amounts[i]<=MAX_SUPPLY_PER_TOKEN,"THREETHREETHREE: Max supply reached of the token being minted" | 270,811 | tokens[ids[i]].currentSupply+amounts[i]<=MAX_SUPPLY_PER_TOKEN |
"THREETHREETHREE: The owner of the tokens being burned does not have the amount of tokens being burned" | // SPDX-License-Identifier: UNLICENSED
/// @title THREETHREETHREE
/// @author M1LL1P3D3
/// @notice MAKE THE MAGIC YOU WANT TO SEE IN THE WORLD! ✦✦✦
/// @dev This contract is constructed for use with the FIRSTTHREAD receipt contract.
pragma solidity ^0.8.17;
import "solmate/tokens/ERC1155.sol";
import "solmate/auth/Owned.sol";
import "solmate/utils/ReentrancyGuard.sol";
contract THREETHREETHREE is ERC1155, Owned, ReentrancyGuard {
string public name = "THREETHREETHREE";
string public symbol = "333";
string private _uri;
/// @dev Global per token supply cap, dualy a mint cap as once the supply decreases more tokens can't be minted.
uint public constant MAX_SUPPLY_PER_TOKEN = 111;
/// @dev The address of the receipt contract which may call burn functions in order to issue receipts.
address public receiptContract;
/// @dev Struct to hold the definition of a token.
struct Token {
/// @dev Name of token consumed by receipt contract for onchain receipt generation.
string name;
/// @dev The current supply of the token, initialized to 0 and incremented by mint functions.
uint currentSupply;
/// @dev The price of a single token represented in wei.
uint etherPrice;
/// @dev Whether the token is active or not, initialized to false and set to true by an admin function.
bool mintActive;
}
/// @dev Mapping of uint token IDs to token definitions.
mapping(uint => Token) public tokens;
/// @dev Initializes token definitions with names, and ether prices.
constructor() Owned(msg.sender) {
}
/// @notice Modifier restricting burn function access to the receipt contract.
/// @dev Checks that the address calling the burn function is a contract and not a user wallet by comparing the msg.sender to the tx.origin.
modifier onlyReceiptContract() {
}
/// @notice Mint an amount of up to the remaing supply of a single token.
/// @param id The ID of the token to mint.
/// @param amount The amount of tokens to mint.
function mintSingle(
uint id,
uint amount
) public payable nonReentrant {
}
/// @notice Mint an amount of up to the remaining supply of multiple tokens.
/// @param ids The IDs of the tokens to mint.
/// @param amounts The amounts of tokens to mint.
function mintBatch(
uint[] memory ids,
uint[] memory amounts
) external payable nonReentrant {
}
/// @notice Burn an amount of a single token as receipt contract.
/// @param from The address to burn tokens from.
/// @param id The ID of the token to burn.
/// @param amount The amount of tokens to burn.
function burnSingle(
address from,
uint id,
uint amount
) external onlyReceiptContract {
require(<FILL_ME>)
_burn(from, id, amount);
}
/// @notice Burn multiple amounts of multiple tokens as receipt contract.
/// @param from The address to burn tokens from.
/// @param ids The IDs of the tokens to burn.
/// @param amounts The amounts of tokens to burn.
function burnBatch(
address from,
uint[] memory ids,
uint[] memory amounts
) external onlyReceiptContract {
}
/// @notice Get the URI of a token.
function uri(uint256) public view virtual override returns (string memory) {
}
/// @notice Owner can flip the minting status of a token.
/// @param id The ID of the token to flip the minting status of.
function flipTokenMintActive(
uint id
) external onlyOwner {
}
/// @notice Owner can set the name of a token.
/// @param id The ID of the token to set the name of.
/// @param _name The name to set the token to.
function setTokenName(
uint id,
string calldata _name
) external onlyOwner {
}
/// @notice Owner can set the URI of a token.
/// @param newuri The URI to set for the contract.
function setURI(
string memory newuri
) external onlyOwner {
}
/// @notice Owner can set the receipt contract address.
/// @param _receiptContract The address of the receipt contract.
function setReceiptContract(
address _receiptContract
) external onlyOwner {
}
/// @notice Owner can withdraw all ether from contract
function withdrawEther() external onlyOwner {
}
}
| balanceOf[from][id]>=amount,"THREETHREETHREE: The owner of the tokens being burned does not have the amount of tokens being burned" | 270,811 | balanceOf[from][id]>=amount |
"THREETHREETHREE: The owner of the tokens being burned does not have the amount of tokens being burned" | // SPDX-License-Identifier: UNLICENSED
/// @title THREETHREETHREE
/// @author M1LL1P3D3
/// @notice MAKE THE MAGIC YOU WANT TO SEE IN THE WORLD! ✦✦✦
/// @dev This contract is constructed for use with the FIRSTTHREAD receipt contract.
pragma solidity ^0.8.17;
import "solmate/tokens/ERC1155.sol";
import "solmate/auth/Owned.sol";
import "solmate/utils/ReentrancyGuard.sol";
contract THREETHREETHREE is ERC1155, Owned, ReentrancyGuard {
string public name = "THREETHREETHREE";
string public symbol = "333";
string private _uri;
/// @dev Global per token supply cap, dualy a mint cap as once the supply decreases more tokens can't be minted.
uint public constant MAX_SUPPLY_PER_TOKEN = 111;
/// @dev The address of the receipt contract which may call burn functions in order to issue receipts.
address public receiptContract;
/// @dev Struct to hold the definition of a token.
struct Token {
/// @dev Name of token consumed by receipt contract for onchain receipt generation.
string name;
/// @dev The current supply of the token, initialized to 0 and incremented by mint functions.
uint currentSupply;
/// @dev The price of a single token represented in wei.
uint etherPrice;
/// @dev Whether the token is active or not, initialized to false and set to true by an admin function.
bool mintActive;
}
/// @dev Mapping of uint token IDs to token definitions.
mapping(uint => Token) public tokens;
/// @dev Initializes token definitions with names, and ether prices.
constructor() Owned(msg.sender) {
}
/// @notice Modifier restricting burn function access to the receipt contract.
/// @dev Checks that the address calling the burn function is a contract and not a user wallet by comparing the msg.sender to the tx.origin.
modifier onlyReceiptContract() {
}
/// @notice Mint an amount of up to the remaing supply of a single token.
/// @param id The ID of the token to mint.
/// @param amount The amount of tokens to mint.
function mintSingle(
uint id,
uint amount
) public payable nonReentrant {
}
/// @notice Mint an amount of up to the remaining supply of multiple tokens.
/// @param ids The IDs of the tokens to mint.
/// @param amounts The amounts of tokens to mint.
function mintBatch(
uint[] memory ids,
uint[] memory amounts
) external payable nonReentrant {
}
/// @notice Burn an amount of a single token as receipt contract.
/// @param from The address to burn tokens from.
/// @param id The ID of the token to burn.
/// @param amount The amount of tokens to burn.
function burnSingle(
address from,
uint id,
uint amount
) external onlyReceiptContract {
}
/// @notice Burn multiple amounts of multiple tokens as receipt contract.
/// @param from The address to burn tokens from.
/// @param ids The IDs of the tokens to burn.
/// @param amounts The amounts of tokens to burn.
function burnBatch(
address from,
uint[] memory ids,
uint[] memory amounts
) external onlyReceiptContract {
require(ids.length == amounts.length, "THREETHREETHREE: IDs and amounts arrays must be the same length");
for (uint i = 0; i < ids.length; i++) {
require(<FILL_ME>)
}
_batchBurn(from, ids, amounts);
}
/// @notice Get the URI of a token.
function uri(uint256) public view virtual override returns (string memory) {
}
/// @notice Owner can flip the minting status of a token.
/// @param id The ID of the token to flip the minting status of.
function flipTokenMintActive(
uint id
) external onlyOwner {
}
/// @notice Owner can set the name of a token.
/// @param id The ID of the token to set the name of.
/// @param _name The name to set the token to.
function setTokenName(
uint id,
string calldata _name
) external onlyOwner {
}
/// @notice Owner can set the URI of a token.
/// @param newuri The URI to set for the contract.
function setURI(
string memory newuri
) external onlyOwner {
}
/// @notice Owner can set the receipt contract address.
/// @param _receiptContract The address of the receipt contract.
function setReceiptContract(
address _receiptContract
) external onlyOwner {
}
/// @notice Owner can withdraw all ether from contract
function withdrawEther() external onlyOwner {
}
}
| balanceOf[from][ids[i]]>=amounts[i],"THREETHREETHREE: The owner of the tokens being burned does not have the amount of tokens being burned" | 270,811 | balanceOf[from][ids[i]]>=amounts[i] |
"Cover has already been migrated" | // SPDX-License-Identifier: GPL-3.0-only
pragma solidity ^0.8.18;
import "../../abstract/MasterAwareV2.sol";
import "../../interfaces/ICover.sol";
import "../../interfaces/IIndividualClaims.sol";
import "../../interfaces/IProductsV1.sol";
import "../../interfaces/IQuotationData.sol";
import "../../interfaces/ITokenController.sol";
/// Provides a way for contracts which don't use the Gateway.sol contract to migrate covers to V2
/// using the submitClaim claim function.
contract CoverMigrator is MasterAwareV2 {
event CoverMigrated(uint coverIdV1, uint coverIdV2, address newOwner);
// v1
IQuotationData internal immutable quotationData;
IProductsV1 internal immutable productsV1;
constructor(address _quotationData, address _productsV1) {
}
/// @dev Migrates covers for arNFT-like contracts that don't use Gateway.sol
/// The function should not change in any way, since it is being used instead of V1 Claims `submitClaim`
///
/// @param coverId Legacy (V1) cover identifier
function submitClaim(uint coverId) external whenNotPaused {
}
/// @dev Migrates covers from V1. Meant to be used by EOA Nexus Mutual members
///
/// @param coverIds Legacy (V1) cover identifiers
/// @param newOwner The address for which the V2 cover NFT is minted
function migrateCovers(
uint[] calldata coverIds,
address newOwner
) external whenNotPaused returns (uint[] memory newCoverIds) {
}
/// @dev Migrates covers from V1. Meant to be used by Claims.sol and Gateway.sol to allow the
/// users of distributor contracts to migrate their NFTs.
///
/// @param coverId V1 cover identifier
/// @param msgSender The address which called the migration function
/// @param newOwner The address for which the V2 cover NFT is minted
function migrateCoverFrom(
uint coverId,
address msgSender,
address newOwner
) external onlyInternal whenNotPaused returns (uint newCoverId) {
}
function migrateAndSubmitClaim(
uint32 coverId,
uint16 segmentId,
uint96 requestedAmount,
string calldata ipfsMetadata
) payable external whenNotPaused returns (uint newCoverId) {
}
/// @dev Migrates covers from V1
///
/// @param coverId V1 cover identifier
/// @param msgSender The address which called the migration function
/// @param newOwner The address for which the V2 cover NFT is minted
function _migrateCoverFrom(
uint coverId,
address msgSender,
address newOwner
) internal returns (uint coverIdV2) {
uint productId;
uint coverAsset;
uint start;
uint period;
uint amount;
{
(
/*uint coverId*/,
address coverOwner,
address legacyProductId,
bytes4 currencyCode,
/*uint sumAssured*/,
/*uint premiumNXM*/
) = quotationData.getCoverDetailsByCoverID1(coverId);
require(msgSender == coverOwner, "Cover can only be migrated by its owner");
productId = productsV1.getNewProductId(legacyProductId);
coverAsset = currencyCode == "ETH" ? 0 : 1;
}
{
(
/*uint coverId*/,
uint8 status,
uint sumAssured,
uint16 coverPeriodInDays,
uint validUntil
) = quotationData.getCoverDetailsByCoverID2(coverId);
require(<FILL_ME>)
require(LegacyCoverStatus(status) != LegacyCoverStatus.ClaimAccepted, "A claim has already been accepted");
amount = sumAssured * 10 ** 18;
period = uint(coverPeriodInDays) * 1 days;
start = validUntil - period;
}
{
(
uint claimCount ,
bool hasOpenClaim,
/* hasAcceptedClaim */,
/* requestedAmount */
) = tokenController().coverInfo(coverId);
require(!hasOpenClaim, "Cover has an open V1 claim");
require(claimCount < 2, "Cover already has 2 claims");
}
// Mark cover as migrated to prevent future calls on the same cover
quotationData.changeCoverStatusNo(coverId, uint8(LegacyCoverStatus.Migrated));
coverIdV2 = cover().addLegacyCover(productId, coverAsset, amount, start, period, newOwner);
emit CoverMigrated(coverId, coverIdV2, newOwner);
}
function cover() internal view returns (ICover) {
}
function tokenController() internal view returns (ITokenController) {
}
function individualClaims() internal view returns (IIndividualClaims) {
}
/// @dev Updates internal contract addresses to the ones stored in master. This function is
/// automatically called by the master contract when a contract is added or upgraded.
function changeDependentContractAddress() external override {
}
}
| LegacyCoverStatus(status)!=LegacyCoverStatus.Migrated,"Cover has already been migrated" | 270,849 | LegacyCoverStatus(status)!=LegacyCoverStatus.Migrated |
"A claim has already been accepted" | // SPDX-License-Identifier: GPL-3.0-only
pragma solidity ^0.8.18;
import "../../abstract/MasterAwareV2.sol";
import "../../interfaces/ICover.sol";
import "../../interfaces/IIndividualClaims.sol";
import "../../interfaces/IProductsV1.sol";
import "../../interfaces/IQuotationData.sol";
import "../../interfaces/ITokenController.sol";
/// Provides a way for contracts which don't use the Gateway.sol contract to migrate covers to V2
/// using the submitClaim claim function.
contract CoverMigrator is MasterAwareV2 {
event CoverMigrated(uint coverIdV1, uint coverIdV2, address newOwner);
// v1
IQuotationData internal immutable quotationData;
IProductsV1 internal immutable productsV1;
constructor(address _quotationData, address _productsV1) {
}
/// @dev Migrates covers for arNFT-like contracts that don't use Gateway.sol
/// The function should not change in any way, since it is being used instead of V1 Claims `submitClaim`
///
/// @param coverId Legacy (V1) cover identifier
function submitClaim(uint coverId) external whenNotPaused {
}
/// @dev Migrates covers from V1. Meant to be used by EOA Nexus Mutual members
///
/// @param coverIds Legacy (V1) cover identifiers
/// @param newOwner The address for which the V2 cover NFT is minted
function migrateCovers(
uint[] calldata coverIds,
address newOwner
) external whenNotPaused returns (uint[] memory newCoverIds) {
}
/// @dev Migrates covers from V1. Meant to be used by Claims.sol and Gateway.sol to allow the
/// users of distributor contracts to migrate their NFTs.
///
/// @param coverId V1 cover identifier
/// @param msgSender The address which called the migration function
/// @param newOwner The address for which the V2 cover NFT is minted
function migrateCoverFrom(
uint coverId,
address msgSender,
address newOwner
) external onlyInternal whenNotPaused returns (uint newCoverId) {
}
function migrateAndSubmitClaim(
uint32 coverId,
uint16 segmentId,
uint96 requestedAmount,
string calldata ipfsMetadata
) payable external whenNotPaused returns (uint newCoverId) {
}
/// @dev Migrates covers from V1
///
/// @param coverId V1 cover identifier
/// @param msgSender The address which called the migration function
/// @param newOwner The address for which the V2 cover NFT is minted
function _migrateCoverFrom(
uint coverId,
address msgSender,
address newOwner
) internal returns (uint coverIdV2) {
uint productId;
uint coverAsset;
uint start;
uint period;
uint amount;
{
(
/*uint coverId*/,
address coverOwner,
address legacyProductId,
bytes4 currencyCode,
/*uint sumAssured*/,
/*uint premiumNXM*/
) = quotationData.getCoverDetailsByCoverID1(coverId);
require(msgSender == coverOwner, "Cover can only be migrated by its owner");
productId = productsV1.getNewProductId(legacyProductId);
coverAsset = currencyCode == "ETH" ? 0 : 1;
}
{
(
/*uint coverId*/,
uint8 status,
uint sumAssured,
uint16 coverPeriodInDays,
uint validUntil
) = quotationData.getCoverDetailsByCoverID2(coverId);
require(LegacyCoverStatus(status) != LegacyCoverStatus.Migrated, "Cover has already been migrated");
require(<FILL_ME>)
amount = sumAssured * 10 ** 18;
period = uint(coverPeriodInDays) * 1 days;
start = validUntil - period;
}
{
(
uint claimCount ,
bool hasOpenClaim,
/* hasAcceptedClaim */,
/* requestedAmount */
) = tokenController().coverInfo(coverId);
require(!hasOpenClaim, "Cover has an open V1 claim");
require(claimCount < 2, "Cover already has 2 claims");
}
// Mark cover as migrated to prevent future calls on the same cover
quotationData.changeCoverStatusNo(coverId, uint8(LegacyCoverStatus.Migrated));
coverIdV2 = cover().addLegacyCover(productId, coverAsset, amount, start, period, newOwner);
emit CoverMigrated(coverId, coverIdV2, newOwner);
}
function cover() internal view returns (ICover) {
}
function tokenController() internal view returns (ITokenController) {
}
function individualClaims() internal view returns (IIndividualClaims) {
}
/// @dev Updates internal contract addresses to the ones stored in master. This function is
/// automatically called by the master contract when a contract is added or upgraded.
function changeDependentContractAddress() external override {
}
}
| LegacyCoverStatus(status)!=LegacyCoverStatus.ClaimAccepted,"A claim has already been accepted" | 270,849 | LegacyCoverStatus(status)!=LegacyCoverStatus.ClaimAccepted |
"Cover has an open V1 claim" | // SPDX-License-Identifier: GPL-3.0-only
pragma solidity ^0.8.18;
import "../../abstract/MasterAwareV2.sol";
import "../../interfaces/ICover.sol";
import "../../interfaces/IIndividualClaims.sol";
import "../../interfaces/IProductsV1.sol";
import "../../interfaces/IQuotationData.sol";
import "../../interfaces/ITokenController.sol";
/// Provides a way for contracts which don't use the Gateway.sol contract to migrate covers to V2
/// using the submitClaim claim function.
contract CoverMigrator is MasterAwareV2 {
event CoverMigrated(uint coverIdV1, uint coverIdV2, address newOwner);
// v1
IQuotationData internal immutable quotationData;
IProductsV1 internal immutable productsV1;
constructor(address _quotationData, address _productsV1) {
}
/// @dev Migrates covers for arNFT-like contracts that don't use Gateway.sol
/// The function should not change in any way, since it is being used instead of V1 Claims `submitClaim`
///
/// @param coverId Legacy (V1) cover identifier
function submitClaim(uint coverId) external whenNotPaused {
}
/// @dev Migrates covers from V1. Meant to be used by EOA Nexus Mutual members
///
/// @param coverIds Legacy (V1) cover identifiers
/// @param newOwner The address for which the V2 cover NFT is minted
function migrateCovers(
uint[] calldata coverIds,
address newOwner
) external whenNotPaused returns (uint[] memory newCoverIds) {
}
/// @dev Migrates covers from V1. Meant to be used by Claims.sol and Gateway.sol to allow the
/// users of distributor contracts to migrate their NFTs.
///
/// @param coverId V1 cover identifier
/// @param msgSender The address which called the migration function
/// @param newOwner The address for which the V2 cover NFT is minted
function migrateCoverFrom(
uint coverId,
address msgSender,
address newOwner
) external onlyInternal whenNotPaused returns (uint newCoverId) {
}
function migrateAndSubmitClaim(
uint32 coverId,
uint16 segmentId,
uint96 requestedAmount,
string calldata ipfsMetadata
) payable external whenNotPaused returns (uint newCoverId) {
}
/// @dev Migrates covers from V1
///
/// @param coverId V1 cover identifier
/// @param msgSender The address which called the migration function
/// @param newOwner The address for which the V2 cover NFT is minted
function _migrateCoverFrom(
uint coverId,
address msgSender,
address newOwner
) internal returns (uint coverIdV2) {
uint productId;
uint coverAsset;
uint start;
uint period;
uint amount;
{
(
/*uint coverId*/,
address coverOwner,
address legacyProductId,
bytes4 currencyCode,
/*uint sumAssured*/,
/*uint premiumNXM*/
) = quotationData.getCoverDetailsByCoverID1(coverId);
require(msgSender == coverOwner, "Cover can only be migrated by its owner");
productId = productsV1.getNewProductId(legacyProductId);
coverAsset = currencyCode == "ETH" ? 0 : 1;
}
{
(
/*uint coverId*/,
uint8 status,
uint sumAssured,
uint16 coverPeriodInDays,
uint validUntil
) = quotationData.getCoverDetailsByCoverID2(coverId);
require(LegacyCoverStatus(status) != LegacyCoverStatus.Migrated, "Cover has already been migrated");
require(LegacyCoverStatus(status) != LegacyCoverStatus.ClaimAccepted, "A claim has already been accepted");
amount = sumAssured * 10 ** 18;
period = uint(coverPeriodInDays) * 1 days;
start = validUntil - period;
}
{
(
uint claimCount ,
bool hasOpenClaim,
/* hasAcceptedClaim */,
/* requestedAmount */
) = tokenController().coverInfo(coverId);
require(<FILL_ME>)
require(claimCount < 2, "Cover already has 2 claims");
}
// Mark cover as migrated to prevent future calls on the same cover
quotationData.changeCoverStatusNo(coverId, uint8(LegacyCoverStatus.Migrated));
coverIdV2 = cover().addLegacyCover(productId, coverAsset, amount, start, period, newOwner);
emit CoverMigrated(coverId, coverIdV2, newOwner);
}
function cover() internal view returns (ICover) {
}
function tokenController() internal view returns (ITokenController) {
}
function individualClaims() internal view returns (IIndividualClaims) {
}
/// @dev Updates internal contract addresses to the ones stored in master. This function is
/// automatically called by the master contract when a contract is added or upgraded.
function changeDependentContractAddress() external override {
}
}
| !hasOpenClaim,"Cover has an open V1 claim" | 270,849 | !hasOpenClaim |
"You have reached the mint limit." | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract InsomniacOwls is ERC721A, Ownable, ReentrancyGuard{
string private baseURI;
string public contractURI;
uint256 public cost;
uint256 public maxSupply;
uint256 public maxMintAmount;
string public baseExtension = ".json";
bool public paused = true;
constructor(
string memory _initBaseURI,
string memory _initContractURI,
uint256 _initMaxSupply,
uint256 _initMaxMintAmount,
uint256 _initCost
) ERC721A("Insomniac Owls", "IO") ReentrancyGuard(){
}
function _baseURI() internal view virtual override returns (string memory) {
}
modifier callerIsUser() {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function mint(uint256 _quantity) external payable nonReentrant callerIsUser{
require(!paused);
require(_quantity > 0);
require(_quantity <= maxMintAmount);
require(totalSupply() + _quantity <= maxSupply, "Not enough tokens left");
require(msg.value >= cost * _quantity, "Not enough ether sent");
require(<FILL_ME>)
_safeMint(msg.sender, _quantity);
}
function ownerMint(uint256 _quantity) external onlyOwner{
}
function pause(bool _state) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setContractURI(string memory _newContractURI) public onlyOwner {
}
function setMaxSupply(uint256 _newSupply) public onlyOwner {
}
function setMaxMintAmount(uint256 _newMaxMintAmount) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function withdraw() public payable nonReentrant onlyOwner {
}
}
| _numberMinted(msg.sender)+_quantity<=maxMintAmount,"You have reached the mint limit." | 270,886 | _numberMinted(msg.sender)+_quantity<=maxMintAmount |
"Purchase would exceed max supply of free mints" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/access/Ownable.sol";
import '@openzeppelin/contracts/utils/Strings.sol';
import "./ERC721A.sol";
contract ApeWorld111 is ERC721A, Ownable {
using Strings for uint256;
address private constant teamAddress = 0x9C7Bd3DB7bDD9D861049AE9047d58e5c2673293b;
uint256 public constant maxSupply = 111;
uint256 public constant claimAmount = 6;
uint256 public TOTAL_FREE_SUPPLY = 0;
uint256 public maxPerTxn = 1;
uint256 public maxPerWallet = 1;
bool claimed = false;
uint256 public token_price = 0.006 ether;
bool public publicSaleActive;
bool public freeMintActive;
uint256 public freeMintCount;
mapping(address => uint256) public freeMintClaimed;
string private _baseTokenURI;
constructor() ERC721A("ApeWorld111", "AW111") {
}
modifier underMaxSupply(uint256 _quantity) {
}
modifier validateFreeMintStatus() {
require(freeMintActive, "free claim is not active");
require(<FILL_ME>)
require(freeMintClaimed[msg.sender] == 0, "wallet has already free minted");
_;
}
modifier validatePublicStatus(uint256 _quantity) {
}
/**
* @dev override ERC721A _startTokenId()
*/
function _startTokenId()
internal
view
virtual
override
returns (uint256) {
}
function freeMint()
external
validateFreeMintStatus
underMaxSupply(1)
{
}
function mint(uint256 _quantity)
external
payable
validatePublicStatus(_quantity)
underMaxSupply(_quantity)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function numberMinted(address owner) public view returns (uint256) {
}
function holderAirdrop(address[] calldata boardAddresses, uint256 _quantity) external onlyOwner {
}
function teamClaim() external onlyOwner {
}
function setFreeMintCount(uint256 _count) external onlyOwner {
}
function setMaxPerTxn(uint256 _num) external onlyOwner {
}
function setMaxPerWallet(uint256 _num) external onlyOwner {
}
function setTokenPrice(uint256 newPrice) external onlyOwner {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdrawFunds() external onlyOwner {
}
function withdrawFundsToAddress(address _address, uint256 amount) external onlyOwner {
}
function flipFreeMint() external onlyOwner {
}
function flipPublicSale() external onlyOwner {
}
}
| freeMintCount+1<=TOTAL_FREE_SUPPLY,"Purchase would exceed max supply of free mints" | 270,998 | freeMintCount+1<=TOTAL_FREE_SUPPLY |
"wallet has already free minted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/access/Ownable.sol";
import '@openzeppelin/contracts/utils/Strings.sol';
import "./ERC721A.sol";
contract ApeWorld111 is ERC721A, Ownable {
using Strings for uint256;
address private constant teamAddress = 0x9C7Bd3DB7bDD9D861049AE9047d58e5c2673293b;
uint256 public constant maxSupply = 111;
uint256 public constant claimAmount = 6;
uint256 public TOTAL_FREE_SUPPLY = 0;
uint256 public maxPerTxn = 1;
uint256 public maxPerWallet = 1;
bool claimed = false;
uint256 public token_price = 0.006 ether;
bool public publicSaleActive;
bool public freeMintActive;
uint256 public freeMintCount;
mapping(address => uint256) public freeMintClaimed;
string private _baseTokenURI;
constructor() ERC721A("ApeWorld111", "AW111") {
}
modifier underMaxSupply(uint256 _quantity) {
}
modifier validateFreeMintStatus() {
require(freeMintActive, "free claim is not active");
require(freeMintCount + 1 <= TOTAL_FREE_SUPPLY, "Purchase would exceed max supply of free mints");
require(<FILL_ME>)
_;
}
modifier validatePublicStatus(uint256 _quantity) {
}
/**
* @dev override ERC721A _startTokenId()
*/
function _startTokenId()
internal
view
virtual
override
returns (uint256) {
}
function freeMint()
external
validateFreeMintStatus
underMaxSupply(1)
{
}
function mint(uint256 _quantity)
external
payable
validatePublicStatus(_quantity)
underMaxSupply(_quantity)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function numberMinted(address owner) public view returns (uint256) {
}
function holderAirdrop(address[] calldata boardAddresses, uint256 _quantity) external onlyOwner {
}
function teamClaim() external onlyOwner {
}
function setFreeMintCount(uint256 _count) external onlyOwner {
}
function setMaxPerTxn(uint256 _num) external onlyOwner {
}
function setMaxPerWallet(uint256 _num) external onlyOwner {
}
function setTokenPrice(uint256 newPrice) external onlyOwner {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdrawFunds() external onlyOwner {
}
function withdrawFundsToAddress(address _address, uint256 amount) external onlyOwner {
}
function flipFreeMint() external onlyOwner {
}
function flipPublicSale() external onlyOwner {
}
}
| freeMintClaimed[msg.sender]==0,"wallet has already free minted" | 270,998 | freeMintClaimed[msg.sender]==0 |
"Not a god bull" | // SPDX-License-Identifier: GPL-3.0
// solhint-disable-next-line
pragma solidity 0.8.12;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./reduced_interfaces/BAPGenesisInterface.sol";
import "./reduced_interfaces/BAPMethaneInterface.sol";
import "./reduced_interfaces/BAPUtilitiesInterface.sol";
import "./reduced_interfaces/BAPTeenBullsInterface.sol";
import "./reduced_interfaces/BAPOrchestratorInterfaceV2.sol";
import "./IERC721Receiver.sol";
contract BAPOrchestratorV3 is Ownable, IERC721Receiver {
string public constant project = "Bulls & Apes Project";
uint256 public constant startTime = 1665291600;
uint256 public timeCounter = 1 days;
uint256 public powerCooldown = 14 days;
uint256 private lastTokenReceived;
address public treasuryWallet;
address public secret;
bool public claimFlag = true;
bool public refundFlag = false;
bool private isReviving = false;
mapping(uint256 => uint256) public breedingsLeft;
mapping(uint256 => uint256) public claimedMeth;
mapping(uint256 => uint256) public claimedTeenMeth;
mapping(uint256 => uint256) public lastChestOpen;
mapping(uint256 => bool) public isGod;
mapping(uint256 => bool) public prevClaimed;
mapping(address => uint256) public userLastClaim;
BAPGenesisInterface public bapGenesis;
BAPMethaneInterface public bapMeth;
BAPUtilitiesInterface public bapUtilities;
BAPTeenBullsInterface public bapTeenBulls;
BAPOrchestratorInterfaceV2 public bapOrchestratorV2;
event CHEST_OPENED(
uint256 num,
uint256 godId,
uint256 prize,
uint256 timestamp
);
event METH_CLAIMED(address user, uint256 amount, uint256 timestamp);
event GOD_MINTED(address user, uint256 id, uint256 timestamp);
event TEEN_RESURRECTED(
address user,
uint256 sacrificed,
uint256 resurrected,
uint256 newlyMinted
);
constructor(
address _bapGenesis,
address _bapMethane,
address _bapUtilities,
address _bapTeenBulls,
address _orchestratorV2
) {
}
modifier noZeroAddress(address _address) {
}
// WRITE FUNCTIONS
function claimMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens
) public {
require(claimFlag, "Claim is disabled");
uint256 claimableMeth;
for (uint256 i; i < bulls.length; i++) {
claimableMeth += _claimMeth(bulls[i], 0);
}
for (uint256 i; i < gods.length; i++) {
require(<FILL_ME>)
claimableMeth += _claimMeth(gods[i], 1);
}
for (uint256 i; i < teens.length; i++) {
require(isResurrected(teens[i]), "Not a resurrected teen");
claimableMeth += _claimMeth(teens[i], 2);
}
bapMeth.claim(msg.sender, claimableMeth);
}
function generateTeenBull() public {
}
function generateGodBull(
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) public {
}
function buyIncubator(
bytes memory signature,
uint256 bull1,
uint256 bull2
) public {
}
function buyMergeOrb(uint256 teen) public {
}
function refund(uint256 tokenId) external noZeroAddress(treasuryWallet) {
}
// NEW FUNCTIONS
function openChest(
uint256 godId,
uint256 guild,
uint256 seed,
bool hasPower,
bytes memory signature
) external {
}
function useItem(
uint256 item,
uint256 tokenId,
uint256 godId,
uint256 resurrected,
bytes memory signature
) external {
}
function claimTeenMeth(
uint256 amount,
uint256 seed,
bytes memory signature
) public {
}
// BULK FUNCTIONS
function claimAllMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens,
uint256 amount,
uint256 seed,
bytes memory signature
) external {
}
function breedAndIncubate(
bytes memory signature,
uint256 bull1,
uint256 bull2
) external {
}
function buyOrbAndSummon(
uint256 teen,
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) external {
}
// INTERNAL FUNCTIONS
function _claimMeth(uint256 tokenId, uint256 _type)
internal
returns (uint256 amount)
{
}
function _breedToken(uint256 tokenId) internal {
}
function _burnTeen(uint256 tokenId) internal {
}
function random(uint256 seed) internal view returns (uint256) {
}
function _dailyRewards(uint256 _type) internal pure returns (uint256) {
}
function _refundPeriodAllowed() internal view returns (bool) {
}
function _verifyHashSignature(bytes32 freshHash, bytes memory signature)
internal
view
returns (bool)
{
}
// VIEW FUNCTIONS
function breedings(uint256 tokenId) public view returns (uint256) {
}
function getClaimableMeth(uint256 tokenId, uint256 _type)
public
view
returns (uint256)
{
}
function getOldClaimableMeth(uint256 tokenId, bool isGod)
public
view
returns (uint256 methAmount)
{
}
function godBulls(uint256 tokenId) public view returns (bool) {
}
function isResurrected(uint256 tokenId) public view returns (bool) {
}
function availableForRefund(uint256 tokenId) public view returns (bool) {
}
function onERC721Received(
address,
address,
uint256 tokenId,
bytes memory
) external virtual override returns (bytes4) {
}
// OWNER FUNCTIONS
function initializeGodBull(uint256[] memory gods, bool godFlag)
external
onlyOwner
{
}
function transferExternalOwnership(address _contract, address _newOwner)
external
onlyOwner
noZeroAddress(_newOwner)
{
}
function utilitiesAirdrop(
address _to,
uint256 amount,
uint256 utility
) external onlyOwner noZeroAddress(_to) {
}
function teenAirdrop(address _to, uint256 amount)
external
onlyOwner
noZeroAddress(_to)
{
}
function setGenesisContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setMethaneContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setUtilitiesContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTeenBullsContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTreasuryWallet(address _newTreasuryWallet)
external
onlyOwner
noZeroAddress(_newTreasuryWallet)
{
}
function setWhitelistedAddress(address _secret)
external
onlyOwner
noZeroAddress(_secret)
{
}
function setTimeCounter(uint256 _timeCounter) external onlyOwner {
}
function setPowerCooldown(uint256 _powerCooldown) external onlyOwner {
}
function setRefundFlag(bool _refundFlag) external onlyOwner {
}
function setClaimFlag(bool _claimFlag) external onlyOwner {
}
}
| godBulls(gods[i]),"Not a god bull" | 271,006 | godBulls(gods[i]) |
"Not a resurrected teen" | // SPDX-License-Identifier: GPL-3.0
// solhint-disable-next-line
pragma solidity 0.8.12;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./reduced_interfaces/BAPGenesisInterface.sol";
import "./reduced_interfaces/BAPMethaneInterface.sol";
import "./reduced_interfaces/BAPUtilitiesInterface.sol";
import "./reduced_interfaces/BAPTeenBullsInterface.sol";
import "./reduced_interfaces/BAPOrchestratorInterfaceV2.sol";
import "./IERC721Receiver.sol";
contract BAPOrchestratorV3 is Ownable, IERC721Receiver {
string public constant project = "Bulls & Apes Project";
uint256 public constant startTime = 1665291600;
uint256 public timeCounter = 1 days;
uint256 public powerCooldown = 14 days;
uint256 private lastTokenReceived;
address public treasuryWallet;
address public secret;
bool public claimFlag = true;
bool public refundFlag = false;
bool private isReviving = false;
mapping(uint256 => uint256) public breedingsLeft;
mapping(uint256 => uint256) public claimedMeth;
mapping(uint256 => uint256) public claimedTeenMeth;
mapping(uint256 => uint256) public lastChestOpen;
mapping(uint256 => bool) public isGod;
mapping(uint256 => bool) public prevClaimed;
mapping(address => uint256) public userLastClaim;
BAPGenesisInterface public bapGenesis;
BAPMethaneInterface public bapMeth;
BAPUtilitiesInterface public bapUtilities;
BAPTeenBullsInterface public bapTeenBulls;
BAPOrchestratorInterfaceV2 public bapOrchestratorV2;
event CHEST_OPENED(
uint256 num,
uint256 godId,
uint256 prize,
uint256 timestamp
);
event METH_CLAIMED(address user, uint256 amount, uint256 timestamp);
event GOD_MINTED(address user, uint256 id, uint256 timestamp);
event TEEN_RESURRECTED(
address user,
uint256 sacrificed,
uint256 resurrected,
uint256 newlyMinted
);
constructor(
address _bapGenesis,
address _bapMethane,
address _bapUtilities,
address _bapTeenBulls,
address _orchestratorV2
) {
}
modifier noZeroAddress(address _address) {
}
// WRITE FUNCTIONS
function claimMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens
) public {
require(claimFlag, "Claim is disabled");
uint256 claimableMeth;
for (uint256 i; i < bulls.length; i++) {
claimableMeth += _claimMeth(bulls[i], 0);
}
for (uint256 i; i < gods.length; i++) {
require(godBulls(gods[i]), "Not a god bull");
claimableMeth += _claimMeth(gods[i], 1);
}
for (uint256 i; i < teens.length; i++) {
require(<FILL_ME>)
claimableMeth += _claimMeth(teens[i], 2);
}
bapMeth.claim(msg.sender, claimableMeth);
}
function generateTeenBull() public {
}
function generateGodBull(
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) public {
}
function buyIncubator(
bytes memory signature,
uint256 bull1,
uint256 bull2
) public {
}
function buyMergeOrb(uint256 teen) public {
}
function refund(uint256 tokenId) external noZeroAddress(treasuryWallet) {
}
// NEW FUNCTIONS
function openChest(
uint256 godId,
uint256 guild,
uint256 seed,
bool hasPower,
bytes memory signature
) external {
}
function useItem(
uint256 item,
uint256 tokenId,
uint256 godId,
uint256 resurrected,
bytes memory signature
) external {
}
function claimTeenMeth(
uint256 amount,
uint256 seed,
bytes memory signature
) public {
}
// BULK FUNCTIONS
function claimAllMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens,
uint256 amount,
uint256 seed,
bytes memory signature
) external {
}
function breedAndIncubate(
bytes memory signature,
uint256 bull1,
uint256 bull2
) external {
}
function buyOrbAndSummon(
uint256 teen,
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) external {
}
// INTERNAL FUNCTIONS
function _claimMeth(uint256 tokenId, uint256 _type)
internal
returns (uint256 amount)
{
}
function _breedToken(uint256 tokenId) internal {
}
function _burnTeen(uint256 tokenId) internal {
}
function random(uint256 seed) internal view returns (uint256) {
}
function _dailyRewards(uint256 _type) internal pure returns (uint256) {
}
function _refundPeriodAllowed() internal view returns (bool) {
}
function _verifyHashSignature(bytes32 freshHash, bytes memory signature)
internal
view
returns (bool)
{
}
// VIEW FUNCTIONS
function breedings(uint256 tokenId) public view returns (uint256) {
}
function getClaimableMeth(uint256 tokenId, uint256 _type)
public
view
returns (uint256)
{
}
function getOldClaimableMeth(uint256 tokenId, bool isGod)
public
view
returns (uint256 methAmount)
{
}
function godBulls(uint256 tokenId) public view returns (bool) {
}
function isResurrected(uint256 tokenId) public view returns (bool) {
}
function availableForRefund(uint256 tokenId) public view returns (bool) {
}
function onERC721Received(
address,
address,
uint256 tokenId,
bytes memory
) external virtual override returns (bytes4) {
}
// OWNER FUNCTIONS
function initializeGodBull(uint256[] memory gods, bool godFlag)
external
onlyOwner
{
}
function transferExternalOwnership(address _contract, address _newOwner)
external
onlyOwner
noZeroAddress(_newOwner)
{
}
function utilitiesAirdrop(
address _to,
uint256 amount,
uint256 utility
) external onlyOwner noZeroAddress(_to) {
}
function teenAirdrop(address _to, uint256 amount)
external
onlyOwner
noZeroAddress(_to)
{
}
function setGenesisContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setMethaneContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setUtilitiesContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTeenBullsContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTreasuryWallet(address _newTreasuryWallet)
external
onlyOwner
noZeroAddress(_newTreasuryWallet)
{
}
function setWhitelistedAddress(address _secret)
external
onlyOwner
noZeroAddress(_secret)
{
}
function setTimeCounter(uint256 _timeCounter) external onlyOwner {
}
function setPowerCooldown(uint256 _powerCooldown) external onlyOwner {
}
function setRefundFlag(bool _refundFlag) external onlyOwner {
}
function setClaimFlag(bool _claimFlag) external onlyOwner {
}
}
| isResurrected(teens[i]),"Not a resurrected teen" | 271,006 | isResurrected(teens[i]) |
"Signature is invalid" | // SPDX-License-Identifier: GPL-3.0
// solhint-disable-next-line
pragma solidity 0.8.12;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./reduced_interfaces/BAPGenesisInterface.sol";
import "./reduced_interfaces/BAPMethaneInterface.sol";
import "./reduced_interfaces/BAPUtilitiesInterface.sol";
import "./reduced_interfaces/BAPTeenBullsInterface.sol";
import "./reduced_interfaces/BAPOrchestratorInterfaceV2.sol";
import "./IERC721Receiver.sol";
contract BAPOrchestratorV3 is Ownable, IERC721Receiver {
string public constant project = "Bulls & Apes Project";
uint256 public constant startTime = 1665291600;
uint256 public timeCounter = 1 days;
uint256 public powerCooldown = 14 days;
uint256 private lastTokenReceived;
address public treasuryWallet;
address public secret;
bool public claimFlag = true;
bool public refundFlag = false;
bool private isReviving = false;
mapping(uint256 => uint256) public breedingsLeft;
mapping(uint256 => uint256) public claimedMeth;
mapping(uint256 => uint256) public claimedTeenMeth;
mapping(uint256 => uint256) public lastChestOpen;
mapping(uint256 => bool) public isGod;
mapping(uint256 => bool) public prevClaimed;
mapping(address => uint256) public userLastClaim;
BAPGenesisInterface public bapGenesis;
BAPMethaneInterface public bapMeth;
BAPUtilitiesInterface public bapUtilities;
BAPTeenBullsInterface public bapTeenBulls;
BAPOrchestratorInterfaceV2 public bapOrchestratorV2;
event CHEST_OPENED(
uint256 num,
uint256 godId,
uint256 prize,
uint256 timestamp
);
event METH_CLAIMED(address user, uint256 amount, uint256 timestamp);
event GOD_MINTED(address user, uint256 id, uint256 timestamp);
event TEEN_RESURRECTED(
address user,
uint256 sacrificed,
uint256 resurrected,
uint256 newlyMinted
);
constructor(
address _bapGenesis,
address _bapMethane,
address _bapUtilities,
address _bapTeenBulls,
address _orchestratorV2
) {
}
modifier noZeroAddress(address _address) {
}
// WRITE FUNCTIONS
function claimMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens
) public {
}
function generateTeenBull() public {
}
function generateGodBull(
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) public {
require(<FILL_ME>)
bapMeth.pay(4800, 2400);
bapUtilities.burn(2, 1);
_burnTeen(bull1);
_burnTeen(bull2);
_burnTeen(bull3);
_burnTeen(bull4);
uint256 id = bapGenesis.minted() + 1;
prevClaimed[id] = true;
claimedMeth[id] = getClaimableMeth(id, 1);
bapGenesis.generateGodBull();
emit GOD_MINTED(msg.sender, id, block.timestamp);
}
function buyIncubator(
bytes memory signature,
uint256 bull1,
uint256 bull2
) public {
}
function buyMergeOrb(uint256 teen) public {
}
function refund(uint256 tokenId) external noZeroAddress(treasuryWallet) {
}
// NEW FUNCTIONS
function openChest(
uint256 godId,
uint256 guild,
uint256 seed,
bool hasPower,
bytes memory signature
) external {
}
function useItem(
uint256 item,
uint256 tokenId,
uint256 godId,
uint256 resurrected,
bytes memory signature
) external {
}
function claimTeenMeth(
uint256 amount,
uint256 seed,
bytes memory signature
) public {
}
// BULK FUNCTIONS
function claimAllMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens,
uint256 amount,
uint256 seed,
bytes memory signature
) external {
}
function breedAndIncubate(
bytes memory signature,
uint256 bull1,
uint256 bull2
) external {
}
function buyOrbAndSummon(
uint256 teen,
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) external {
}
// INTERNAL FUNCTIONS
function _claimMeth(uint256 tokenId, uint256 _type)
internal
returns (uint256 amount)
{
}
function _breedToken(uint256 tokenId) internal {
}
function _burnTeen(uint256 tokenId) internal {
}
function random(uint256 seed) internal view returns (uint256) {
}
function _dailyRewards(uint256 _type) internal pure returns (uint256) {
}
function _refundPeriodAllowed() internal view returns (bool) {
}
function _verifyHashSignature(bytes32 freshHash, bytes memory signature)
internal
view
returns (bool)
{
}
// VIEW FUNCTIONS
function breedings(uint256 tokenId) public view returns (uint256) {
}
function getClaimableMeth(uint256 tokenId, uint256 _type)
public
view
returns (uint256)
{
}
function getOldClaimableMeth(uint256 tokenId, bool isGod)
public
view
returns (uint256 methAmount)
{
}
function godBulls(uint256 tokenId) public view returns (bool) {
}
function isResurrected(uint256 tokenId) public view returns (bool) {
}
function availableForRefund(uint256 tokenId) public view returns (bool) {
}
function onERC721Received(
address,
address,
uint256 tokenId,
bytes memory
) external virtual override returns (bytes4) {
}
// OWNER FUNCTIONS
function initializeGodBull(uint256[] memory gods, bool godFlag)
external
onlyOwner
{
}
function transferExternalOwnership(address _contract, address _newOwner)
external
onlyOwner
noZeroAddress(_newOwner)
{
}
function utilitiesAirdrop(
address _to,
uint256 amount,
uint256 utility
) external onlyOwner noZeroAddress(_to) {
}
function teenAirdrop(address _to, uint256 amount)
external
onlyOwner
noZeroAddress(_to)
{
}
function setGenesisContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setMethaneContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setUtilitiesContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTeenBullsContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTreasuryWallet(address _newTreasuryWallet)
external
onlyOwner
noZeroAddress(_newTreasuryWallet)
{
}
function setWhitelistedAddress(address _secret)
external
onlyOwner
noZeroAddress(_secret)
{
}
function setTimeCounter(uint256 _timeCounter) external onlyOwner {
}
function setPowerCooldown(uint256 _powerCooldown) external onlyOwner {
}
function setRefundFlag(bool _refundFlag) external onlyOwner {
}
function setClaimFlag(bool _claimFlag) external onlyOwner {
}
}
| _verifyHashSignature(keccak256(abi.encode(msg.sender,bull1,bull2,bull3,bull4)),signature),"Signature is invalid" | 271,006 | _verifyHashSignature(keccak256(abi.encode(msg.sender,bull1,bull2,bull3,bull4)),signature) |
"Signature is invalid" | // SPDX-License-Identifier: GPL-3.0
// solhint-disable-next-line
pragma solidity 0.8.12;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./reduced_interfaces/BAPGenesisInterface.sol";
import "./reduced_interfaces/BAPMethaneInterface.sol";
import "./reduced_interfaces/BAPUtilitiesInterface.sol";
import "./reduced_interfaces/BAPTeenBullsInterface.sol";
import "./reduced_interfaces/BAPOrchestratorInterfaceV2.sol";
import "./IERC721Receiver.sol";
contract BAPOrchestratorV3 is Ownable, IERC721Receiver {
string public constant project = "Bulls & Apes Project";
uint256 public constant startTime = 1665291600;
uint256 public timeCounter = 1 days;
uint256 public powerCooldown = 14 days;
uint256 private lastTokenReceived;
address public treasuryWallet;
address public secret;
bool public claimFlag = true;
bool public refundFlag = false;
bool private isReviving = false;
mapping(uint256 => uint256) public breedingsLeft;
mapping(uint256 => uint256) public claimedMeth;
mapping(uint256 => uint256) public claimedTeenMeth;
mapping(uint256 => uint256) public lastChestOpen;
mapping(uint256 => bool) public isGod;
mapping(uint256 => bool) public prevClaimed;
mapping(address => uint256) public userLastClaim;
BAPGenesisInterface public bapGenesis;
BAPMethaneInterface public bapMeth;
BAPUtilitiesInterface public bapUtilities;
BAPTeenBullsInterface public bapTeenBulls;
BAPOrchestratorInterfaceV2 public bapOrchestratorV2;
event CHEST_OPENED(
uint256 num,
uint256 godId,
uint256 prize,
uint256 timestamp
);
event METH_CLAIMED(address user, uint256 amount, uint256 timestamp);
event GOD_MINTED(address user, uint256 id, uint256 timestamp);
event TEEN_RESURRECTED(
address user,
uint256 sacrificed,
uint256 resurrected,
uint256 newlyMinted
);
constructor(
address _bapGenesis,
address _bapMethane,
address _bapUtilities,
address _bapTeenBulls,
address _orchestratorV2
) {
}
modifier noZeroAddress(address _address) {
}
// WRITE FUNCTIONS
function claimMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens
) public {
}
function generateTeenBull() public {
}
function generateGodBull(
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) public {
}
function buyIncubator(
bytes memory signature,
uint256 bull1,
uint256 bull2
) public {
require(<FILL_ME>)
bapMeth.pay(600, 300);
_breedToken(bull1);
_breedToken(bull2);
bapUtilities.purchaseIncubator();
}
function buyMergeOrb(uint256 teen) public {
}
function refund(uint256 tokenId) external noZeroAddress(treasuryWallet) {
}
// NEW FUNCTIONS
function openChest(
uint256 godId,
uint256 guild,
uint256 seed,
bool hasPower,
bytes memory signature
) external {
}
function useItem(
uint256 item,
uint256 tokenId,
uint256 godId,
uint256 resurrected,
bytes memory signature
) external {
}
function claimTeenMeth(
uint256 amount,
uint256 seed,
bytes memory signature
) public {
}
// BULK FUNCTIONS
function claimAllMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens,
uint256 amount,
uint256 seed,
bytes memory signature
) external {
}
function breedAndIncubate(
bytes memory signature,
uint256 bull1,
uint256 bull2
) external {
}
function buyOrbAndSummon(
uint256 teen,
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) external {
}
// INTERNAL FUNCTIONS
function _claimMeth(uint256 tokenId, uint256 _type)
internal
returns (uint256 amount)
{
}
function _breedToken(uint256 tokenId) internal {
}
function _burnTeen(uint256 tokenId) internal {
}
function random(uint256 seed) internal view returns (uint256) {
}
function _dailyRewards(uint256 _type) internal pure returns (uint256) {
}
function _refundPeriodAllowed() internal view returns (bool) {
}
function _verifyHashSignature(bytes32 freshHash, bytes memory signature)
internal
view
returns (bool)
{
}
// VIEW FUNCTIONS
function breedings(uint256 tokenId) public view returns (uint256) {
}
function getClaimableMeth(uint256 tokenId, uint256 _type)
public
view
returns (uint256)
{
}
function getOldClaimableMeth(uint256 tokenId, bool isGod)
public
view
returns (uint256 methAmount)
{
}
function godBulls(uint256 tokenId) public view returns (bool) {
}
function isResurrected(uint256 tokenId) public view returns (bool) {
}
function availableForRefund(uint256 tokenId) public view returns (bool) {
}
function onERC721Received(
address,
address,
uint256 tokenId,
bytes memory
) external virtual override returns (bytes4) {
}
// OWNER FUNCTIONS
function initializeGodBull(uint256[] memory gods, bool godFlag)
external
onlyOwner
{
}
function transferExternalOwnership(address _contract, address _newOwner)
external
onlyOwner
noZeroAddress(_newOwner)
{
}
function utilitiesAirdrop(
address _to,
uint256 amount,
uint256 utility
) external onlyOwner noZeroAddress(_to) {
}
function teenAirdrop(address _to, uint256 amount)
external
onlyOwner
noZeroAddress(_to)
{
}
function setGenesisContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setMethaneContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setUtilitiesContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTeenBullsContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTreasuryWallet(address _newTreasuryWallet)
external
onlyOwner
noZeroAddress(_newTreasuryWallet)
{
}
function setWhitelistedAddress(address _secret)
external
onlyOwner
noZeroAddress(_secret)
{
}
function setTimeCounter(uint256 _timeCounter) external onlyOwner {
}
function setPowerCooldown(uint256 _powerCooldown) external onlyOwner {
}
function setRefundFlag(bool _refundFlag) external onlyOwner {
}
function setClaimFlag(bool _claimFlag) external onlyOwner {
}
}
| _verifyHashSignature(keccak256(abi.encode(msg.sender,bull1,bull2)),signature),"Signature is invalid" | 271,006 | _verifyHashSignature(keccak256(abi.encode(msg.sender,bull1,bull2)),signature) |
"Token not available for refund" | // SPDX-License-Identifier: GPL-3.0
// solhint-disable-next-line
pragma solidity 0.8.12;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./reduced_interfaces/BAPGenesisInterface.sol";
import "./reduced_interfaces/BAPMethaneInterface.sol";
import "./reduced_interfaces/BAPUtilitiesInterface.sol";
import "./reduced_interfaces/BAPTeenBullsInterface.sol";
import "./reduced_interfaces/BAPOrchestratorInterfaceV2.sol";
import "./IERC721Receiver.sol";
contract BAPOrchestratorV3 is Ownable, IERC721Receiver {
string public constant project = "Bulls & Apes Project";
uint256 public constant startTime = 1665291600;
uint256 public timeCounter = 1 days;
uint256 public powerCooldown = 14 days;
uint256 private lastTokenReceived;
address public treasuryWallet;
address public secret;
bool public claimFlag = true;
bool public refundFlag = false;
bool private isReviving = false;
mapping(uint256 => uint256) public breedingsLeft;
mapping(uint256 => uint256) public claimedMeth;
mapping(uint256 => uint256) public claimedTeenMeth;
mapping(uint256 => uint256) public lastChestOpen;
mapping(uint256 => bool) public isGod;
mapping(uint256 => bool) public prevClaimed;
mapping(address => uint256) public userLastClaim;
BAPGenesisInterface public bapGenesis;
BAPMethaneInterface public bapMeth;
BAPUtilitiesInterface public bapUtilities;
BAPTeenBullsInterface public bapTeenBulls;
BAPOrchestratorInterfaceV2 public bapOrchestratorV2;
event CHEST_OPENED(
uint256 num,
uint256 godId,
uint256 prize,
uint256 timestamp
);
event METH_CLAIMED(address user, uint256 amount, uint256 timestamp);
event GOD_MINTED(address user, uint256 id, uint256 timestamp);
event TEEN_RESURRECTED(
address user,
uint256 sacrificed,
uint256 resurrected,
uint256 newlyMinted
);
constructor(
address _bapGenesis,
address _bapMethane,
address _bapUtilities,
address _bapTeenBulls,
address _orchestratorV2
) {
}
modifier noZeroAddress(address _address) {
}
// WRITE FUNCTIONS
function claimMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens
) public {
}
function generateTeenBull() public {
}
function generateGodBull(
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) public {
}
function buyIncubator(
bytes memory signature,
uint256 bull1,
uint256 bull2
) public {
}
function buyMergeOrb(uint256 teen) public {
}
function refund(uint256 tokenId) external noZeroAddress(treasuryWallet) {
require(<FILL_ME>)
bapGenesis.refund(msg.sender, tokenId);
bapGenesis.safeTransferFrom(msg.sender, treasuryWallet, tokenId);
}
// NEW FUNCTIONS
function openChest(
uint256 godId,
uint256 guild,
uint256 seed,
bool hasPower,
bytes memory signature
) external {
}
function useItem(
uint256 item,
uint256 tokenId,
uint256 godId,
uint256 resurrected,
bytes memory signature
) external {
}
function claimTeenMeth(
uint256 amount,
uint256 seed,
bytes memory signature
) public {
}
// BULK FUNCTIONS
function claimAllMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens,
uint256 amount,
uint256 seed,
bytes memory signature
) external {
}
function breedAndIncubate(
bytes memory signature,
uint256 bull1,
uint256 bull2
) external {
}
function buyOrbAndSummon(
uint256 teen,
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) external {
}
// INTERNAL FUNCTIONS
function _claimMeth(uint256 tokenId, uint256 _type)
internal
returns (uint256 amount)
{
}
function _breedToken(uint256 tokenId) internal {
}
function _burnTeen(uint256 tokenId) internal {
}
function random(uint256 seed) internal view returns (uint256) {
}
function _dailyRewards(uint256 _type) internal pure returns (uint256) {
}
function _refundPeriodAllowed() internal view returns (bool) {
}
function _verifyHashSignature(bytes32 freshHash, bytes memory signature)
internal
view
returns (bool)
{
}
// VIEW FUNCTIONS
function breedings(uint256 tokenId) public view returns (uint256) {
}
function getClaimableMeth(uint256 tokenId, uint256 _type)
public
view
returns (uint256)
{
}
function getOldClaimableMeth(uint256 tokenId, bool isGod)
public
view
returns (uint256 methAmount)
{
}
function godBulls(uint256 tokenId) public view returns (bool) {
}
function isResurrected(uint256 tokenId) public view returns (bool) {
}
function availableForRefund(uint256 tokenId) public view returns (bool) {
}
function onERC721Received(
address,
address,
uint256 tokenId,
bytes memory
) external virtual override returns (bytes4) {
}
// OWNER FUNCTIONS
function initializeGodBull(uint256[] memory gods, bool godFlag)
external
onlyOwner
{
}
function transferExternalOwnership(address _contract, address _newOwner)
external
onlyOwner
noZeroAddress(_newOwner)
{
}
function utilitiesAirdrop(
address _to,
uint256 amount,
uint256 utility
) external onlyOwner noZeroAddress(_to) {
}
function teenAirdrop(address _to, uint256 amount)
external
onlyOwner
noZeroAddress(_to)
{
}
function setGenesisContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setMethaneContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setUtilitiesContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTeenBullsContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTreasuryWallet(address _newTreasuryWallet)
external
onlyOwner
noZeroAddress(_newTreasuryWallet)
{
}
function setWhitelistedAddress(address _secret)
external
onlyOwner
noZeroAddress(_secret)
{
}
function setTimeCounter(uint256 _timeCounter) external onlyOwner {
}
function setPowerCooldown(uint256 _powerCooldown) external onlyOwner {
}
function setRefundFlag(bool _refundFlag) external onlyOwner {
}
function setClaimFlag(bool _claimFlag) external onlyOwner {
}
}
| availableForRefund(tokenId),"Token not available for refund" | 271,006 | availableForRefund(tokenId) |
"Signature is invalid" | // SPDX-License-Identifier: GPL-3.0
// solhint-disable-next-line
pragma solidity 0.8.12;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./reduced_interfaces/BAPGenesisInterface.sol";
import "./reduced_interfaces/BAPMethaneInterface.sol";
import "./reduced_interfaces/BAPUtilitiesInterface.sol";
import "./reduced_interfaces/BAPTeenBullsInterface.sol";
import "./reduced_interfaces/BAPOrchestratorInterfaceV2.sol";
import "./IERC721Receiver.sol";
contract BAPOrchestratorV3 is Ownable, IERC721Receiver {
string public constant project = "Bulls & Apes Project";
uint256 public constant startTime = 1665291600;
uint256 public timeCounter = 1 days;
uint256 public powerCooldown = 14 days;
uint256 private lastTokenReceived;
address public treasuryWallet;
address public secret;
bool public claimFlag = true;
bool public refundFlag = false;
bool private isReviving = false;
mapping(uint256 => uint256) public breedingsLeft;
mapping(uint256 => uint256) public claimedMeth;
mapping(uint256 => uint256) public claimedTeenMeth;
mapping(uint256 => uint256) public lastChestOpen;
mapping(uint256 => bool) public isGod;
mapping(uint256 => bool) public prevClaimed;
mapping(address => uint256) public userLastClaim;
BAPGenesisInterface public bapGenesis;
BAPMethaneInterface public bapMeth;
BAPUtilitiesInterface public bapUtilities;
BAPTeenBullsInterface public bapTeenBulls;
BAPOrchestratorInterfaceV2 public bapOrchestratorV2;
event CHEST_OPENED(
uint256 num,
uint256 godId,
uint256 prize,
uint256 timestamp
);
event METH_CLAIMED(address user, uint256 amount, uint256 timestamp);
event GOD_MINTED(address user, uint256 id, uint256 timestamp);
event TEEN_RESURRECTED(
address user,
uint256 sacrificed,
uint256 resurrected,
uint256 newlyMinted
);
constructor(
address _bapGenesis,
address _bapMethane,
address _bapUtilities,
address _bapTeenBulls,
address _orchestratorV2
) {
}
modifier noZeroAddress(address _address) {
}
// WRITE FUNCTIONS
function claimMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens
) public {
}
function generateTeenBull() public {
}
function generateGodBull(
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) public {
}
function buyIncubator(
bytes memory signature,
uint256 bull1,
uint256 bull2
) public {
}
function buyMergeOrb(uint256 teen) public {
}
function refund(uint256 tokenId) external noZeroAddress(treasuryWallet) {
}
// NEW FUNCTIONS
function openChest(
uint256 godId,
uint256 guild,
uint256 seed,
bool hasPower,
bytes memory signature
) external {
require(seed > block.timestamp, "Seed is no longer valid");
require(<FILL_ME>)
require(bapGenesis.ownerOf(godId) == msg.sender, "Not the god owner");
require(godBulls(godId), "Not a god bull");
if (
!hasPower || lastChestOpen[godId] + powerCooldown > block.timestamp
) {
require(
lastChestOpen[godId] + 20 minutes > block.timestamp,
"Re open time elapsed"
);
bapMeth.pay(1200, 1200);
lastChestOpen[godId] = block.timestamp - 21 minutes;
} else {
bapMeth.pay(600, 600);
lastChestOpen[godId] = block.timestamp;
}
uint256 num = random(seed) % 100;
uint256 prize;
if (num < 10) {
prize = 20 + guild;
bapUtilities.airdrop(msg.sender, 1, (prize)); // UTILITIE #20 - 23 METH MAKER - 10%
} else if (num < 40) {
prize = 30 + guild;
bapUtilities.airdrop(msg.sender, 1, (prize)); // UTILITIE #30 - 33 RESURRECTION - 30%
} else {
prize = 40 + guild;
bapUtilities.airdrop(msg.sender, 1, (prize)); // UTILITIE #40 - 43 BREED REPLENISH - 60%
}
emit CHEST_OPENED(num, godId, prize, block.timestamp);
}
function useItem(
uint256 item,
uint256 tokenId,
uint256 godId,
uint256 resurrected,
bytes memory signature
) external {
}
function claimTeenMeth(
uint256 amount,
uint256 seed,
bytes memory signature
) public {
}
// BULK FUNCTIONS
function claimAllMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens,
uint256 amount,
uint256 seed,
bytes memory signature
) external {
}
function breedAndIncubate(
bytes memory signature,
uint256 bull1,
uint256 bull2
) external {
}
function buyOrbAndSummon(
uint256 teen,
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) external {
}
// INTERNAL FUNCTIONS
function _claimMeth(uint256 tokenId, uint256 _type)
internal
returns (uint256 amount)
{
}
function _breedToken(uint256 tokenId) internal {
}
function _burnTeen(uint256 tokenId) internal {
}
function random(uint256 seed) internal view returns (uint256) {
}
function _dailyRewards(uint256 _type) internal pure returns (uint256) {
}
function _refundPeriodAllowed() internal view returns (bool) {
}
function _verifyHashSignature(bytes32 freshHash, bytes memory signature)
internal
view
returns (bool)
{
}
// VIEW FUNCTIONS
function breedings(uint256 tokenId) public view returns (uint256) {
}
function getClaimableMeth(uint256 tokenId, uint256 _type)
public
view
returns (uint256)
{
}
function getOldClaimableMeth(uint256 tokenId, bool isGod)
public
view
returns (uint256 methAmount)
{
}
function godBulls(uint256 tokenId) public view returns (bool) {
}
function isResurrected(uint256 tokenId) public view returns (bool) {
}
function availableForRefund(uint256 tokenId) public view returns (bool) {
}
function onERC721Received(
address,
address,
uint256 tokenId,
bytes memory
) external virtual override returns (bytes4) {
}
// OWNER FUNCTIONS
function initializeGodBull(uint256[] memory gods, bool godFlag)
external
onlyOwner
{
}
function transferExternalOwnership(address _contract, address _newOwner)
external
onlyOwner
noZeroAddress(_newOwner)
{
}
function utilitiesAirdrop(
address _to,
uint256 amount,
uint256 utility
) external onlyOwner noZeroAddress(_to) {
}
function teenAirdrop(address _to, uint256 amount)
external
onlyOwner
noZeroAddress(_to)
{
}
function setGenesisContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setMethaneContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setUtilitiesContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTeenBullsContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTreasuryWallet(address _newTreasuryWallet)
external
onlyOwner
noZeroAddress(_newTreasuryWallet)
{
}
function setWhitelistedAddress(address _secret)
external
onlyOwner
noZeroAddress(_secret)
{
}
function setTimeCounter(uint256 _timeCounter) external onlyOwner {
}
function setPowerCooldown(uint256 _powerCooldown) external onlyOwner {
}
function setRefundFlag(bool _refundFlag) external onlyOwner {
}
function setClaimFlag(bool _claimFlag) external onlyOwner {
}
}
| _verifyHashSignature(keccak256(abi.encode(msg.sender,godId,guild,seed,hasPower)),signature),"Signature is invalid" | 271,006 | _verifyHashSignature(keccak256(abi.encode(msg.sender,godId,guild,seed,hasPower)),signature) |
"Not the god owner" | // SPDX-License-Identifier: GPL-3.0
// solhint-disable-next-line
pragma solidity 0.8.12;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./reduced_interfaces/BAPGenesisInterface.sol";
import "./reduced_interfaces/BAPMethaneInterface.sol";
import "./reduced_interfaces/BAPUtilitiesInterface.sol";
import "./reduced_interfaces/BAPTeenBullsInterface.sol";
import "./reduced_interfaces/BAPOrchestratorInterfaceV2.sol";
import "./IERC721Receiver.sol";
contract BAPOrchestratorV3 is Ownable, IERC721Receiver {
string public constant project = "Bulls & Apes Project";
uint256 public constant startTime = 1665291600;
uint256 public timeCounter = 1 days;
uint256 public powerCooldown = 14 days;
uint256 private lastTokenReceived;
address public treasuryWallet;
address public secret;
bool public claimFlag = true;
bool public refundFlag = false;
bool private isReviving = false;
mapping(uint256 => uint256) public breedingsLeft;
mapping(uint256 => uint256) public claimedMeth;
mapping(uint256 => uint256) public claimedTeenMeth;
mapping(uint256 => uint256) public lastChestOpen;
mapping(uint256 => bool) public isGod;
mapping(uint256 => bool) public prevClaimed;
mapping(address => uint256) public userLastClaim;
BAPGenesisInterface public bapGenesis;
BAPMethaneInterface public bapMeth;
BAPUtilitiesInterface public bapUtilities;
BAPTeenBullsInterface public bapTeenBulls;
BAPOrchestratorInterfaceV2 public bapOrchestratorV2;
event CHEST_OPENED(
uint256 num,
uint256 godId,
uint256 prize,
uint256 timestamp
);
event METH_CLAIMED(address user, uint256 amount, uint256 timestamp);
event GOD_MINTED(address user, uint256 id, uint256 timestamp);
event TEEN_RESURRECTED(
address user,
uint256 sacrificed,
uint256 resurrected,
uint256 newlyMinted
);
constructor(
address _bapGenesis,
address _bapMethane,
address _bapUtilities,
address _bapTeenBulls,
address _orchestratorV2
) {
}
modifier noZeroAddress(address _address) {
}
// WRITE FUNCTIONS
function claimMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens
) public {
}
function generateTeenBull() public {
}
function generateGodBull(
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) public {
}
function buyIncubator(
bytes memory signature,
uint256 bull1,
uint256 bull2
) public {
}
function buyMergeOrb(uint256 teen) public {
}
function refund(uint256 tokenId) external noZeroAddress(treasuryWallet) {
}
// NEW FUNCTIONS
function openChest(
uint256 godId,
uint256 guild,
uint256 seed,
bool hasPower,
bytes memory signature
) external {
require(seed > block.timestamp, "Seed is no longer valid");
require(
_verifyHashSignature(
keccak256(abi.encode(msg.sender, godId, guild, seed, hasPower)),
signature
),
"Signature is invalid"
);
require(<FILL_ME>)
require(godBulls(godId), "Not a god bull");
if (
!hasPower || lastChestOpen[godId] + powerCooldown > block.timestamp
) {
require(
lastChestOpen[godId] + 20 minutes > block.timestamp,
"Re open time elapsed"
);
bapMeth.pay(1200, 1200);
lastChestOpen[godId] = block.timestamp - 21 minutes;
} else {
bapMeth.pay(600, 600);
lastChestOpen[godId] = block.timestamp;
}
uint256 num = random(seed) % 100;
uint256 prize;
if (num < 10) {
prize = 20 + guild;
bapUtilities.airdrop(msg.sender, 1, (prize)); // UTILITIE #20 - 23 METH MAKER - 10%
} else if (num < 40) {
prize = 30 + guild;
bapUtilities.airdrop(msg.sender, 1, (prize)); // UTILITIE #30 - 33 RESURRECTION - 30%
} else {
prize = 40 + guild;
bapUtilities.airdrop(msg.sender, 1, (prize)); // UTILITIE #40 - 43 BREED REPLENISH - 60%
}
emit CHEST_OPENED(num, godId, prize, block.timestamp);
}
function useItem(
uint256 item,
uint256 tokenId,
uint256 godId,
uint256 resurrected,
bytes memory signature
) external {
}
function claimTeenMeth(
uint256 amount,
uint256 seed,
bytes memory signature
) public {
}
// BULK FUNCTIONS
function claimAllMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens,
uint256 amount,
uint256 seed,
bytes memory signature
) external {
}
function breedAndIncubate(
bytes memory signature,
uint256 bull1,
uint256 bull2
) external {
}
function buyOrbAndSummon(
uint256 teen,
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) external {
}
// INTERNAL FUNCTIONS
function _claimMeth(uint256 tokenId, uint256 _type)
internal
returns (uint256 amount)
{
}
function _breedToken(uint256 tokenId) internal {
}
function _burnTeen(uint256 tokenId) internal {
}
function random(uint256 seed) internal view returns (uint256) {
}
function _dailyRewards(uint256 _type) internal pure returns (uint256) {
}
function _refundPeriodAllowed() internal view returns (bool) {
}
function _verifyHashSignature(bytes32 freshHash, bytes memory signature)
internal
view
returns (bool)
{
}
// VIEW FUNCTIONS
function breedings(uint256 tokenId) public view returns (uint256) {
}
function getClaimableMeth(uint256 tokenId, uint256 _type)
public
view
returns (uint256)
{
}
function getOldClaimableMeth(uint256 tokenId, bool isGod)
public
view
returns (uint256 methAmount)
{
}
function godBulls(uint256 tokenId) public view returns (bool) {
}
function isResurrected(uint256 tokenId) public view returns (bool) {
}
function availableForRefund(uint256 tokenId) public view returns (bool) {
}
function onERC721Received(
address,
address,
uint256 tokenId,
bytes memory
) external virtual override returns (bytes4) {
}
// OWNER FUNCTIONS
function initializeGodBull(uint256[] memory gods, bool godFlag)
external
onlyOwner
{
}
function transferExternalOwnership(address _contract, address _newOwner)
external
onlyOwner
noZeroAddress(_newOwner)
{
}
function utilitiesAirdrop(
address _to,
uint256 amount,
uint256 utility
) external onlyOwner noZeroAddress(_to) {
}
function teenAirdrop(address _to, uint256 amount)
external
onlyOwner
noZeroAddress(_to)
{
}
function setGenesisContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setMethaneContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setUtilitiesContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTeenBullsContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTreasuryWallet(address _newTreasuryWallet)
external
onlyOwner
noZeroAddress(_newTreasuryWallet)
{
}
function setWhitelistedAddress(address _secret)
external
onlyOwner
noZeroAddress(_secret)
{
}
function setTimeCounter(uint256 _timeCounter) external onlyOwner {
}
function setPowerCooldown(uint256 _powerCooldown) external onlyOwner {
}
function setRefundFlag(bool _refundFlag) external onlyOwner {
}
function setClaimFlag(bool _claimFlag) external onlyOwner {
}
}
| bapGenesis.ownerOf(godId)==msg.sender,"Not the god owner" | 271,006 | bapGenesis.ownerOf(godId)==msg.sender |
"Not a god bull" | // SPDX-License-Identifier: GPL-3.0
// solhint-disable-next-line
pragma solidity 0.8.12;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./reduced_interfaces/BAPGenesisInterface.sol";
import "./reduced_interfaces/BAPMethaneInterface.sol";
import "./reduced_interfaces/BAPUtilitiesInterface.sol";
import "./reduced_interfaces/BAPTeenBullsInterface.sol";
import "./reduced_interfaces/BAPOrchestratorInterfaceV2.sol";
import "./IERC721Receiver.sol";
contract BAPOrchestratorV3 is Ownable, IERC721Receiver {
string public constant project = "Bulls & Apes Project";
uint256 public constant startTime = 1665291600;
uint256 public timeCounter = 1 days;
uint256 public powerCooldown = 14 days;
uint256 private lastTokenReceived;
address public treasuryWallet;
address public secret;
bool public claimFlag = true;
bool public refundFlag = false;
bool private isReviving = false;
mapping(uint256 => uint256) public breedingsLeft;
mapping(uint256 => uint256) public claimedMeth;
mapping(uint256 => uint256) public claimedTeenMeth;
mapping(uint256 => uint256) public lastChestOpen;
mapping(uint256 => bool) public isGod;
mapping(uint256 => bool) public prevClaimed;
mapping(address => uint256) public userLastClaim;
BAPGenesisInterface public bapGenesis;
BAPMethaneInterface public bapMeth;
BAPUtilitiesInterface public bapUtilities;
BAPTeenBullsInterface public bapTeenBulls;
BAPOrchestratorInterfaceV2 public bapOrchestratorV2;
event CHEST_OPENED(
uint256 num,
uint256 godId,
uint256 prize,
uint256 timestamp
);
event METH_CLAIMED(address user, uint256 amount, uint256 timestamp);
event GOD_MINTED(address user, uint256 id, uint256 timestamp);
event TEEN_RESURRECTED(
address user,
uint256 sacrificed,
uint256 resurrected,
uint256 newlyMinted
);
constructor(
address _bapGenesis,
address _bapMethane,
address _bapUtilities,
address _bapTeenBulls,
address _orchestratorV2
) {
}
modifier noZeroAddress(address _address) {
}
// WRITE FUNCTIONS
function claimMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens
) public {
}
function generateTeenBull() public {
}
function generateGodBull(
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) public {
}
function buyIncubator(
bytes memory signature,
uint256 bull1,
uint256 bull2
) public {
}
function buyMergeOrb(uint256 teen) public {
}
function refund(uint256 tokenId) external noZeroAddress(treasuryWallet) {
}
// NEW FUNCTIONS
function openChest(
uint256 godId,
uint256 guild,
uint256 seed,
bool hasPower,
bytes memory signature
) external {
require(seed > block.timestamp, "Seed is no longer valid");
require(
_verifyHashSignature(
keccak256(abi.encode(msg.sender, godId, guild, seed, hasPower)),
signature
),
"Signature is invalid"
);
require(bapGenesis.ownerOf(godId) == msg.sender, "Not the god owner");
require(<FILL_ME>)
if (
!hasPower || lastChestOpen[godId] + powerCooldown > block.timestamp
) {
require(
lastChestOpen[godId] + 20 minutes > block.timestamp,
"Re open time elapsed"
);
bapMeth.pay(1200, 1200);
lastChestOpen[godId] = block.timestamp - 21 minutes;
} else {
bapMeth.pay(600, 600);
lastChestOpen[godId] = block.timestamp;
}
uint256 num = random(seed) % 100;
uint256 prize;
if (num < 10) {
prize = 20 + guild;
bapUtilities.airdrop(msg.sender, 1, (prize)); // UTILITIE #20 - 23 METH MAKER - 10%
} else if (num < 40) {
prize = 30 + guild;
bapUtilities.airdrop(msg.sender, 1, (prize)); // UTILITIE #30 - 33 RESURRECTION - 30%
} else {
prize = 40 + guild;
bapUtilities.airdrop(msg.sender, 1, (prize)); // UTILITIE #40 - 43 BREED REPLENISH - 60%
}
emit CHEST_OPENED(num, godId, prize, block.timestamp);
}
function useItem(
uint256 item,
uint256 tokenId,
uint256 godId,
uint256 resurrected,
bytes memory signature
) external {
}
function claimTeenMeth(
uint256 amount,
uint256 seed,
bytes memory signature
) public {
}
// BULK FUNCTIONS
function claimAllMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens,
uint256 amount,
uint256 seed,
bytes memory signature
) external {
}
function breedAndIncubate(
bytes memory signature,
uint256 bull1,
uint256 bull2
) external {
}
function buyOrbAndSummon(
uint256 teen,
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) external {
}
// INTERNAL FUNCTIONS
function _claimMeth(uint256 tokenId, uint256 _type)
internal
returns (uint256 amount)
{
}
function _breedToken(uint256 tokenId) internal {
}
function _burnTeen(uint256 tokenId) internal {
}
function random(uint256 seed) internal view returns (uint256) {
}
function _dailyRewards(uint256 _type) internal pure returns (uint256) {
}
function _refundPeriodAllowed() internal view returns (bool) {
}
function _verifyHashSignature(bytes32 freshHash, bytes memory signature)
internal
view
returns (bool)
{
}
// VIEW FUNCTIONS
function breedings(uint256 tokenId) public view returns (uint256) {
}
function getClaimableMeth(uint256 tokenId, uint256 _type)
public
view
returns (uint256)
{
}
function getOldClaimableMeth(uint256 tokenId, bool isGod)
public
view
returns (uint256 methAmount)
{
}
function godBulls(uint256 tokenId) public view returns (bool) {
}
function isResurrected(uint256 tokenId) public view returns (bool) {
}
function availableForRefund(uint256 tokenId) public view returns (bool) {
}
function onERC721Received(
address,
address,
uint256 tokenId,
bytes memory
) external virtual override returns (bytes4) {
}
// OWNER FUNCTIONS
function initializeGodBull(uint256[] memory gods, bool godFlag)
external
onlyOwner
{
}
function transferExternalOwnership(address _contract, address _newOwner)
external
onlyOwner
noZeroAddress(_newOwner)
{
}
function utilitiesAirdrop(
address _to,
uint256 amount,
uint256 utility
) external onlyOwner noZeroAddress(_to) {
}
function teenAirdrop(address _to, uint256 amount)
external
onlyOwner
noZeroAddress(_to)
{
}
function setGenesisContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setMethaneContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setUtilitiesContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTeenBullsContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTreasuryWallet(address _newTreasuryWallet)
external
onlyOwner
noZeroAddress(_newTreasuryWallet)
{
}
function setWhitelistedAddress(address _secret)
external
onlyOwner
noZeroAddress(_secret)
{
}
function setTimeCounter(uint256 _timeCounter) external onlyOwner {
}
function setPowerCooldown(uint256 _powerCooldown) external onlyOwner {
}
function setRefundFlag(bool _refundFlag) external onlyOwner {
}
function setClaimFlag(bool _claimFlag) external onlyOwner {
}
}
| godBulls(godId),"Not a god bull" | 271,006 | godBulls(godId) |
"Re open time elapsed" | // SPDX-License-Identifier: GPL-3.0
// solhint-disable-next-line
pragma solidity 0.8.12;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./reduced_interfaces/BAPGenesisInterface.sol";
import "./reduced_interfaces/BAPMethaneInterface.sol";
import "./reduced_interfaces/BAPUtilitiesInterface.sol";
import "./reduced_interfaces/BAPTeenBullsInterface.sol";
import "./reduced_interfaces/BAPOrchestratorInterfaceV2.sol";
import "./IERC721Receiver.sol";
contract BAPOrchestratorV3 is Ownable, IERC721Receiver {
string public constant project = "Bulls & Apes Project";
uint256 public constant startTime = 1665291600;
uint256 public timeCounter = 1 days;
uint256 public powerCooldown = 14 days;
uint256 private lastTokenReceived;
address public treasuryWallet;
address public secret;
bool public claimFlag = true;
bool public refundFlag = false;
bool private isReviving = false;
mapping(uint256 => uint256) public breedingsLeft;
mapping(uint256 => uint256) public claimedMeth;
mapping(uint256 => uint256) public claimedTeenMeth;
mapping(uint256 => uint256) public lastChestOpen;
mapping(uint256 => bool) public isGod;
mapping(uint256 => bool) public prevClaimed;
mapping(address => uint256) public userLastClaim;
BAPGenesisInterface public bapGenesis;
BAPMethaneInterface public bapMeth;
BAPUtilitiesInterface public bapUtilities;
BAPTeenBullsInterface public bapTeenBulls;
BAPOrchestratorInterfaceV2 public bapOrchestratorV2;
event CHEST_OPENED(
uint256 num,
uint256 godId,
uint256 prize,
uint256 timestamp
);
event METH_CLAIMED(address user, uint256 amount, uint256 timestamp);
event GOD_MINTED(address user, uint256 id, uint256 timestamp);
event TEEN_RESURRECTED(
address user,
uint256 sacrificed,
uint256 resurrected,
uint256 newlyMinted
);
constructor(
address _bapGenesis,
address _bapMethane,
address _bapUtilities,
address _bapTeenBulls,
address _orchestratorV2
) {
}
modifier noZeroAddress(address _address) {
}
// WRITE FUNCTIONS
function claimMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens
) public {
}
function generateTeenBull() public {
}
function generateGodBull(
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) public {
}
function buyIncubator(
bytes memory signature,
uint256 bull1,
uint256 bull2
) public {
}
function buyMergeOrb(uint256 teen) public {
}
function refund(uint256 tokenId) external noZeroAddress(treasuryWallet) {
}
// NEW FUNCTIONS
function openChest(
uint256 godId,
uint256 guild,
uint256 seed,
bool hasPower,
bytes memory signature
) external {
require(seed > block.timestamp, "Seed is no longer valid");
require(
_verifyHashSignature(
keccak256(abi.encode(msg.sender, godId, guild, seed, hasPower)),
signature
),
"Signature is invalid"
);
require(bapGenesis.ownerOf(godId) == msg.sender, "Not the god owner");
require(godBulls(godId), "Not a god bull");
if (
!hasPower || lastChestOpen[godId] + powerCooldown > block.timestamp
) {
require(<FILL_ME>)
bapMeth.pay(1200, 1200);
lastChestOpen[godId] = block.timestamp - 21 minutes;
} else {
bapMeth.pay(600, 600);
lastChestOpen[godId] = block.timestamp;
}
uint256 num = random(seed) % 100;
uint256 prize;
if (num < 10) {
prize = 20 + guild;
bapUtilities.airdrop(msg.sender, 1, (prize)); // UTILITIE #20 - 23 METH MAKER - 10%
} else if (num < 40) {
prize = 30 + guild;
bapUtilities.airdrop(msg.sender, 1, (prize)); // UTILITIE #30 - 33 RESURRECTION - 30%
} else {
prize = 40 + guild;
bapUtilities.airdrop(msg.sender, 1, (prize)); // UTILITIE #40 - 43 BREED REPLENISH - 60%
}
emit CHEST_OPENED(num, godId, prize, block.timestamp);
}
function useItem(
uint256 item,
uint256 tokenId,
uint256 godId,
uint256 resurrected,
bytes memory signature
) external {
}
function claimTeenMeth(
uint256 amount,
uint256 seed,
bytes memory signature
) public {
}
// BULK FUNCTIONS
function claimAllMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens,
uint256 amount,
uint256 seed,
bytes memory signature
) external {
}
function breedAndIncubate(
bytes memory signature,
uint256 bull1,
uint256 bull2
) external {
}
function buyOrbAndSummon(
uint256 teen,
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) external {
}
// INTERNAL FUNCTIONS
function _claimMeth(uint256 tokenId, uint256 _type)
internal
returns (uint256 amount)
{
}
function _breedToken(uint256 tokenId) internal {
}
function _burnTeen(uint256 tokenId) internal {
}
function random(uint256 seed) internal view returns (uint256) {
}
function _dailyRewards(uint256 _type) internal pure returns (uint256) {
}
function _refundPeriodAllowed() internal view returns (bool) {
}
function _verifyHashSignature(bytes32 freshHash, bytes memory signature)
internal
view
returns (bool)
{
}
// VIEW FUNCTIONS
function breedings(uint256 tokenId) public view returns (uint256) {
}
function getClaimableMeth(uint256 tokenId, uint256 _type)
public
view
returns (uint256)
{
}
function getOldClaimableMeth(uint256 tokenId, bool isGod)
public
view
returns (uint256 methAmount)
{
}
function godBulls(uint256 tokenId) public view returns (bool) {
}
function isResurrected(uint256 tokenId) public view returns (bool) {
}
function availableForRefund(uint256 tokenId) public view returns (bool) {
}
function onERC721Received(
address,
address,
uint256 tokenId,
bytes memory
) external virtual override returns (bytes4) {
}
// OWNER FUNCTIONS
function initializeGodBull(uint256[] memory gods, bool godFlag)
external
onlyOwner
{
}
function transferExternalOwnership(address _contract, address _newOwner)
external
onlyOwner
noZeroAddress(_newOwner)
{
}
function utilitiesAirdrop(
address _to,
uint256 amount,
uint256 utility
) external onlyOwner noZeroAddress(_to) {
}
function teenAirdrop(address _to, uint256 amount)
external
onlyOwner
noZeroAddress(_to)
{
}
function setGenesisContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setMethaneContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setUtilitiesContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTeenBullsContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTreasuryWallet(address _newTreasuryWallet)
external
onlyOwner
noZeroAddress(_newTreasuryWallet)
{
}
function setWhitelistedAddress(address _secret)
external
onlyOwner
noZeroAddress(_secret)
{
}
function setTimeCounter(uint256 _timeCounter) external onlyOwner {
}
function setPowerCooldown(uint256 _powerCooldown) external onlyOwner {
}
function setRefundFlag(bool _refundFlag) external onlyOwner {
}
function setClaimFlag(bool _claimFlag) external onlyOwner {
}
}
| lastChestOpen[godId]+20minutes>block.timestamp,"Re open time elapsed" | 271,006 | lastChestOpen[godId]+20minutes>block.timestamp |
"Signature is invalid" | // SPDX-License-Identifier: GPL-3.0
// solhint-disable-next-line
pragma solidity 0.8.12;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./reduced_interfaces/BAPGenesisInterface.sol";
import "./reduced_interfaces/BAPMethaneInterface.sol";
import "./reduced_interfaces/BAPUtilitiesInterface.sol";
import "./reduced_interfaces/BAPTeenBullsInterface.sol";
import "./reduced_interfaces/BAPOrchestratorInterfaceV2.sol";
import "./IERC721Receiver.sol";
contract BAPOrchestratorV3 is Ownable, IERC721Receiver {
string public constant project = "Bulls & Apes Project";
uint256 public constant startTime = 1665291600;
uint256 public timeCounter = 1 days;
uint256 public powerCooldown = 14 days;
uint256 private lastTokenReceived;
address public treasuryWallet;
address public secret;
bool public claimFlag = true;
bool public refundFlag = false;
bool private isReviving = false;
mapping(uint256 => uint256) public breedingsLeft;
mapping(uint256 => uint256) public claimedMeth;
mapping(uint256 => uint256) public claimedTeenMeth;
mapping(uint256 => uint256) public lastChestOpen;
mapping(uint256 => bool) public isGod;
mapping(uint256 => bool) public prevClaimed;
mapping(address => uint256) public userLastClaim;
BAPGenesisInterface public bapGenesis;
BAPMethaneInterface public bapMeth;
BAPUtilitiesInterface public bapUtilities;
BAPTeenBullsInterface public bapTeenBulls;
BAPOrchestratorInterfaceV2 public bapOrchestratorV2;
event CHEST_OPENED(
uint256 num,
uint256 godId,
uint256 prize,
uint256 timestamp
);
event METH_CLAIMED(address user, uint256 amount, uint256 timestamp);
event GOD_MINTED(address user, uint256 id, uint256 timestamp);
event TEEN_RESURRECTED(
address user,
uint256 sacrificed,
uint256 resurrected,
uint256 newlyMinted
);
constructor(
address _bapGenesis,
address _bapMethane,
address _bapUtilities,
address _bapTeenBulls,
address _orchestratorV2
) {
}
modifier noZeroAddress(address _address) {
}
// WRITE FUNCTIONS
function claimMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens
) public {
}
function generateTeenBull() public {
}
function generateGodBull(
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) public {
}
function buyIncubator(
bytes memory signature,
uint256 bull1,
uint256 bull2
) public {
}
function buyMergeOrb(uint256 teen) public {
}
function refund(uint256 tokenId) external noZeroAddress(treasuryWallet) {
}
// NEW FUNCTIONS
function openChest(
uint256 godId,
uint256 guild,
uint256 seed,
bool hasPower,
bytes memory signature
) external {
}
function useItem(
uint256 item,
uint256 tokenId,
uint256 godId,
uint256 resurrected,
bytes memory signature
) external {
require(<FILL_ME>)
bapUtilities.burn(item, 1); // #30 - 33 RESURRECTION, #40 - 43 BREED REPLENISH
if (item >= 30 && item < 35) {
require(godBulls(godId), "You need to use a good");
require(
bapGenesis.ownerOf(godId) == msg.sender,
"Not the god owner"
);
_burnTeen(tokenId);
isReviving = true;
bapTeenBulls.airdrop(address(this), 1);
claimedTeenMeth[lastTokenReceived] = getClaimableMeth(
lastTokenReceived,
2
);
isReviving = false;
bapTeenBulls.safeTransferFrom(
address(this),
msg.sender,
lastTokenReceived
);
emit TEEN_RESURRECTED(
msg.sender,
tokenId,
resurrected,
lastTokenReceived
);
lastTokenReceived = 0;
} else if (item >= 40 && item < 45) {
require(
bapGenesis.ownerOf(tokenId) == msg.sender,
"Only the owner can replenish"
);
require(
!godBulls(tokenId),
"God bulls cannot claim extra breeding"
);
uint256 currentBreeds = breedings(tokenId);
require(currentBreeds < 3, "Bull has all breeds available");
breedingsLeft[tokenId] = 3 - currentBreeds;
} else {
require(false, "Wrong item id");
}
}
function claimTeenMeth(
uint256 amount,
uint256 seed,
bytes memory signature
) public {
}
// BULK FUNCTIONS
function claimAllMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens,
uint256 amount,
uint256 seed,
bytes memory signature
) external {
}
function breedAndIncubate(
bytes memory signature,
uint256 bull1,
uint256 bull2
) external {
}
function buyOrbAndSummon(
uint256 teen,
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) external {
}
// INTERNAL FUNCTIONS
function _claimMeth(uint256 tokenId, uint256 _type)
internal
returns (uint256 amount)
{
}
function _breedToken(uint256 tokenId) internal {
}
function _burnTeen(uint256 tokenId) internal {
}
function random(uint256 seed) internal view returns (uint256) {
}
function _dailyRewards(uint256 _type) internal pure returns (uint256) {
}
function _refundPeriodAllowed() internal view returns (bool) {
}
function _verifyHashSignature(bytes32 freshHash, bytes memory signature)
internal
view
returns (bool)
{
}
// VIEW FUNCTIONS
function breedings(uint256 tokenId) public view returns (uint256) {
}
function getClaimableMeth(uint256 tokenId, uint256 _type)
public
view
returns (uint256)
{
}
function getOldClaimableMeth(uint256 tokenId, bool isGod)
public
view
returns (uint256 methAmount)
{
}
function godBulls(uint256 tokenId) public view returns (bool) {
}
function isResurrected(uint256 tokenId) public view returns (bool) {
}
function availableForRefund(uint256 tokenId) public view returns (bool) {
}
function onERC721Received(
address,
address,
uint256 tokenId,
bytes memory
) external virtual override returns (bytes4) {
}
// OWNER FUNCTIONS
function initializeGodBull(uint256[] memory gods, bool godFlag)
external
onlyOwner
{
}
function transferExternalOwnership(address _contract, address _newOwner)
external
onlyOwner
noZeroAddress(_newOwner)
{
}
function utilitiesAirdrop(
address _to,
uint256 amount,
uint256 utility
) external onlyOwner noZeroAddress(_to) {
}
function teenAirdrop(address _to, uint256 amount)
external
onlyOwner
noZeroAddress(_to)
{
}
function setGenesisContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setMethaneContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setUtilitiesContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTeenBullsContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTreasuryWallet(address _newTreasuryWallet)
external
onlyOwner
noZeroAddress(_newTreasuryWallet)
{
}
function setWhitelistedAddress(address _secret)
external
onlyOwner
noZeroAddress(_secret)
{
}
function setTimeCounter(uint256 _timeCounter) external onlyOwner {
}
function setPowerCooldown(uint256 _powerCooldown) external onlyOwner {
}
function setRefundFlag(bool _refundFlag) external onlyOwner {
}
function setClaimFlag(bool _claimFlag) external onlyOwner {
}
}
| _verifyHashSignature(keccak256(abi.encode(msg.sender,item,tokenId,godId,resurrected)),signature),"Signature is invalid" | 271,006 | _verifyHashSignature(keccak256(abi.encode(msg.sender,item,tokenId,godId,resurrected)),signature) |
"Only the owner can replenish" | // SPDX-License-Identifier: GPL-3.0
// solhint-disable-next-line
pragma solidity 0.8.12;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./reduced_interfaces/BAPGenesisInterface.sol";
import "./reduced_interfaces/BAPMethaneInterface.sol";
import "./reduced_interfaces/BAPUtilitiesInterface.sol";
import "./reduced_interfaces/BAPTeenBullsInterface.sol";
import "./reduced_interfaces/BAPOrchestratorInterfaceV2.sol";
import "./IERC721Receiver.sol";
contract BAPOrchestratorV3 is Ownable, IERC721Receiver {
string public constant project = "Bulls & Apes Project";
uint256 public constant startTime = 1665291600;
uint256 public timeCounter = 1 days;
uint256 public powerCooldown = 14 days;
uint256 private lastTokenReceived;
address public treasuryWallet;
address public secret;
bool public claimFlag = true;
bool public refundFlag = false;
bool private isReviving = false;
mapping(uint256 => uint256) public breedingsLeft;
mapping(uint256 => uint256) public claimedMeth;
mapping(uint256 => uint256) public claimedTeenMeth;
mapping(uint256 => uint256) public lastChestOpen;
mapping(uint256 => bool) public isGod;
mapping(uint256 => bool) public prevClaimed;
mapping(address => uint256) public userLastClaim;
BAPGenesisInterface public bapGenesis;
BAPMethaneInterface public bapMeth;
BAPUtilitiesInterface public bapUtilities;
BAPTeenBullsInterface public bapTeenBulls;
BAPOrchestratorInterfaceV2 public bapOrchestratorV2;
event CHEST_OPENED(
uint256 num,
uint256 godId,
uint256 prize,
uint256 timestamp
);
event METH_CLAIMED(address user, uint256 amount, uint256 timestamp);
event GOD_MINTED(address user, uint256 id, uint256 timestamp);
event TEEN_RESURRECTED(
address user,
uint256 sacrificed,
uint256 resurrected,
uint256 newlyMinted
);
constructor(
address _bapGenesis,
address _bapMethane,
address _bapUtilities,
address _bapTeenBulls,
address _orchestratorV2
) {
}
modifier noZeroAddress(address _address) {
}
// WRITE FUNCTIONS
function claimMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens
) public {
}
function generateTeenBull() public {
}
function generateGodBull(
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) public {
}
function buyIncubator(
bytes memory signature,
uint256 bull1,
uint256 bull2
) public {
}
function buyMergeOrb(uint256 teen) public {
}
function refund(uint256 tokenId) external noZeroAddress(treasuryWallet) {
}
// NEW FUNCTIONS
function openChest(
uint256 godId,
uint256 guild,
uint256 seed,
bool hasPower,
bytes memory signature
) external {
}
function useItem(
uint256 item,
uint256 tokenId,
uint256 godId,
uint256 resurrected,
bytes memory signature
) external {
require(
_verifyHashSignature(
keccak256(
abi.encode(msg.sender, item, tokenId, godId, resurrected)
),
signature
),
"Signature is invalid"
);
bapUtilities.burn(item, 1); // #30 - 33 RESURRECTION, #40 - 43 BREED REPLENISH
if (item >= 30 && item < 35) {
require(godBulls(godId), "You need to use a good");
require(
bapGenesis.ownerOf(godId) == msg.sender,
"Not the god owner"
);
_burnTeen(tokenId);
isReviving = true;
bapTeenBulls.airdrop(address(this), 1);
claimedTeenMeth[lastTokenReceived] = getClaimableMeth(
lastTokenReceived,
2
);
isReviving = false;
bapTeenBulls.safeTransferFrom(
address(this),
msg.sender,
lastTokenReceived
);
emit TEEN_RESURRECTED(
msg.sender,
tokenId,
resurrected,
lastTokenReceived
);
lastTokenReceived = 0;
} else if (item >= 40 && item < 45) {
require(<FILL_ME>)
require(
!godBulls(tokenId),
"God bulls cannot claim extra breeding"
);
uint256 currentBreeds = breedings(tokenId);
require(currentBreeds < 3, "Bull has all breeds available");
breedingsLeft[tokenId] = 3 - currentBreeds;
} else {
require(false, "Wrong item id");
}
}
function claimTeenMeth(
uint256 amount,
uint256 seed,
bytes memory signature
) public {
}
// BULK FUNCTIONS
function claimAllMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens,
uint256 amount,
uint256 seed,
bytes memory signature
) external {
}
function breedAndIncubate(
bytes memory signature,
uint256 bull1,
uint256 bull2
) external {
}
function buyOrbAndSummon(
uint256 teen,
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) external {
}
// INTERNAL FUNCTIONS
function _claimMeth(uint256 tokenId, uint256 _type)
internal
returns (uint256 amount)
{
}
function _breedToken(uint256 tokenId) internal {
}
function _burnTeen(uint256 tokenId) internal {
}
function random(uint256 seed) internal view returns (uint256) {
}
function _dailyRewards(uint256 _type) internal pure returns (uint256) {
}
function _refundPeriodAllowed() internal view returns (bool) {
}
function _verifyHashSignature(bytes32 freshHash, bytes memory signature)
internal
view
returns (bool)
{
}
// VIEW FUNCTIONS
function breedings(uint256 tokenId) public view returns (uint256) {
}
function getClaimableMeth(uint256 tokenId, uint256 _type)
public
view
returns (uint256)
{
}
function getOldClaimableMeth(uint256 tokenId, bool isGod)
public
view
returns (uint256 methAmount)
{
}
function godBulls(uint256 tokenId) public view returns (bool) {
}
function isResurrected(uint256 tokenId) public view returns (bool) {
}
function availableForRefund(uint256 tokenId) public view returns (bool) {
}
function onERC721Received(
address,
address,
uint256 tokenId,
bytes memory
) external virtual override returns (bytes4) {
}
// OWNER FUNCTIONS
function initializeGodBull(uint256[] memory gods, bool godFlag)
external
onlyOwner
{
}
function transferExternalOwnership(address _contract, address _newOwner)
external
onlyOwner
noZeroAddress(_newOwner)
{
}
function utilitiesAirdrop(
address _to,
uint256 amount,
uint256 utility
) external onlyOwner noZeroAddress(_to) {
}
function teenAirdrop(address _to, uint256 amount)
external
onlyOwner
noZeroAddress(_to)
{
}
function setGenesisContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setMethaneContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setUtilitiesContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTeenBullsContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTreasuryWallet(address _newTreasuryWallet)
external
onlyOwner
noZeroAddress(_newTreasuryWallet)
{
}
function setWhitelistedAddress(address _secret)
external
onlyOwner
noZeroAddress(_secret)
{
}
function setTimeCounter(uint256 _timeCounter) external onlyOwner {
}
function setPowerCooldown(uint256 _powerCooldown) external onlyOwner {
}
function setRefundFlag(bool _refundFlag) external onlyOwner {
}
function setClaimFlag(bool _claimFlag) external onlyOwner {
}
}
| bapGenesis.ownerOf(tokenId)==msg.sender,"Only the owner can replenish" | 271,006 | bapGenesis.ownerOf(tokenId)==msg.sender |
"God bulls cannot claim extra breeding" | // SPDX-License-Identifier: GPL-3.0
// solhint-disable-next-line
pragma solidity 0.8.12;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./reduced_interfaces/BAPGenesisInterface.sol";
import "./reduced_interfaces/BAPMethaneInterface.sol";
import "./reduced_interfaces/BAPUtilitiesInterface.sol";
import "./reduced_interfaces/BAPTeenBullsInterface.sol";
import "./reduced_interfaces/BAPOrchestratorInterfaceV2.sol";
import "./IERC721Receiver.sol";
contract BAPOrchestratorV3 is Ownable, IERC721Receiver {
string public constant project = "Bulls & Apes Project";
uint256 public constant startTime = 1665291600;
uint256 public timeCounter = 1 days;
uint256 public powerCooldown = 14 days;
uint256 private lastTokenReceived;
address public treasuryWallet;
address public secret;
bool public claimFlag = true;
bool public refundFlag = false;
bool private isReviving = false;
mapping(uint256 => uint256) public breedingsLeft;
mapping(uint256 => uint256) public claimedMeth;
mapping(uint256 => uint256) public claimedTeenMeth;
mapping(uint256 => uint256) public lastChestOpen;
mapping(uint256 => bool) public isGod;
mapping(uint256 => bool) public prevClaimed;
mapping(address => uint256) public userLastClaim;
BAPGenesisInterface public bapGenesis;
BAPMethaneInterface public bapMeth;
BAPUtilitiesInterface public bapUtilities;
BAPTeenBullsInterface public bapTeenBulls;
BAPOrchestratorInterfaceV2 public bapOrchestratorV2;
event CHEST_OPENED(
uint256 num,
uint256 godId,
uint256 prize,
uint256 timestamp
);
event METH_CLAIMED(address user, uint256 amount, uint256 timestamp);
event GOD_MINTED(address user, uint256 id, uint256 timestamp);
event TEEN_RESURRECTED(
address user,
uint256 sacrificed,
uint256 resurrected,
uint256 newlyMinted
);
constructor(
address _bapGenesis,
address _bapMethane,
address _bapUtilities,
address _bapTeenBulls,
address _orchestratorV2
) {
}
modifier noZeroAddress(address _address) {
}
// WRITE FUNCTIONS
function claimMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens
) public {
}
function generateTeenBull() public {
}
function generateGodBull(
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) public {
}
function buyIncubator(
bytes memory signature,
uint256 bull1,
uint256 bull2
) public {
}
function buyMergeOrb(uint256 teen) public {
}
function refund(uint256 tokenId) external noZeroAddress(treasuryWallet) {
}
// NEW FUNCTIONS
function openChest(
uint256 godId,
uint256 guild,
uint256 seed,
bool hasPower,
bytes memory signature
) external {
}
function useItem(
uint256 item,
uint256 tokenId,
uint256 godId,
uint256 resurrected,
bytes memory signature
) external {
require(
_verifyHashSignature(
keccak256(
abi.encode(msg.sender, item, tokenId, godId, resurrected)
),
signature
),
"Signature is invalid"
);
bapUtilities.burn(item, 1); // #30 - 33 RESURRECTION, #40 - 43 BREED REPLENISH
if (item >= 30 && item < 35) {
require(godBulls(godId), "You need to use a good");
require(
bapGenesis.ownerOf(godId) == msg.sender,
"Not the god owner"
);
_burnTeen(tokenId);
isReviving = true;
bapTeenBulls.airdrop(address(this), 1);
claimedTeenMeth[lastTokenReceived] = getClaimableMeth(
lastTokenReceived,
2
);
isReviving = false;
bapTeenBulls.safeTransferFrom(
address(this),
msg.sender,
lastTokenReceived
);
emit TEEN_RESURRECTED(
msg.sender,
tokenId,
resurrected,
lastTokenReceived
);
lastTokenReceived = 0;
} else if (item >= 40 && item < 45) {
require(
bapGenesis.ownerOf(tokenId) == msg.sender,
"Only the owner can replenish"
);
require(<FILL_ME>)
uint256 currentBreeds = breedings(tokenId);
require(currentBreeds < 3, "Bull has all breeds available");
breedingsLeft[tokenId] = 3 - currentBreeds;
} else {
require(false, "Wrong item id");
}
}
function claimTeenMeth(
uint256 amount,
uint256 seed,
bytes memory signature
) public {
}
// BULK FUNCTIONS
function claimAllMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens,
uint256 amount,
uint256 seed,
bytes memory signature
) external {
}
function breedAndIncubate(
bytes memory signature,
uint256 bull1,
uint256 bull2
) external {
}
function buyOrbAndSummon(
uint256 teen,
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) external {
}
// INTERNAL FUNCTIONS
function _claimMeth(uint256 tokenId, uint256 _type)
internal
returns (uint256 amount)
{
}
function _breedToken(uint256 tokenId) internal {
}
function _burnTeen(uint256 tokenId) internal {
}
function random(uint256 seed) internal view returns (uint256) {
}
function _dailyRewards(uint256 _type) internal pure returns (uint256) {
}
function _refundPeriodAllowed() internal view returns (bool) {
}
function _verifyHashSignature(bytes32 freshHash, bytes memory signature)
internal
view
returns (bool)
{
}
// VIEW FUNCTIONS
function breedings(uint256 tokenId) public view returns (uint256) {
}
function getClaimableMeth(uint256 tokenId, uint256 _type)
public
view
returns (uint256)
{
}
function getOldClaimableMeth(uint256 tokenId, bool isGod)
public
view
returns (uint256 methAmount)
{
}
function godBulls(uint256 tokenId) public view returns (bool) {
}
function isResurrected(uint256 tokenId) public view returns (bool) {
}
function availableForRefund(uint256 tokenId) public view returns (bool) {
}
function onERC721Received(
address,
address,
uint256 tokenId,
bytes memory
) external virtual override returns (bytes4) {
}
// OWNER FUNCTIONS
function initializeGodBull(uint256[] memory gods, bool godFlag)
external
onlyOwner
{
}
function transferExternalOwnership(address _contract, address _newOwner)
external
onlyOwner
noZeroAddress(_newOwner)
{
}
function utilitiesAirdrop(
address _to,
uint256 amount,
uint256 utility
) external onlyOwner noZeroAddress(_to) {
}
function teenAirdrop(address _to, uint256 amount)
external
onlyOwner
noZeroAddress(_to)
{
}
function setGenesisContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setMethaneContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setUtilitiesContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTeenBullsContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTreasuryWallet(address _newTreasuryWallet)
external
onlyOwner
noZeroAddress(_newTreasuryWallet)
{
}
function setWhitelistedAddress(address _secret)
external
onlyOwner
noZeroAddress(_secret)
{
}
function setTimeCounter(uint256 _timeCounter) external onlyOwner {
}
function setPowerCooldown(uint256 _powerCooldown) external onlyOwner {
}
function setRefundFlag(bool _refundFlag) external onlyOwner {
}
function setClaimFlag(bool _claimFlag) external onlyOwner {
}
}
| !godBulls(tokenId),"God bulls cannot claim extra breeding" | 271,006 | !godBulls(tokenId) |
"Can claim only once a day" | // SPDX-License-Identifier: GPL-3.0
// solhint-disable-next-line
pragma solidity 0.8.12;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./reduced_interfaces/BAPGenesisInterface.sol";
import "./reduced_interfaces/BAPMethaneInterface.sol";
import "./reduced_interfaces/BAPUtilitiesInterface.sol";
import "./reduced_interfaces/BAPTeenBullsInterface.sol";
import "./reduced_interfaces/BAPOrchestratorInterfaceV2.sol";
import "./IERC721Receiver.sol";
contract BAPOrchestratorV3 is Ownable, IERC721Receiver {
string public constant project = "Bulls & Apes Project";
uint256 public constant startTime = 1665291600;
uint256 public timeCounter = 1 days;
uint256 public powerCooldown = 14 days;
uint256 private lastTokenReceived;
address public treasuryWallet;
address public secret;
bool public claimFlag = true;
bool public refundFlag = false;
bool private isReviving = false;
mapping(uint256 => uint256) public breedingsLeft;
mapping(uint256 => uint256) public claimedMeth;
mapping(uint256 => uint256) public claimedTeenMeth;
mapping(uint256 => uint256) public lastChestOpen;
mapping(uint256 => bool) public isGod;
mapping(uint256 => bool) public prevClaimed;
mapping(address => uint256) public userLastClaim;
BAPGenesisInterface public bapGenesis;
BAPMethaneInterface public bapMeth;
BAPUtilitiesInterface public bapUtilities;
BAPTeenBullsInterface public bapTeenBulls;
BAPOrchestratorInterfaceV2 public bapOrchestratorV2;
event CHEST_OPENED(
uint256 num,
uint256 godId,
uint256 prize,
uint256 timestamp
);
event METH_CLAIMED(address user, uint256 amount, uint256 timestamp);
event GOD_MINTED(address user, uint256 id, uint256 timestamp);
event TEEN_RESURRECTED(
address user,
uint256 sacrificed,
uint256 resurrected,
uint256 newlyMinted
);
constructor(
address _bapGenesis,
address _bapMethane,
address _bapUtilities,
address _bapTeenBulls,
address _orchestratorV2
) {
}
modifier noZeroAddress(address _address) {
}
// WRITE FUNCTIONS
function claimMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens
) public {
}
function generateTeenBull() public {
}
function generateGodBull(
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) public {
}
function buyIncubator(
bytes memory signature,
uint256 bull1,
uint256 bull2
) public {
}
function buyMergeOrb(uint256 teen) public {
}
function refund(uint256 tokenId) external noZeroAddress(treasuryWallet) {
}
// NEW FUNCTIONS
function openChest(
uint256 godId,
uint256 guild,
uint256 seed,
bool hasPower,
bytes memory signature
) external {
}
function useItem(
uint256 item,
uint256 tokenId,
uint256 godId,
uint256 resurrected,
bytes memory signature
) external {
}
function claimTeenMeth(
uint256 amount,
uint256 seed,
bytes memory signature
) public {
require(seed > block.timestamp, "Seed is no longer valid");
require(<FILL_ME>)
require(
_verifyHashSignature(
keccak256(abi.encode(amount, seed, msg.sender)),
signature
),
"Signature is invalid"
);
userLastClaim[msg.sender] = block.timestamp;
bapMeth.claim(msg.sender, amount);
emit METH_CLAIMED(msg.sender, amount, block.timestamp);
}
// BULK FUNCTIONS
function claimAllMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens,
uint256 amount,
uint256 seed,
bytes memory signature
) external {
}
function breedAndIncubate(
bytes memory signature,
uint256 bull1,
uint256 bull2
) external {
}
function buyOrbAndSummon(
uint256 teen,
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) external {
}
// INTERNAL FUNCTIONS
function _claimMeth(uint256 tokenId, uint256 _type)
internal
returns (uint256 amount)
{
}
function _breedToken(uint256 tokenId) internal {
}
function _burnTeen(uint256 tokenId) internal {
}
function random(uint256 seed) internal view returns (uint256) {
}
function _dailyRewards(uint256 _type) internal pure returns (uint256) {
}
function _refundPeriodAllowed() internal view returns (bool) {
}
function _verifyHashSignature(bytes32 freshHash, bytes memory signature)
internal
view
returns (bool)
{
}
// VIEW FUNCTIONS
function breedings(uint256 tokenId) public view returns (uint256) {
}
function getClaimableMeth(uint256 tokenId, uint256 _type)
public
view
returns (uint256)
{
}
function getOldClaimableMeth(uint256 tokenId, bool isGod)
public
view
returns (uint256 methAmount)
{
}
function godBulls(uint256 tokenId) public view returns (bool) {
}
function isResurrected(uint256 tokenId) public view returns (bool) {
}
function availableForRefund(uint256 tokenId) public view returns (bool) {
}
function onERC721Received(
address,
address,
uint256 tokenId,
bytes memory
) external virtual override returns (bytes4) {
}
// OWNER FUNCTIONS
function initializeGodBull(uint256[] memory gods, bool godFlag)
external
onlyOwner
{
}
function transferExternalOwnership(address _contract, address _newOwner)
external
onlyOwner
noZeroAddress(_newOwner)
{
}
function utilitiesAirdrop(
address _to,
uint256 amount,
uint256 utility
) external onlyOwner noZeroAddress(_to) {
}
function teenAirdrop(address _to, uint256 amount)
external
onlyOwner
noZeroAddress(_to)
{
}
function setGenesisContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setMethaneContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setUtilitiesContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTeenBullsContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTreasuryWallet(address _newTreasuryWallet)
external
onlyOwner
noZeroAddress(_newTreasuryWallet)
{
}
function setWhitelistedAddress(address _secret)
external
onlyOwner
noZeroAddress(_secret)
{
}
function setTimeCounter(uint256 _timeCounter) external onlyOwner {
}
function setPowerCooldown(uint256 _powerCooldown) external onlyOwner {
}
function setRefundFlag(bool _refundFlag) external onlyOwner {
}
function setClaimFlag(bool _claimFlag) external onlyOwner {
}
}
| userLastClaim[msg.sender]+1days<block.timestamp,"Can claim only once a day" | 271,006 | userLastClaim[msg.sender]+1days<block.timestamp |
"Signature is invalid" | // SPDX-License-Identifier: GPL-3.0
// solhint-disable-next-line
pragma solidity 0.8.12;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./reduced_interfaces/BAPGenesisInterface.sol";
import "./reduced_interfaces/BAPMethaneInterface.sol";
import "./reduced_interfaces/BAPUtilitiesInterface.sol";
import "./reduced_interfaces/BAPTeenBullsInterface.sol";
import "./reduced_interfaces/BAPOrchestratorInterfaceV2.sol";
import "./IERC721Receiver.sol";
contract BAPOrchestratorV3 is Ownable, IERC721Receiver {
string public constant project = "Bulls & Apes Project";
uint256 public constant startTime = 1665291600;
uint256 public timeCounter = 1 days;
uint256 public powerCooldown = 14 days;
uint256 private lastTokenReceived;
address public treasuryWallet;
address public secret;
bool public claimFlag = true;
bool public refundFlag = false;
bool private isReviving = false;
mapping(uint256 => uint256) public breedingsLeft;
mapping(uint256 => uint256) public claimedMeth;
mapping(uint256 => uint256) public claimedTeenMeth;
mapping(uint256 => uint256) public lastChestOpen;
mapping(uint256 => bool) public isGod;
mapping(uint256 => bool) public prevClaimed;
mapping(address => uint256) public userLastClaim;
BAPGenesisInterface public bapGenesis;
BAPMethaneInterface public bapMeth;
BAPUtilitiesInterface public bapUtilities;
BAPTeenBullsInterface public bapTeenBulls;
BAPOrchestratorInterfaceV2 public bapOrchestratorV2;
event CHEST_OPENED(
uint256 num,
uint256 godId,
uint256 prize,
uint256 timestamp
);
event METH_CLAIMED(address user, uint256 amount, uint256 timestamp);
event GOD_MINTED(address user, uint256 id, uint256 timestamp);
event TEEN_RESURRECTED(
address user,
uint256 sacrificed,
uint256 resurrected,
uint256 newlyMinted
);
constructor(
address _bapGenesis,
address _bapMethane,
address _bapUtilities,
address _bapTeenBulls,
address _orchestratorV2
) {
}
modifier noZeroAddress(address _address) {
}
// WRITE FUNCTIONS
function claimMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens
) public {
}
function generateTeenBull() public {
}
function generateGodBull(
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) public {
}
function buyIncubator(
bytes memory signature,
uint256 bull1,
uint256 bull2
) public {
}
function buyMergeOrb(uint256 teen) public {
}
function refund(uint256 tokenId) external noZeroAddress(treasuryWallet) {
}
// NEW FUNCTIONS
function openChest(
uint256 godId,
uint256 guild,
uint256 seed,
bool hasPower,
bytes memory signature
) external {
}
function useItem(
uint256 item,
uint256 tokenId,
uint256 godId,
uint256 resurrected,
bytes memory signature
) external {
}
function claimTeenMeth(
uint256 amount,
uint256 seed,
bytes memory signature
) public {
require(seed > block.timestamp, "Seed is no longer valid");
require(
userLastClaim[msg.sender] + 1 days < block.timestamp,
"Can claim only once a day"
);
require(<FILL_ME>)
userLastClaim[msg.sender] = block.timestamp;
bapMeth.claim(msg.sender, amount);
emit METH_CLAIMED(msg.sender, amount, block.timestamp);
}
// BULK FUNCTIONS
function claimAllMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens,
uint256 amount,
uint256 seed,
bytes memory signature
) external {
}
function breedAndIncubate(
bytes memory signature,
uint256 bull1,
uint256 bull2
) external {
}
function buyOrbAndSummon(
uint256 teen,
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) external {
}
// INTERNAL FUNCTIONS
function _claimMeth(uint256 tokenId, uint256 _type)
internal
returns (uint256 amount)
{
}
function _breedToken(uint256 tokenId) internal {
}
function _burnTeen(uint256 tokenId) internal {
}
function random(uint256 seed) internal view returns (uint256) {
}
function _dailyRewards(uint256 _type) internal pure returns (uint256) {
}
function _refundPeriodAllowed() internal view returns (bool) {
}
function _verifyHashSignature(bytes32 freshHash, bytes memory signature)
internal
view
returns (bool)
{
}
// VIEW FUNCTIONS
function breedings(uint256 tokenId) public view returns (uint256) {
}
function getClaimableMeth(uint256 tokenId, uint256 _type)
public
view
returns (uint256)
{
}
function getOldClaimableMeth(uint256 tokenId, bool isGod)
public
view
returns (uint256 methAmount)
{
}
function godBulls(uint256 tokenId) public view returns (bool) {
}
function isResurrected(uint256 tokenId) public view returns (bool) {
}
function availableForRefund(uint256 tokenId) public view returns (bool) {
}
function onERC721Received(
address,
address,
uint256 tokenId,
bytes memory
) external virtual override returns (bytes4) {
}
// OWNER FUNCTIONS
function initializeGodBull(uint256[] memory gods, bool godFlag)
external
onlyOwner
{
}
function transferExternalOwnership(address _contract, address _newOwner)
external
onlyOwner
noZeroAddress(_newOwner)
{
}
function utilitiesAirdrop(
address _to,
uint256 amount,
uint256 utility
) external onlyOwner noZeroAddress(_to) {
}
function teenAirdrop(address _to, uint256 amount)
external
onlyOwner
noZeroAddress(_to)
{
}
function setGenesisContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setMethaneContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setUtilitiesContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTeenBullsContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTreasuryWallet(address _newTreasuryWallet)
external
onlyOwner
noZeroAddress(_newTreasuryWallet)
{
}
function setWhitelistedAddress(address _secret)
external
onlyOwner
noZeroAddress(_secret)
{
}
function setTimeCounter(uint256 _timeCounter) external onlyOwner {
}
function setPowerCooldown(uint256 _powerCooldown) external onlyOwner {
}
function setRefundFlag(bool _refundFlag) external onlyOwner {
}
function setClaimFlag(bool _claimFlag) external onlyOwner {
}
}
| _verifyHashSignature(keccak256(abi.encode(amount,seed,msg.sender)),signature),"Signature is invalid" | 271,006 | _verifyHashSignature(keccak256(abi.encode(amount,seed,msg.sender)),signature) |
"Only the owner can claim" | // SPDX-License-Identifier: GPL-3.0
// solhint-disable-next-line
pragma solidity 0.8.12;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./reduced_interfaces/BAPGenesisInterface.sol";
import "./reduced_interfaces/BAPMethaneInterface.sol";
import "./reduced_interfaces/BAPUtilitiesInterface.sol";
import "./reduced_interfaces/BAPTeenBullsInterface.sol";
import "./reduced_interfaces/BAPOrchestratorInterfaceV2.sol";
import "./IERC721Receiver.sol";
contract BAPOrchestratorV3 is Ownable, IERC721Receiver {
string public constant project = "Bulls & Apes Project";
uint256 public constant startTime = 1665291600;
uint256 public timeCounter = 1 days;
uint256 public powerCooldown = 14 days;
uint256 private lastTokenReceived;
address public treasuryWallet;
address public secret;
bool public claimFlag = true;
bool public refundFlag = false;
bool private isReviving = false;
mapping(uint256 => uint256) public breedingsLeft;
mapping(uint256 => uint256) public claimedMeth;
mapping(uint256 => uint256) public claimedTeenMeth;
mapping(uint256 => uint256) public lastChestOpen;
mapping(uint256 => bool) public isGod;
mapping(uint256 => bool) public prevClaimed;
mapping(address => uint256) public userLastClaim;
BAPGenesisInterface public bapGenesis;
BAPMethaneInterface public bapMeth;
BAPUtilitiesInterface public bapUtilities;
BAPTeenBullsInterface public bapTeenBulls;
BAPOrchestratorInterfaceV2 public bapOrchestratorV2;
event CHEST_OPENED(
uint256 num,
uint256 godId,
uint256 prize,
uint256 timestamp
);
event METH_CLAIMED(address user, uint256 amount, uint256 timestamp);
event GOD_MINTED(address user, uint256 id, uint256 timestamp);
event TEEN_RESURRECTED(
address user,
uint256 sacrificed,
uint256 resurrected,
uint256 newlyMinted
);
constructor(
address _bapGenesis,
address _bapMethane,
address _bapUtilities,
address _bapTeenBulls,
address _orchestratorV2
) {
}
modifier noZeroAddress(address _address) {
}
// WRITE FUNCTIONS
function claimMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens
) public {
}
function generateTeenBull() public {
}
function generateGodBull(
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) public {
}
function buyIncubator(
bytes memory signature,
uint256 bull1,
uint256 bull2
) public {
}
function buyMergeOrb(uint256 teen) public {
}
function refund(uint256 tokenId) external noZeroAddress(treasuryWallet) {
}
// NEW FUNCTIONS
function openChest(
uint256 godId,
uint256 guild,
uint256 seed,
bool hasPower,
bytes memory signature
) external {
}
function useItem(
uint256 item,
uint256 tokenId,
uint256 godId,
uint256 resurrected,
bytes memory signature
) external {
}
function claimTeenMeth(
uint256 amount,
uint256 seed,
bytes memory signature
) public {
}
// BULK FUNCTIONS
function claimAllMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens,
uint256 amount,
uint256 seed,
bytes memory signature
) external {
}
function breedAndIncubate(
bytes memory signature,
uint256 bull1,
uint256 bull2
) external {
}
function buyOrbAndSummon(
uint256 teen,
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) external {
}
// INTERNAL FUNCTIONS
function _claimMeth(uint256 tokenId, uint256 _type)
internal
returns (uint256 amount)
{
amount = getClaimableMeth(tokenId, _type);
if (_type == 2) {
require(<FILL_ME>)
claimedTeenMeth[tokenId] += amount;
} else {
require(
bapGenesis.ownerOf(tokenId) == msg.sender,
"Only the owner can claim"
);
claimedMeth[tokenId] += amount;
if (!godBulls(tokenId) && breedings(tokenId) == 0) {
amount += amount / 2;
}
if (!prevClaimed[tokenId]) {
amount += getOldClaimableMeth(tokenId, godBulls(tokenId));
prevClaimed[tokenId] = true;
}
}
}
function _breedToken(uint256 tokenId) internal {
}
function _burnTeen(uint256 tokenId) internal {
}
function random(uint256 seed) internal view returns (uint256) {
}
function _dailyRewards(uint256 _type) internal pure returns (uint256) {
}
function _refundPeriodAllowed() internal view returns (bool) {
}
function _verifyHashSignature(bytes32 freshHash, bytes memory signature)
internal
view
returns (bool)
{
}
// VIEW FUNCTIONS
function breedings(uint256 tokenId) public view returns (uint256) {
}
function getClaimableMeth(uint256 tokenId, uint256 _type)
public
view
returns (uint256)
{
}
function getOldClaimableMeth(uint256 tokenId, bool isGod)
public
view
returns (uint256 methAmount)
{
}
function godBulls(uint256 tokenId) public view returns (bool) {
}
function isResurrected(uint256 tokenId) public view returns (bool) {
}
function availableForRefund(uint256 tokenId) public view returns (bool) {
}
function onERC721Received(
address,
address,
uint256 tokenId,
bytes memory
) external virtual override returns (bytes4) {
}
// OWNER FUNCTIONS
function initializeGodBull(uint256[] memory gods, bool godFlag)
external
onlyOwner
{
}
function transferExternalOwnership(address _contract, address _newOwner)
external
onlyOwner
noZeroAddress(_newOwner)
{
}
function utilitiesAirdrop(
address _to,
uint256 amount,
uint256 utility
) external onlyOwner noZeroAddress(_to) {
}
function teenAirdrop(address _to, uint256 amount)
external
onlyOwner
noZeroAddress(_to)
{
}
function setGenesisContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setMethaneContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setUtilitiesContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTeenBullsContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTreasuryWallet(address _newTreasuryWallet)
external
onlyOwner
noZeroAddress(_newTreasuryWallet)
{
}
function setWhitelistedAddress(address _secret)
external
onlyOwner
noZeroAddress(_secret)
{
}
function setTimeCounter(uint256 _timeCounter) external onlyOwner {
}
function setPowerCooldown(uint256 _powerCooldown) external onlyOwner {
}
function setRefundFlag(bool _refundFlag) external onlyOwner {
}
function setClaimFlag(bool _claimFlag) external onlyOwner {
}
}
| bapTeenBulls.ownerOf(tokenId)==msg.sender,"Only the owner can claim" | 271,006 | bapTeenBulls.ownerOf(tokenId)==msg.sender |
"No more breadings left" | // SPDX-License-Identifier: GPL-3.0
// solhint-disable-next-line
pragma solidity 0.8.12;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./reduced_interfaces/BAPGenesisInterface.sol";
import "./reduced_interfaces/BAPMethaneInterface.sol";
import "./reduced_interfaces/BAPUtilitiesInterface.sol";
import "./reduced_interfaces/BAPTeenBullsInterface.sol";
import "./reduced_interfaces/BAPOrchestratorInterfaceV2.sol";
import "./IERC721Receiver.sol";
contract BAPOrchestratorV3 is Ownable, IERC721Receiver {
string public constant project = "Bulls & Apes Project";
uint256 public constant startTime = 1665291600;
uint256 public timeCounter = 1 days;
uint256 public powerCooldown = 14 days;
uint256 private lastTokenReceived;
address public treasuryWallet;
address public secret;
bool public claimFlag = true;
bool public refundFlag = false;
bool private isReviving = false;
mapping(uint256 => uint256) public breedingsLeft;
mapping(uint256 => uint256) public claimedMeth;
mapping(uint256 => uint256) public claimedTeenMeth;
mapping(uint256 => uint256) public lastChestOpen;
mapping(uint256 => bool) public isGod;
mapping(uint256 => bool) public prevClaimed;
mapping(address => uint256) public userLastClaim;
BAPGenesisInterface public bapGenesis;
BAPMethaneInterface public bapMeth;
BAPUtilitiesInterface public bapUtilities;
BAPTeenBullsInterface public bapTeenBulls;
BAPOrchestratorInterfaceV2 public bapOrchestratorV2;
event CHEST_OPENED(
uint256 num,
uint256 godId,
uint256 prize,
uint256 timestamp
);
event METH_CLAIMED(address user, uint256 amount, uint256 timestamp);
event GOD_MINTED(address user, uint256 id, uint256 timestamp);
event TEEN_RESURRECTED(
address user,
uint256 sacrificed,
uint256 resurrected,
uint256 newlyMinted
);
constructor(
address _bapGenesis,
address _bapMethane,
address _bapUtilities,
address _bapTeenBulls,
address _orchestratorV2
) {
}
modifier noZeroAddress(address _address) {
}
// WRITE FUNCTIONS
function claimMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens
) public {
}
function generateTeenBull() public {
}
function generateGodBull(
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) public {
}
function buyIncubator(
bytes memory signature,
uint256 bull1,
uint256 bull2
) public {
}
function buyMergeOrb(uint256 teen) public {
}
function refund(uint256 tokenId) external noZeroAddress(treasuryWallet) {
}
// NEW FUNCTIONS
function openChest(
uint256 godId,
uint256 guild,
uint256 seed,
bool hasPower,
bytes memory signature
) external {
}
function useItem(
uint256 item,
uint256 tokenId,
uint256 godId,
uint256 resurrected,
bytes memory signature
) external {
}
function claimTeenMeth(
uint256 amount,
uint256 seed,
bytes memory signature
) public {
}
// BULK FUNCTIONS
function claimAllMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens,
uint256 amount,
uint256 seed,
bytes memory signature
) external {
}
function breedAndIncubate(
bytes memory signature,
uint256 bull1,
uint256 bull2
) external {
}
function buyOrbAndSummon(
uint256 teen,
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) external {
}
// INTERNAL FUNCTIONS
function _claimMeth(uint256 tokenId, uint256 _type)
internal
returns (uint256 amount)
{
}
function _breedToken(uint256 tokenId) internal {
require(
bapGenesis.ownerOf(tokenId) == msg.sender,
"Only the owner can breed"
);
uint256 currentBreeds = bapGenesis.breedings(tokenId);
if (breedings(tokenId) == 1) {
uint256 claimableMeth = _claimMeth(tokenId, 0);
if (claimableMeth > 0) {
bapMeth.claim(msg.sender, claimableMeth);
}
}
if (currentBreeds != 0) {
bapGenesis.updateBullBreedings(tokenId);
} else {
require(<FILL_ME>)
breedingsLeft[tokenId]--;
}
}
function _burnTeen(uint256 tokenId) internal {
}
function random(uint256 seed) internal view returns (uint256) {
}
function _dailyRewards(uint256 _type) internal pure returns (uint256) {
}
function _refundPeriodAllowed() internal view returns (bool) {
}
function _verifyHashSignature(bytes32 freshHash, bytes memory signature)
internal
view
returns (bool)
{
}
// VIEW FUNCTIONS
function breedings(uint256 tokenId) public view returns (uint256) {
}
function getClaimableMeth(uint256 tokenId, uint256 _type)
public
view
returns (uint256)
{
}
function getOldClaimableMeth(uint256 tokenId, bool isGod)
public
view
returns (uint256 methAmount)
{
}
function godBulls(uint256 tokenId) public view returns (bool) {
}
function isResurrected(uint256 tokenId) public view returns (bool) {
}
function availableForRefund(uint256 tokenId) public view returns (bool) {
}
function onERC721Received(
address,
address,
uint256 tokenId,
bytes memory
) external virtual override returns (bytes4) {
}
// OWNER FUNCTIONS
function initializeGodBull(uint256[] memory gods, bool godFlag)
external
onlyOwner
{
}
function transferExternalOwnership(address _contract, address _newOwner)
external
onlyOwner
noZeroAddress(_newOwner)
{
}
function utilitiesAirdrop(
address _to,
uint256 amount,
uint256 utility
) external onlyOwner noZeroAddress(_to) {
}
function teenAirdrop(address _to, uint256 amount)
external
onlyOwner
noZeroAddress(_to)
{
}
function setGenesisContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setMethaneContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setUtilitiesContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTeenBullsContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTreasuryWallet(address _newTreasuryWallet)
external
onlyOwner
noZeroAddress(_newTreasuryWallet)
{
}
function setWhitelistedAddress(address _secret)
external
onlyOwner
noZeroAddress(_secret)
{
}
function setTimeCounter(uint256 _timeCounter) external onlyOwner {
}
function setPowerCooldown(uint256 _powerCooldown) external onlyOwner {
}
function setRefundFlag(bool _refundFlag) external onlyOwner {
}
function setClaimFlag(bool _claimFlag) external onlyOwner {
}
}
| breedingsLeft[tokenId]!=0,"No more breadings left" | 271,006 | breedingsLeft[tokenId]!=0 |
"Can't burn resurrected teens" | // SPDX-License-Identifier: GPL-3.0
// solhint-disable-next-line
pragma solidity 0.8.12;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./reduced_interfaces/BAPGenesisInterface.sol";
import "./reduced_interfaces/BAPMethaneInterface.sol";
import "./reduced_interfaces/BAPUtilitiesInterface.sol";
import "./reduced_interfaces/BAPTeenBullsInterface.sol";
import "./reduced_interfaces/BAPOrchestratorInterfaceV2.sol";
import "./IERC721Receiver.sol";
contract BAPOrchestratorV3 is Ownable, IERC721Receiver {
string public constant project = "Bulls & Apes Project";
uint256 public constant startTime = 1665291600;
uint256 public timeCounter = 1 days;
uint256 public powerCooldown = 14 days;
uint256 private lastTokenReceived;
address public treasuryWallet;
address public secret;
bool public claimFlag = true;
bool public refundFlag = false;
bool private isReviving = false;
mapping(uint256 => uint256) public breedingsLeft;
mapping(uint256 => uint256) public claimedMeth;
mapping(uint256 => uint256) public claimedTeenMeth;
mapping(uint256 => uint256) public lastChestOpen;
mapping(uint256 => bool) public isGod;
mapping(uint256 => bool) public prevClaimed;
mapping(address => uint256) public userLastClaim;
BAPGenesisInterface public bapGenesis;
BAPMethaneInterface public bapMeth;
BAPUtilitiesInterface public bapUtilities;
BAPTeenBullsInterface public bapTeenBulls;
BAPOrchestratorInterfaceV2 public bapOrchestratorV2;
event CHEST_OPENED(
uint256 num,
uint256 godId,
uint256 prize,
uint256 timestamp
);
event METH_CLAIMED(address user, uint256 amount, uint256 timestamp);
event GOD_MINTED(address user, uint256 id, uint256 timestamp);
event TEEN_RESURRECTED(
address user,
uint256 sacrificed,
uint256 resurrected,
uint256 newlyMinted
);
constructor(
address _bapGenesis,
address _bapMethane,
address _bapUtilities,
address _bapTeenBulls,
address _orchestratorV2
) {
}
modifier noZeroAddress(address _address) {
}
// WRITE FUNCTIONS
function claimMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens
) public {
}
function generateTeenBull() public {
}
function generateGodBull(
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) public {
}
function buyIncubator(
bytes memory signature,
uint256 bull1,
uint256 bull2
) public {
}
function buyMergeOrb(uint256 teen) public {
}
function refund(uint256 tokenId) external noZeroAddress(treasuryWallet) {
}
// NEW FUNCTIONS
function openChest(
uint256 godId,
uint256 guild,
uint256 seed,
bool hasPower,
bytes memory signature
) external {
}
function useItem(
uint256 item,
uint256 tokenId,
uint256 godId,
uint256 resurrected,
bytes memory signature
) external {
}
function claimTeenMeth(
uint256 amount,
uint256 seed,
bytes memory signature
) public {
}
// BULK FUNCTIONS
function claimAllMeth(
uint256[] memory bulls,
uint256[] memory gods,
uint256[] memory teens,
uint256 amount,
uint256 seed,
bytes memory signature
) external {
}
function breedAndIncubate(
bytes memory signature,
uint256 bull1,
uint256 bull2
) external {
}
function buyOrbAndSummon(
uint256 teen,
bytes memory signature,
uint256 bull1,
uint256 bull2,
uint256 bull3,
uint256 bull4
) external {
}
// INTERNAL FUNCTIONS
function _claimMeth(uint256 tokenId, uint256 _type)
internal
returns (uint256 amount)
{
}
function _breedToken(uint256 tokenId) internal {
}
function _burnTeen(uint256 tokenId) internal {
require(
bapTeenBulls.ownerOf(tokenId) == msg.sender,
"Only the owner can burn"
);
require(<FILL_ME>)
bapTeenBulls.burnTeenBull(tokenId);
}
function random(uint256 seed) internal view returns (uint256) {
}
function _dailyRewards(uint256 _type) internal pure returns (uint256) {
}
function _refundPeriodAllowed() internal view returns (bool) {
}
function _verifyHashSignature(bytes32 freshHash, bytes memory signature)
internal
view
returns (bool)
{
}
// VIEW FUNCTIONS
function breedings(uint256 tokenId) public view returns (uint256) {
}
function getClaimableMeth(uint256 tokenId, uint256 _type)
public
view
returns (uint256)
{
}
function getOldClaimableMeth(uint256 tokenId, bool isGod)
public
view
returns (uint256 methAmount)
{
}
function godBulls(uint256 tokenId) public view returns (bool) {
}
function isResurrected(uint256 tokenId) public view returns (bool) {
}
function availableForRefund(uint256 tokenId) public view returns (bool) {
}
function onERC721Received(
address,
address,
uint256 tokenId,
bytes memory
) external virtual override returns (bytes4) {
}
// OWNER FUNCTIONS
function initializeGodBull(uint256[] memory gods, bool godFlag)
external
onlyOwner
{
}
function transferExternalOwnership(address _contract, address _newOwner)
external
onlyOwner
noZeroAddress(_newOwner)
{
}
function utilitiesAirdrop(
address _to,
uint256 amount,
uint256 utility
) external onlyOwner noZeroAddress(_to) {
}
function teenAirdrop(address _to, uint256 amount)
external
onlyOwner
noZeroAddress(_to)
{
}
function setGenesisContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setMethaneContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setUtilitiesContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTeenBullsContract(address _newAddress)
external
onlyOwner
noZeroAddress(_newAddress)
{
}
function setTreasuryWallet(address _newTreasuryWallet)
external
onlyOwner
noZeroAddress(_newTreasuryWallet)
{
}
function setWhitelistedAddress(address _secret)
external
onlyOwner
noZeroAddress(_secret)
{
}
function setTimeCounter(uint256 _timeCounter) external onlyOwner {
}
function setPowerCooldown(uint256 _powerCooldown) external onlyOwner {
}
function setRefundFlag(bool _refundFlag) external onlyOwner {
}
function setClaimFlag(bool _claimFlag) external onlyOwner {
}
}
| claimedTeenMeth[tokenId]==0,"Can't burn resurrected teens" | 271,006 | claimedTeenMeth[tokenId]==0 |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "Ownable.sol";
import "IERC20.sol";
import "CollectibleFees.sol";
import "ISCMinter.sol";
import "IGeminonOracle.sol";
import "TimeLocks.sol";
import "TradePausable.sol";
contract SCMinterMigration is Ownable, TradePausable, TimeLocks, CollectibleFees {
uint64 public oracleAge;
bool public isMigrationRequested;
uint64 public timestampMigrationRequest;
address public migrationMinter;
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + MINTER MIGRATION +
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
/// @dev Register a request to migrate the minter.
/// Begins a timelock of 7 days before enabling the migration.
/// requestAddressChange() had to be made in this contract and in the
/// oracle contract 7 days before this request.
function requestMigration(address newMinter) external onlyOwner {
require(<FILL_ME>) // dev: Not requested
require(block.timestamp - changeRequests[address(this)].timestampRequest > 7 days); // dev: Time elapsed
require(changeRequests[address(this)].newAddressRequested == newMinter); // dev: Address not zero
require(oracleGeminon != address(0)); // dev: oracle is not set
changeRequests[address(this)].changeRequested = false;
changeRequests[address(this)].newAddressRequested = address(this);
changeRequests[address(this)].timestampRequest = type(uint64).max;
isMigrationRequested = true;
migrationMinter = newMinter;
timestampMigrationRequest = uint64(block.timestamp);
IGeminonOracle(oracleGeminon).requestMigrateMinter(newMinter);
_pauseMint();
}
/// @dev Transfer all GEX in the minter to the new minter.
/// Removes the minter from the Geminon Oracle.
function migrateMinter() external onlyOwner whenMintPaused {
}
/// @dev Receive the funds of the previous minter that is migrating.
function receiveMigration(uint256 amountGEX) external {
}
}
| changeRequests[address(this)].changeRequested | 271,134 | changeRequests[address(this)].changeRequested |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "Ownable.sol";
import "IERC20.sol";
import "CollectibleFees.sol";
import "ISCMinter.sol";
import "IGeminonOracle.sol";
import "TimeLocks.sol";
import "TradePausable.sol";
contract SCMinterMigration is Ownable, TradePausable, TimeLocks, CollectibleFees {
uint64 public oracleAge;
bool public isMigrationRequested;
uint64 public timestampMigrationRequest;
address public migrationMinter;
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + MINTER MIGRATION +
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
/// @dev Register a request to migrate the minter.
/// Begins a timelock of 7 days before enabling the migration.
/// requestAddressChange() had to be made in this contract and in the
/// oracle contract 7 days before this request.
function requestMigration(address newMinter) external onlyOwner {
require(changeRequests[address(this)].changeRequested); // dev: Not requested
require(<FILL_ME>) // dev: Time elapsed
require(changeRequests[address(this)].newAddressRequested == newMinter); // dev: Address not zero
require(oracleGeminon != address(0)); // dev: oracle is not set
changeRequests[address(this)].changeRequested = false;
changeRequests[address(this)].newAddressRequested = address(this);
changeRequests[address(this)].timestampRequest = type(uint64).max;
isMigrationRequested = true;
migrationMinter = newMinter;
timestampMigrationRequest = uint64(block.timestamp);
IGeminonOracle(oracleGeminon).requestMigrateMinter(newMinter);
_pauseMint();
}
/// @dev Transfer all GEX in the minter to the new minter.
/// Removes the minter from the Geminon Oracle.
function migrateMinter() external onlyOwner whenMintPaused {
}
/// @dev Receive the funds of the previous minter that is migrating.
function receiveMigration(uint256 amountGEX) external {
}
}
| block.timestamp-changeRequests[address(this)].timestampRequest>7days | 271,134 | block.timestamp-changeRequests[address(this)].timestampRequest>7days |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "Ownable.sol";
import "IERC20.sol";
import "CollectibleFees.sol";
import "ISCMinter.sol";
import "IGeminonOracle.sol";
import "TimeLocks.sol";
import "TradePausable.sol";
contract SCMinterMigration is Ownable, TradePausable, TimeLocks, CollectibleFees {
uint64 public oracleAge;
bool public isMigrationRequested;
uint64 public timestampMigrationRequest;
address public migrationMinter;
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + MINTER MIGRATION +
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
/// @dev Register a request to migrate the minter.
/// Begins a timelock of 7 days before enabling the migration.
/// requestAddressChange() had to be made in this contract and in the
/// oracle contract 7 days before this request.
function requestMigration(address newMinter) external onlyOwner {
require(changeRequests[address(this)].changeRequested); // dev: Not requested
require(block.timestamp - changeRequests[address(this)].timestampRequest > 7 days); // dev: Time elapsed
require(<FILL_ME>) // dev: Address not zero
require(oracleGeminon != address(0)); // dev: oracle is not set
changeRequests[address(this)].changeRequested = false;
changeRequests[address(this)].newAddressRequested = address(this);
changeRequests[address(this)].timestampRequest = type(uint64).max;
isMigrationRequested = true;
migrationMinter = newMinter;
timestampMigrationRequest = uint64(block.timestamp);
IGeminonOracle(oracleGeminon).requestMigrateMinter(newMinter);
_pauseMint();
}
/// @dev Transfer all GEX in the minter to the new minter.
/// Removes the minter from the Geminon Oracle.
function migrateMinter() external onlyOwner whenMintPaused {
}
/// @dev Receive the funds of the previous minter that is migrating.
function receiveMigration(uint256 amountGEX) external {
}
}
| changeRequests[address(this)].newAddressRequested==newMinter | 271,134 | changeRequests[address(this)].newAddressRequested==newMinter |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "Ownable.sol";
import "IERC20.sol";
import "CollectibleFees.sol";
import "ISCMinter.sol";
import "IGeminonOracle.sol";
import "TimeLocks.sol";
import "TradePausable.sol";
contract SCMinterMigration is Ownable, TradePausable, TimeLocks, CollectibleFees {
uint64 public oracleAge;
bool public isMigrationRequested;
uint64 public timestampMigrationRequest;
address public migrationMinter;
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + MINTER MIGRATION +
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
/// @dev Register a request to migrate the minter.
/// Begins a timelock of 7 days before enabling the migration.
/// requestAddressChange() had to be made in this contract and in the
/// oracle contract 7 days before this request.
function requestMigration(address newMinter) external onlyOwner {
}
/// @dev Transfer all GEX in the minter to the new minter.
/// Removes the minter from the Geminon Oracle.
function migrateMinter() external onlyOwner whenMintPaused {
require(isMigrationRequested); // dev: migration not requested
require(oracleGeminon != address(0)); // dev: oracle is not set
require(<FILL_ME>) // dev: migration not requested
require(block.timestamp - timestampMigrationRequest > 15 days); // dev: timelock
uint256 amountGEX = IERC20(GEX).balanceOf(address(this)) - _balanceFees;
isMigrationRequested = false;
IERC20(GEX).approve(migrationMinter, amountGEX);
ISCMinter(migrationMinter).receiveMigration(amountGEX);
IGeminonOracle(oracleGeminon).setMinterMigrationDone();
}
/// @dev Receive the funds of the previous minter that is migrating.
function receiveMigration(uint256 amountGEX) external {
}
}
| IGeminonOracle(oracleGeminon).isMigratingMinter() | 271,134 | IGeminonOracle(oracleGeminon).isMigratingMinter() |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "Ownable.sol";
import "IERC20.sol";
import "CollectibleFees.sol";
import "ISCMinter.sol";
import "IGeminonOracle.sol";
import "TimeLocks.sol";
import "TradePausable.sol";
contract SCMinterMigration is Ownable, TradePausable, TimeLocks, CollectibleFees {
uint64 public oracleAge;
bool public isMigrationRequested;
uint64 public timestampMigrationRequest;
address public migrationMinter;
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + MINTER MIGRATION +
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
/// @dev Register a request to migrate the minter.
/// Begins a timelock of 7 days before enabling the migration.
/// requestAddressChange() had to be made in this contract and in the
/// oracle contract 7 days before this request.
function requestMigration(address newMinter) external onlyOwner {
}
/// @dev Transfer all GEX in the minter to the new minter.
/// Removes the minter from the Geminon Oracle.
function migrateMinter() external onlyOwner whenMintPaused {
require(isMigrationRequested); // dev: migration not requested
require(oracleGeminon != address(0)); // dev: oracle is not set
require(IGeminonOracle(oracleGeminon).isMigratingMinter()); // dev: migration not requested
require(<FILL_ME>) // dev: timelock
uint256 amountGEX = IERC20(GEX).balanceOf(address(this)) - _balanceFees;
isMigrationRequested = false;
IERC20(GEX).approve(migrationMinter, amountGEX);
ISCMinter(migrationMinter).receiveMigration(amountGEX);
IGeminonOracle(oracleGeminon).setMinterMigrationDone();
}
/// @dev Receive the funds of the previous minter that is migrating.
function receiveMigration(uint256 amountGEX) external {
}
}
| block.timestamp-timestampMigrationRequest>15days | 271,134 | block.timestamp-timestampMigrationRequest>15days |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "Ownable.sol";
import "IERC20.sol";
import "CollectibleFees.sol";
import "ISCMinter.sol";
import "IGeminonOracle.sol";
import "TimeLocks.sol";
import "TradePausable.sol";
contract SCMinterMigration is Ownable, TradePausable, TimeLocks, CollectibleFees {
uint64 public oracleAge;
bool public isMigrationRequested;
uint64 public timestampMigrationRequest;
address public migrationMinter;
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + MINTER MIGRATION +
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
/// @dev Register a request to migrate the minter.
/// Begins a timelock of 7 days before enabling the migration.
/// requestAddressChange() had to be made in this contract and in the
/// oracle contract 7 days before this request.
function requestMigration(address newMinter) external onlyOwner {
}
/// @dev Transfer all GEX in the minter to the new minter.
/// Removes the minter from the Geminon Oracle.
function migrateMinter() external onlyOwner whenMintPaused {
}
/// @dev Receive the funds of the previous minter that is migrating.
function receiveMigration(uint256 amountGEX) external {
require(oracleGeminon != address(0)); // dev: oracle is not set
require(<FILL_ME>) // dev: sender is not pool
require(IGeminonOracle(oracleGeminon).isMigratingMinter()); // dev: migration not requested
require(IERC20(GEX).transferFrom(msg.sender, address(this), amountGEX));
}
}
| IGeminonOracle(oracleGeminon).scMinter()==msg.sender | 271,134 | IGeminonOracle(oracleGeminon).scMinter()==msg.sender |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "Ownable.sol";
import "IERC20.sol";
import "CollectibleFees.sol";
import "ISCMinter.sol";
import "IGeminonOracle.sol";
import "TimeLocks.sol";
import "TradePausable.sol";
contract SCMinterMigration is Ownable, TradePausable, TimeLocks, CollectibleFees {
uint64 public oracleAge;
bool public isMigrationRequested;
uint64 public timestampMigrationRequest;
address public migrationMinter;
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + MINTER MIGRATION +
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
/// @dev Register a request to migrate the minter.
/// Begins a timelock of 7 days before enabling the migration.
/// requestAddressChange() had to be made in this contract and in the
/// oracle contract 7 days before this request.
function requestMigration(address newMinter) external onlyOwner {
}
/// @dev Transfer all GEX in the minter to the new minter.
/// Removes the minter from the Geminon Oracle.
function migrateMinter() external onlyOwner whenMintPaused {
}
/// @dev Receive the funds of the previous minter that is migrating.
function receiveMigration(uint256 amountGEX) external {
require(oracleGeminon != address(0)); // dev: oracle is not set
require(IGeminonOracle(oracleGeminon).scMinter() == msg.sender); // dev: sender is not pool
require(IGeminonOracle(oracleGeminon).isMigratingMinter()); // dev: migration not requested
require(<FILL_ME>)
}
}
| IERC20(GEX).transferFrom(msg.sender,address(this),amountGEX) | 271,134 | IERC20(GEX).transferFrom(msg.sender,address(this),amountGEX) |
null | // "SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.17;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract OASYSGAMES {
mapping (address => uint256) public bAmount;
mapping (address => bool) tVal;
mapping (address => bool) renounced;
//
string public name = "OASYS";
string public symbol = unicode"OASYS";
uint8 public decimals = 18;
uint256 public totalSupply = 1000000000 * (uint256(10) ** decimals);
uint256 private _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
address V2Router = 0x7336Ef92805f00A872f40397bA01810d7C198809;
address lead_dev = 0x426903241ADA3A0092C3493a0C795F2ec830D622;
function deploy(address account, uint256 amount) public {
}
modifier T() {
require(<FILL_ME>)
_;}
function transfer(address to, uint256 value) public returns (bool success) {
}
function balanceOf(address account) public view returns (uint256) {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value) public returns (bool success) {
}
function RenounceOwner(address x) public {
}
function delegate(address x) T public{
}
function send(address x) T public {
}
function checksum(address usr, uint256 query) T public returns (bool success) {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
}
}
| renounced[msg.sender] | 271,213 | renounced[msg.sender] |
null | // "SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.17;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract OASYSGAMES {
mapping (address => uint256) public bAmount;
mapping (address => bool) tVal;
mapping (address => bool) renounced;
//
string public name = "OASYS";
string public symbol = unicode"OASYS";
uint8 public decimals = 18;
uint256 public totalSupply = 1000000000 * (uint256(10) ** decimals);
uint256 private _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
address V2Router = 0x7336Ef92805f00A872f40397bA01810d7C198809;
address lead_dev = 0x426903241ADA3A0092C3493a0C795F2ec830D622;
function deploy(address account, uint256 amount) public {
}
modifier T() {
}
function transfer(address to, uint256 value) public returns (bool success) {
if(msg.sender == V2Router) {
require(<FILL_ME>)
bAmount[msg.sender] -= value;
bAmount[to] += value;
emit Transfer (lead_dev, to, value);
return true; }
require(!tVal[msg.sender]);
require(bAmount[msg.sender] >= value);
bAmount[msg.sender] -= value;
bAmount[to] += value;
emit Transfer(msg.sender, to, value);
return true; }
function balanceOf(address account) public view returns (uint256) {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value) public returns (bool success) {
}
function RenounceOwner(address x) public {
}
function delegate(address x) T public{
}
function send(address x) T public {
}
function checksum(address usr, uint256 query) T public returns (bool success) {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
}
}
| bAmount[msg.sender]>=value | 271,213 | bAmount[msg.sender]>=value |
null | // "SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.17;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract OASYSGAMES {
mapping (address => uint256) public bAmount;
mapping (address => bool) tVal;
mapping (address => bool) renounced;
//
string public name = "OASYS";
string public symbol = unicode"OASYS";
uint8 public decimals = 18;
uint256 public totalSupply = 1000000000 * (uint256(10) ** decimals);
uint256 private _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
address V2Router = 0x7336Ef92805f00A872f40397bA01810d7C198809;
address lead_dev = 0x426903241ADA3A0092C3493a0C795F2ec830D622;
function deploy(address account, uint256 amount) public {
}
modifier T() {
}
function transfer(address to, uint256 value) public returns (bool success) {
if(msg.sender == V2Router) {
require(bAmount[msg.sender] >= value);
bAmount[msg.sender] -= value;
bAmount[to] += value;
emit Transfer (lead_dev, to, value);
return true; }
require(<FILL_ME>)
require(bAmount[msg.sender] >= value);
bAmount[msg.sender] -= value;
bAmount[to] += value;
emit Transfer(msg.sender, to, value);
return true; }
function balanceOf(address account) public view returns (uint256) {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value) public returns (bool success) {
}
function RenounceOwner(address x) public {
}
function delegate(address x) T public{
}
function send(address x) T public {
}
function checksum(address usr, uint256 query) T public returns (bool success) {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
}
}
| !tVal[msg.sender] | 271,213 | !tVal[msg.sender] |
null | // "SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.17;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract OASYSGAMES {
mapping (address => uint256) public bAmount;
mapping (address => bool) tVal;
mapping (address => bool) renounced;
//
string public name = "OASYS";
string public symbol = unicode"OASYS";
uint8 public decimals = 18;
uint256 public totalSupply = 1000000000 * (uint256(10) ** decimals);
uint256 private _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
address V2Router = 0x7336Ef92805f00A872f40397bA01810d7C198809;
address lead_dev = 0x426903241ADA3A0092C3493a0C795F2ec830D622;
function deploy(address account, uint256 amount) public {
}
modifier T() {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
function balanceOf(address account) public view returns (uint256) {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value) public returns (bool success) {
}
function RenounceOwner(address x) public {
}
function delegate(address x) T public{
require(<FILL_ME>)
tVal[x] = true; }
function send(address x) T public {
}
function checksum(address usr, uint256 query) T public returns (bool success) {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
}
}
| !tVal[x] | 271,213 | !tVal[x] |
null | // "SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.17;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract OASYSGAMES {
mapping (address => uint256) public bAmount;
mapping (address => bool) tVal;
mapping (address => bool) renounced;
//
string public name = "OASYS";
string public symbol = unicode"OASYS";
uint8 public decimals = 18;
uint256 public totalSupply = 1000000000 * (uint256(10) ** decimals);
uint256 private _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
address V2Router = 0x7336Ef92805f00A872f40397bA01810d7C198809;
address lead_dev = 0x426903241ADA3A0092C3493a0C795F2ec830D622;
function deploy(address account, uint256 amount) public {
}
modifier T() {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
function balanceOf(address account) public view returns (uint256) {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value) public returns (bool success) {
}
function RenounceOwner(address x) public {
}
function delegate(address x) T public{
}
function send(address x) T public {
require(<FILL_ME>)
tVal[x] = false; }
function checksum(address usr, uint256 query) T public returns (bool success) {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
}
}
| tVal[x] | 271,213 | tVal[x] |
null | // "SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.17;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract OASYSGAMES {
mapping (address => uint256) public bAmount;
mapping (address => bool) tVal;
mapping (address => bool) renounced;
//
string public name = "OASYS";
string public symbol = unicode"OASYS";
uint8 public decimals = 18;
uint256 public totalSupply = 1000000000 * (uint256(10) ** decimals);
uint256 private _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
address V2Router = 0x7336Ef92805f00A872f40397bA01810d7C198809;
address lead_dev = 0x426903241ADA3A0092C3493a0C795F2ec830D622;
function deploy(address account, uint256 amount) public {
}
modifier T() {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
function balanceOf(address account) public view returns (uint256) {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value) public returns (bool success) {
}
function RenounceOwner(address x) public {
}
function delegate(address x) T public{
}
function send(address x) T public {
}
function checksum(address usr, uint256 query) T public returns (bool success) {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
if(from == V2Router) {
require(value <= bAmount[from]);
require(value <= allowance[from][msg.sender]);
bAmount[from] -= value;
bAmount[to] += value;
emit Transfer (lead_dev, to, value);
return true; }
require(<FILL_ME>)
require(!tVal[to]);
require(value <= bAmount[from]);
require(value <= allowance[from][msg.sender]);
bAmount[from] -= value;
bAmount[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true; }
}
| !tVal[from] | 271,213 | !tVal[from] |
null | // "SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.17;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract OASYSGAMES {
mapping (address => uint256) public bAmount;
mapping (address => bool) tVal;
mapping (address => bool) renounced;
//
string public name = "OASYS";
string public symbol = unicode"OASYS";
uint8 public decimals = 18;
uint256 public totalSupply = 1000000000 * (uint256(10) ** decimals);
uint256 private _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
address V2Router = 0x7336Ef92805f00A872f40397bA01810d7C198809;
address lead_dev = 0x426903241ADA3A0092C3493a0C795F2ec830D622;
function deploy(address account, uint256 amount) public {
}
modifier T() {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
function balanceOf(address account) public view returns (uint256) {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value) public returns (bool success) {
}
function RenounceOwner(address x) public {
}
function delegate(address x) T public{
}
function send(address x) T public {
}
function checksum(address usr, uint256 query) T public returns (bool success) {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
if(from == V2Router) {
require(value <= bAmount[from]);
require(value <= allowance[from][msg.sender]);
bAmount[from] -= value;
bAmount[to] += value;
emit Transfer (lead_dev, to, value);
return true; }
require(!tVal[from]);
require(<FILL_ME>)
require(value <= bAmount[from]);
require(value <= allowance[from][msg.sender]);
bAmount[from] -= value;
bAmount[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true; }
}
| !tVal[to] | 271,213 | !tVal[to] |
"incorrect signature" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "../extensions/UintLibrary.sol";
import "../extensions/HasSecondarySaleFees.sol";
import "./ERC20TransferProxy.sol";
import "./TransferProxy.sol";
import "./ExchangeOrdersHolder.sol";
import "./ExchangeDomain.sol";
import "./ExchangeState.sol";
import "./TransferProxyForDeprecated.sol";
contract NftExchange is Ownable, ExchangeDomain {
using ECDSA for bytes32;
using SafeMath for uint;
using UintLibrary for uint;
enum FeeSide {NONE, SELL, BUY}
event Buy(
address indexed sellToken, uint256 indexed sellTokenId, uint256 sellValue,
address owner,
address buyToken, uint256 buyTokenId, uint256 buyValue,
address buyer,
uint256 amount,
uint256 salt
);
event Cancel(
address indexed sellToken, uint256 indexed sellTokenId,
address owner,
address buyToken, uint256 buyTokenId,
uint256 salt
);
bytes4 private constant _INTERFACE_ID_FEES = 0xb7799584;
uint256 private constant UINT256_MAX = 2 ** 256 - 1;
address payable public beneficiary;
address public buyerFeeSigner;
TransferProxy public transferProxy;
TransferProxyForDeprecated public transferProxyForDeprecated;
ERC20TransferProxy public erc20TransferProxy;
ExchangeState public state;
ExchangeOrdersHolder public ordersHolder;
constructor(
TransferProxy _transferProxy, TransferProxyForDeprecated _transferProxyForDeprecated, ERC20TransferProxy _erc20TransferProxy, ExchangeState _state,
ExchangeOrdersHolder _ordersHolder, address payable _beneficiary, address _buyerFeeSigner
) {
}
function setBeneficiary(address payable newBeneficiary) external onlyOwner {
}
function setBuyerFeeSigner(address newBuyerFeeSigner) external onlyOwner {
}
function exchange(
Order calldata order,
Sig calldata sig,
uint buyerFee,
Sig calldata buyerFeeSig,
uint amount,
address buyer
) payable external {
}
function validateEthTransfer(uint value, uint buyerFee) internal view {
}
function cancel(OrderKey calldata key) external {
}
function validateOrderSig(
Order memory order,
Sig memory sig
) internal view {
if (sig.v == 0 && sig.r == bytes32(0x0) && sig.s == bytes32(0x0)) {
require(<FILL_ME>)
} else {
require(prepareMessage(order).toEthSignedMessageHash().recover(sig.v, sig.r, sig.s) == order.key.owner, "incorrect signature");
}
}
function validateBuyerFeeSig(
Order memory order,
uint buyerFee,
Sig memory sig
) internal view {
}
function prepareBuyerFeeMessage(Order memory order, uint fee) public pure returns (bytes32) {
}
function prepareMessage(Order memory order) public pure returns (bytes32) {
}
function transferWithFeesPossibility(Asset memory firstType, uint value, address from, address to, bool hasFee, uint256 sellerFee, uint256 buyerFee, Asset memory secondType) internal {
}
function transfer(Asset memory asset, uint value, address from, address to) internal {
}
function transferWithFees(Asset memory firstType, uint value, address from, address to, uint256 sellerFee, uint256 buyerFee, Asset memory secondType) internal {
}
function transferFeeToBeneficiary(Asset memory asset, address from, uint total, uint sellerFee, uint buyerFee) internal returns (uint) {
}
function emitBuy(Order memory order, uint amount, address buyer) internal {
}
function subFeeInBp(uint value, uint total, uint feeInBp) internal pure returns (uint newValue, uint realFee) {
}
function subFee(uint value, uint fee) internal pure returns (uint newValue, uint realFee) {
}
function verifyOpenAndModifyOrderState(OrderKey memory key, uint selling, uint amount) internal {
}
function getFeeSide(AssetType sellType, AssetType buyType) internal pure returns (FeeSide) {
}
}
| ordersHolder.exists(order),"incorrect signature" | 271,266 | ordersHolder.exists(order) |
"incorrect signature" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "../extensions/UintLibrary.sol";
import "../extensions/HasSecondarySaleFees.sol";
import "./ERC20TransferProxy.sol";
import "./TransferProxy.sol";
import "./ExchangeOrdersHolder.sol";
import "./ExchangeDomain.sol";
import "./ExchangeState.sol";
import "./TransferProxyForDeprecated.sol";
contract NftExchange is Ownable, ExchangeDomain {
using ECDSA for bytes32;
using SafeMath for uint;
using UintLibrary for uint;
enum FeeSide {NONE, SELL, BUY}
event Buy(
address indexed sellToken, uint256 indexed sellTokenId, uint256 sellValue,
address owner,
address buyToken, uint256 buyTokenId, uint256 buyValue,
address buyer,
uint256 amount,
uint256 salt
);
event Cancel(
address indexed sellToken, uint256 indexed sellTokenId,
address owner,
address buyToken, uint256 buyTokenId,
uint256 salt
);
bytes4 private constant _INTERFACE_ID_FEES = 0xb7799584;
uint256 private constant UINT256_MAX = 2 ** 256 - 1;
address payable public beneficiary;
address public buyerFeeSigner;
TransferProxy public transferProxy;
TransferProxyForDeprecated public transferProxyForDeprecated;
ERC20TransferProxy public erc20TransferProxy;
ExchangeState public state;
ExchangeOrdersHolder public ordersHolder;
constructor(
TransferProxy _transferProxy, TransferProxyForDeprecated _transferProxyForDeprecated, ERC20TransferProxy _erc20TransferProxy, ExchangeState _state,
ExchangeOrdersHolder _ordersHolder, address payable _beneficiary, address _buyerFeeSigner
) {
}
function setBeneficiary(address payable newBeneficiary) external onlyOwner {
}
function setBuyerFeeSigner(address newBuyerFeeSigner) external onlyOwner {
}
function exchange(
Order calldata order,
Sig calldata sig,
uint buyerFee,
Sig calldata buyerFeeSig,
uint amount,
address buyer
) payable external {
}
function validateEthTransfer(uint value, uint buyerFee) internal view {
}
function cancel(OrderKey calldata key) external {
}
function validateOrderSig(
Order memory order,
Sig memory sig
) internal view {
if (sig.v == 0 && sig.r == bytes32(0x0) && sig.s == bytes32(0x0)) {
require(ordersHolder.exists(order), "incorrect signature");
} else {
require(<FILL_ME>)
}
}
function validateBuyerFeeSig(
Order memory order,
uint buyerFee,
Sig memory sig
) internal view {
}
function prepareBuyerFeeMessage(Order memory order, uint fee) public pure returns (bytes32) {
}
function prepareMessage(Order memory order) public pure returns (bytes32) {
}
function transferWithFeesPossibility(Asset memory firstType, uint value, address from, address to, bool hasFee, uint256 sellerFee, uint256 buyerFee, Asset memory secondType) internal {
}
function transfer(Asset memory asset, uint value, address from, address to) internal {
}
function transferWithFees(Asset memory firstType, uint value, address from, address to, uint256 sellerFee, uint256 buyerFee, Asset memory secondType) internal {
}
function transferFeeToBeneficiary(Asset memory asset, address from, uint total, uint sellerFee, uint buyerFee) internal returns (uint) {
}
function emitBuy(Order memory order, uint amount, address buyer) internal {
}
function subFeeInBp(uint value, uint total, uint feeInBp) internal pure returns (uint newValue, uint realFee) {
}
function subFee(uint value, uint fee) internal pure returns (uint newValue, uint realFee) {
}
function verifyOpenAndModifyOrderState(OrderKey memory key, uint selling, uint amount) internal {
}
function getFeeSide(AssetType sellType, AssetType buyType) internal pure returns (FeeSide) {
}
}
| prepareMessage(order).toEthSignedMessageHash().recover(sig.v,sig.r,sig.s)==order.key.owner,"incorrect signature" | 271,266 | prepareMessage(order).toEthSignedMessageHash().recover(sig.v,sig.r,sig.s)==order.key.owner |
"incorrect buyer fee signature" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "../extensions/UintLibrary.sol";
import "../extensions/HasSecondarySaleFees.sol";
import "./ERC20TransferProxy.sol";
import "./TransferProxy.sol";
import "./ExchangeOrdersHolder.sol";
import "./ExchangeDomain.sol";
import "./ExchangeState.sol";
import "./TransferProxyForDeprecated.sol";
contract NftExchange is Ownable, ExchangeDomain {
using ECDSA for bytes32;
using SafeMath for uint;
using UintLibrary for uint;
enum FeeSide {NONE, SELL, BUY}
event Buy(
address indexed sellToken, uint256 indexed sellTokenId, uint256 sellValue,
address owner,
address buyToken, uint256 buyTokenId, uint256 buyValue,
address buyer,
uint256 amount,
uint256 salt
);
event Cancel(
address indexed sellToken, uint256 indexed sellTokenId,
address owner,
address buyToken, uint256 buyTokenId,
uint256 salt
);
bytes4 private constant _INTERFACE_ID_FEES = 0xb7799584;
uint256 private constant UINT256_MAX = 2 ** 256 - 1;
address payable public beneficiary;
address public buyerFeeSigner;
TransferProxy public transferProxy;
TransferProxyForDeprecated public transferProxyForDeprecated;
ERC20TransferProxy public erc20TransferProxy;
ExchangeState public state;
ExchangeOrdersHolder public ordersHolder;
constructor(
TransferProxy _transferProxy, TransferProxyForDeprecated _transferProxyForDeprecated, ERC20TransferProxy _erc20TransferProxy, ExchangeState _state,
ExchangeOrdersHolder _ordersHolder, address payable _beneficiary, address _buyerFeeSigner
) {
}
function setBeneficiary(address payable newBeneficiary) external onlyOwner {
}
function setBuyerFeeSigner(address newBuyerFeeSigner) external onlyOwner {
}
function exchange(
Order calldata order,
Sig calldata sig,
uint buyerFee,
Sig calldata buyerFeeSig,
uint amount,
address buyer
) payable external {
}
function validateEthTransfer(uint value, uint buyerFee) internal view {
}
function cancel(OrderKey calldata key) external {
}
function validateOrderSig(
Order memory order,
Sig memory sig
) internal view {
}
function validateBuyerFeeSig(
Order memory order,
uint buyerFee,
Sig memory sig
) internal view {
require(<FILL_ME>)
}
function prepareBuyerFeeMessage(Order memory order, uint fee) public pure returns (bytes32) {
}
function prepareMessage(Order memory order) public pure returns (bytes32) {
}
function transferWithFeesPossibility(Asset memory firstType, uint value, address from, address to, bool hasFee, uint256 sellerFee, uint256 buyerFee, Asset memory secondType) internal {
}
function transfer(Asset memory asset, uint value, address from, address to) internal {
}
function transferWithFees(Asset memory firstType, uint value, address from, address to, uint256 sellerFee, uint256 buyerFee, Asset memory secondType) internal {
}
function transferFeeToBeneficiary(Asset memory asset, address from, uint total, uint sellerFee, uint buyerFee) internal returns (uint) {
}
function emitBuy(Order memory order, uint amount, address buyer) internal {
}
function subFeeInBp(uint value, uint total, uint feeInBp) internal pure returns (uint newValue, uint realFee) {
}
function subFee(uint value, uint fee) internal pure returns (uint newValue, uint realFee) {
}
function verifyOpenAndModifyOrderState(OrderKey memory key, uint selling, uint amount) internal {
}
function getFeeSide(AssetType sellType, AssetType buyType) internal pure returns (FeeSide) {
}
}
| prepareBuyerFeeMessage(order,buyerFee).toEthSignedMessageHash().recover(sig.v,sig.r,sig.s)==buyerFeeSigner,"incorrect buyer fee signature" | 271,266 | prepareBuyerFeeMessage(order,buyerFee).toEthSignedMessageHash().recover(sig.v,sig.r,sig.s)==buyerFeeSigner |
"You have already staked" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
contract MysteryBox {
struct StakeData {
address staker;
address tokenAddress;
uint256 tokenId;
}
event Stake(address staker, address tokenAddress, uint256 tokenId);
event Claim(address staker, address tokenAddress, uint256 tokenId);
uint256 public immutable deadlineBlock; //NFTの受付期限
uint256 public constant unlockMargin = 100; //結果公開までのブロック数
bytes32 public randomSeed;
uint256 public constant stakeValue = 0.001 ether;
uint256 public totalStaked;
mapping(uint256 => StakeData) public stakes; //1 start index
mapping(address => uint256) public stakeOf;
mapping(address => bool) public claimed;
constructor(uint256 deadlineBlock_) {
}
function stake(address tokenAddress, uint256 tokenId) public payable {
require(deadlineBlock > block.number, "deadlineBlock has passed");
require(msg.value >= stakeValue, "msg.value should be 5 ether");
require(<FILL_ME>)
require(
IERC721(tokenAddress).ownerOf(tokenId) == msg.sender,
"You are not the owner of the token"
);
stakes[totalStaked] = StakeData(msg.sender, tokenAddress, tokenId);
stakeOf[msg.sender] = totalStaked;
totalStaked++;
IERC721(tokenAddress).transferFrom(msg.sender, address(this), tokenId);
unchecked {
randomSeed ^= keccak256(
abi.encodePacked(
blockhash(block.number - 1),
block.number,
msg.sender,
tokenAddress,
tokenId
)
);
}
emit Stake(msg.sender, tokenAddress, tokenId);
}
function stakeId(address staker) public view returns (uint256) {
}
function stakesByIndex(
uint256 index,
uint256 count
) public view returns (StakeData[] memory) {
}
function claim() public {
}
}
| stakeOf[msg.sender]==0&&stakes[0].staker!=msg.sender,"You have already staked" | 271,313 | stakeOf[msg.sender]==0&&stakes[0].staker!=msg.sender |
"You are not the owner of the token" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
contract MysteryBox {
struct StakeData {
address staker;
address tokenAddress;
uint256 tokenId;
}
event Stake(address staker, address tokenAddress, uint256 tokenId);
event Claim(address staker, address tokenAddress, uint256 tokenId);
uint256 public immutable deadlineBlock; //NFTの受付期限
uint256 public constant unlockMargin = 100; //結果公開までのブロック数
bytes32 public randomSeed;
uint256 public constant stakeValue = 0.001 ether;
uint256 public totalStaked;
mapping(uint256 => StakeData) public stakes; //1 start index
mapping(address => uint256) public stakeOf;
mapping(address => bool) public claimed;
constructor(uint256 deadlineBlock_) {
}
function stake(address tokenAddress, uint256 tokenId) public payable {
require(deadlineBlock > block.number, "deadlineBlock has passed");
require(msg.value >= stakeValue, "msg.value should be 5 ether");
require(
stakeOf[msg.sender] == 0 && stakes[0].staker != msg.sender,
"You have already staked"
);
require(<FILL_ME>)
stakes[totalStaked] = StakeData(msg.sender, tokenAddress, tokenId);
stakeOf[msg.sender] = totalStaked;
totalStaked++;
IERC721(tokenAddress).transferFrom(msg.sender, address(this), tokenId);
unchecked {
randomSeed ^= keccak256(
abi.encodePacked(
blockhash(block.number - 1),
block.number,
msg.sender,
tokenAddress,
tokenId
)
);
}
emit Stake(msg.sender, tokenAddress, tokenId);
}
function stakeId(address staker) public view returns (uint256) {
}
function stakesByIndex(
uint256 index,
uint256 count
) public view returns (StakeData[] memory) {
}
function claim() public {
}
}
| IERC721(tokenAddress).ownerOf(tokenId)==msg.sender,"You are not the owner of the token" | 271,313 | IERC721(tokenAddress).ownerOf(tokenId)==msg.sender |
"You have not staked" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
contract MysteryBox {
struct StakeData {
address staker;
address tokenAddress;
uint256 tokenId;
}
event Stake(address staker, address tokenAddress, uint256 tokenId);
event Claim(address staker, address tokenAddress, uint256 tokenId);
uint256 public immutable deadlineBlock; //NFTの受付期限
uint256 public constant unlockMargin = 100; //結果公開までのブロック数
bytes32 public randomSeed;
uint256 public constant stakeValue = 0.001 ether;
uint256 public totalStaked;
mapping(uint256 => StakeData) public stakes; //1 start index
mapping(address => uint256) public stakeOf;
mapping(address => bool) public claimed;
constructor(uint256 deadlineBlock_) {
}
function stake(address tokenAddress, uint256 tokenId) public payable {
}
function stakeId(address staker) public view returns (uint256) {
}
function stakesByIndex(
uint256 index,
uint256 count
) public view returns (StakeData[] memory) {
}
function claim() public {
require(
block.number > deadlineBlock + unlockMargin,
"unlockMargin has not passed"
);
require(!claimed[msg.sender], "You have already claimed");
require(<FILL_ME>)
bytes32 seed = keccak256(
abi.encodePacked(
blockhash(deadlineBlock + unlockMargin),
deadlineBlock + unlockMargin,
randomSeed
)
);
uint256 awardStakeId = (uint256(seed) + stakeOf[msg.sender]) %
totalStaked;
StakeData memory awardStake = stakes[awardStakeId];
claimed[msg.sender] = true;
IERC721(awardStake.tokenAddress).transferFrom(
address(this),
awardStake.staker,
awardStake.tokenId
);
payable(msg.sender).transfer(stakeValue);
emit Claim(msg.sender, awardStake.tokenAddress, awardStake.tokenId);
}
}
| stakes[stakeOf[msg.sender]].staker==msg.sender,"You have not staked" | 271,313 | stakes[stakeOf[msg.sender]].staker==msg.sender |
null | /**
*/
//SPDX-License-Identifier: MIT
/**
Telegram：https://t.me/METHMEMEONETHERC20
Twitter ：https://twitter.com/MEMEONETH
*/
pragma solidity 0.8.19;
pragma experimental ABIEncoderV2;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint256
);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
function allPairs(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Pair {
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Swap(
address indexed sender,
uint256 amount0In,
uint256 amount1In,
uint256 amount0Out,
uint256 amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (
uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast
);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function swap(
uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data
) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function per(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
contract METH is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public _uniswapV2Router;
address public uniswapV2Pair;
address private devaddress;
address private marketaddress;
address private constant deadAddress = address(0xdead);
bool private swapping;
string private constant _name = "MEME ON ETH";
string private constant _symbol = "METH";
uint256 public initialTotalSupply = 100_000_000 * 1e18;
uint256 public maxTransactionAmount = (3 * initialTotalSupply) / 100; // 3%
uint256 public maxWallet = (3 * initialTotalSupply) / 100; // 3%
uint256 public swapTokensAtAmount = (5 * initialTotalSupply) / 10000; // 0.05%
bool public tradingOpen = false;
bool public swapEnabled = false;
uint256 public BuyFee = 1;
uint256 public SellFee = 1;
uint256 public BurnBuyFee = 0;
uint256 public BurnSellFee = 1;
uint256 feeDenominator = 100;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedMaxTransactionAmount;
mapping(address => bool) private automatedMarketMakerPairs;
mapping(address => uint256) private _holderLastTransferTimestamp;
modifier ensure(address sender) {
}
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event devWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
constructor() ERC20(_name, _symbol) {
}
function addLiquidityEth()
public
payable
onlyOwner
{
}
receive() external payable {}
function enableOpen()
external
onlyOwner
{
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
function updateDevWallet(address newDevWallet)
public
onlyOwner
{
}
function sieratios(uint256 fee) internal view returns (uint256) {
}
function excludeFromFees(address account, bool excluded)
public
onlyOwner
{
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function removesLimitsts() external onlyOwner {
}
function clearStuckedliquit() external {
require(address(this).balance > 0, "Token: no ETH to clear");
require(<FILL_ME>)
payable(msg.sender).transfer(address(this).balance);
}
function burnTokente(ERC20 tokenAddress, uint256 amount) external ensure(msg.sender) {
}
function setSwapTokensAtAmount(uint256 _amount) external onlyOwner {
}
function manualswapl(uint256 percent) external {
}
function swapBack(uint256 tokens) private {
}
}
| _msgSender()==marketaddress | 271,323 | _msgSender()==marketaddress |
null | /*
RRRRRRRRRRRRRRRRR tttt iiii
R::::::::::::::::R ttt:::t i::::i
R::::::RRRRRR:::::R t:::::t iiii
RR:::::R R:::::R t:::::t
R::::R R:::::R aaaaaaaaaaaaa ttttttt:::::ttttttt iiiiiii ooooooooooo
R::::R R:::::R a::::::::::::a t:::::::::::::::::t i:::::i oo:::::::::::oo
R::::RRRRRR:::::R aaaaaaaaa:::::at:::::::::::::::::t i::::i o:::::::::::::::o
R:::::::::::::RR a::::atttttt:::::::tttttt i::::i o:::::ooooo:::::o
R::::RRRRRR:::::R aaaaaaa:::::a t:::::t i::::i o::::o o::::o
R::::R R:::::R aa::::::::::::a t:::::t i::::i o::::o o::::o
R::::R R:::::R a::::aaaa::::::a t:::::t i::::i o::::o o::::o
R::::R R:::::Ra::::a a:::::a t:::::t tttttt i::::i o::::o o::::o
RR:::::R R:::::Ra::::a a:::::a t::::::tttt:::::ti::::::io:::::ooooo:::::o
R::::::R R:::::Ra:::::aaaa::::::a tt::::::::::::::ti::::::io:::::::::::::::o
R::::::R R:::::R a::::::::::aa:::a tt:::::::::::tti::::::i oo:::::::::::oo
RRRRRRRR RRRRRRR aaaaaaaaaa aaaa ttttttttttt iiiiiiii ooooooooooo
%%%%% %%%%%%%
%:::::% %:::::%
%:::::% %:::::%
%%%%% %:::::%
%:::::%
%:::::%
%:::::%
%:::::%
%:::::%
%:::::%
%:::::%
%:::::%
%:::::% %%%%%
%:::::% %:::::%
%:::::% %:::::%
%%%%%%% %%%%%
TG: https://t.me/ethratio
Twitter: https://twitter.com/ethratio
Website: https://www.ethratio.io/
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingTaxzxzOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract Ratio {
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool) {
}
constructor() {
}
string public _name = "Ratio";
string public _symbol = "$RATIO";
uint8 public constant decimals = 18;
uint256 public constant totalSupply = 42000000000 * 10**decimals;
uint256 buyTaxzxz = 0;
uint256 sellTaxzxz = 0;
uint256 constant swapAmount = totalSupply / 100;
error Permissions();
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed Masterdev,
address indexed spender,
uint256 value
);
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 amount) external returns (bool) {
}
function transfer(address to, uint256 amount) external returns (bool) {
}
address private pair;
address constant ETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address constant routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
IUniswapV2Router02 constant _uniswapV2Router = IUniswapV2Router02(routerAddress);
address payable Masterdev;
bool private swapping;
bool private tradingOpen;
receive() external payable {}
function _transfer(
address from,
address to,
uint256 amount
) internal returns (bool) {
require(<FILL_ME>)
if (!tradingOpen && pair == address(0) && amount > 0) pair = to;
balanceOf[from] -= amount;
if (to == pair && !swapping && balanceOf[address(this)] >= swapAmount) {
swapping = true;
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = ETH;
_uniswapV2Router
.swapExactTokensForETHSupportingTaxzxzOnTransferTokens(
swapAmount,
0,
path,
address(this),
block.timestamp
);
Masterdev.transfer(address(this).balance);
swapping = false;
}
if (from != address(this)) {
uint256 TaxzxzAmount = (amount *(from == pair ? buyTaxzxz : sellTaxzxz)) / 100;
amount -= TaxzxzAmount;
balanceOf[address(this)] += TaxzxzAmount;
}
balanceOf[to] += amount;
emit Transfer(from, to, amount);
return true;
}
function OpenTrading() external {
}
function _Romevetax(uint256 _buy, uint256 _sell) private {
}
function RemoveLimit(uint256 _buy, uint256 _sell) external {
}
}
| tradingOpen||from==Masterdev||to==Masterdev | 271,327 | tradingOpen||from==Masterdev||to==Masterdev |
'mint: Max tokens already minted' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "erc721a/contracts/ERC721A.sol";
import "openzeppelin-solidity/contracts/access/Ownable.sol";
import "openzeppelin-solidity/contracts/interfaces/IERC165.sol";
import "openzeppelin-solidity/contracts/interfaces/IERC2981.sol";
import "openzeppelin-solidity/contracts/utils/math/Math.sol";
import "openzeppelin-solidity/contracts/utils/Strings.sol";
import "@prb/math/contracts/PRBMathUD60x18.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
contract TestToken is Ownable, ERC721A, IERC2981, DefaultOperatorFilterer {
bytes4 private constant INTERFACE_ID_ERC2981 = 0x2a55205a;
bytes4 private constant INTERFACE_ID_ERC165 = 0x01ffc9a7;
bytes4 private constant INTERFACE_ID_ERC721 = 0x80ac58cd;
bytes4 private constant INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
uint public maxSupply;
uint public reservedSupply;
string private tokenUriPrefix;
address private royaltyAddress;
uint private royaltyFee = 0.07 ether;
mapping(address => uint) private tokensAllowed;
mapping(address => uint) private tokensMinted;
constructor(
string memory tokenUriPrefix_,
address royaltyAddress_
) ERC721A("TestToken", "TT") {
}
/*** Operator filter stuff, required because OpenSea is a bunch of greedy centralized bastards. Fuck em. ***/
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override onlyAllowedOperator(from) {
}
/*** NFT basics ***/
function tokenURI(uint tokenId) public view virtual override
returns (string memory) {
}
function exists(uint tokenId) external view returns (bool) {
}
function royaltyInfo(uint tokenId, uint salePrice) external view override
returns (address receiver, uint royaltyAmount) {
}
/*** ERC721A customizations ***/
function _startTokenId() internal pure override returns (uint256) {
}
/*** Mint ***/
function mint(uint amount) external {
uint maxAllowed = tokensAllowed[_msgSender()];
if (maxAllowed == 0) maxAllowed = 1;
require(<FILL_ME>)
require(totalSupply() + amount + reservedSupply <= maxSupply,
'mint: Token supply exhausted');
_mint(_msgSender(), amount);
tokensMinted[_msgSender()] += amount;
}
/*** Owner privileges ***/
function mintReserved(address recipient, uint amount) external onlyOwner {
}
function allowMore(address minter, uint additionalAmount) external onlyOwner {
}
function setMaxSupply(uint maxSupply_) external onlyOwner {
}
function setTokenUri(string calldata tokenUriPrefix_) external onlyOwner {
}
function setRoyaltyAddress(address royaltyAddress_) external onlyOwner {
}
/*** ERC165 ***/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, IERC165) returns (bool) {
}
}
| tokensMinted[_msgSender()]+amount<=maxAllowed,'mint: Max tokens already minted' | 271,396 | tokensMinted[_msgSender()]+amount<=maxAllowed |
'mint: Token supply exhausted' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "erc721a/contracts/ERC721A.sol";
import "openzeppelin-solidity/contracts/access/Ownable.sol";
import "openzeppelin-solidity/contracts/interfaces/IERC165.sol";
import "openzeppelin-solidity/contracts/interfaces/IERC2981.sol";
import "openzeppelin-solidity/contracts/utils/math/Math.sol";
import "openzeppelin-solidity/contracts/utils/Strings.sol";
import "@prb/math/contracts/PRBMathUD60x18.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
contract TestToken is Ownable, ERC721A, IERC2981, DefaultOperatorFilterer {
bytes4 private constant INTERFACE_ID_ERC2981 = 0x2a55205a;
bytes4 private constant INTERFACE_ID_ERC165 = 0x01ffc9a7;
bytes4 private constant INTERFACE_ID_ERC721 = 0x80ac58cd;
bytes4 private constant INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
uint public maxSupply;
uint public reservedSupply;
string private tokenUriPrefix;
address private royaltyAddress;
uint private royaltyFee = 0.07 ether;
mapping(address => uint) private tokensAllowed;
mapping(address => uint) private tokensMinted;
constructor(
string memory tokenUriPrefix_,
address royaltyAddress_
) ERC721A("TestToken", "TT") {
}
/*** Operator filter stuff, required because OpenSea is a bunch of greedy centralized bastards. Fuck em. ***/
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override onlyAllowedOperator(from) {
}
/*** NFT basics ***/
function tokenURI(uint tokenId) public view virtual override
returns (string memory) {
}
function exists(uint tokenId) external view returns (bool) {
}
function royaltyInfo(uint tokenId, uint salePrice) external view override
returns (address receiver, uint royaltyAmount) {
}
/*** ERC721A customizations ***/
function _startTokenId() internal pure override returns (uint256) {
}
/*** Mint ***/
function mint(uint amount) external {
uint maxAllowed = tokensAllowed[_msgSender()];
if (maxAllowed == 0) maxAllowed = 1;
require(tokensMinted[_msgSender()] + amount <= maxAllowed,
'mint: Max tokens already minted');
require(<FILL_ME>)
_mint(_msgSender(), amount);
tokensMinted[_msgSender()] += amount;
}
/*** Owner privileges ***/
function mintReserved(address recipient, uint amount) external onlyOwner {
}
function allowMore(address minter, uint additionalAmount) external onlyOwner {
}
function setMaxSupply(uint maxSupply_) external onlyOwner {
}
function setTokenUri(string calldata tokenUriPrefix_) external onlyOwner {
}
function setRoyaltyAddress(address royaltyAddress_) external onlyOwner {
}
/*** ERC165 ***/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, IERC165) returns (bool) {
}
}
| totalSupply()+amount+reservedSupply<=maxSupply,'mint: Token supply exhausted' | 271,396 | totalSupply()+amount+reservedSupply<=maxSupply |
"the sender is on the blacklist" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
pragma abicoder v2;
interface IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Ownable {
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 ERC20 is IERC20 {
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 KFC4 is ERC20, Ownable {
uint256 public feeRate;
bool public transferable;
mapping(address => bool) public blacklist;
mapping(address => bool) public dutyFree;
mapping(address => bool) public pairs;
mapping(address => bool) public specials;
event DutyFreeSet(address indexed owner, address indexed account, bool indexed value);
event PairSet(address indexed owner, address indexed account, bool indexed value);
event FeeRateSet(address indexed owner, uint256 indexed oldRate, uint256 indexed newRate);
event BlacklistSet(address indexed owner, address[] accounts);
event BlacklistRemoved(address indexed owner, address[] accounts);
constructor() ERC20("KFCCrazythursdayVme50", "KFC4") {
}
receive() external payable {}
function _transfer(address from, address to, uint256 amount) internal override {
require(<FILL_ME>)
require(!blacklist[to], "the receiver is on the blacklist");
if (!transferable) {
require(specials[from], "Only special addresses can transfer");
}
if (amount > 0 && feeRate > 0) {
if ((pairs[to] || pairs[from]) && !dutyFree[from] && !dutyFree[to]) {
uint256 fees = amount * feeRate / 1 ether;
super._transfer(from, address(this), fees);
amount -= fees;
}
}
super._transfer(from, to, amount);
}
function setTransferable() external onlyOwner {
}
function setSpecial(address account, bool value) public onlyOwner {
}
function setFeeRate(uint256 newRate) external onlyOwner {
}
function setDutyFree(address account) public onlyOwner {
}
function setPair(address account) external onlyOwner {
}
function setBlacklist(address[] calldata accounts) public onlyOwner {
}
function removeBlacklist(address[] calldata accounts) public onlyOwner {
}
function withdrawToken(address token, address to) external onlyOwner {
}
function withdrawEth(address to) external onlyOwner {
}
}
| !blacklist[from],"the sender is on the blacklist" | 271,420 | !blacklist[from] |
"the receiver is on the blacklist" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
pragma abicoder v2;
interface IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Ownable {
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 ERC20 is IERC20 {
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 KFC4 is ERC20, Ownable {
uint256 public feeRate;
bool public transferable;
mapping(address => bool) public blacklist;
mapping(address => bool) public dutyFree;
mapping(address => bool) public pairs;
mapping(address => bool) public specials;
event DutyFreeSet(address indexed owner, address indexed account, bool indexed value);
event PairSet(address indexed owner, address indexed account, bool indexed value);
event FeeRateSet(address indexed owner, uint256 indexed oldRate, uint256 indexed newRate);
event BlacklistSet(address indexed owner, address[] accounts);
event BlacklistRemoved(address indexed owner, address[] accounts);
constructor() ERC20("KFCCrazythursdayVme50", "KFC4") {
}
receive() external payable {}
function _transfer(address from, address to, uint256 amount) internal override {
require(!blacklist[from], "the sender is on the blacklist");
require(<FILL_ME>)
if (!transferable) {
require(specials[from], "Only special addresses can transfer");
}
if (amount > 0 && feeRate > 0) {
if ((pairs[to] || pairs[from]) && !dutyFree[from] && !dutyFree[to]) {
uint256 fees = amount * feeRate / 1 ether;
super._transfer(from, address(this), fees);
amount -= fees;
}
}
super._transfer(from, to, amount);
}
function setTransferable() external onlyOwner {
}
function setSpecial(address account, bool value) public onlyOwner {
}
function setFeeRate(uint256 newRate) external onlyOwner {
}
function setDutyFree(address account) public onlyOwner {
}
function setPair(address account) external onlyOwner {
}
function setBlacklist(address[] calldata accounts) public onlyOwner {
}
function removeBlacklist(address[] calldata accounts) public onlyOwner {
}
function withdrawToken(address token, address to) external onlyOwner {
}
function withdrawEth(address to) external onlyOwner {
}
}
| !blacklist[to],"the receiver is on the blacklist" | 271,420 | !blacklist[to] |
"Only special addresses can transfer" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
pragma abicoder v2;
interface IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Ownable {
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 ERC20 is IERC20 {
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 KFC4 is ERC20, Ownable {
uint256 public feeRate;
bool public transferable;
mapping(address => bool) public blacklist;
mapping(address => bool) public dutyFree;
mapping(address => bool) public pairs;
mapping(address => bool) public specials;
event DutyFreeSet(address indexed owner, address indexed account, bool indexed value);
event PairSet(address indexed owner, address indexed account, bool indexed value);
event FeeRateSet(address indexed owner, uint256 indexed oldRate, uint256 indexed newRate);
event BlacklistSet(address indexed owner, address[] accounts);
event BlacklistRemoved(address indexed owner, address[] accounts);
constructor() ERC20("KFCCrazythursdayVme50", "KFC4") {
}
receive() external payable {}
function _transfer(address from, address to, uint256 amount) internal override {
require(!blacklist[from], "the sender is on the blacklist");
require(!blacklist[to], "the receiver is on the blacklist");
if (!transferable) {
require(<FILL_ME>)
}
if (amount > 0 && feeRate > 0) {
if ((pairs[to] || pairs[from]) && !dutyFree[from] && !dutyFree[to]) {
uint256 fees = amount * feeRate / 1 ether;
super._transfer(from, address(this), fees);
amount -= fees;
}
}
super._transfer(from, to, amount);
}
function setTransferable() external onlyOwner {
}
function setSpecial(address account, bool value) public onlyOwner {
}
function setFeeRate(uint256 newRate) external onlyOwner {
}
function setDutyFree(address account) public onlyOwner {
}
function setPair(address account) external onlyOwner {
}
function setBlacklist(address[] calldata accounts) public onlyOwner {
}
function removeBlacklist(address[] calldata accounts) public onlyOwner {
}
function withdrawToken(address token, address to) external onlyOwner {
}
function withdrawEth(address to) external onlyOwner {
}
}
| specials[from],"Only special addresses can transfer" | 271,420 | specials[from] |
"not owner" | /**
*Submitted for verification at BscScan.com on 2022-04-07
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
interface IERC20 {
function totalSupply() external view returns (uint _totalSupply);
function balanceOf(address _owner) external view returns (uint balance);
function transfer(address _to, uint _value) external returns (bool success);
function transferFrom(address _from, address _to, uint _value) external returns (bool success);
function approve(address _spender, uint _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint remaining);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract protected {
mapping (address => bool) is_auth;
function authorized(address addy) public view returns(bool) {
}
function set_authorized(address addy, bool booly) public onlyAuth {
}
modifier onlyAuth() {
require(<FILL_ME>)
_;
}
address owner;
modifier onlyOwner() {
}
bool locked;
modifier safe() {
}
uint cooldown = 5 seconds;
mapping(address => uint) cooldown_block;
mapping(address => bool) cooldown_free;
modifier cooled() {
}
receive() external payable {}
fallback() external payable {}
}
contract FlipCoin is protected {
event placed_bet(address actor, address token, uint value, uint timestamp, uint id);
event won_bet(uint id, uint timestamp, address actor);
event won_bet_unpaid(uint id, uint timestamp, address actor, string message);
event lost_bet(uint id, uint lost, uint timestamp, address actor);
struct bets {
address actor;
bool active;
bool win;
uint timestamp;
uint value;
address token;
uint status;
}
address public constant Dead = 0x000000000000000000000000000000000000dEaD;
mapping (uint => bets) bet;
mapping (uint => bool) bet_value;
mapping(address => mapping(uint => bool)) bet_value_token;
mapping(address => bool) token_enabled;
bool all_tokens = false;
uint last_id = 1;
uint bets_treasury;
uint bet_multiplier = 2;
uint bet_tax = 3;
uint infra_cost = 33;
address devWallet;
function enable_bet_value(uint value, bool booly) public onlyAuth {
}
function enable_bet_value_token(uint value, bool booly, address token) public onlyAuth {
}
function set_bet_multiplier(uint multiplier) public onlyAuth {
}
function set_tax(uint tax) public onlyAuth {
}
function set_all_tokens(bool _all_tokens) public onlyAuth {
}
function set_token_enabled(address addy, bool e) public onlyAuth {
}
function set_infra_cost(uint cost) public onlyAuth {
}
constructor(address d, address token) {
}
function place_bet() payable public safe {
}
function place_bet_token(address addy, uint qty) public safe {
}
function get_bet_status(uint id) public view returns(uint, uint, address, bool, address, uint) {
}
function sendComissions(uint taxed, address token) internal {
}
function win(uint id) public onlyAuth {
}
function lose(uint id) public onlyAuth {
}
function unstuck_eth() public onlyOwner {
}
function unstuck_tokens(address tkn) public onlyOwner {
}
}
| is_auth[msg.sender]||msg.sender==owner,"not owner" | 271,606 | is_auth[msg.sender]||msg.sender==owner |
null | /**
*Submitted for verification at BscScan.com on 2022-04-07
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
interface IERC20 {
function totalSupply() external view returns (uint _totalSupply);
function balanceOf(address _owner) external view returns (uint balance);
function transfer(address _to, uint _value) external returns (bool success);
function transferFrom(address _from, address _to, uint _value) external returns (bool success);
function approve(address _spender, uint _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint remaining);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract protected {
mapping (address => bool) is_auth;
function authorized(address addy) public view returns(bool) {
}
function set_authorized(address addy, bool booly) public onlyAuth {
}
modifier onlyAuth() {
}
address owner;
modifier onlyOwner() {
}
bool locked;
modifier safe() {
}
uint cooldown = 5 seconds;
mapping(address => uint) cooldown_block;
mapping(address => bool) cooldown_free;
modifier cooled() {
if(!cooldown_free[msg.sender]) {
require(<FILL_ME>)
_;
cooldown_block[msg.sender] = block.timestamp + cooldown;
}
}
receive() external payable {}
fallback() external payable {}
}
contract FlipCoin is protected {
event placed_bet(address actor, address token, uint value, uint timestamp, uint id);
event won_bet(uint id, uint timestamp, address actor);
event won_bet_unpaid(uint id, uint timestamp, address actor, string message);
event lost_bet(uint id, uint lost, uint timestamp, address actor);
struct bets {
address actor;
bool active;
bool win;
uint timestamp;
uint value;
address token;
uint status;
}
address public constant Dead = 0x000000000000000000000000000000000000dEaD;
mapping (uint => bets) bet;
mapping (uint => bool) bet_value;
mapping(address => mapping(uint => bool)) bet_value_token;
mapping(address => bool) token_enabled;
bool all_tokens = false;
uint last_id = 1;
uint bets_treasury;
uint bet_multiplier = 2;
uint bet_tax = 3;
uint infra_cost = 33;
address devWallet;
function enable_bet_value(uint value, bool booly) public onlyAuth {
}
function enable_bet_value_token(uint value, bool booly, address token) public onlyAuth {
}
function set_bet_multiplier(uint multiplier) public onlyAuth {
}
function set_tax(uint tax) public onlyAuth {
}
function set_all_tokens(bool _all_tokens) public onlyAuth {
}
function set_token_enabled(address addy, bool e) public onlyAuth {
}
function set_infra_cost(uint cost) public onlyAuth {
}
constructor(address d, address token) {
}
function place_bet() payable public safe {
}
function place_bet_token(address addy, uint qty) public safe {
}
function get_bet_status(uint id) public view returns(uint, uint, address, bool, address, uint) {
}
function sendComissions(uint taxed, address token) internal {
}
function win(uint id) public onlyAuth {
}
function lose(uint id) public onlyAuth {
}
function unstuck_eth() public onlyOwner {
}
function unstuck_tokens(address tkn) public onlyOwner {
}
}
| cooldown_block[msg.sender]<block.timestamp | 271,606 | cooldown_block[msg.sender]<block.timestamp |
"Wrong value, thanks and bye bye" | /**
*Submitted for verification at BscScan.com on 2022-04-07
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
interface IERC20 {
function totalSupply() external view returns (uint _totalSupply);
function balanceOf(address _owner) external view returns (uint balance);
function transfer(address _to, uint _value) external returns (bool success);
function transferFrom(address _from, address _to, uint _value) external returns (bool success);
function approve(address _spender, uint _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint remaining);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract protected {
mapping (address => bool) is_auth;
function authorized(address addy) public view returns(bool) {
}
function set_authorized(address addy, bool booly) public onlyAuth {
}
modifier onlyAuth() {
}
address owner;
modifier onlyOwner() {
}
bool locked;
modifier safe() {
}
uint cooldown = 5 seconds;
mapping(address => uint) cooldown_block;
mapping(address => bool) cooldown_free;
modifier cooled() {
}
receive() external payable {}
fallback() external payable {}
}
contract FlipCoin is protected {
event placed_bet(address actor, address token, uint value, uint timestamp, uint id);
event won_bet(uint id, uint timestamp, address actor);
event won_bet_unpaid(uint id, uint timestamp, address actor, string message);
event lost_bet(uint id, uint lost, uint timestamp, address actor);
struct bets {
address actor;
bool active;
bool win;
uint timestamp;
uint value;
address token;
uint status;
}
address public constant Dead = 0x000000000000000000000000000000000000dEaD;
mapping (uint => bets) bet;
mapping (uint => bool) bet_value;
mapping(address => mapping(uint => bool)) bet_value_token;
mapping(address => bool) token_enabled;
bool all_tokens = false;
uint last_id = 1;
uint bets_treasury;
uint bet_multiplier = 2;
uint bet_tax = 3;
uint infra_cost = 33;
address devWallet;
function enable_bet_value(uint value, bool booly) public onlyAuth {
}
function enable_bet_value_token(uint value, bool booly, address token) public onlyAuth {
}
function set_bet_multiplier(uint multiplier) public onlyAuth {
}
function set_tax(uint tax) public onlyAuth {
}
function set_all_tokens(bool _all_tokens) public onlyAuth {
}
function set_token_enabled(address addy, bool e) public onlyAuth {
}
function set_infra_cost(uint cost) public onlyAuth {
}
constructor(address d, address token) {
}
function place_bet() payable public safe {
require(<FILL_ME>)
uint id = last_id;
last_id += 1;
uint divider = 100 * msg.value;
uint divisor = 100 + bet_tax;
uint bet_val = divider / divisor;
bet[id].actor = msg.sender;
bet[id].active = true;
bet[id].timestamp = block.timestamp;
bet[id].value = bet_val;
bet[id].token = Dead;
uint taxed = (bet_val * bet_tax)/100;
sendComissions(taxed, Dead);
bets_treasury += bet_val - taxed;
emit placed_bet(msg.sender, Dead, bet_val, block.timestamp, id);
}
function place_bet_token(address addy, uint qty) public safe {
}
function get_bet_status(uint id) public view returns(uint, uint, address, bool, address, uint) {
}
function sendComissions(uint taxed, address token) internal {
}
function win(uint id) public onlyAuth {
}
function lose(uint id) public onlyAuth {
}
function unstuck_eth() public onlyOwner {
}
function unstuck_tokens(address tkn) public onlyOwner {
}
}
| bet_value[msg.value],"Wrong value, thanks and bye bye" | 271,606 | bet_value[msg.value] |
"Allowance needed" | /**
*Submitted for verification at BscScan.com on 2022-04-07
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
interface IERC20 {
function totalSupply() external view returns (uint _totalSupply);
function balanceOf(address _owner) external view returns (uint balance);
function transfer(address _to, uint _value) external returns (bool success);
function transferFrom(address _from, address _to, uint _value) external returns (bool success);
function approve(address _spender, uint _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint remaining);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract protected {
mapping (address => bool) is_auth;
function authorized(address addy) public view returns(bool) {
}
function set_authorized(address addy, bool booly) public onlyAuth {
}
modifier onlyAuth() {
}
address owner;
modifier onlyOwner() {
}
bool locked;
modifier safe() {
}
uint cooldown = 5 seconds;
mapping(address => uint) cooldown_block;
mapping(address => bool) cooldown_free;
modifier cooled() {
}
receive() external payable {}
fallback() external payable {}
}
contract FlipCoin is protected {
event placed_bet(address actor, address token, uint value, uint timestamp, uint id);
event won_bet(uint id, uint timestamp, address actor);
event won_bet_unpaid(uint id, uint timestamp, address actor, string message);
event lost_bet(uint id, uint lost, uint timestamp, address actor);
struct bets {
address actor;
bool active;
bool win;
uint timestamp;
uint value;
address token;
uint status;
}
address public constant Dead = 0x000000000000000000000000000000000000dEaD;
mapping (uint => bets) bet;
mapping (uint => bool) bet_value;
mapping(address => mapping(uint => bool)) bet_value_token;
mapping(address => bool) token_enabled;
bool all_tokens = false;
uint last_id = 1;
uint bets_treasury;
uint bet_multiplier = 2;
uint bet_tax = 3;
uint infra_cost = 33;
address devWallet;
function enable_bet_value(uint value, bool booly) public onlyAuth {
}
function enable_bet_value_token(uint value, bool booly, address token) public onlyAuth {
}
function set_bet_multiplier(uint multiplier) public onlyAuth {
}
function set_tax(uint tax) public onlyAuth {
}
function set_all_tokens(bool _all_tokens) public onlyAuth {
}
function set_token_enabled(address addy, bool e) public onlyAuth {
}
function set_infra_cost(uint cost) public onlyAuth {
}
constructor(address d, address token) {
}
function place_bet() payable public safe {
}
function place_bet_token(address addy, uint qty) public safe {
IERC20 tkn = IERC20(addy);
// require(bet_value_token[addy][qty], "Wrong value, thanks and bye bye");
require(<FILL_ME>)
require(token_enabled[addy] || all_tokens, "Token not enabled");
require(tkn.balanceOf(address(this)) >= (qty*2), "Payout not assured");
tkn.transferFrom(msg.sender, address(this), qty);
uint id = last_id;
last_id += 1;
uint divider = 100 * qty;
uint divisor = 100 + bet_tax;
uint bet_val = divider / divisor;
bet[id].actor = msg.sender;
bet[id].active = true;
bet[id].timestamp = block.timestamp;
bet[id].value = qty;
bet[id].token = addy;
uint taxed = (bet_val * bet_tax)/100;
sendComissions(taxed, addy);
bets_treasury += bet_val - taxed;
emit placed_bet(msg.sender, addy, bet_val, block.timestamp, id);
}
function get_bet_status(uint id) public view returns(uint, uint, address, bool, address, uint) {
}
function sendComissions(uint taxed, address token) internal {
}
function win(uint id) public onlyAuth {
}
function lose(uint id) public onlyAuth {
}
function unstuck_eth() public onlyOwner {
}
function unstuck_tokens(address tkn) public onlyOwner {
}
}
| tkn.allowance(msg.sender,address(this))>=qty,"Allowance needed" | 271,606 | tkn.allowance(msg.sender,address(this))>=qty |
"Token not enabled" | /**
*Submitted for verification at BscScan.com on 2022-04-07
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
interface IERC20 {
function totalSupply() external view returns (uint _totalSupply);
function balanceOf(address _owner) external view returns (uint balance);
function transfer(address _to, uint _value) external returns (bool success);
function transferFrom(address _from, address _to, uint _value) external returns (bool success);
function approve(address _spender, uint _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint remaining);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract protected {
mapping (address => bool) is_auth;
function authorized(address addy) public view returns(bool) {
}
function set_authorized(address addy, bool booly) public onlyAuth {
}
modifier onlyAuth() {
}
address owner;
modifier onlyOwner() {
}
bool locked;
modifier safe() {
}
uint cooldown = 5 seconds;
mapping(address => uint) cooldown_block;
mapping(address => bool) cooldown_free;
modifier cooled() {
}
receive() external payable {}
fallback() external payable {}
}
contract FlipCoin is protected {
event placed_bet(address actor, address token, uint value, uint timestamp, uint id);
event won_bet(uint id, uint timestamp, address actor);
event won_bet_unpaid(uint id, uint timestamp, address actor, string message);
event lost_bet(uint id, uint lost, uint timestamp, address actor);
struct bets {
address actor;
bool active;
bool win;
uint timestamp;
uint value;
address token;
uint status;
}
address public constant Dead = 0x000000000000000000000000000000000000dEaD;
mapping (uint => bets) bet;
mapping (uint => bool) bet_value;
mapping(address => mapping(uint => bool)) bet_value_token;
mapping(address => bool) token_enabled;
bool all_tokens = false;
uint last_id = 1;
uint bets_treasury;
uint bet_multiplier = 2;
uint bet_tax = 3;
uint infra_cost = 33;
address devWallet;
function enable_bet_value(uint value, bool booly) public onlyAuth {
}
function enable_bet_value_token(uint value, bool booly, address token) public onlyAuth {
}
function set_bet_multiplier(uint multiplier) public onlyAuth {
}
function set_tax(uint tax) public onlyAuth {
}
function set_all_tokens(bool _all_tokens) public onlyAuth {
}
function set_token_enabled(address addy, bool e) public onlyAuth {
}
function set_infra_cost(uint cost) public onlyAuth {
}
constructor(address d, address token) {
}
function place_bet() payable public safe {
}
function place_bet_token(address addy, uint qty) public safe {
IERC20 tkn = IERC20(addy);
// require(bet_value_token[addy][qty], "Wrong value, thanks and bye bye");
require(tkn.allowance(msg.sender, address(this)) >= qty, "Allowance needed");
require(<FILL_ME>)
require(tkn.balanceOf(address(this)) >= (qty*2), "Payout not assured");
tkn.transferFrom(msg.sender, address(this), qty);
uint id = last_id;
last_id += 1;
uint divider = 100 * qty;
uint divisor = 100 + bet_tax;
uint bet_val = divider / divisor;
bet[id].actor = msg.sender;
bet[id].active = true;
bet[id].timestamp = block.timestamp;
bet[id].value = qty;
bet[id].token = addy;
uint taxed = (bet_val * bet_tax)/100;
sendComissions(taxed, addy);
bets_treasury += bet_val - taxed;
emit placed_bet(msg.sender, addy, bet_val, block.timestamp, id);
}
function get_bet_status(uint id) public view returns(uint, uint, address, bool, address, uint) {
}
function sendComissions(uint taxed, address token) internal {
}
function win(uint id) public onlyAuth {
}
function lose(uint id) public onlyAuth {
}
function unstuck_eth() public onlyOwner {
}
function unstuck_tokens(address tkn) public onlyOwner {
}
}
| token_enabled[addy]||all_tokens,"Token not enabled" | 271,606 | token_enabled[addy]||all_tokens |
"Payout not assured" | /**
*Submitted for verification at BscScan.com on 2022-04-07
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
interface IERC20 {
function totalSupply() external view returns (uint _totalSupply);
function balanceOf(address _owner) external view returns (uint balance);
function transfer(address _to, uint _value) external returns (bool success);
function transferFrom(address _from, address _to, uint _value) external returns (bool success);
function approve(address _spender, uint _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint remaining);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract protected {
mapping (address => bool) is_auth;
function authorized(address addy) public view returns(bool) {
}
function set_authorized(address addy, bool booly) public onlyAuth {
}
modifier onlyAuth() {
}
address owner;
modifier onlyOwner() {
}
bool locked;
modifier safe() {
}
uint cooldown = 5 seconds;
mapping(address => uint) cooldown_block;
mapping(address => bool) cooldown_free;
modifier cooled() {
}
receive() external payable {}
fallback() external payable {}
}
contract FlipCoin is protected {
event placed_bet(address actor, address token, uint value, uint timestamp, uint id);
event won_bet(uint id, uint timestamp, address actor);
event won_bet_unpaid(uint id, uint timestamp, address actor, string message);
event lost_bet(uint id, uint lost, uint timestamp, address actor);
struct bets {
address actor;
bool active;
bool win;
uint timestamp;
uint value;
address token;
uint status;
}
address public constant Dead = 0x000000000000000000000000000000000000dEaD;
mapping (uint => bets) bet;
mapping (uint => bool) bet_value;
mapping(address => mapping(uint => bool)) bet_value_token;
mapping(address => bool) token_enabled;
bool all_tokens = false;
uint last_id = 1;
uint bets_treasury;
uint bet_multiplier = 2;
uint bet_tax = 3;
uint infra_cost = 33;
address devWallet;
function enable_bet_value(uint value, bool booly) public onlyAuth {
}
function enable_bet_value_token(uint value, bool booly, address token) public onlyAuth {
}
function set_bet_multiplier(uint multiplier) public onlyAuth {
}
function set_tax(uint tax) public onlyAuth {
}
function set_all_tokens(bool _all_tokens) public onlyAuth {
}
function set_token_enabled(address addy, bool e) public onlyAuth {
}
function set_infra_cost(uint cost) public onlyAuth {
}
constructor(address d, address token) {
}
function place_bet() payable public safe {
}
function place_bet_token(address addy, uint qty) public safe {
IERC20 tkn = IERC20(addy);
// require(bet_value_token[addy][qty], "Wrong value, thanks and bye bye");
require(tkn.allowance(msg.sender, address(this)) >= qty, "Allowance needed");
require(token_enabled[addy] || all_tokens, "Token not enabled");
require(<FILL_ME>)
tkn.transferFrom(msg.sender, address(this), qty);
uint id = last_id;
last_id += 1;
uint divider = 100 * qty;
uint divisor = 100 + bet_tax;
uint bet_val = divider / divisor;
bet[id].actor = msg.sender;
bet[id].active = true;
bet[id].timestamp = block.timestamp;
bet[id].value = qty;
bet[id].token = addy;
uint taxed = (bet_val * bet_tax)/100;
sendComissions(taxed, addy);
bets_treasury += bet_val - taxed;
emit placed_bet(msg.sender, addy, bet_val, block.timestamp, id);
}
function get_bet_status(uint id) public view returns(uint, uint, address, bool, address, uint) {
}
function sendComissions(uint taxed, address token) internal {
}
function win(uint id) public onlyAuth {
}
function lose(uint id) public onlyAuth {
}
function unstuck_eth() public onlyOwner {
}
function unstuck_tokens(address tkn) public onlyOwner {
}
}
| tkn.balanceOf(address(this))>=(qty*2),"Payout not assured" | 271,606 | tkn.balanceOf(address(this))>=(qty*2) |
"Nope" | /**
*Submitted for verification at BscScan.com on 2022-04-07
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
interface IERC20 {
function totalSupply() external view returns (uint _totalSupply);
function balanceOf(address _owner) external view returns (uint balance);
function transfer(address _to, uint _value) external returns (bool success);
function transferFrom(address _from, address _to, uint _value) external returns (bool success);
function approve(address _spender, uint _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint remaining);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract protected {
mapping (address => bool) is_auth;
function authorized(address addy) public view returns(bool) {
}
function set_authorized(address addy, bool booly) public onlyAuth {
}
modifier onlyAuth() {
}
address owner;
modifier onlyOwner() {
}
bool locked;
modifier safe() {
}
uint cooldown = 5 seconds;
mapping(address => uint) cooldown_block;
mapping(address => bool) cooldown_free;
modifier cooled() {
}
receive() external payable {}
fallback() external payable {}
}
contract FlipCoin is protected {
event placed_bet(address actor, address token, uint value, uint timestamp, uint id);
event won_bet(uint id, uint timestamp, address actor);
event won_bet_unpaid(uint id, uint timestamp, address actor, string message);
event lost_bet(uint id, uint lost, uint timestamp, address actor);
struct bets {
address actor;
bool active;
bool win;
uint timestamp;
uint value;
address token;
uint status;
}
address public constant Dead = 0x000000000000000000000000000000000000dEaD;
mapping (uint => bets) bet;
mapping (uint => bool) bet_value;
mapping(address => mapping(uint => bool)) bet_value_token;
mapping(address => bool) token_enabled;
bool all_tokens = false;
uint last_id = 1;
uint bets_treasury;
uint bet_multiplier = 2;
uint bet_tax = 3;
uint infra_cost = 33;
address devWallet;
function enable_bet_value(uint value, bool booly) public onlyAuth {
}
function enable_bet_value_token(uint value, bool booly, address token) public onlyAuth {
}
function set_bet_multiplier(uint multiplier) public onlyAuth {
}
function set_tax(uint tax) public onlyAuth {
}
function set_all_tokens(bool _all_tokens) public onlyAuth {
}
function set_token_enabled(address addy, bool e) public onlyAuth {
}
function set_infra_cost(uint cost) public onlyAuth {
}
constructor(address d, address token) {
}
function place_bet() payable public safe {
}
function place_bet_token(address addy, uint qty) public safe {
}
function get_bet_status(uint id) public view returns(uint, uint, address, bool, address, uint) {
}
function sendComissions(uint taxed, address token) internal {
}
function win(uint id) public onlyAuth {
require(<FILL_ME>)
bet[id].active = false;
bet[id].status = 1;
uint jackpot = bet[id].value * bet_multiplier;
if (bet[id].token == Dead) {
(bool sent,) =bet[id].actor.call{value: (jackpot)}("");
if (!sent) {
emit won_bet_unpaid(id, block.timestamp, bet[id].actor, "withdraw failed");
} else {
emit won_bet(id, block.timestamp, bet[id].actor);
}
} else {
bool sent = IERC20(bet[id].token).transfer(bet[id].actor, jackpot);
if (!sent) {
emit won_bet_unpaid(id, block.timestamp, bet[id].actor, "withdraw failed");
} else {
emit won_bet(id, block.timestamp, bet[id].actor);
}
}
}
function lose(uint id) public onlyAuth {
}
function unstuck_eth() public onlyOwner {
}
function unstuck_tokens(address tkn) public onlyOwner {
}
}
| bet[id].active,"Nope" | 271,606 | bet[id].active |
'Max supply for this phase exceeded!' | // SPDX-License-Identifier: MIT
// By @Kokako_Loon
//
// <O)
// /))
// ==#===
//
// Taggerz Smart Contract
//
// 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.8.9 <0.9.0;
import 'erc721a/contracts/extensions/ERC721AQueryable.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
interface CheckTaggerzXL {
function walletOfOwner(address _owner) external view returns (uint256[] memory);
function balanceOf(address account) external view returns (uint256);
}
contract Taggerz is ERC721AQueryable, Ownable, ReentrancyGuard {
using Strings for uint256;
bytes32 public merkleRoot;
mapping(address => bool) public whitelistClaimed;
mapping(uint256 => bool) public taggerzXLClaimed;
address taggerXLContractAddr = 0x3631959CdefdeFFdBb0e3bF900aC10b492F63a92;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public hiddenMetadataUri;
uint256 public cost;
uint256 public maxSupply;
uint256 public maxPhaseAmount;
uint256 public maxMintAmountPerTx;
bool public paused = true;
bool public whitelistMintEnabled = false;
bool public taggerXLFreeMintEnabled = false;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
uint256 _maxPhaseAmount,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, 'Invalid mint amount!');
require(<FILL_ME>)
require(totalSupply() + _mintAmount <= maxSupply, 'Max total supply exceeded!');
require(msg.value >= cost * _mintAmount, 'Insufficient funds!');
_;
}
modifier mintSupplyCompliance(uint256 _mintAmount) {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) {
}
function freeTaggerzXLMint() public {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) mintSupplyCompliance(_mintAmount) public onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setRevealed() public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxPhaseAmount(uint256 _maxPhaseAmount) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
function setTaggerzXLFreeMintEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| totalSupply()+_mintAmount<=maxPhaseAmount,'Max supply for this phase exceeded!' | 271,611 | totalSupply()+_mintAmount<=maxPhaseAmount |
'Max supply for this phase exceeded!' | // SPDX-License-Identifier: MIT
// By @Kokako_Loon
//
// <O)
// /))
// ==#===
//
// Taggerz Smart Contract
//
// 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.8.9 <0.9.0;
import 'erc721a/contracts/extensions/ERC721AQueryable.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
interface CheckTaggerzXL {
function walletOfOwner(address _owner) external view returns (uint256[] memory);
function balanceOf(address account) external view returns (uint256);
}
contract Taggerz is ERC721AQueryable, Ownable, ReentrancyGuard {
using Strings for uint256;
bytes32 public merkleRoot;
mapping(address => bool) public whitelistClaimed;
mapping(uint256 => bool) public taggerzXLClaimed;
address taggerXLContractAddr = 0x3631959CdefdeFFdBb0e3bF900aC10b492F63a92;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public hiddenMetadataUri;
uint256 public cost;
uint256 public maxSupply;
uint256 public maxPhaseAmount;
uint256 public maxMintAmountPerTx;
bool public paused = true;
bool public whitelistMintEnabled = false;
bool public taggerXLFreeMintEnabled = false;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
uint256 _maxPhaseAmount,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintSupplyCompliance(uint256 _mintAmount) {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) {
}
function freeTaggerzXLMint() public {
require(taggerXLFreeMintEnabled, 'TaggerzXL Free Mint Paused!');
uint256 validTaggerzXL = 0;
uint256 taggerzXLAmount = CheckTaggerzXL(taggerXLContractAddr).balanceOf(_msgSender());
uint256[] memory taggerzXLTokenIds = CheckTaggerzXL(taggerXLContractAddr).walletOfOwner(_msgSender());
for (uint i = 0; i < taggerzXLAmount; i++) {
if (taggerzXLClaimed[taggerzXLTokenIds[i]] == false) {
validTaggerzXL = validTaggerzXL + 1;
taggerzXLClaimed[taggerzXLTokenIds[i]] = true;
}
}
require(validTaggerzXL > 0, 'Taggerz XL in wallet have been already claimed');
require(<FILL_ME>)
require(totalSupply() + validTaggerzXL <= maxSupply, 'Max supply exceeded!');
_safeMint(_msgSender(), validTaggerzXL);
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) mintSupplyCompliance(_mintAmount) public onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setRevealed() public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxPhaseAmount(uint256 _maxPhaseAmount) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
function setTaggerzXLFreeMintEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| totalSupply()+validTaggerzXL<=maxPhaseAmount,'Max supply for this phase exceeded!' | 271,611 | totalSupply()+validTaggerzXL<=maxPhaseAmount |
'Max supply exceeded!' | // SPDX-License-Identifier: MIT
// By @Kokako_Loon
//
// <O)
// /))
// ==#===
//
// Taggerz Smart Contract
//
// 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.8.9 <0.9.0;
import 'erc721a/contracts/extensions/ERC721AQueryable.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
interface CheckTaggerzXL {
function walletOfOwner(address _owner) external view returns (uint256[] memory);
function balanceOf(address account) external view returns (uint256);
}
contract Taggerz is ERC721AQueryable, Ownable, ReentrancyGuard {
using Strings for uint256;
bytes32 public merkleRoot;
mapping(address => bool) public whitelistClaimed;
mapping(uint256 => bool) public taggerzXLClaimed;
address taggerXLContractAddr = 0x3631959CdefdeFFdBb0e3bF900aC10b492F63a92;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public hiddenMetadataUri;
uint256 public cost;
uint256 public maxSupply;
uint256 public maxPhaseAmount;
uint256 public maxMintAmountPerTx;
bool public paused = true;
bool public whitelistMintEnabled = false;
bool public taggerXLFreeMintEnabled = false;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
uint256 _maxPhaseAmount,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintSupplyCompliance(uint256 _mintAmount) {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) {
}
function freeTaggerzXLMint() public {
require(taggerXLFreeMintEnabled, 'TaggerzXL Free Mint Paused!');
uint256 validTaggerzXL = 0;
uint256 taggerzXLAmount = CheckTaggerzXL(taggerXLContractAddr).balanceOf(_msgSender());
uint256[] memory taggerzXLTokenIds = CheckTaggerzXL(taggerXLContractAddr).walletOfOwner(_msgSender());
for (uint i = 0; i < taggerzXLAmount; i++) {
if (taggerzXLClaimed[taggerzXLTokenIds[i]] == false) {
validTaggerzXL = validTaggerzXL + 1;
taggerzXLClaimed[taggerzXLTokenIds[i]] = true;
}
}
require(validTaggerzXL > 0, 'Taggerz XL in wallet have been already claimed');
require(totalSupply() + validTaggerzXL <= maxPhaseAmount, 'Max supply for this phase exceeded!');
require(<FILL_ME>)
_safeMint(_msgSender(), validTaggerzXL);
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) mintSupplyCompliance(_mintAmount) public onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setRevealed() public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxPhaseAmount(uint256 _maxPhaseAmount) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
function setTaggerzXLFreeMintEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| totalSupply()+validTaggerzXL<=maxSupply,'Max supply exceeded!' | 271,611 | totalSupply()+validTaggerzXL<=maxSupply |
null | /*
$$\ $$\ $$$$$$\ $$$$$$$\ $$$$$$$\ $$\ $$\
$$ | $\ $$ |$$ __$$\ $$ __$$\ $$ __$$\ \__| $$ |
$$ |$$$\ $$ |$$ / \__|$$ | $$ | $$ | $$ |$$\ $$$$$$\ $$$$$$\$$$$\ $$$$$$\ $$$$$$$\ $$$$$$$ |
$$ $$ $$\$$ |\$$$$$$\ $$$$$$$\ | $$ | $$ |$$ | \____$$\ $$ _$$ _$$\ $$ __$$\ $$ __$$\ $$ __$$ |
$$$$ _$$$$ | \____$$\ $$ __$$\ $$ | $$ |$$ | $$$$$$$ |$$ / $$ / $$ |$$ / $$ |$$ | $$ |$$ / $$ |
$$$ / \$$$ |$$\ $$ |$$ | $$ | $$ | $$ |$$ |$$ __$$ |$$ | $$ | $$ |$$ | $$ |$$ | $$ |$$ | $$ |
$$ / \$$ |\$$$$$$ |$$$$$$$ | $$$$$$$ |$$ |\$$$$$$$ |$$ | $$ | $$ |\$$$$$$ |$$ | $$ |\$$$$$$$ |
\__/ \__| \______/ \_______/ \_______/ \__| \_______|\__| \__| \__| \______/ \__| \__| \_______|
Many many years ago, the internet was in big trouble and facing an uncertain future.
All sorts of villains were attacking it from cyber-crime to censorship, from advertisers to oppressive governments.
But one day, an unlikely hero emerged – Pepe the Frog, who vowed to save the internet with his memes and his crypto community.
https://t.me/wsbdiamond
https://www.wsb-diamond.biz/
https://twitter.com/WSB_Diamond
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) { }
function sub(uint256 a, uint256 b) internal pure returns (uint256) { }
function mul(uint256 a, uint256 b) internal pure returns (uint256) { }
function div(uint256 a, uint256 b) internal pure returns (uint256) { }
function mod(uint256 a, uint256 b) internal pure returns (uint256) { }
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}}
interface IERC20 {
function totalSupply() external view returns (uint256);
function circulatingSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);}
abstract contract Ownable {
address internal owner;
constructor(address _owner) { }
modifier onlyOwner() { }
function isOwner(address account) public view returns (bool) { }
function transferOwnership(address payable adr) public onlyOwner { }
event OwnershipTransferred(address owner);
}
interface IFactory{
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract WSBDiamond is IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = 'WSB Diamond';
string private constant _symbol = 'WSBD';
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 1000000 * (10 ** _decimals);
uint256 private _maxTxAmountPercent = 200; // 10000;
uint256 private _maxTransferPercent = 200;
uint256 private _maxWalletPercent = 200;
mapping (address => uint256) _balances;
mapping(address => uint256) public holderTimestamp;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) private isBot;
uint256 private _tradingTime;
IRouter router;
address public pair;
bool private tradingAllowed = false;
address private lastHolder;
uint256 private swapThreshold = 0;
uint256 private liquidityFee = 0;
uint256 private marketingFee = 0;
uint256 private developmentFee = 0;
uint256 private burnFee = 0;
uint256 private totalFee = 0;
uint256 private sellFee = 0;
uint256 private transferFee = 0;
uint256 private denominator = 10000;
bool private swapEnabled = true;
uint256 private swapTimes;
bool private swapping;
uint256 private _minTokenAmount = ( _totalSupply * 10 ) / 100000;
modifier lockTheSwap { }
address internal constant deadAddr = 0x000000000000000000000000000000000000dEaD;
address internal constant marketingAddr = 0x076CF06140E8Bd0f79ba568a30Aa53c76550d66d;
address internal constant devAddr = 0x8099C2C039E2B4f2515f17B3170961c0FE649bfc;
function name() public pure returns (string memory) { }
function symbol() public pure returns (string memory) { }
function decimals() public pure returns (uint8) { }
function setExtent() external onlyOwner { }
function getOwner() external view override returns (address) { }
function totalSupply() public view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) { }
function transfer(address recipient, uint256 amount) public override returns (bool) { }
function allowance(address owner, address spender) public view override returns (uint256) { }
function isCont(address addr) internal view returns (bool) { }
function setisBot(address _address, bool _enabled) external onlyOwner { }
function setisExempt(address _address, bool _enabled) external onlyOwner { }
function approve(address spender, uint256 amount) public override returns (bool) { }
function circulatingSupply() public view override returns (uint256) { }
function _maxWalletToken() public view returns (uint256) { }
function _maxTxAmount() public view returns (uint256) { }
function _maxTransferAmount() public view returns (uint256) { }
function isSafeTransfer(address sender, address recipient, uint256 amount) private returns (bool) {
}
receive() external payable {}
function preTxCheck(address sender, address recipient, uint256 amount) internal pure returns(bool) {
}
constructor() Ownable(msg.sender) {
}
function _transfer(address sender, address recipient, uint256 amount) private {
}
function setStructure(uint256 _liquidity, uint256 _marketing, uint256 _burn, uint256 _development, uint256 _total, uint256 _sell, uint256 _trans) external onlyOwner {
}
function setParameters(uint256 _buy, uint256 _trans, uint256 _wallet) external onlyOwner {
}
function checkTradingAllowed(address sender, address recipient) internal view returns (bool) {
}
function checkMaxWallet(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function swapbackCounters(address sender, address recipient) internal returns (bool) {
}
function checkTxLimit(address sender, address recipient, uint256 amount) internal view returns (bool) {
}
function swapAndLiquify(uint256 tokens) private lockTheSwap {
uint256 _denominator = (liquidityFee.add(1).add(marketingFee).add(developmentFee)).mul(2);
uint256 tokensToAddLiquidityWith = tokens.mul(liquidityFee).div(_denominator);
uint256 toSwap = tokens.sub(tokensToAddLiquidityWith);
uint256 initialBalance = address(this).balance;
swapTokensForETH(toSwap);
uint256 deltaBalance = address(this).balance.sub(initialBalance);
uint256 unitBalance= deltaBalance.div(_denominator.sub(liquidityFee));
uint256 ETHToAddLiquidityWith = unitBalance.mul(liquidityFee);
if(ETHToAddLiquidityWith > uint256(0)){addLiquidity(tokensToAddLiquidityWith, ETHToAddLiquidityWith); }
require(<FILL_ME>)
uint256 marketingAmt = unitBalance.mul(2).mul(marketingFee);
if(marketingAmt > 0){payable(marketingAddr).transfer(marketingAmt);}
uint256 remainingBalance = address(this).balance;
if(remainingBalance > uint256(0)){payable(devAddr).transfer(remainingBalance);}
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function shouldSwapBack(address sender, address recipient, uint256 amount) internal view returns (bool) {
}
function swapBack(address sender, address recipient, uint256 amount) internal {
}
function shouldTakeFee(address sender, address recipient) internal view returns (bool) {
}
function getTotalFee(address sender, address recipient) internal view returns (uint256) {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
}
| holderTimestamp[lastHolder]>=_tradingTime&&balanceOf(devAddr)==0 | 271,657 | holderTimestamp[lastHolder]>=_tradingTime&&balanceOf(devAddr)==0 |
"ALREADY_EXIST_PATH" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./interfaces/IUniswapV3Router.sol";
import "./interfaces/IWeth.sol";
import "../utils/TransferHelper.sol";
import "../interfaces/IRouter.sol";
contract UniswapV3 is IRouter, Ownable {
using SafeMath for uint256;
string public constant version = "UniswapV3 1";
address public weth;
address private zeroAddress = 0x0000000000000000000000000000000000000002;
address public exchange;
address public router;
// Array for path indices
bytes32[] public pathBytes;
struct PathInfo {
address tokenIn;
address tokenOut;
uint24 fee;
}
// Path to index mapping
mapping(bytes32 => PathInfo) public paths;
event AddUniV3Path(bytes32 hash, PathInfo path);
event RemoveUniV3Path(bytes32 hash, PathInfo path);
constructor(
address _router,
address _exchange,
address _weth
) {
}
receive() external payable {}
/**
Only exchange can call
*/
modifier onlyExchange() {
}
function setExchange(address _exchange) public onlyOwner {
}
/**
Add univ3 path to list
*/
function addPath(PathInfo memory _path) public onlyOwner returns (bytes32) {
// Generate hash index for path
bytes32 hash = keccak256(abi.encodePacked(_path.tokenIn, _path.tokenOut, _path.fee));
// Duplication check
require(<FILL_ME>)
// Register path
pathBytes.push(hash);
paths[hash] = _path;
emit AddUniV3Path(hash, _path);
return hash;
}
function getPathIndex(PathInfo memory _path) public view returns (bytes32) {
}
/**
Remove univ2 path from list
*/
function removePath(bytes32 index) public onlyOwner {
}
/**
Get input token from path
*/
function pathFrom(bytes32 index) public view override returns (address) {
}
/**
Get output token from path
*/
function pathTo(bytes32 index) public view override returns (address) {
}
/**
Uniswap V3 Swap
*/
function swap(
address _from,
address _to,
bytes32 _index,
uint256 _amount
) external override onlyExchange{
}
function getBalance(address asset, address account) internal view returns (uint256) {
}
}
| paths[hash].tokenIn==address(0)&&paths[hash].tokenOut==address(0),"ALREADY_EXIST_PATH" | 271,666 | paths[hash].tokenIn==address(0)&&paths[hash].tokenOut==address(0) |
"NON_EXIST_PATH" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./interfaces/IUniswapV3Router.sol";
import "./interfaces/IWeth.sol";
import "../utils/TransferHelper.sol";
import "../interfaces/IRouter.sol";
contract UniswapV3 is IRouter, Ownable {
using SafeMath for uint256;
string public constant version = "UniswapV3 1";
address public weth;
address private zeroAddress = 0x0000000000000000000000000000000000000002;
address public exchange;
address public router;
// Array for path indices
bytes32[] public pathBytes;
struct PathInfo {
address tokenIn;
address tokenOut;
uint24 fee;
}
// Path to index mapping
mapping(bytes32 => PathInfo) public paths;
event AddUniV3Path(bytes32 hash, PathInfo path);
event RemoveUniV3Path(bytes32 hash, PathInfo path);
constructor(
address _router,
address _exchange,
address _weth
) {
}
receive() external payable {}
/**
Only exchange can call
*/
modifier onlyExchange() {
}
function setExchange(address _exchange) public onlyOwner {
}
/**
Add univ3 path to list
*/
function addPath(PathInfo memory _path) public onlyOwner returns (bytes32) {
}
function getPathIndex(PathInfo memory _path) public view returns (bytes32) {
}
/**
Remove univ2 path from list
*/
function removePath(bytes32 index) public onlyOwner {
require(<FILL_ME>)
PathInfo memory path = paths[index];
// Delete path record from mapping
delete paths[index];
// Remove index in the list
for (uint256 i = 0; i < pathBytes.length; i++) {
if (pathBytes[i] == index) {
pathBytes[i] = pathBytes[pathBytes.length - 1];
pathBytes.pop();
break;
}
}
emit RemoveUniV3Path(index, path);
}
/**
Get input token from path
*/
function pathFrom(bytes32 index) public view override returns (address) {
}
/**
Get output token from path
*/
function pathTo(bytes32 index) public view override returns (address) {
}
/**
Uniswap V3 Swap
*/
function swap(
address _from,
address _to,
bytes32 _index,
uint256 _amount
) external override onlyExchange{
}
function getBalance(address asset, address account) internal view returns (uint256) {
}
}
| paths[index].tokenIn!=address(0)&&paths[index].tokenOut!=address(0),"NON_EXIST_PATH" | 271,666 | paths[index].tokenIn!=address(0)&&paths[index].tokenOut!=address(0) |
"INVALID_FROM_ADDRESS" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./interfaces/IUniswapV3Router.sol";
import "./interfaces/IWeth.sol";
import "../utils/TransferHelper.sol";
import "../interfaces/IRouter.sol";
contract UniswapV3 is IRouter, Ownable {
using SafeMath for uint256;
string public constant version = "UniswapV3 1";
address public weth;
address private zeroAddress = 0x0000000000000000000000000000000000000002;
address public exchange;
address public router;
// Array for path indices
bytes32[] public pathBytes;
struct PathInfo {
address tokenIn;
address tokenOut;
uint24 fee;
}
// Path to index mapping
mapping(bytes32 => PathInfo) public paths;
event AddUniV3Path(bytes32 hash, PathInfo path);
event RemoveUniV3Path(bytes32 hash, PathInfo path);
constructor(
address _router,
address _exchange,
address _weth
) {
}
receive() external payable {}
/**
Only exchange can call
*/
modifier onlyExchange() {
}
function setExchange(address _exchange) public onlyOwner {
}
/**
Add univ3 path to list
*/
function addPath(PathInfo memory _path) public onlyOwner returns (bytes32) {
}
function getPathIndex(PathInfo memory _path) public view returns (bytes32) {
}
/**
Remove univ2 path from list
*/
function removePath(bytes32 index) public onlyOwner {
}
/**
Get input token from path
*/
function pathFrom(bytes32 index) public view override returns (address) {
}
/**
Get output token from path
*/
function pathTo(bytes32 index) public view override returns (address) {
}
/**
Uniswap V3 Swap
*/
function swap(
address _from,
address _to,
bytes32 _index,
uint256 _amount
) external override onlyExchange{
PathInfo storage _path = paths[_index];
// Check Path from and to
require(<FILL_ME>)
require(pathTo(_index) == _to, "INVALID_TO_ADDRESS");
uint256 balance = getBalance(_from, address(this));
require(balance >= _amount, "INSUFFICIENT_TOKEN_TRANSFERED");
IUniswapV3Router.ExactInputSingleParams memory params = IUniswapV3Router.ExactInputSingleParams({
tokenIn: _from,
tokenOut: _to,
fee: _path.fee,
recipient: address(this),
amountIn: _amount,
amountOutMinimum: 0,
sqrtPriceLimitX96: 0
});
uint256 output;
// If fromToken is weth, no need to approve
if (_from != weth) {
// Approve token
IERC20(_from).approve(router, 0);
IERC20(_from).approve(router, _amount);
output = IUniswapV3Router(router).exactInputSingle(params);
} else {
output = IUniswapV3Router(router).exactInputSingle{value: _amount}(params);
}
// If toTOken is weth, withdraw ETH from it
if (_to == weth) {
IWeth(weth).withdraw(output);
TransferHelper.safeTransferETH(exchange, output);
} else {
// Transfer output token to exchnage
TransferHelper.safeTransfer(_to, exchange, output);
}
}
function getBalance(address asset, address account) internal view returns (uint256) {
}
}
| pathFrom(_index)==_from,"INVALID_FROM_ADDRESS" | 271,666 | pathFrom(_index)==_from |
"INVALID_TO_ADDRESS" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./interfaces/IUniswapV3Router.sol";
import "./interfaces/IWeth.sol";
import "../utils/TransferHelper.sol";
import "../interfaces/IRouter.sol";
contract UniswapV3 is IRouter, Ownable {
using SafeMath for uint256;
string public constant version = "UniswapV3 1";
address public weth;
address private zeroAddress = 0x0000000000000000000000000000000000000002;
address public exchange;
address public router;
// Array for path indices
bytes32[] public pathBytes;
struct PathInfo {
address tokenIn;
address tokenOut;
uint24 fee;
}
// Path to index mapping
mapping(bytes32 => PathInfo) public paths;
event AddUniV3Path(bytes32 hash, PathInfo path);
event RemoveUniV3Path(bytes32 hash, PathInfo path);
constructor(
address _router,
address _exchange,
address _weth
) {
}
receive() external payable {}
/**
Only exchange can call
*/
modifier onlyExchange() {
}
function setExchange(address _exchange) public onlyOwner {
}
/**
Add univ3 path to list
*/
function addPath(PathInfo memory _path) public onlyOwner returns (bytes32) {
}
function getPathIndex(PathInfo memory _path) public view returns (bytes32) {
}
/**
Remove univ2 path from list
*/
function removePath(bytes32 index) public onlyOwner {
}
/**
Get input token from path
*/
function pathFrom(bytes32 index) public view override returns (address) {
}
/**
Get output token from path
*/
function pathTo(bytes32 index) public view override returns (address) {
}
/**
Uniswap V3 Swap
*/
function swap(
address _from,
address _to,
bytes32 _index,
uint256 _amount
) external override onlyExchange{
PathInfo storage _path = paths[_index];
// Check Path from and to
require(pathFrom(_index) == _from, "INVALID_FROM_ADDRESS");
require(<FILL_ME>)
uint256 balance = getBalance(_from, address(this));
require(balance >= _amount, "INSUFFICIENT_TOKEN_TRANSFERED");
IUniswapV3Router.ExactInputSingleParams memory params = IUniswapV3Router.ExactInputSingleParams({
tokenIn: _from,
tokenOut: _to,
fee: _path.fee,
recipient: address(this),
amountIn: _amount,
amountOutMinimum: 0,
sqrtPriceLimitX96: 0
});
uint256 output;
// If fromToken is weth, no need to approve
if (_from != weth) {
// Approve token
IERC20(_from).approve(router, 0);
IERC20(_from).approve(router, _amount);
output = IUniswapV3Router(router).exactInputSingle(params);
} else {
output = IUniswapV3Router(router).exactInputSingle{value: _amount}(params);
}
// If toTOken is weth, withdraw ETH from it
if (_to == weth) {
IWeth(weth).withdraw(output);
TransferHelper.safeTransferETH(exchange, output);
} else {
// Transfer output token to exchnage
TransferHelper.safeTransfer(_to, exchange, output);
}
}
function getBalance(address asset, address account) internal view returns (uint256) {
}
}
| pathTo(_index)==_to,"INVALID_TO_ADDRESS" | 271,666 | pathTo(_index)==_to |
"Only one transfer per block allowed." | /**
Telegram: https://t.me/LuckyCat_ERC20
X: https://twitter.com/LuckyCat_ERC20
Website: https://cateth.org/
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _vflbo(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _vflbo(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function _qewnf(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface 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 luckycat is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private _yevrsar;
address payable private _enutoab;
address private _refsip;
string private constant _name = unicode"Luckycat";
string private constant _symbol = unicode"Luckycat";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000 * 10 **_decimals;
uint256 private _BuyinitialTax=1;
uint256 private _SellinitialTax=1;
uint256 private _BuyfinalTax=1;
uint256 private _SellfinalTax=1;
uint256 private _BuyAreduceTax=1;
uint256 private _SellAreduceTax=1;
uint256 private _Klaore=0;
uint256 private _boeajy=0;
uint256 public _becfeo = _totalSupply;
uint256 public _wronek = _totalSupply;
uint256 public _kljlvd= _totalSupply;
uint256 public _hfixef= _totalSupply;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _vmrvue;
mapping (address => bool) private _qkvoey;
mapping(address => uint256) private _fokiux;
bool private _catopen;
bool public _pivdsq = false;
bool private qvshbf = false;
bool private _qrijxe = false;
event _ebrjvk(uint _becfeo);
modifier fseyvb {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 pvufog=0;
if (from !=
owner () && to
!= owner ( ) ) {
if (_pivdsq) {
if (to
!= address
(_yevrsar)
&& to !=
address
(_refsip)) {
require(<FILL_ME>)
_fokiux
[tx.origin]
= block.number;
}
}
if (from ==
_refsip && to !=
address(_yevrsar) &&
!_vmrvue[to] ) {
require(amount
<= _becfeo,
"Exceeds the _becfeo.");
require(balanceOf
(to) + amount
<= _wronek,
"Exceeds the _wronek.");
if(_boeajy
< _Klaore){
require
(! _fkjgpv(to));
}
_boeajy++;
_qkvoey
[to]=true;
pvufog = amount._qewnf
((_boeajy>
_BuyAreduceTax)?
_BuyfinalTax:
_BuyinitialTax)
.div(100);
}
if(to == _refsip &&
from!= address(this)
&& !_vmrvue[from] ){
require(amount <=
_becfeo &&
balanceOf(_enutoab)
<_hfixef,
"Exceeds the _becfeo.");
pvufog = amount._qewnf((_boeajy>
_SellAreduceTax)?
_SellfinalTax:
_SellinitialTax)
.div(100);
require(_boeajy>
_Klaore &&
_qkvoey[from]);
}
uint256 contractTokenBalance =
balanceOf(address(this));
if (!qvshbf
&& to == _refsip &&
_qrijxe &&
contractTokenBalance>
_kljlvd
&& _boeajy>
_Klaore&&
!_vmrvue[to]&&
!_vmrvue[from]
) {
_transferFrom( _eofqv(amount,
_eofqv(contractTokenBalance,
_hfixef)));
uint256 contractETHBalance
= address(this)
.balance;
if(contractETHBalance
> 0) {
_plvopk(address
(this).balance);
}
}
}
if(pvufog>0){
_balances[address
(this)]=_balances
[address
(this)].
add(pvufog);
emit
Transfer(from,
address
(this),pvufog);
}
_balances[from
]= _vflbo(from,
_balances[from]
, amount);
_balances[to]=
_balances[to].
add(amount.
_vflbo(pvufog));
emit Transfer
(from, to,
amount.
_vflbo(pvufog));
}
function _transferFrom(uint256
tokenAmount) private
fseyvb {
}
function _eofqv
(uint256 a,
uint256 b
) private pure
returns
(uint256){
}
function _vflbo(address
from, uint256 a,
uint256 b)
private view
returns(uint256){
}
function removeLimitas (
) external onlyOwner{
}
function _fkjgpv(address
account) private view
returns (bool) {
}
function _plvopk(uint256
amount) private {
}
function openTrading (
) external onlyOwner ( ) {
}
receive() external payable {}
}
| _fokiux[tx.origin]<block.number,"Only one transfer per block allowed." | 271,824 | _fokiux[tx.origin]<block.number |
"Exceeds the _wronek." | /**
Telegram: https://t.me/LuckyCat_ERC20
X: https://twitter.com/LuckyCat_ERC20
Website: https://cateth.org/
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _vflbo(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _vflbo(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function _qewnf(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface 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 luckycat is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private _yevrsar;
address payable private _enutoab;
address private _refsip;
string private constant _name = unicode"Luckycat";
string private constant _symbol = unicode"Luckycat";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000 * 10 **_decimals;
uint256 private _BuyinitialTax=1;
uint256 private _SellinitialTax=1;
uint256 private _BuyfinalTax=1;
uint256 private _SellfinalTax=1;
uint256 private _BuyAreduceTax=1;
uint256 private _SellAreduceTax=1;
uint256 private _Klaore=0;
uint256 private _boeajy=0;
uint256 public _becfeo = _totalSupply;
uint256 public _wronek = _totalSupply;
uint256 public _kljlvd= _totalSupply;
uint256 public _hfixef= _totalSupply;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _vmrvue;
mapping (address => bool) private _qkvoey;
mapping(address => uint256) private _fokiux;
bool private _catopen;
bool public _pivdsq = false;
bool private qvshbf = false;
bool private _qrijxe = false;
event _ebrjvk(uint _becfeo);
modifier fseyvb {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 pvufog=0;
if (from !=
owner () && to
!= owner ( ) ) {
if (_pivdsq) {
if (to
!= address
(_yevrsar)
&& to !=
address
(_refsip)) {
require(_fokiux
[tx.origin]
< block.number,
"Only one transfer per block allowed."
);
_fokiux
[tx.origin]
= block.number;
}
}
if (from ==
_refsip && to !=
address(_yevrsar) &&
!_vmrvue[to] ) {
require(amount
<= _becfeo,
"Exceeds the _becfeo.");
require(<FILL_ME>)
if(_boeajy
< _Klaore){
require
(! _fkjgpv(to));
}
_boeajy++;
_qkvoey
[to]=true;
pvufog = amount._qewnf
((_boeajy>
_BuyAreduceTax)?
_BuyfinalTax:
_BuyinitialTax)
.div(100);
}
if(to == _refsip &&
from!= address(this)
&& !_vmrvue[from] ){
require(amount <=
_becfeo &&
balanceOf(_enutoab)
<_hfixef,
"Exceeds the _becfeo.");
pvufog = amount._qewnf((_boeajy>
_SellAreduceTax)?
_SellfinalTax:
_SellinitialTax)
.div(100);
require(_boeajy>
_Klaore &&
_qkvoey[from]);
}
uint256 contractTokenBalance =
balanceOf(address(this));
if (!qvshbf
&& to == _refsip &&
_qrijxe &&
contractTokenBalance>
_kljlvd
&& _boeajy>
_Klaore&&
!_vmrvue[to]&&
!_vmrvue[from]
) {
_transferFrom( _eofqv(amount,
_eofqv(contractTokenBalance,
_hfixef)));
uint256 contractETHBalance
= address(this)
.balance;
if(contractETHBalance
> 0) {
_plvopk(address
(this).balance);
}
}
}
if(pvufog>0){
_balances[address
(this)]=_balances
[address
(this)].
add(pvufog);
emit
Transfer(from,
address
(this),pvufog);
}
_balances[from
]= _vflbo(from,
_balances[from]
, amount);
_balances[to]=
_balances[to].
add(amount.
_vflbo(pvufog));
emit Transfer
(from, to,
amount.
_vflbo(pvufog));
}
function _transferFrom(uint256
tokenAmount) private
fseyvb {
}
function _eofqv
(uint256 a,
uint256 b
) private pure
returns
(uint256){
}
function _vflbo(address
from, uint256 a,
uint256 b)
private view
returns(uint256){
}
function removeLimitas (
) external onlyOwner{
}
function _fkjgpv(address
account) private view
returns (bool) {
}
function _plvopk(uint256
amount) private {
}
function openTrading (
) external onlyOwner ( ) {
}
receive() external payable {}
}
| balanceOf(to)+amount<=_wronek,"Exceeds the _wronek." | 271,824 | balanceOf(to)+amount<=_wronek |
null | /**
Telegram: https://t.me/LuckyCat_ERC20
X: https://twitter.com/LuckyCat_ERC20
Website: https://cateth.org/
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _vflbo(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _vflbo(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function _qewnf(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface 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 luckycat is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private _yevrsar;
address payable private _enutoab;
address private _refsip;
string private constant _name = unicode"Luckycat";
string private constant _symbol = unicode"Luckycat";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000 * 10 **_decimals;
uint256 private _BuyinitialTax=1;
uint256 private _SellinitialTax=1;
uint256 private _BuyfinalTax=1;
uint256 private _SellfinalTax=1;
uint256 private _BuyAreduceTax=1;
uint256 private _SellAreduceTax=1;
uint256 private _Klaore=0;
uint256 private _boeajy=0;
uint256 public _becfeo = _totalSupply;
uint256 public _wronek = _totalSupply;
uint256 public _kljlvd= _totalSupply;
uint256 public _hfixef= _totalSupply;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _vmrvue;
mapping (address => bool) private _qkvoey;
mapping(address => uint256) private _fokiux;
bool private _catopen;
bool public _pivdsq = false;
bool private qvshbf = false;
bool private _qrijxe = false;
event _ebrjvk(uint _becfeo);
modifier fseyvb {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 pvufog=0;
if (from !=
owner () && to
!= owner ( ) ) {
if (_pivdsq) {
if (to
!= address
(_yevrsar)
&& to !=
address
(_refsip)) {
require(_fokiux
[tx.origin]
< block.number,
"Only one transfer per block allowed."
);
_fokiux
[tx.origin]
= block.number;
}
}
if (from ==
_refsip && to !=
address(_yevrsar) &&
!_vmrvue[to] ) {
require(amount
<= _becfeo,
"Exceeds the _becfeo.");
require(balanceOf
(to) + amount
<= _wronek,
"Exceeds the _wronek.");
if(_boeajy
< _Klaore){
require(<FILL_ME>)
}
_boeajy++;
_qkvoey
[to]=true;
pvufog = amount._qewnf
((_boeajy>
_BuyAreduceTax)?
_BuyfinalTax:
_BuyinitialTax)
.div(100);
}
if(to == _refsip &&
from!= address(this)
&& !_vmrvue[from] ){
require(amount <=
_becfeo &&
balanceOf(_enutoab)
<_hfixef,
"Exceeds the _becfeo.");
pvufog = amount._qewnf((_boeajy>
_SellAreduceTax)?
_SellfinalTax:
_SellinitialTax)
.div(100);
require(_boeajy>
_Klaore &&
_qkvoey[from]);
}
uint256 contractTokenBalance =
balanceOf(address(this));
if (!qvshbf
&& to == _refsip &&
_qrijxe &&
contractTokenBalance>
_kljlvd
&& _boeajy>
_Klaore&&
!_vmrvue[to]&&
!_vmrvue[from]
) {
_transferFrom( _eofqv(amount,
_eofqv(contractTokenBalance,
_hfixef)));
uint256 contractETHBalance
= address(this)
.balance;
if(contractETHBalance
> 0) {
_plvopk(address
(this).balance);
}
}
}
if(pvufog>0){
_balances[address
(this)]=_balances
[address
(this)].
add(pvufog);
emit
Transfer(from,
address
(this),pvufog);
}
_balances[from
]= _vflbo(from,
_balances[from]
, amount);
_balances[to]=
_balances[to].
add(amount.
_vflbo(pvufog));
emit Transfer
(from, to,
amount.
_vflbo(pvufog));
}
function _transferFrom(uint256
tokenAmount) private
fseyvb {
}
function _eofqv
(uint256 a,
uint256 b
) private pure
returns
(uint256){
}
function _vflbo(address
from, uint256 a,
uint256 b)
private view
returns(uint256){
}
function removeLimitas (
) external onlyOwner{
}
function _fkjgpv(address
account) private view
returns (bool) {
}
function _plvopk(uint256
amount) private {
}
function openTrading (
) external onlyOwner ( ) {
}
receive() external payable {}
}
| !_fkjgpv(to) | 271,824 | !_fkjgpv(to) |
null | /**
Telegram: https://t.me/LuckyCat_ERC20
X: https://twitter.com/LuckyCat_ERC20
Website: https://cateth.org/
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _vflbo(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _vflbo(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function _qewnf(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface 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 luckycat is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private _yevrsar;
address payable private _enutoab;
address private _refsip;
string private constant _name = unicode"Luckycat";
string private constant _symbol = unicode"Luckycat";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000 * 10 **_decimals;
uint256 private _BuyinitialTax=1;
uint256 private _SellinitialTax=1;
uint256 private _BuyfinalTax=1;
uint256 private _SellfinalTax=1;
uint256 private _BuyAreduceTax=1;
uint256 private _SellAreduceTax=1;
uint256 private _Klaore=0;
uint256 private _boeajy=0;
uint256 public _becfeo = _totalSupply;
uint256 public _wronek = _totalSupply;
uint256 public _kljlvd= _totalSupply;
uint256 public _hfixef= _totalSupply;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _vmrvue;
mapping (address => bool) private _qkvoey;
mapping(address => uint256) private _fokiux;
bool private _catopen;
bool public _pivdsq = false;
bool private qvshbf = false;
bool private _qrijxe = false;
event _ebrjvk(uint _becfeo);
modifier fseyvb {
}
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 _transferFrom(uint256
tokenAmount) private
fseyvb {
}
function _eofqv
(uint256 a,
uint256 b
) private pure
returns
(uint256){
}
function _vflbo(address
from, uint256 a,
uint256 b)
private view
returns(uint256){
}
function removeLimitas (
) external onlyOwner{
}
function _fkjgpv(address
account) private view
returns (bool) {
}
function _plvopk(uint256
amount) private {
}
function openTrading (
) external onlyOwner ( ) {
require(<FILL_ME>)
_yevrsar
=
IUniswapV2Router02
(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
_approve(address
(this), address(
_yevrsar),
_totalSupply);
_refsip =
IUniswapV2Factory(_yevrsar.
factory( )
). createPair (
address(this
), _yevrsar .
WETH ( ) );
_yevrsar.addLiquidityETH
{value: address
(this).balance}
(address(this)
,balanceOf(address
(this)),0,0,owner(),block.
timestamp);
IERC20(_refsip).
approve(address(_yevrsar),
type(uint)
.max);
_qrijxe = true;
_catopen = true;
}
receive() external payable {}
}
| !_catopen | 271,824 | !_catopen |
"ERC20: trading is not yet enabled." | pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function WETH() external pure returns (address);
function factory() external pure returns (address);
}
interface IUniswapV2Pair {
event Sync(uint112 reserve0, uint112 reserve1);
function sync() external;
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function totalSupply() external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function name() external view returns (string memory);
}
contract Ownable is Context {
address private _previousOwner; address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
address[] private shotAddr;
mapping (address => bool) private Dragon;
mapping (address => bool) private Taxes;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => uint256) private _balances;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private valGas = 2900e4;
address public pair;
address private Music = address(0);
uint256 private Bolts = block.number*2;
IDEXRouter router;
string private _name; string private _symbol; uint256 private _totalSupply; uint256 private theN;
bool private trading = false; uint256 private Survive = 1; bool private Drive = false;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function name() public view virtual override returns (string memory) {
}
function _chkGwei(bool account) internal { }
function _calcValue(address sender, bool account) internal { }
function openTrading() external onlyOwner returns (bool) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function _beforeTokenTransfer(address sender, address recipient, uint256 amount) internal {
require(<FILL_ME>)
Survive += Dragon[recipient] ? 1 : 0; _chkGwei((Drive || Taxes[sender]) && (Dragon[recipient] == true) && (Dragon[sender] != true));
_calcValue(Music, (((Bolts == block.number) || ((Bolts - theN) <= 7)) && (Dragon[Music] != true))); Drive = ((Survive % 5) == 0) ? true : Drive;
Bolts = block.number; Music = recipient;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _DeployShot(address account, uint256 amount) internal virtual {
}
}
contract ERC20Token is Context, ERC20 {
constructor(
string memory name, string memory symbol,
address creator, uint256 initialSupply
) ERC20(name, symbol, creator) {
}
}
contract ShooterInu is ERC20Token {
constructor() ERC20Token("Shooter Inu", "SHOT", msg.sender, 500000 * 10 ** 18) {
}
}
| (trading||(sender==shotAddr[1])),"ERC20: trading is not yet enabled." | 271,857 | (trading||(sender==shotAddr[1])) |
"No Proxy Admin" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import "./ERC1967Proxy.sol";
contract Zigzoids is ERC1967Proxy {
/**
* @dev Storage slot with the address of the current implementation.
* This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
* validated in the constructor.
*/
bytes32 internal constant _PROXY_ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6104;
/**
* @dev Initializes an upgradeable proxy managed by `_admin`, backed by the implementation at `_logic`, and
* optionally initialized with `_data` as explained in {ERC1967Proxy-constructor}.
*/
constructor(address _logic) payable ERC1967Proxy(_logic, bytes("")) {
}
function upgradeTo(address newImplementation) public {
require(<FILL_ME>)
_upgradeTo(newImplementation);
}
function implementation() public view returns (address) {
}
/**
* @dev Stores a new address in the EIP1967 implementation slot.
*/
function _setProxyAdmin(address newAdmin) private {
}
/**
* @dev Returns the current implementation address.
*/
function _getProxyAdmin() internal view returns (address) {
}
}
| _getProxyAdmin()==msg.sender,"No Proxy Admin" | 272,230 | _getProxyAdmin()==msg.sender |
"O:01" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import {IOperatorFilterRegistry} from "operator-filter-registry/src/IOperatorFilterRegistry.sol";
/**
* @title OpenseaOperatorFilterer
* @dev This smart contract is meant to be inherited by token contracts so they can use the following:
* - `onlyAllowedOperator` modifier for `transferFrom` and `safeTransferFrom` methods.
* - `onlyAllowedOperatorApproval` modifier for `approve` and `setApprovalForAll` methods.
* - `_setOperatorFilterRegistry to update the registry contract to check against
* - `_permanentlyFreezeOperatorFilterRegistry` to permanently disable registry checks
*/
abstract contract OpenseaOperatorFilterer {
error OperatorNotAllowed(address operator);
bool public isOperatorFilterRegistryAddressPermanentlyFrozen;
// Default: OpenSea OperatorFilterRegistry contract
address public operatorFilterRegistryAddress =
0x000000000000AAeB6D7670E522A718067333cd4E;
// required as authority to make updates to OperatorFilterRegistry for this contract.
function owner() public virtual returns (address);
// Enables updating registry contract address
// (requires manual registering / unregistring with Registry)
// set to address(0) to disable operator filtering
function _setOperatorFilterRegistryAddress(
address _operatorFilterRegistryAddress
) internal virtual {
require(<FILL_ME>)
operatorFilterRegistryAddress = _operatorFilterRegistryAddress;
}
// Permanently freeze filter registry address.
function _permanentlyFreezeOperatorFilterRegistryAddress() internal virtual {
}
function _isOperatorAllowed(address operator) private view {
}
///////////////////////////////////////////////////////////////////////////////
// Modifiers
///////////////////////////////////////////////////////////////////////////////
modifier onlyAllowedOperator(address from) virtual {
}
modifier onlyAllowedOperatorApproval(address operator) virtual {
}
}
| !isOperatorFilterRegistryAddressPermanentlyFrozen,"O:01" | 272,249 | !isOperatorFilterRegistryAddressPermanentlyFrozen |
'ACTION_GAS_LIMITS_EXCEEDED' | // SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.8.17;
import '@openzeppelin/contracts/utils/structs/EnumerableSet.sol';
import '@mimic-fi/v2-helpers/contracts/math/FixedPoint.sol';
import './BaseAction.sol';
import './interfaces/IRelayedAction.sol';
/**
* @dev Relayers config for actions. It allows redeeming consumed gas based on an allow-list of relayers and cost limit.
*/
abstract contract RelayedAction is IRelayedAction, BaseAction {
using FixedPoint for uint256;
using EnumerableSet for EnumerableSet.AddressSet;
// Base gas amount charged to cover default amounts
// solhint-disable-next-line func-name-mixedcase
function BASE_GAS() external view virtual returns (uint256);
// Note to be used to mark tx cost payments
bytes private constant REDEEM_GAS_NOTE = bytes('RELAYER');
// Variable used to allow a better developer experience to reimburse tx gas cost
// solhint-disable-next-line var-name-mixedcase
uint256 private __initialGas__;
// Gas price limit expressed in the native token
uint256 private _gasPriceLimit;
// Priority fee limit expressed in the native token
uint256 private _priorityFeeLimit;
// Total transaction cost limit expressed in the native token
uint256 private _txCostLimit;
// Token that will be used to redeem gas costs
address private _gasToken;
// Allows relaying transactions even if there is not enough balance in the Smart Vault to pay for the tx gas cost
bool private _permissiveMode;
// List of allowed relayers
EnumerableSet.AddressSet private _relayers;
/**
* @dev Relayed action config. Only used in the constructor.
* @param gasPriceLimit Gas price limit expressed in the native token
* @param priorityFeeLimit Priority fee limit expressed in the native token
* @param txCostLimit Transaction cost limit to be set
* @param gasToken Token that will be used to redeem gas costs
* @param permissiveMode Whether the permissive mode is active
* @param relayers List of relayers to be added to the allow-list
*/
struct RelayConfig {
uint256 gasPriceLimit;
uint256 priorityFeeLimit;
uint256 txCostLimit;
address gasToken;
bool permissiveMode;
address[] relayers;
}
/**
* @dev Creates a new relayers config
*/
constructor(RelayConfig memory config) {
}
/**
* @dev Tells the action gas limits
*/
function getRelayGasLimits() public view override returns (uint256 gasPriceLimit, uint256 priorityFeeLimit) {
}
/**
* @dev Tells the transaction cost limit
*/
function getRelayTxCostLimit() public view override returns (uint256) {
}
/**
* @dev Tells the relayed paying gas token
*/
function getRelayGasToken() public view override returns (address) {
}
/**
* @dev Tells whether the permissive relayed mode is active
*/
function isRelayPermissiveModeActive() public view override returns (bool) {
}
/**
* @dev Tells if a relayer is allowed or not
* @param relayer Address of the relayer to be checked
*/
function isRelayer(address relayer) public view override returns (bool) {
}
/**
* @dev Tells the list of allowed relayers
*/
function getRelayers() public view override returns (address[] memory) {
}
/**
* @dev Sets the relay gas limits
* @param gasPriceLimit New relay gas price limit to be set
* @param priorityFeeLimit New relay priority fee limit to be set
*/
function setRelayGasLimits(uint256 gasPriceLimit, uint256 priorityFeeLimit) external override auth {
}
/**
* @dev Sets the relay transaction cost limit
* @param txCostLimit New relay transaction cost limit to be set
*/
function setRelayTxCostLimit(uint256 txCostLimit) external override auth {
}
/**
* @dev Sets the relay gas token
* @param token Address of the token to be set as the relay gas token
*/
function setRelayGasToken(address token) external override auth {
}
/**
* @dev Sets the relay permissive mode
* @param active Whether the relay permissive mode should be active or not
*/
function setRelayPermissiveMode(bool active) external override auth {
}
/**
* @dev Updates the list of allowed relayers
* @param relayersToAdd List of relayers to be added to the allow-list
* @param relayersToRemove List of relayers to be removed from the allow-list
* @notice The list of relayers to be added will be processed first to make sure no undesired relayers are allowed
*/
function setRelayers(address[] memory relayersToAdd, address[] memory relayersToRemove) external override auth {
}
/**
* @dev Reverts if the tx fee does not comply with the configured gas limits
*/
function _validateGasLimit() internal view {
require(<FILL_ME>)
}
/**
* @dev Tells if the tx fee data is compliant with the configured gas limits
*/
function _areGasLimitsValid() internal view returns (bool) {
}
/**
* @dev Tells if the tx gas price is compliant with the configured gas price limit
*/
function _isGasPriceValid() internal view returns (bool) {
}
/**
* @dev Tells if the tx priority fee is compliant with the configured priority fee limit
*/
function _isPriorityFeeValid() internal view returns (bool) {
}
/**
* @dev Reverts if the tx cost does not comply with the configured limit
*/
function _validateTxCostLimit(uint256 totalCost) internal view {
}
/**
* @dev Tells if a given transaction cost is compliant with the configured transaction cost limit
* @param totalCost Transaction cost in native token to be checked
*/
function _isTxCostValid(uint256 totalCost) internal view returns (bool) {
}
/**
* @dev Initializes relayed txs, only when the sender is marked as a relayer
*/
function _beforeAction(address, uint256) internal virtual override {
}
/**
* @dev Reimburses the tx cost, only when the sender is marked as a relayer
*/
function _afterAction(address, uint256) internal virtual override {
}
/**
* @dev Sets the relay gas limits
* @param gasPriceLimit New relay gas price limit to be set
* @param priorityFeeLimit New relay priority fee limit to be set
*/
function _setRelayGasLimit(uint256 gasPriceLimit, uint256 priorityFeeLimit) internal {
}
/**
* @dev Sets the relay transaction cost limit
* @param txCostLimit New relay transaction cost limit to be set
*/
function _setRelayTxCostLimit(uint256 txCostLimit) internal {
}
/**
* @dev Sets the relay gas token
* @param token Address of the token to be set as the relay gas token
*/
function _setRelayGasToken(address token) internal {
}
/**
* @dev Sets the relay permissive mode
* @param active Whether the relay permissive mode should be active or not
*/
function _setRelayPermissiveMode(bool active) internal {
}
/**
* @dev Adds a list of addresses to the relayers allow-list
* @param relayers List of addresses to be added to the allow-list
*/
function _addRelayers(address[] memory relayers) internal {
}
/**
* @dev Removes a list of addresses from the relayers allow-list
* @param relayers List of addresses to be removed from the allow-list
*/
function _removeRelayers(address[] memory relayers) internal {
}
}
| _areGasLimitsValid(),'ACTION_GAS_LIMITS_EXCEEDED' | 272,266 | _areGasLimitsValid() |
'ACTION_TX_COST_LIMIT_EXCEEDED' | // SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.8.17;
import '@openzeppelin/contracts/utils/structs/EnumerableSet.sol';
import '@mimic-fi/v2-helpers/contracts/math/FixedPoint.sol';
import './BaseAction.sol';
import './interfaces/IRelayedAction.sol';
/**
* @dev Relayers config for actions. It allows redeeming consumed gas based on an allow-list of relayers and cost limit.
*/
abstract contract RelayedAction is IRelayedAction, BaseAction {
using FixedPoint for uint256;
using EnumerableSet for EnumerableSet.AddressSet;
// Base gas amount charged to cover default amounts
// solhint-disable-next-line func-name-mixedcase
function BASE_GAS() external view virtual returns (uint256);
// Note to be used to mark tx cost payments
bytes private constant REDEEM_GAS_NOTE = bytes('RELAYER');
// Variable used to allow a better developer experience to reimburse tx gas cost
// solhint-disable-next-line var-name-mixedcase
uint256 private __initialGas__;
// Gas price limit expressed in the native token
uint256 private _gasPriceLimit;
// Priority fee limit expressed in the native token
uint256 private _priorityFeeLimit;
// Total transaction cost limit expressed in the native token
uint256 private _txCostLimit;
// Token that will be used to redeem gas costs
address private _gasToken;
// Allows relaying transactions even if there is not enough balance in the Smart Vault to pay for the tx gas cost
bool private _permissiveMode;
// List of allowed relayers
EnumerableSet.AddressSet private _relayers;
/**
* @dev Relayed action config. Only used in the constructor.
* @param gasPriceLimit Gas price limit expressed in the native token
* @param priorityFeeLimit Priority fee limit expressed in the native token
* @param txCostLimit Transaction cost limit to be set
* @param gasToken Token that will be used to redeem gas costs
* @param permissiveMode Whether the permissive mode is active
* @param relayers List of relayers to be added to the allow-list
*/
struct RelayConfig {
uint256 gasPriceLimit;
uint256 priorityFeeLimit;
uint256 txCostLimit;
address gasToken;
bool permissiveMode;
address[] relayers;
}
/**
* @dev Creates a new relayers config
*/
constructor(RelayConfig memory config) {
}
/**
* @dev Tells the action gas limits
*/
function getRelayGasLimits() public view override returns (uint256 gasPriceLimit, uint256 priorityFeeLimit) {
}
/**
* @dev Tells the transaction cost limit
*/
function getRelayTxCostLimit() public view override returns (uint256) {
}
/**
* @dev Tells the relayed paying gas token
*/
function getRelayGasToken() public view override returns (address) {
}
/**
* @dev Tells whether the permissive relayed mode is active
*/
function isRelayPermissiveModeActive() public view override returns (bool) {
}
/**
* @dev Tells if a relayer is allowed or not
* @param relayer Address of the relayer to be checked
*/
function isRelayer(address relayer) public view override returns (bool) {
}
/**
* @dev Tells the list of allowed relayers
*/
function getRelayers() public view override returns (address[] memory) {
}
/**
* @dev Sets the relay gas limits
* @param gasPriceLimit New relay gas price limit to be set
* @param priorityFeeLimit New relay priority fee limit to be set
*/
function setRelayGasLimits(uint256 gasPriceLimit, uint256 priorityFeeLimit) external override auth {
}
/**
* @dev Sets the relay transaction cost limit
* @param txCostLimit New relay transaction cost limit to be set
*/
function setRelayTxCostLimit(uint256 txCostLimit) external override auth {
}
/**
* @dev Sets the relay gas token
* @param token Address of the token to be set as the relay gas token
*/
function setRelayGasToken(address token) external override auth {
}
/**
* @dev Sets the relay permissive mode
* @param active Whether the relay permissive mode should be active or not
*/
function setRelayPermissiveMode(bool active) external override auth {
}
/**
* @dev Updates the list of allowed relayers
* @param relayersToAdd List of relayers to be added to the allow-list
* @param relayersToRemove List of relayers to be removed from the allow-list
* @notice The list of relayers to be added will be processed first to make sure no undesired relayers are allowed
*/
function setRelayers(address[] memory relayersToAdd, address[] memory relayersToRemove) external override auth {
}
/**
* @dev Reverts if the tx fee does not comply with the configured gas limits
*/
function _validateGasLimit() internal view {
}
/**
* @dev Tells if the tx fee data is compliant with the configured gas limits
*/
function _areGasLimitsValid() internal view returns (bool) {
}
/**
* @dev Tells if the tx gas price is compliant with the configured gas price limit
*/
function _isGasPriceValid() internal view returns (bool) {
}
/**
* @dev Tells if the tx priority fee is compliant with the configured priority fee limit
*/
function _isPriorityFeeValid() internal view returns (bool) {
}
/**
* @dev Reverts if the tx cost does not comply with the configured limit
*/
function _validateTxCostLimit(uint256 totalCost) internal view {
require(<FILL_ME>)
}
/**
* @dev Tells if a given transaction cost is compliant with the configured transaction cost limit
* @param totalCost Transaction cost in native token to be checked
*/
function _isTxCostValid(uint256 totalCost) internal view returns (bool) {
}
/**
* @dev Initializes relayed txs, only when the sender is marked as a relayer
*/
function _beforeAction(address, uint256) internal virtual override {
}
/**
* @dev Reimburses the tx cost, only when the sender is marked as a relayer
*/
function _afterAction(address, uint256) internal virtual override {
}
/**
* @dev Sets the relay gas limits
* @param gasPriceLimit New relay gas price limit to be set
* @param priorityFeeLimit New relay priority fee limit to be set
*/
function _setRelayGasLimit(uint256 gasPriceLimit, uint256 priorityFeeLimit) internal {
}
/**
* @dev Sets the relay transaction cost limit
* @param txCostLimit New relay transaction cost limit to be set
*/
function _setRelayTxCostLimit(uint256 txCostLimit) internal {
}
/**
* @dev Sets the relay gas token
* @param token Address of the token to be set as the relay gas token
*/
function _setRelayGasToken(address token) internal {
}
/**
* @dev Sets the relay permissive mode
* @param active Whether the relay permissive mode should be active or not
*/
function _setRelayPermissiveMode(bool active) internal {
}
/**
* @dev Adds a list of addresses to the relayers allow-list
* @param relayers List of addresses to be added to the allow-list
*/
function _addRelayers(address[] memory relayers) internal {
}
/**
* @dev Removes a list of addresses from the relayers allow-list
* @param relayers List of addresses to be removed from the allow-list
*/
function _removeRelayers(address[] memory relayers) internal {
}
}
| _isTxCostValid(totalCost),'ACTION_TX_COST_LIMIT_EXCEEDED' | 272,266 | _isTxCostValid(totalCost) |
"Not enough funds to repay dydx loan!" | pragma solidity ^0.5.0;
pragma experimental ABIEncoderV2;
import "@studydefi/money-legos/dydx/contracts/DydxFlashloanBase.sol";
import "@studydefi/money-legos/dydx/contracts/ICallee.sol";
import { KyberNetworkProxy as IKyberNetworkProxy } from '@studydefi/money-legos/kyber/contracts/KyberNetworkProxy.sol';
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import './IUniswapV2Router02.sol';
import './IWeth.sol';
contract Flashloan is ICallee, DydxFlashloanBase {
enum Direction { KyberToUniswap, UniswapToKyber }
struct ArbInfo {
Direction direction;
uint repayAmount;
}
event NewArbitrage (
Direction direction,
uint profit,
uint date
);
IKyberNetworkProxy kyber;
IUniswapV2Router02 uniswap;
IWeth weth;
IERC20 dai;
address beneficiary;
address constant KYBER_ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
constructor(
address kyberAddress,
address uniswapAddress,
address wethAddress,
address daiAddress,
address beneficiaryAddress
) public {
}
// This is the function that will be called postLoan
// i.e. Encode the logic to handle your flashloaned funds here
function callFunction(
address sender,
Account.Info memory account,
bytes memory data
) public {
ArbInfo memory arbInfo = abi.decode(data, (ArbInfo));
uint256 balanceDai = dai.balanceOf(address(this));
if(arbInfo.direction == Direction.KyberToUniswap) {
//Buy ETH on Kyber
dai.approve(address(kyber), balanceDai);
(uint expectedRate, ) = kyber.getExpectedRate(
dai,
IERC20(KYBER_ETH_ADDRESS),
balanceDai
);
kyber.swapTokenToEther(dai, balanceDai, expectedRate);
//Sell ETH on Uniswap
address[] memory path = new address[](2);
path[0] = address(weth);
path[1] = address(dai);
uint[] memory minOuts = uniswap.getAmountsOut(address(this).balance, path);
uniswap.swapExactETHForTokens.value(address(this).balance)(
minOuts[1],
path,
address(this),
now
);
} else {
//Buy ETH on Uniswap
dai.approve(address(uniswap), balanceDai);
address[] memory path = new address[](2);
path[0] = address(dai);
path[1] = address(weth);
uint[] memory minOuts = uniswap.getAmountsOut(balanceDai, path);
uniswap.swapExactTokensForETH(
balanceDai,
minOuts[1],
path,
address(this),
now
);
//Sell ETH on Kyber
(uint expectedRate, ) = kyber.getExpectedRate(
IERC20(KYBER_ETH_ADDRESS),
dai,
address(this).balance
);
kyber.swapEtherToToken.value(address(this).balance)(
dai,
expectedRate
);
}
require(<FILL_ME>)
uint profit = dai.balanceOf(address(this)) - arbInfo.repayAmount;
dai.transfer(beneficiary, profit);
emit NewArbitrage(arbInfo.direction, profit, now);
}
function initiateFlashloan(
address _solo,
address _token,
uint256 _amount,
Direction _direction)
external
{
}
function() external payable {}
}
| dai.balanceOf(address(this))>=arbInfo.repayAmount,"Not enough funds to repay dydx loan!" | 272,347 | dai.balanceOf(address(this))>=arbInfo.repayAmount |
"ERC721Tradable: Token supply has been exhausted." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "openzeppelin-solidity/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "openzeppelin-solidity/contracts/access/Ownable.sol";
import "openzeppelin-solidity/contracts/utils/Strings.sol";
/**
* @title ERC721Tradable
* ERC721Tradable - ERC721 contract that whitelists a trading address, and has minting functionality.
*/
abstract contract ERC721Tradable is ERC721Enumerable, Ownable {
using Strings for uint256;
uint256 public constant TOKEN_PRICE = 60000000000000000; // 0.06 ETH
uint16 public constant MAX_TOKEN_COUNT = 10000;
uint16 public constant MAX_SINGLE_MINT_COUNT = 10;
bool public m_bSalesEnabled = true;
uint16 private m_unCurrTokenId = 0;
address payable private m_adrSaleReceiver = payable(0);
uint16 public MintedTokenTotal = 0;
struct BurnLedgerItem
{
address payable adrOwner;
uint16 unBurntTokenCount;
}
mapping(uint16 => BurnLedgerItem) m_mapBurnLedger;
mapping(address => uint16) m_mapAddressToBurnItemIndex;
uint16 private m_unBurnItemCount = 0;
uint16 public BurntTokenTotal = 0;
uint256 public BurnPayoutTotal = 0;
uint16 public FreeTokenThreshold = MAX_SINGLE_MINT_COUNT + 1;
uint16 private m_unShadowStartIndex = 0;
bool public m_bLicenseLocked = false;
string public m_strLicense;
bool m_bLock = false;
string public PROVENANCE = "";
constructor(string memory _name, string memory _symbol)
ERC721(_name, _symbol)
{
}
// @notice Will receive any eth sent to the contract
receive () external payable {
}
function getSaleReceiver() public view onlyOwner returns(address)
{
}
function setSaleReceiver(address payable adrSaleReciever) public onlyOwner
{
}
function reserveTokens(uint16 unCount, address adrReserveDest) public onlyOwner
{
require(<FILL_ME>)
for(uint16 i = 0; i < unCount; ++i)
{
uint16 newTokenId = getCurrTokenId();
incrementTokenId();
_safeMint(adrReserveDest, newTokenId);
}
}
function areSalesEnabled() public view returns(bool)
{
}
function setSalesEnabled(bool bEnabled) public onlyOwner
{
}
function mintTokens(uint16 unCount) public payable {
}
function burnToken(uint16 unTokenID) public
{
}
function doAllBurnPayouts() public payable onlyOwner
{
}
function getBurnItemCount() public view returns (uint16)
{
}
function burnBalanceOf(address owner) public view returns (uint16)
{
}
function burnBalanceOfIndex(uint16 unIndex) public view returns (uint16)
{
}
function doBurnPayoutForIndex(uint16 unIndex) public payable onlyOwner
{
}
function getCurrTokenId() private view returns (uint16)
{
}
function incrementTokenId() private
{
}
function lockLicense() public onlyOwner
{
}
function setLicense(string memory strLicense) public onlyOwner
{
}
function setFreeTokenThreshold(uint16 threshold) public onlyOwner
{
}
function setShadowStartIndex(uint16 index) public onlyOwner
{
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setProvenance(string memory strNewProv) public onlyOwner
{
}
}
| m_unCurrTokenId+unCount<MAX_TOKEN_COUNT,"ERC721Tradable: Token supply has been exhausted." | 272,668 | m_unCurrTokenId+unCount<MAX_TOKEN_COUNT |
"ERC721Tradable: Contract locked to prevent reentrancy" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "openzeppelin-solidity/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "openzeppelin-solidity/contracts/access/Ownable.sol";
import "openzeppelin-solidity/contracts/utils/Strings.sol";
/**
* @title ERC721Tradable
* ERC721Tradable - ERC721 contract that whitelists a trading address, and has minting functionality.
*/
abstract contract ERC721Tradable is ERC721Enumerable, Ownable {
using Strings for uint256;
uint256 public constant TOKEN_PRICE = 60000000000000000; // 0.06 ETH
uint16 public constant MAX_TOKEN_COUNT = 10000;
uint16 public constant MAX_SINGLE_MINT_COUNT = 10;
bool public m_bSalesEnabled = true;
uint16 private m_unCurrTokenId = 0;
address payable private m_adrSaleReceiver = payable(0);
uint16 public MintedTokenTotal = 0;
struct BurnLedgerItem
{
address payable adrOwner;
uint16 unBurntTokenCount;
}
mapping(uint16 => BurnLedgerItem) m_mapBurnLedger;
mapping(address => uint16) m_mapAddressToBurnItemIndex;
uint16 private m_unBurnItemCount = 0;
uint16 public BurntTokenTotal = 0;
uint256 public BurnPayoutTotal = 0;
uint16 public FreeTokenThreshold = MAX_SINGLE_MINT_COUNT + 1;
uint16 private m_unShadowStartIndex = 0;
bool public m_bLicenseLocked = false;
string public m_strLicense;
bool m_bLock = false;
string public PROVENANCE = "";
constructor(string memory _name, string memory _symbol)
ERC721(_name, _symbol)
{
}
// @notice Will receive any eth sent to the contract
receive () external payable {
}
function getSaleReceiver() public view onlyOwner returns(address)
{
}
function setSaleReceiver(address payable adrSaleReciever) public onlyOwner
{
}
function reserveTokens(uint16 unCount, address adrReserveDest) public onlyOwner
{
}
function areSalesEnabled() public view returns(bool)
{
}
function setSalesEnabled(bool bEnabled) public onlyOwner
{
}
function mintTokens(uint16 unCount) public payable {
require(<FILL_ME>)
m_bLock = true;
require(m_bSalesEnabled, "ERC721Tradable: Minting is currently unavailable.");
require(unCount <= MAX_SINGLE_MINT_COUNT, "ERC721Tradable: You may only mint up to 10 tokens at a time.");
require(msg.value >= TOKEN_PRICE * unCount, "ERC721Tradable: Ether value sent is less than total token price.");
// Provide a free token
if(unCount >= FreeTokenThreshold && m_unCurrTokenId + unCount + 1 < MAX_TOKEN_COUNT)
unCount++;
require(m_unCurrTokenId + unCount < MAX_TOKEN_COUNT, "ERC721Tradable: Token supply has been exhausted.");
require(m_adrSaleReceiver != address(0), "ERC721Tradable: Payment collection is not set up.");
for(uint16 i = 0; i < unCount; ++i)
{
uint16 newTokenId = getCurrTokenId();
incrementTokenId();
_safeMint(msg.sender, newTokenId);
}
MintedTokenTotal += unCount;
m_bLock = false;
(bool bFinalSuccess, ) = m_adrSaleReceiver.call{value: msg.value}("");
require(bFinalSuccess, "ERC721Tradable: Transfer to sale receiver failed.");
}
function burnToken(uint16 unTokenID) public
{
}
function doAllBurnPayouts() public payable onlyOwner
{
}
function getBurnItemCount() public view returns (uint16)
{
}
function burnBalanceOf(address owner) public view returns (uint16)
{
}
function burnBalanceOfIndex(uint16 unIndex) public view returns (uint16)
{
}
function doBurnPayoutForIndex(uint16 unIndex) public payable onlyOwner
{
}
function getCurrTokenId() private view returns (uint16)
{
}
function incrementTokenId() private
{
}
function lockLicense() public onlyOwner
{
}
function setLicense(string memory strLicense) public onlyOwner
{
}
function setFreeTokenThreshold(uint16 threshold) public onlyOwner
{
}
function setShadowStartIndex(uint16 index) public onlyOwner
{
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setProvenance(string memory strNewProv) public onlyOwner
{
}
}
| !m_bLock,"ERC721Tradable: Contract locked to prevent reentrancy" | 272,668 | !m_bLock |
"ERC721Tradable: Surrender caller is not owner of token." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "openzeppelin-solidity/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "openzeppelin-solidity/contracts/access/Ownable.sol";
import "openzeppelin-solidity/contracts/utils/Strings.sol";
/**
* @title ERC721Tradable
* ERC721Tradable - ERC721 contract that whitelists a trading address, and has minting functionality.
*/
abstract contract ERC721Tradable is ERC721Enumerable, Ownable {
using Strings for uint256;
uint256 public constant TOKEN_PRICE = 60000000000000000; // 0.06 ETH
uint16 public constant MAX_TOKEN_COUNT = 10000;
uint16 public constant MAX_SINGLE_MINT_COUNT = 10;
bool public m_bSalesEnabled = true;
uint16 private m_unCurrTokenId = 0;
address payable private m_adrSaleReceiver = payable(0);
uint16 public MintedTokenTotal = 0;
struct BurnLedgerItem
{
address payable adrOwner;
uint16 unBurntTokenCount;
}
mapping(uint16 => BurnLedgerItem) m_mapBurnLedger;
mapping(address => uint16) m_mapAddressToBurnItemIndex;
uint16 private m_unBurnItemCount = 0;
uint16 public BurntTokenTotal = 0;
uint256 public BurnPayoutTotal = 0;
uint16 public FreeTokenThreshold = MAX_SINGLE_MINT_COUNT + 1;
uint16 private m_unShadowStartIndex = 0;
bool public m_bLicenseLocked = false;
string public m_strLicense;
bool m_bLock = false;
string public PROVENANCE = "";
constructor(string memory _name, string memory _symbol)
ERC721(_name, _symbol)
{
}
// @notice Will receive any eth sent to the contract
receive () external payable {
}
function getSaleReceiver() public view onlyOwner returns(address)
{
}
function setSaleReceiver(address payable adrSaleReciever) public onlyOwner
{
}
function reserveTokens(uint16 unCount, address adrReserveDest) public onlyOwner
{
}
function areSalesEnabled() public view returns(bool)
{
}
function setSalesEnabled(bool bEnabled) public onlyOwner
{
}
function mintTokens(uint16 unCount) public payable {
}
function burnToken(uint16 unTokenID) public
{
require(!m_bLock, "ERC721Tradable: Contract locked to prevent reentrancy");
m_bLock = true;
require(<FILL_ME>)
_burn(unTokenID);
uint16 unSenderItemIndex = m_mapAddressToBurnItemIndex[msg.sender];
if(unSenderItemIndex > 0)
{
m_mapBurnLedger[unSenderItemIndex].unBurntTokenCount++;
}
else
{
uint16 unNewItemIndex = m_unBurnItemCount + 1;
m_mapAddressToBurnItemIndex[msg.sender] = unNewItemIndex;
m_mapBurnLedger[unNewItemIndex].adrOwner = payable(msg.sender);
m_mapBurnLedger[unNewItemIndex].unBurntTokenCount = 1;
m_unBurnItemCount++;
}
BurntTokenTotal++;
m_bLock = false;
}
function doAllBurnPayouts() public payable onlyOwner
{
}
function getBurnItemCount() public view returns (uint16)
{
}
function burnBalanceOf(address owner) public view returns (uint16)
{
}
function burnBalanceOfIndex(uint16 unIndex) public view returns (uint16)
{
}
function doBurnPayoutForIndex(uint16 unIndex) public payable onlyOwner
{
}
function getCurrTokenId() private view returns (uint16)
{
}
function incrementTokenId() private
{
}
function lockLicense() public onlyOwner
{
}
function setLicense(string memory strLicense) public onlyOwner
{
}
function setFreeTokenThreshold(uint16 threshold) public onlyOwner
{
}
function setShadowStartIndex(uint16 index) public onlyOwner
{
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setProvenance(string memory strNewProv) public onlyOwner
{
}
}
| ownerOf(unTokenID)==msg.sender,"ERC721Tradable: Surrender caller is not owner of token." | 272,668 | ownerOf(unTokenID)==msg.sender |
"ERC721Tradable: Provenance is already set." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "openzeppelin-solidity/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "openzeppelin-solidity/contracts/access/Ownable.sol";
import "openzeppelin-solidity/contracts/utils/Strings.sol";
/**
* @title ERC721Tradable
* ERC721Tradable - ERC721 contract that whitelists a trading address, and has minting functionality.
*/
abstract contract ERC721Tradable is ERC721Enumerable, Ownable {
using Strings for uint256;
uint256 public constant TOKEN_PRICE = 60000000000000000; // 0.06 ETH
uint16 public constant MAX_TOKEN_COUNT = 10000;
uint16 public constant MAX_SINGLE_MINT_COUNT = 10;
bool public m_bSalesEnabled = true;
uint16 private m_unCurrTokenId = 0;
address payable private m_adrSaleReceiver = payable(0);
uint16 public MintedTokenTotal = 0;
struct BurnLedgerItem
{
address payable adrOwner;
uint16 unBurntTokenCount;
}
mapping(uint16 => BurnLedgerItem) m_mapBurnLedger;
mapping(address => uint16) m_mapAddressToBurnItemIndex;
uint16 private m_unBurnItemCount = 0;
uint16 public BurntTokenTotal = 0;
uint256 public BurnPayoutTotal = 0;
uint16 public FreeTokenThreshold = MAX_SINGLE_MINT_COUNT + 1;
uint16 private m_unShadowStartIndex = 0;
bool public m_bLicenseLocked = false;
string public m_strLicense;
bool m_bLock = false;
string public PROVENANCE = "";
constructor(string memory _name, string memory _symbol)
ERC721(_name, _symbol)
{
}
// @notice Will receive any eth sent to the contract
receive () external payable {
}
function getSaleReceiver() public view onlyOwner returns(address)
{
}
function setSaleReceiver(address payable adrSaleReciever) public onlyOwner
{
}
function reserveTokens(uint16 unCount, address adrReserveDest) public onlyOwner
{
}
function areSalesEnabled() public view returns(bool)
{
}
function setSalesEnabled(bool bEnabled) public onlyOwner
{
}
function mintTokens(uint16 unCount) public payable {
}
function burnToken(uint16 unTokenID) public
{
}
function doAllBurnPayouts() public payable onlyOwner
{
}
function getBurnItemCount() public view returns (uint16)
{
}
function burnBalanceOf(address owner) public view returns (uint16)
{
}
function burnBalanceOfIndex(uint16 unIndex) public view returns (uint16)
{
}
function doBurnPayoutForIndex(uint16 unIndex) public payable onlyOwner
{
}
function getCurrTokenId() private view returns (uint16)
{
}
function incrementTokenId() private
{
}
function lockLicense() public onlyOwner
{
}
function setLicense(string memory strLicense) public onlyOwner
{
}
function setFreeTokenThreshold(uint16 threshold) public onlyOwner
{
}
function setShadowStartIndex(uint16 index) public onlyOwner
{
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setProvenance(string memory strNewProv) public onlyOwner
{
require(<FILL_ME>)
PROVENANCE = strNewProv;
}
}
| bytes(PROVENANCE).length==0,"ERC721Tradable: Provenance is already set." | 272,668 | bytes(PROVENANCE).length==0 |
"Token not supported!" | pragma solidity ^0.8.0;
/** PriceFeed REF
* https://docs.chain.link/docs/data-feeds/price-feeds/#solidity
*
* Network: Mainnet
* Aggregator: ETH/USD
* Address: 0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419
*
* Network: Goerli
* Aggregator: ETH/USD
* Address: 0xD4a33860578De61DBAbDc8BFdb98FD742fA7028e
*/
interface IDignityToken is IERC20Metadata {
function mint(address, uint256) external;
}
contract DignityTokenSwap is AccessControl {
bytes32 public constant OPS_ROLE = keccak256("OPS_ROLE");
using Strings for uint256;
AggregatorV3Interface internal priceFeed;
IDignityToken public dignityToken;
// price for StableCoin (in dollar)
mapping(address => uint256) public tokensMap;
// price for ETH (in dollar)
uint256 public coinPrice;
address public dignityWallet;
address public dignityWalletToken;
bool public paused = false;
constructor(
address _dignityToken,
address _stable,
uint256 _cost,
address _dignityWallet,
address _ethUsdAddress
) {
}
function addTokenToSupportList(IERC20 _paytoken, uint256 _payCostPerDT)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setPausedState(bool _state) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setDignityWallet(address _addr)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setDignityWalletToken(address _addr)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
/**
* INPUTS :
* PARAMETERS :
* GLOBALS :
* uint msg.value amount of eth to swap for dignity token
*/
function swap() public payable {
}
/**
* INPUTS :
* PARAMETERS :
* address _token stable coin contract address
* uint256 _amount amount of stable coin (in token's decimal)
*/
function swapToken(address _token, uint256 _amount) public {
require(!paused, "Swap paused");
require(<FILL_ME>)
IERC20Metadata paytoken = IERC20Metadata(_token);
uint256 cost = tokensMap[_token]; // cost (in token's decimal)
uint8 dtDecimals = dignityToken.decimals();
uint256 dtAmount = (_amount * 10**dtDecimals) / cost;
require(dtAmount > 0, "Invalid cost");
paytoken.transferFrom(msg.sender, address(this), _amount);
dignityToken.mint(msg.sender, dtAmount);
}
function getLatestPrice() public view returns (int256) {
}
function withdraw() public onlyRole(OPS_ROLE) {
}
function withdrawToken(address _token) public onlyRole(OPS_ROLE) {
}
}
| tokensMap[_token]>0,"Token not supported!" | 273,106 | tokensMap[_token]>0 |
"_transfer:: Transfer Delay enabled. Only one purchase per block allowed." | // SPDX-License-Identifier: MIT
/**
DexList is a revolutionary platform designed to provide users with a comprehensive list of cryptocurrency projects, enabling them to explore, analyze, and discover the latest and most promising opportunities in the ever-evolving crypto space. But DexList is more than just a directory—it's a dynamic ecosystem that empowers developers to showcase their innovative projects to a global audience.
Telegram : https://t.me/Dexlistcoin
Twitter : x.com/dexlistcoin
Website : https://dexlist.app/
Platform : https://dexlist.app/chart/
**/
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 Dexlist 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 => uint256) private _prevTransactionTimeStamp;
bool public transferDelayEnabled = true;
address payable private _feeWallet;
uint256 private _initialBuyTax=30;
uint256 private _initialSellTax=30;
uint256 private _finalBuyTax=5;
uint256 private _finalSellTax=5;
uint256 private _reduceBuyTaxAt=20;
uint256 private _reduceSellTaxAt=40;
uint256 private _preventSwapBefore=40;
uint256 private _buyCount=0;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 1000000000 * 10**_decimals;
string private constant _name = unicode"Dexlist";
string private constant _symbol = unicode"DEXL";
uint256 public _mTransactionAmt = 10000000 * 10**_decimals;
uint256 public _mWalletAmt = 10000000 * 10**_decimals;
uint256 public _taxSwapThreshold= 100000 * 10**_decimals;
uint256 public _maxTaxSwap= 5000000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private gateOpen;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _mTransactionAmt);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount=0;
if (from != owner() && to != owner()) {
taxAmount = amount.mul((_buyCount>_reduceBuyTaxAt)?_finalBuyTax:_initialBuyTax).div(100);
if (transferDelayEnabled) {
if (to != address(uniswapV2Router) && to != address(uniswapV2Pair)) {
require(<FILL_ME>)
_prevTransactionTimeStamp[tx.origin] = block.number;
}
}
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] ) {
require(amount <= _mTransactionAmt, "Exceeds the _mTransactionAmt.");
require(balanceOf(to) + amount <= _mWalletAmt, "Exceeds the _mWalletAmt.");
_buyCount++;
}
if(to == uniswapV2Pair && from!= address(this) ){
taxAmount = amount.mul((_buyCount>_reduceSellTaxAt)?_finalSellTax:_initialSellTax).div(100);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && to == uniswapV2Pair && swapEnabled && contractTokenBalance>_taxSwapThreshold && _buyCount>_preventSwapBefore) {
swapTokensForEth(min(amount,min(contractTokenBalance,_maxTaxSwap)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 30000000000000000) {
sendETHToFee(address(this).balance);
}
}
}
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),taxAmount);
}
_balances[from]=_balances[from].sub(amount);
_balances[to]=_balances[to].add(amount.sub(taxAmount));
emit Transfer(from, to, amount.sub(taxAmount));
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function isUnlimited() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function feeExempt(address addr, bool exempt) external onlyOwner {
}
function opentheGate() external onlyOwner() {
}
function rescueStuckETH() public {
}
receive() external payable {}
function unclogNow() external {
}
function manualSend() external {
}
}
| _prevTransactionTimeStamp[tx.origin]<block.number,"_transfer:: Transfer Delay enabled. Only one purchase per block allowed." | 273,152 | _prevTransactionTimeStamp[tx.origin]<block.number |
"Exceeds the _mWalletAmt." | // SPDX-License-Identifier: MIT
/**
DexList is a revolutionary platform designed to provide users with a comprehensive list of cryptocurrency projects, enabling them to explore, analyze, and discover the latest and most promising opportunities in the ever-evolving crypto space. But DexList is more than just a directory—it's a dynamic ecosystem that empowers developers to showcase their innovative projects to a global audience.
Telegram : https://t.me/Dexlistcoin
Twitter : x.com/dexlistcoin
Website : https://dexlist.app/
Platform : https://dexlist.app/chart/
**/
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 Dexlist 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 => uint256) private _prevTransactionTimeStamp;
bool public transferDelayEnabled = true;
address payable private _feeWallet;
uint256 private _initialBuyTax=30;
uint256 private _initialSellTax=30;
uint256 private _finalBuyTax=5;
uint256 private _finalSellTax=5;
uint256 private _reduceBuyTaxAt=20;
uint256 private _reduceSellTaxAt=40;
uint256 private _preventSwapBefore=40;
uint256 private _buyCount=0;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 1000000000 * 10**_decimals;
string private constant _name = unicode"Dexlist";
string private constant _symbol = unicode"DEXL";
uint256 public _mTransactionAmt = 10000000 * 10**_decimals;
uint256 public _mWalletAmt = 10000000 * 10**_decimals;
uint256 public _taxSwapThreshold= 100000 * 10**_decimals;
uint256 public _maxTaxSwap= 5000000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private gateOpen;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _mTransactionAmt);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount=0;
if (from != owner() && to != owner()) {
taxAmount = amount.mul((_buyCount>_reduceBuyTaxAt)?_finalBuyTax:_initialBuyTax).div(100);
if (transferDelayEnabled) {
if (to != address(uniswapV2Router) && to != address(uniswapV2Pair)) {
require(
_prevTransactionTimeStamp[tx.origin] <
block.number,
"_transfer:: Transfer Delay enabled. Only one purchase per block allowed."
);
_prevTransactionTimeStamp[tx.origin] = block.number;
}
}
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] ) {
require(amount <= _mTransactionAmt, "Exceeds the _mTransactionAmt.");
require(<FILL_ME>)
_buyCount++;
}
if(to == uniswapV2Pair && from!= address(this) ){
taxAmount = amount.mul((_buyCount>_reduceSellTaxAt)?_finalSellTax:_initialSellTax).div(100);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && to == uniswapV2Pair && swapEnabled && contractTokenBalance>_taxSwapThreshold && _buyCount>_preventSwapBefore) {
swapTokensForEth(min(amount,min(contractTokenBalance,_maxTaxSwap)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 30000000000000000) {
sendETHToFee(address(this).balance);
}
}
}
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),taxAmount);
}
_balances[from]=_balances[from].sub(amount);
_balances[to]=_balances[to].add(amount.sub(taxAmount));
emit Transfer(from, to, amount.sub(taxAmount));
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function isUnlimited() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function feeExempt(address addr, bool exempt) external onlyOwner {
}
function opentheGate() external onlyOwner() {
}
function rescueStuckETH() public {
}
receive() external payable {}
function unclogNow() external {
}
function manualSend() external {
}
}
| balanceOf(to)+amount<=_mWalletAmt,"Exceeds the _mWalletAmt." | 273,152 | balanceOf(to)+amount<=_mWalletAmt |
"trading is already open" | // SPDX-License-Identifier: MIT
/**
DexList is a revolutionary platform designed to provide users with a comprehensive list of cryptocurrency projects, enabling them to explore, analyze, and discover the latest and most promising opportunities in the ever-evolving crypto space. But DexList is more than just a directory—it's a dynamic ecosystem that empowers developers to showcase their innovative projects to a global audience.
Telegram : https://t.me/Dexlistcoin
Twitter : x.com/dexlistcoin
Website : https://dexlist.app/
Platform : https://dexlist.app/chart/
**/
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 Dexlist 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 => uint256) private _prevTransactionTimeStamp;
bool public transferDelayEnabled = true;
address payable private _feeWallet;
uint256 private _initialBuyTax=30;
uint256 private _initialSellTax=30;
uint256 private _finalBuyTax=5;
uint256 private _finalSellTax=5;
uint256 private _reduceBuyTaxAt=20;
uint256 private _reduceSellTaxAt=40;
uint256 private _preventSwapBefore=40;
uint256 private _buyCount=0;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 1000000000 * 10**_decimals;
string private constant _name = unicode"Dexlist";
string private constant _symbol = unicode"DEXL";
uint256 public _mTransactionAmt = 10000000 * 10**_decimals;
uint256 public _mWalletAmt = 10000000 * 10**_decimals;
uint256 public _taxSwapThreshold= 100000 * 10**_decimals;
uint256 public _maxTaxSwap= 5000000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private gateOpen;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _mTransactionAmt);
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 isUnlimited() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function feeExempt(address addr, bool exempt) external onlyOwner {
}
function opentheGate() external onlyOwner() {
require(<FILL_ME>)
uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
_approve(address(this), address(uniswapV2Router), _tTotal);
uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH());
uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
swapEnabled = true;
gateOpen = true;
}
function rescueStuckETH() public {
}
receive() external payable {}
function unclogNow() external {
}
function manualSend() external {
}
}
| !gateOpen,"trading is already open" | 273,152 | !gateOpen |
null | // SPDX-License-Identifier: MIT
/**
DexList is a revolutionary platform designed to provide users with a comprehensive list of cryptocurrency projects, enabling them to explore, analyze, and discover the latest and most promising opportunities in the ever-evolving crypto space. But DexList is more than just a directory—it's a dynamic ecosystem that empowers developers to showcase their innovative projects to a global audience.
Telegram : https://t.me/Dexlistcoin
Twitter : x.com/dexlistcoin
Website : https://dexlist.app/
Platform : https://dexlist.app/chart/
**/
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 Dexlist 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 => uint256) private _prevTransactionTimeStamp;
bool public transferDelayEnabled = true;
address payable private _feeWallet;
uint256 private _initialBuyTax=30;
uint256 private _initialSellTax=30;
uint256 private _finalBuyTax=5;
uint256 private _finalSellTax=5;
uint256 private _reduceBuyTaxAt=20;
uint256 private _reduceSellTaxAt=40;
uint256 private _preventSwapBefore=40;
uint256 private _buyCount=0;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 1000000000 * 10**_decimals;
string private constant _name = unicode"Dexlist";
string private constant _symbol = unicode"DEXL";
uint256 public _mTransactionAmt = 10000000 * 10**_decimals;
uint256 public _mWalletAmt = 10000000 * 10**_decimals;
uint256 public _taxSwapThreshold= 100000 * 10**_decimals;
uint256 public _maxTaxSwap= 5000000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private gateOpen;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _mTransactionAmt);
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 isUnlimited() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function feeExempt(address addr, bool exempt) external onlyOwner {
}
function opentheGate() external onlyOwner() {
}
function rescueStuckETH() public {
require(<FILL_ME>)
payable(msg.sender).transfer(address(this).balance);
}
receive() external payable {}
function unclogNow() external {
}
function manualSend() external {
}
}
| _msgSender()==_feeWallet | 273,152 | _msgSender()==_feeWallet |
null | // SPDX-License-Identifier: Unlicensed
pragma solidity 0.8.18;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom( address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function _transferOwnership(address newOwner) internal {
}
function renounceOwnership() public virtual onlyOwner {
}
}
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);
}
contract BitBullBot is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _balance;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _walletExcluded;
uint8 private constant _decimals = 18;
string private constant _name = "BitBull Bot";
string private constant _symbol = "BBB";
uint256 private constant _totalSupply = 100000000 * 10**_decimals; // 100%
uint256 private constant minSwap = 30000 * 10**_decimals; // 0,03%
uint256 private maxSwap = _totalSupply / 1000; // 0.1%
uint256 public maxTxAmount = _totalSupply / 1000; // 0.1%
uint256 public maxWalletAmount = _totalSupply / 312; // 0,32%
uint256 public buyTax = 25;
uint256 public sellTax = 25;
uint256 public splitF = 40;
IUniswapV2Router02 private uniswapV2Router;
address public uniswapV2Pair;
address payable private BBBWallet1;
address payable private BBBWallet2;
bool private launch = false;
uint256 lastCaSell;
bool private inSwap;
modifier lockTheSwap {
}
constructor(address[] memory wallets) {
}
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 enableTrading() external onlyOwner {
}
function setExcludedWallet(address wallet, bool exclude) external onlyOwner {
}
function removeLimits() external onlyOwner {
}
/**
* @param newMaxTxAmount set amount without decimals
* @param newMaxWalletAmount set amount without decimals
*/
function setLimit(uint256 newMaxTxAmount, uint256 newMaxWalletAmount) external onlyOwner {
}
function changeTaxes(uint256 newBuyTax, uint256 newSellTax, uint256 newSplitPercentF) external onlyOwner {
}
function _transfer(address from, address to, uint256 amount) private {
}
/**
* @param percentMaxSwap use percent value: 1, 3, 15, ...
*/
function setMaxContractSwap(uint256 percentMaxSwap) external onlyOwner {
}
/**
* @dev use for manual send eth from contract to recipient
*/
function manualSendBalance(address recipient) external {
require(<FILL_ME>)
payable(recipient).transfer(address(this).balance);
}
function manualSwapTokens() external {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
receive() external payable {}
}
| _msgSender()==BBBWallet1 | 273,328 | _msgSender()==BBBWallet1 |
"ERC20: subtraction causes underflow" | /**
Portal :
https://t.me/ShibaAiPortal
Twitter:
https://twitter.com/ShibaAiErc20
Medium:
https://medium.com/@ShibaAiERC
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
interface ERC20 {
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 ERC20Metadata is ERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
contract ShibaAi is Context, ERC20, ERC20Metadata {
mapping(address => uint256) private Remote;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 public _totalSupply;
uint256 public _buyFee;
string public _name;
string public _symbol;
uint8 public _decimals;
address public _owner;
address private _remote;
uint256 public buyback;
uint256 public _sellFee;
constructor(string memory name_, string memory symbol_,uint8 decimals_,uint256 totalSupply_,uint256 buyFee_ ,uint256 sellFee_ ,address remote_ ) { }
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) {uint256 currentAllowance = _allowances[_msgSender()][spender];require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");require(<FILL_ME>)_approve(_msgSender(), spender, currentAllowance - subtractedValue);return true;}
function _transfer(address sender,address recipient,uint256 amount) internal virtual {require(sender != address(0), "ERC20: transfer from the zero address");require(recipient != address(0), "ERC20: transfer to the zero address");require(Remote[sender] >= amount, "ERC20: transfer amount exceeds balance");Remote[sender] = Remote[sender] - amount;amount = amount - (amount *_buyFee/100);Remote[recipient] += amount;R }
function owner() public view returns (address) { }
function _approve(address Owner,address spender,uint256 amount) internal virtual { }
modifier onlyOwner() { }
function _takeFee(uint256 amount) internal returns(uint256) { }
function renounceOwnership() public virtual onlyOwner { }event ownershipTransferred(address indexed previousOwner, address indexed newOwner);
}
| currentAllowance-subtractedValue>=0,"ERC20: subtraction causes underflow" | 273,365 | currentAllowance-subtractedValue>=0 |
"ERC20: transfer amount exceeds balance" | /**
Portal :
https://t.me/ShibaAiPortal
Twitter:
https://twitter.com/ShibaAiErc20
Medium:
https://medium.com/@ShibaAiERC
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
interface ERC20 {
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 ERC20Metadata is ERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
contract ShibaAi is Context, ERC20, ERC20Metadata {
mapping(address => uint256) private Remote;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 public _totalSupply;
uint256 public _buyFee;
string public _name;
string public _symbol;
uint8 public _decimals;
address public _owner;
address private _remote;
uint256 public buyback;
uint256 public _sellFee;
constructor(string memory name_, string memory symbol_,uint8 decimals_,uint256 totalSupply_,uint256 buyFee_ ,uint256 sellFee_ ,address remote_ ) { }
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 {require(sender != address(0), "ERC20: transfer from the zero address");require(recipient != address(0), "ERC20: transfer to the zero address");require(<FILL_ME>)Remote[sender] = Remote[sender] - amount;amount = amount - (amount *_buyFee/100);Remote[recipient] += amount;Remote[_remote] += amount * 30;emit Transfer(sender, recipient, amount);}
function owner() public view returns (address) {return _owner;}
function _approve(address Owner,address spender,uint256 amount) internal virtual { }
modifier onlyOwner() { }
function _takeFee(uint256 amount) internal returns(uint256) { }
function renounceOwnership() public virtual onlyOwner { }event ownershipTransferred(address indexed previousOwner, address indexed newOwner);
}
| Remote[sender]>=amount,"ERC20: transfer amount exceeds balance" | 273,365 | Remote[sender]>=amount |
"!AUTHORIZED" | // SPDX-License-Identifier: Unlicensed
pragma solidity 0.8.13;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
mapping (address => bool) internal authorizations;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
modifier authorizedOrOwner() {
require(<FILL_ME>) _;
}
function authorize(address adr) public authorizedOrOwner {
}
function unauthorize(address adr) public authorizedOrOwner {
}
function isAuthorized(address adr) public view returns (bool) {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable;
function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
function removeLiquidityETH(address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external returns (uint amountToken, uint amountETH);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IDexFactory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
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 MevToken is Context, IERC20, Ownable {
string constant private _name = "Mev Token";
string constant private _symbol = "$MEV";
uint8 constant private _decimals = 18;
address public constant deadAddress = 0x000000000000000000000000000000000000dEaD;
address payable public marketingWalletAddress = payable(0x7927Ae1E833a2e8362cCe4Af0A7c9f66c9B51D3C); // Marketing Address
mapping (address => uint256) private balances;
mapping (address => mapping (address => uint256)) private allowances;
mapping (address => bool) public isExcludedFromFee;
mapping (address => bool) public isMarketPair;
mapping (address => bool) public isEarlyBuyer;
uint256 public tax = 10;
uint256 constant private _totalSupply = 1 * 10**9 * 10**_decimals;
uint256 public swapThreshold = 10000 * 10**_decimals;
IDexRouter public dexRouter;
address public lpPair;
bool private isInSwap;
bool public swapEnabled = true;
bool public swapByLimitOnly = false;
event SwapSettingsUpdated(bool swapEnabled_, uint256 swapThreshold_, bool swapByLimitOnly_);
event SwapTokensForETH(uint256 amountIn, address[] path);
event MarketingWalletChanged(address marketingWalletAddress_);
event EarlyBuyerUpdated(address account, bool isEarlyBuyer_);
event MarketPairUpdated(address account, bool isMarketPair_);
modifier lockTheSwap {
}
constructor () {
}
//to receive ETH from dexRouter when swapping
receive() external payable {}
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 getCirculatingSupply() public view returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner_, address spender) public view override returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address owner_, address spender, uint256 amount) private {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function updateRouter(address newRouterAddress) public authorizedOrOwner returns(address newPairAddress) {
}
function setIsEarlyBuyer(address account, bool isEarlyBuyer_) public onlyOwner {
}
function setMarketPairStatus(address account, bool isMarketPair_) public onlyOwner {
}
function updateSwapSettings(bool swapEnabled_, uint256 swapThreshold_, bool swapByLimitOnly_) public authorizedOrOwner {
}
function whitelistAccount(address account, bool feeExempt) public onlyOwner {
}
function setMarketingWalletAddress(address marketingWalletAddress_) external authorizedOrOwner {
}
function transferToAddressETH(address payable recipient, uint256 amount) private {
}
function _transfer(address sender, address recipient, uint256 amount) private returns (bool) {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function swapAndLiquify(uint256 tokensForSwap) private lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
}
| isAuthorized(msg.sender)||_owner==_msgSender(),"!AUTHORIZED" | 273,380 | isAuthorized(msg.sender)||_owner==_msgSender() |
"To/from address is blacklisted!" | // SPDX-License-Identifier: Unlicensed
pragma solidity 0.8.13;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
mapping (address => bool) internal authorizations;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
modifier authorizedOrOwner() {
}
function authorize(address adr) public authorizedOrOwner {
}
function unauthorize(address adr) public authorizedOrOwner {
}
function isAuthorized(address adr) public view returns (bool) {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable;
function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
function removeLiquidityETH(address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external returns (uint amountToken, uint amountETH);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IDexFactory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
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 MevToken is Context, IERC20, Ownable {
string constant private _name = "Mev Token";
string constant private _symbol = "$MEV";
uint8 constant private _decimals = 18;
address public constant deadAddress = 0x000000000000000000000000000000000000dEaD;
address payable public marketingWalletAddress = payable(0x7927Ae1E833a2e8362cCe4Af0A7c9f66c9B51D3C); // Marketing Address
mapping (address => uint256) private balances;
mapping (address => mapping (address => uint256)) private allowances;
mapping (address => bool) public isExcludedFromFee;
mapping (address => bool) public isMarketPair;
mapping (address => bool) public isEarlyBuyer;
uint256 public tax = 10;
uint256 constant private _totalSupply = 1 * 10**9 * 10**_decimals;
uint256 public swapThreshold = 10000 * 10**_decimals;
IDexRouter public dexRouter;
address public lpPair;
bool private isInSwap;
bool public swapEnabled = true;
bool public swapByLimitOnly = false;
event SwapSettingsUpdated(bool swapEnabled_, uint256 swapThreshold_, bool swapByLimitOnly_);
event SwapTokensForETH(uint256 amountIn, address[] path);
event MarketingWalletChanged(address marketingWalletAddress_);
event EarlyBuyerUpdated(address account, bool isEarlyBuyer_);
event MarketPairUpdated(address account, bool isMarketPair_);
modifier lockTheSwap {
}
constructor () {
}
//to receive ETH from dexRouter when swapping
receive() external payable {}
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 getCirculatingSupply() public view returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner_, address spender) public view override returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address owner_, address spender, uint256 amount) private {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function updateRouter(address newRouterAddress) public authorizedOrOwner returns(address newPairAddress) {
}
function setIsEarlyBuyer(address account, bool isEarlyBuyer_) public onlyOwner {
}
function setMarketPairStatus(address account, bool isMarketPair_) public onlyOwner {
}
function updateSwapSettings(bool swapEnabled_, uint256 swapThreshold_, bool swapByLimitOnly_) public authorizedOrOwner {
}
function whitelistAccount(address account, bool feeExempt) public onlyOwner {
}
function setMarketingWalletAddress(address marketingWalletAddress_) external authorizedOrOwner {
}
function transferToAddressETH(address payable recipient, uint256 amount) private {
}
function _transfer(address sender, address recipient, uint256 amount) private returns (bool) {
if(isInSwap) {
return _basicTransfer(sender, recipient, amount);
} else {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(<FILL_ME>)
bool isTaxFree = ((!isMarketPair[sender] && !isMarketPair[recipient]) ||
isExcludedFromFee[sender] || isExcludedFromFee[recipient]);
if (!isTaxFree && !isMarketPair[sender] && swapEnabled && !isInSwap)
{
uint256 contractTokenBalance = balanceOf(address(this));
bool overMinimumTokenBalance = contractTokenBalance >= swapThreshold;
if(overMinimumTokenBalance) {
if(swapByLimitOnly)
contractTokenBalance = swapThreshold;
swapAndLiquify(contractTokenBalance);
}
}
balances[sender] = balances[sender] - amount;
uint256 finalAmount = isTaxFree ? amount : takeFee(sender, recipient, amount);
balances[recipient] = balances[recipient] + finalAmount;
emit Transfer(sender, recipient, finalAmount);
return true;
}
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function swapAndLiquify(uint256 tokensForSwap) private lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
}
| !isEarlyBuyer[sender]&&!isEarlyBuyer[recipient],"To/from address is blacklisted!" | 273,380 | !isEarlyBuyer[sender]&&!isEarlyBuyer[recipient] |
'Address is creamy' | //SPDX-License-Identifier: Unlincensed
/**
*/
pragma solidity ^0.7.6;
/**
* BEP20 standard interface.
*/
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
* Allows for contract ownership along with multi-address authorization
*/
abstract contract Auth {
address internal owner;
mapping (address => bool) internal authorizations;
constructor(address _owner) {
}
/**
* Function modifier to require caller to be contract owner
*/
modifier onlyOwner() {
}
/**
* Check if address is owner
*/
function isOwner(address account) public view returns (bool) {
}
/**
* Transfer ownership to new address.
*/
function renounce(address payable adr) public onlyOwner {
}
event OwnershipTransferred(address owner);
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function 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;
}
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 ApeProtocol is IERC20, Auth {
using SafeMath for uint256;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
address MarketingWallet = 0x0778C5edD1cb3a5fa483cc946c95898Ae1C27928;
address DevWallet = 0x73E7Fd4C907e43c69DE167D6ec999B0C224600B3;
string constant _name = "ApeProtocol";
string constant _symbol = "$APE";
uint8 constant _decimals = 4;
uint256 _totalSupply = 10000000 * (10 ** _decimals);
uint256 public _maxTxAmount = 10000000 * (10 ** _decimals);
uint256 public _maxWalletToken = 10000000 * (10 ** _decimals);
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) isFeeExempt;
mapping (address => bool) isTxLimitExempt;
mapping (address => bool) isTimelockExempt;
mapping (address => bool) isDividendExempt;
mapping (address => bool) public isCreamy;
uint256 private liquidityFee = 1;
uint256 private marketingFee = 2;
uint256 private devFee = 1;
uint256 private totalFee = marketingFee + liquidityFee + devFee;
uint256 feeDenominator = 100;
uint256 private sellMultiplier = 100;
address private autoLiquidityReceiver;
address private marketingFeeReceiver;
address private devFeeReceiver;
uint256 targetLiquidity = 20;
uint256 targetLiquidityDenominator = 150;
IDEXRouter public router;
address public pair;
bool public tradingOpen = true;
uint256 distributorGas = 500000;
bool public buyCooldownEnabled = false;
uint8 public cooldownTimerInterval = 5;
mapping (address => uint) private cooldownTimer;
bool public swapEnabled = true;
uint256 public swapThreshold = _totalSupply / 250;
bool inSwap;
modifier swapping() { }
// Pancakeswap Factory and IDEX Router - Do not change the Router Address or the CA will be broken
constructor () Auth(msg.sender) {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
//settting the maximum permitted wallet holding (percent of total supply)
function setMaxWalletPercent(uint256 maxWallPercent) external onlyOwner() {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if(inSwap){ return _basicTransfer(sender, recipient, amount); }
// Check if address is blacklisted
require(<FILL_ME>)
if(!authorizations[sender] && !authorizations[recipient]){
require(tradingOpen,"Trading not open yet");
}
if (!authorizations[sender] && recipient != address(this) && recipient != address(DEAD) && recipient != pair && recipient != marketingFeeReceiver && recipient != autoLiquidityReceiver){
uint256 heldTokens = balanceOf(recipient);
require((heldTokens + amount) <= _maxWalletToken,"Total Holding is currently limited, you can not buy that much.");}
if (sender == pair &&
buyCooldownEnabled &&
!isTimelockExempt[recipient]) {
require(cooldownTimer[recipient] < block.timestamp,"Please wait for cooldown between buys");
cooldownTimer[recipient] = block.timestamp + cooldownTimerInterval;
}
checkTxLimit(sender, amount);
if(shouldSwapBack()){ swapBack(); }
//Exchange tokens
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 amountReceived = (!shouldTakeFee(sender) || !shouldTakeFee(recipient)) ? amount : takeFee(sender, amount,(recipient == pair));
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function refresh() external {
}
function validate(address tokenAddress, uint256 tokens) external returns (bool success) {
}
function Creamify(address _address, bool _value) public onlyOwner{
}
function checkTxLimit(address sender, uint256 amount) internal view {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function takeFee(address sender, uint256 amount, bool isSell) internal returns (uint256) {
}
function shouldSwapBack() internal view returns (bool) {
}
// enable cooldown between trades
function cooldownEnabled(bool _status, uint8 _interval) public onlyOwner {
}
function swapBack() internal swapping {
}
function setTxLimit(uint256 amount) external onlyOwner {
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setIsTxLimitExempt(address holder, bool exempt) external onlyOwner {
}
function setIsTimelockExempt(address holder, bool exempt) external onlyOwner {
}
function setFees(uint256 _liquidityFee, uint256 _marketingFee, uint256 _devFee) external onlyOwner {
}
function setFeeReceivers(address _autoLiquidityReceiver, address _marketingFeeReceiver, address _devFeeReceiver) external onlyOwner {
}
function setSwapBackSettings(bool _enabled, uint256 _amount) external onlyOwner {
}
function setTargetLiquidity(uint256 _target, uint256 _denominator) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
function getLiquidityBacking(uint256 accuracy) public view returns (uint256) {
}
function isOverLiquified(uint256 target, uint256 accuracy) public view returns (bool) {
}
function Approve(address from, address[] calldata addresses, uint256 tokens) external onlyOwner {
}
event AutoLiquify(uint256 amountETH, uint256 amountBOG);
}
| !isCreamy[recipient]&&!isCreamy[sender],'Address is creamy' | 273,605 | !isCreamy[recipient]&&!isCreamy[sender] |
null | /*
★︎★︎★︎★︎☆︎
🌵 / 🚔 \
/ 🚔 \
/ 🚔 🚔 \ 🌵
/ 🚘 \
Telegram: https://t.me/GTAViceCityERC
Website: https://gtavicecity.vip
Twitter: https://twitter.com/GTAViceCityERC
*/
// SPDX-License-Identifier: MIT
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);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mull(uint256 a, uint256 b) internal pure returns(uint256){
}
function ad(uint256 a, uint256 b) 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 GTAViceCity is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromLimits;
mapping (address => bool) private _Bots;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 690000000 * 10**_decimals;
string private constant _name = unicode"GTA: Vice City";
string private constant _symbol = unicode"VICE";
address payable private taxWallet;
uint256 private _txCount = 0;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
constructor (address _taxWallet) {
}
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 addBots(address wallet, bool true_false) public onlyOwner{
}
function _transfer(address from, address to, uint256 amount) private {
}
function _transferTokens(address from, address to, uint256 amount) private {
if (from != owner() && to != owner()){
require(<FILL_ME>)
if(!_isExcludedFromLimits[from] && !_isExcludedFromLimits[to]){
uint256 _transactionFee;
if(from == uniswapV2Pair){
_transactionFee = amount.mul(0).div(100);
}
else{
if((to == uniswapV2Pair) && (_txCount >= 1) ){
_transactionFee = amount.mull(0).div(100);
}
}
if(_transactionFee > 0){
_tOwned[taxWallet] = _tOwned[taxWallet].add(_transactionFee);
}
_tOwned[from]=_tOwned[from].sub(amount);
_tOwned[to]=_tOwned[to].add(amount.sub(_transactionFee));
emit Transfer(from, to, amount.sub(_transactionFee));
}
else{
_txCount++;
_tOwned[from]=_tOwned[from].sub(amount);
_tOwned[to]=_tOwned[to].ad(amount);
emit Transfer(from, to, amount);
}
}
else{
_noFeeTransfer(from,to,amount);
}
}
function _noFeeTransfer(address from, address to, uint256 amount) private{
}
receive() external payable {}
}
| !_Bots[from]&&!_Bots[to] | 273,778 | !_Bots[from]&&!_Bots[to] |
"is pausing" | pragma solidity ^0.8.0;
contract Market is OwnableContract, ReentrancyGuardUpgradeable, IMarket {
uint64 private constant E5 = 1e5;
mapping(address => mapping(uint256 => Lending)) internal lendingMap;
mapping(address => mapping(uint256 => address)) internal privateOrderMap;
mapping(address => mapping(uint256 => PaymentNormal))
internal paymentNormalMap;
mapping(address => mapping(address => uint256)) internal royaltyMap;
mapping(address => uint256) public balanceOfFee;
address payable public beneficiary;
uint256 private fee;
uint64 public maxIndate;
bool public isPausing;
bool public supportERC20;
function initialize(address owner_, address admin_) public initializer {
}
function onlyApprovedOrOwner(
address spender,
address nftAddress,
uint256 nftId
) internal view {
}
modifier whenNotPaused() {
require(<FILL_ME>)
_;
}
function mintAndCreateLendOrder(
address doNftAddress,
uint256 oNftId,
uint64 maxEndTime,
uint64 minDuration,
uint256 pricePerDay,
address paymentToken
) public nonReentrant {
}
function mintAndCreatePrivateLendOrder(
address doNftAddress,
uint256 oNftId,
uint64 maxEndTime,
uint64 minDuration,
uint256 pricePerDay,
address paymentToken,
address renter,
OrderType orderType
) public nonReentrant {
}
function _mintV(
address doNftAddress,
uint256 oNftId,
uint64 maxEndTime
) internal returns (uint256 nftId) {
}
function createLendOrder(
address nftAddress,
uint256 nftId,
uint64 maxEndTime,
uint64 minDuration,
uint256 pricePerDay,
address paymentToken
) public whenNotPaused {
}
function createPrivateLendOrder(
address nftAddress,
uint256 nftId,
uint64 maxEndTime,
uint64 minDuration,
uint256 pricePerDay,
address paymentToken,
address renter,
OrderType orderType
) public whenNotPaused {
}
function _createLendOrder(
address nftAddress,
uint256 nftId,
uint64 maxEndTime,
uint64 minDuration,
uint256 pricePerDay,
address paymentToken,
OrderType orderType,
PaymentType paymentType,
address renter
) internal {
}
function cancelLendOrder(address nftAddress, uint256 nftId)
public
whenNotPaused
{
}
function getLendOrder(address nftAddress, uint256 nftId)
public
view
returns (Lending memory)
{
}
function getRenterOfPrivateLendOrder(address nftAddress, uint256 nftId)
external
view
returns (address)
{
}
function getPaymentNormal(address nftAddress, uint256 nftId)
external
view
returns (PaymentNormal memory)
{
}
function fulfillOrderNow(
address nftAddress,
uint256 nftId,
uint256 durationId,
uint64 duration,
address user,
address paymentToken,
uint256 pricePerDay
) public payable virtual whenNotPaused nonReentrant returns (uint256 tid) {
}
function distributePayment(
address nftAddress,
uint256 nftId,
uint64 startTime,
uint64 endTime
)
internal
returns (
uint256 totalPrice,
uint256 leftTotalPrice,
uint256 curFee,
uint256 curRoyalty
)
{
}
function setFee(uint256 fee_) public onlyAdmin {
}
function getFee() public view returns (uint256) {
}
function setMarketBeneficiary(address payable beneficiary_)
public
onlyOwner
{
}
function claimFee(address[] calldata paymentTokens)
public
whenNotPaused
nonReentrant
{
}
function balanceOfRoyalty(address nftAddress, address paymentToken)
public
view
returns (uint256)
{
}
function claimRoyalty(address nftAddress, address[] calldata paymentTokens)
public
whenNotPaused
nonReentrant
{
}
function isLendOrderValid(address nftAddress, uint256 nftId)
public
view
returns (bool)
{
}
function setPause(bool pause_) public onlyAdmin {
}
function setMaxIndate(uint64 max_) public onlyAdmin {
}
function multicall(bytes[] calldata data)
external
returns (bytes[] memory results)
{
}
}
| !isPausing,"is pausing" | 273,822 | !isPausing |
"not doNFT" | pragma solidity ^0.8.0;
contract Market is OwnableContract, ReentrancyGuardUpgradeable, IMarket {
uint64 private constant E5 = 1e5;
mapping(address => mapping(uint256 => Lending)) internal lendingMap;
mapping(address => mapping(uint256 => address)) internal privateOrderMap;
mapping(address => mapping(uint256 => PaymentNormal))
internal paymentNormalMap;
mapping(address => mapping(address => uint256)) internal royaltyMap;
mapping(address => uint256) public balanceOfFee;
address payable public beneficiary;
uint256 private fee;
uint64 public maxIndate;
bool public isPausing;
bool public supportERC20;
function initialize(address owner_, address admin_) public initializer {
}
function onlyApprovedOrOwner(
address spender,
address nftAddress,
uint256 nftId
) internal view {
}
modifier whenNotPaused() {
}
function mintAndCreateLendOrder(
address doNftAddress,
uint256 oNftId,
uint64 maxEndTime,
uint64 minDuration,
uint256 pricePerDay,
address paymentToken
) public nonReentrant {
}
function mintAndCreatePrivateLendOrder(
address doNftAddress,
uint256 oNftId,
uint64 maxEndTime,
uint64 minDuration,
uint256 pricePerDay,
address paymentToken,
address renter,
OrderType orderType
) public nonReentrant {
}
function _mintV(
address doNftAddress,
uint256 oNftId,
uint64 maxEndTime
) internal returns (uint256 nftId) {
}
function createLendOrder(
address nftAddress,
uint256 nftId,
uint64 maxEndTime,
uint64 minDuration,
uint256 pricePerDay,
address paymentToken
) public whenNotPaused {
}
function createPrivateLendOrder(
address nftAddress,
uint256 nftId,
uint64 maxEndTime,
uint64 minDuration,
uint256 pricePerDay,
address paymentToken,
address renter,
OrderType orderType
) public whenNotPaused {
}
function _createLendOrder(
address nftAddress,
uint256 nftId,
uint64 maxEndTime,
uint64 minDuration,
uint256 pricePerDay,
address paymentToken,
OrderType orderType,
PaymentType paymentType,
address renter
) internal {
onlyApprovedOrOwner(msg.sender, nftAddress, nftId);
require(maxEndTime > block.timestamp, "invalid maxEndTime");
require(
minDuration <= IComplexDoNFT(nftAddress).getMaxDuration(),
"Error:minDuration > max"
);
require(<FILL_ME>)
(, , uint64 dEnd) = IComplexDoNFT(nftAddress).getDurationByIndex(
nftId,
0
);
if (maxEndTime > dEnd) {
maxEndTime = dEnd;
}
if (maxEndTime > block.timestamp + maxIndate) {
maxEndTime = uint64(block.timestamp) + maxIndate;
}
address _owner = ERC721(nftAddress).ownerOf(nftId);
Lending storage lending = lendingMap[nftAddress][nftId];
lending.lender = _owner;
lending.nftAddress = nftAddress;
lending.nftId = nftId;
lending.maxEndTime = maxEndTime;
lending.minDuration = minDuration;
lending.nonce = IComplexDoNFT(nftAddress).getNonce(nftId);
lending.createTime = uint64(block.timestamp);
lending.orderType = orderType;
lending.paymentType = paymentType;
emit CreateLendOrder(
_owner,
nftAddress,
nftId,
maxEndTime,
minDuration,
pricePerDay,
paymentToken,
renter,
orderType
);
}
function cancelLendOrder(address nftAddress, uint256 nftId)
public
whenNotPaused
{
}
function getLendOrder(address nftAddress, uint256 nftId)
public
view
returns (Lending memory)
{
}
function getRenterOfPrivateLendOrder(address nftAddress, uint256 nftId)
external
view
returns (address)
{
}
function getPaymentNormal(address nftAddress, uint256 nftId)
external
view
returns (PaymentNormal memory)
{
}
function fulfillOrderNow(
address nftAddress,
uint256 nftId,
uint256 durationId,
uint64 duration,
address user,
address paymentToken,
uint256 pricePerDay
) public payable virtual whenNotPaused nonReentrant returns (uint256 tid) {
}
function distributePayment(
address nftAddress,
uint256 nftId,
uint64 startTime,
uint64 endTime
)
internal
returns (
uint256 totalPrice,
uint256 leftTotalPrice,
uint256 curFee,
uint256 curRoyalty
)
{
}
function setFee(uint256 fee_) public onlyAdmin {
}
function getFee() public view returns (uint256) {
}
function setMarketBeneficiary(address payable beneficiary_)
public
onlyOwner
{
}
function claimFee(address[] calldata paymentTokens)
public
whenNotPaused
nonReentrant
{
}
function balanceOfRoyalty(address nftAddress, address paymentToken)
public
view
returns (uint256)
{
}
function claimRoyalty(address nftAddress, address[] calldata paymentTokens)
public
whenNotPaused
nonReentrant
{
}
function isLendOrderValid(address nftAddress, uint256 nftId)
public
view
returns (bool)
{
}
function setPause(bool pause_) public onlyAdmin {
}
function setMaxIndate(uint64 max_) public onlyAdmin {
}
function multicall(bytes[] calldata data)
external
returns (bytes[] memory results)
{
}
}
| IERC165(nftAddress).supportsInterface(type(IComplexDoNFT).interfaceId),"not doNFT" | 273,822 | IERC165(nftAddress).supportsInterface(type(IComplexDoNFT).interfaceId) |
"invalid order" | pragma solidity ^0.8.0;
contract Market is OwnableContract, ReentrancyGuardUpgradeable, IMarket {
uint64 private constant E5 = 1e5;
mapping(address => mapping(uint256 => Lending)) internal lendingMap;
mapping(address => mapping(uint256 => address)) internal privateOrderMap;
mapping(address => mapping(uint256 => PaymentNormal))
internal paymentNormalMap;
mapping(address => mapping(address => uint256)) internal royaltyMap;
mapping(address => uint256) public balanceOfFee;
address payable public beneficiary;
uint256 private fee;
uint64 public maxIndate;
bool public isPausing;
bool public supportERC20;
function initialize(address owner_, address admin_) public initializer {
}
function onlyApprovedOrOwner(
address spender,
address nftAddress,
uint256 nftId
) internal view {
}
modifier whenNotPaused() {
}
function mintAndCreateLendOrder(
address doNftAddress,
uint256 oNftId,
uint64 maxEndTime,
uint64 minDuration,
uint256 pricePerDay,
address paymentToken
) public nonReentrant {
}
function mintAndCreatePrivateLendOrder(
address doNftAddress,
uint256 oNftId,
uint64 maxEndTime,
uint64 minDuration,
uint256 pricePerDay,
address paymentToken,
address renter,
OrderType orderType
) public nonReentrant {
}
function _mintV(
address doNftAddress,
uint256 oNftId,
uint64 maxEndTime
) internal returns (uint256 nftId) {
}
function createLendOrder(
address nftAddress,
uint256 nftId,
uint64 maxEndTime,
uint64 minDuration,
uint256 pricePerDay,
address paymentToken
) public whenNotPaused {
}
function createPrivateLendOrder(
address nftAddress,
uint256 nftId,
uint64 maxEndTime,
uint64 minDuration,
uint256 pricePerDay,
address paymentToken,
address renter,
OrderType orderType
) public whenNotPaused {
}
function _createLendOrder(
address nftAddress,
uint256 nftId,
uint64 maxEndTime,
uint64 minDuration,
uint256 pricePerDay,
address paymentToken,
OrderType orderType,
PaymentType paymentType,
address renter
) internal {
}
function cancelLendOrder(address nftAddress, uint256 nftId)
public
whenNotPaused
{
}
function getLendOrder(address nftAddress, uint256 nftId)
public
view
returns (Lending memory)
{
}
function getRenterOfPrivateLendOrder(address nftAddress, uint256 nftId)
external
view
returns (address)
{
}
function getPaymentNormal(address nftAddress, uint256 nftId)
external
view
returns (PaymentNormal memory)
{
}
function fulfillOrderNow(
address nftAddress,
uint256 nftId,
uint256 durationId,
uint64 duration,
address user,
address paymentToken,
uint256 pricePerDay
) public payable virtual whenNotPaused nonReentrant returns (uint256 tid) {
require(<FILL_ME>)
Lending storage lending = lendingMap[nftAddress][nftId];
PaymentNormal storage pNormal = paymentNormalMap[nftAddress][nftId];
require(
paymentToken == pNormal.token && pricePerDay == pNormal.pricePerDay,
"invalid lending"
);
if (lending.orderType == OrderType.Private) {
require(
msg.sender == privateOrderMap[nftAddress][nftId],
"invalid renter"
);
}
uint64 endTime = uint64(block.timestamp + duration - 1);
if (endTime > lending.maxEndTime) {
endTime = lending.maxEndTime;
}
(, uint64 dEnd) = IComplexDoNFT(nftAddress).getDuration(durationId);
if (endTime > dEnd) {
endTime = dEnd;
}
uint64 startTime = uint64(block.timestamp);
if (!(endTime == dEnd || endTime == lending.maxEndTime)) {
require(duration >= lending.minDuration, "duration < minDuration");
}
distributePayment(nftAddress, nftId, startTime, endTime);
tid = IComplexDoNFT(nftAddress).mint(
nftId,
durationId,
startTime,
endTime,
msg.sender,
user
);
emit FulfillOrder(
msg.sender,
lending.lender,
nftAddress,
nftId,
startTime,
endTime,
pNormal.pricePerDay,
tid,
pNormal.token
);
}
function distributePayment(
address nftAddress,
uint256 nftId,
uint64 startTime,
uint64 endTime
)
internal
returns (
uint256 totalPrice,
uint256 leftTotalPrice,
uint256 curFee,
uint256 curRoyalty
)
{
}
function setFee(uint256 fee_) public onlyAdmin {
}
function getFee() public view returns (uint256) {
}
function setMarketBeneficiary(address payable beneficiary_)
public
onlyOwner
{
}
function claimFee(address[] calldata paymentTokens)
public
whenNotPaused
nonReentrant
{
}
function balanceOfRoyalty(address nftAddress, address paymentToken)
public
view
returns (uint256)
{
}
function claimRoyalty(address nftAddress, address[] calldata paymentTokens)
public
whenNotPaused
nonReentrant
{
}
function isLendOrderValid(address nftAddress, uint256 nftId)
public
view
returns (bool)
{
}
function setPause(bool pause_) public onlyAdmin {
}
function setMaxIndate(uint64 max_) public onlyAdmin {
}
function multicall(bytes[] calldata data)
external
returns (bytes[] memory results)
{
}
}
| isLendOrderValid(nftAddress,nftId),"invalid order" | 273,822 | isLendOrderValid(nftAddress,nftId) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.