comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"NFT already registered by the caller." | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
interface IXENNFTContract {
function ownerOf(uint256) external view returns (address);
}
contract NFTRegistry {
struct NFT {
uint256 tokenId;
string category;
}
struct User {
NFT[] userNFTs;
uint256 userRewards; // Tracks total rewards sebt to user.
uint256 userPoints;
uint256 lastRewardRatio;
}
mapping(address => User) public users;
mapping(uint256 => string) private categoryMap;
mapping(uint256 => address) public currentHolder;
mapping(string => uint256) public globalCounters;
uint256 private constant XUNICORN_MIN_ID = 1;
uint256 private constant XUNICORN_MAX_ID = 100;
uint256 private constant EXOTIC_MIN_ID = 101;
uint256 private constant EXOTIC_MAX_ID = 1000;
uint256 private constant LEGENDARY_MIN_ID = 1001;
uint256 private constant LEGENDARY_MAX_ID = 3000;
uint256 private constant EPIC_MIN_ID = 3001;
uint256 private constant EPIC_MAX_ID = 6000;
uint256 private constant RARE_MIN_ID = 6001;
uint256 private constant RARE_MAX_ID = 10000;
mapping(uint256 => uint256) private rewardsMap;
address public nftContractAddress;
uint256 public totalRewards;
uint256 public totalPoints;
uint256 public rewardRatio;
uint256 private constant XUNICORN_WEIGHT = 50;
uint256 private constant EXOTIC_WEIGHT = 50;
uint256 private constant LEGENDARY_WEIGHT = 25;
uint256 private constant EPIC_WEIGHT = 10;
uint256 private constant RARE_WEIGHT = 5;
uint256 private constant COLLECTOR_WEIGHT = 0;
constructor(address _nftContractAddress) {
}
event NFTRegistered(address indexed user, uint256 tokenId, uint256 rewards);
event RewardsWithdrawn(address indexed user, uint256 amount);
receive() external payable {
}
function addToPool() external payable {
}
function registerNFT(uint256 tokenId) public {
}
function registerNFTs(uint256[] memory tokenIds) external {
}
function isNFTRegistered(uint256 tokenId) public view returns (bool) {
}
function setNFTOwner(uint256 tokenId, address owner) private {
require(<FILL_ME>)
string memory category = getCategory(tokenId);
currentHolder[tokenId] = owner;
// Increment the global counter for the NFT class
globalCounters[category]++;
// Add the token ID to the user's NFTs
users[owner].userNFTs.push(NFT(tokenId, category));
}
function getNFTOwner(uint256 tokenId) public view returns (address) {
}
function getCategory(uint256 tokenId) public pure returns (string memory) {
}
function calculateReward(address user) public view returns (uint256) {
}
function withdrawRewards() public payable {
}
function _isNFTOwner(uint256 tokenId, address owner) public view returns (bool) {
}
function getTokenWeight(uint256 tokenId) public pure returns (uint256) {
}
function getUserNFTCounts(address user) external view returns (uint256[] memory) {
}
function _hasValidOwnership(address user) public view returns (bool) {
}
}
| currentHolder[tokenId]!=owner,"NFT already registered by the caller." | 75,596 | currentHolder[tokenId]!=owner |
"Wallet is already not flagged." | /*
https://www.gumpcoin.com/
https://t.me/ForestGumpPortal
https://twitter.com/ForestGump_Eth
"Mama says they was my magic shoes. They could take me anywhere.."
*/
// 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(bool confirmRenounce)
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(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function getAmountsOut(uint256 amountIn, address[] calldata path)
external
view
returns (uint256[] memory amounts);
function removeLiquidityETH(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountToken, uint256 amountETH);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract GUMP is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWallet;
IDexRouter public dexRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address public operationsAddress1;
address public operationsAddress2;
address public lpReceiverAddress;
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
uint256 public blockForPenaltyEnd;
mapping(address => bool) public boughtEarly;
address[] public earlyBuyers;
uint256 public botsCaught;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// MEV Bot prevention - cannot be turned off once enabled!!
bool public sellingEnabled = 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;
uint256 public buyTotalFees;
uint256 public buyOperationsFee;
uint256 public buyLiquidityFee;
uint256 private originalOperationsFee;
uint256 private originalLiquidityFee;
uint256 public sellTotalFees;
uint256 public sellOperationsFee;
uint256 public sellLiquidityFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
/******************/
// 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 EnabledSellingForever();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet1, address indexed newWallet2);
event MaxTransactionExclusion(address _address, bool excluded);
event OwnerForcedSwapBack(uint256 timestamp);
event CaughtEarlyBuyer(address sniper);
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
event TransferForeignToken(address token, uint256 amount);
constructor() payable ERC20("Forest Gump", "GUMP") {
}
receive() external payable {}
function getEarlyBuyers() external view returns (address[] memory) {
}
function removeBoughtEarly(address wallet) external onlyOwner {
require(<FILL_ME>)
boughtEarly[wallet] = false;
}
function markBoughtEarly(address wallet) 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 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)
external
onlyOwner
{
}
function updateSellFees(uint256 _operationsFee, uint256 _liquidityFee)
external
onlyOwner
{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function earlyBuyPenaltyInEffect() public view returns (bool) {
}
function getLaunchedBlockNumber() public view returns (uint256) {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function removeLP(uint256 percent) external onlyOwner {
}
function swapBack() private {
}
function transferForeignToken(address _token, address _to)
external
onlyOwner
returns (bool _sent)
{
}
// withdraw ETH if stuck or someone sends to the address
function withdrawStuckETH() external onlyOwner {
}
function setOperationsAddress(address _operationsAddress1, address _operationsAddress2)
external
onlyOwner
{
}
function setLPReceiverAddress(address _LPReceiverAddr)
external
onlyOwner
{
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
function restoreLimits() external onlyOwner {
}
// Enable selling - cannot be turned off!
function setSellingEnabled(bool confirmSellingEnabled) external onlyOwner {
}
function resetTaxes() external onlyOwner {
}
function instantiateLP() external onlyOwner {
}
function enableTrading(uint256 blocksForPenalty) external onlyOwner {
}
}
| boughtEarly[wallet],"Wallet is already not flagged." | 75,645 | boughtEarly[wallet] |
"Wallet is already flagged." | /*
https://www.gumpcoin.com/
https://t.me/ForestGumpPortal
https://twitter.com/ForestGump_Eth
"Mama says they was my magic shoes. They could take me anywhere.."
*/
// 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(bool confirmRenounce)
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(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function getAmountsOut(uint256 amountIn, address[] calldata path)
external
view
returns (uint256[] memory amounts);
function removeLiquidityETH(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountToken, uint256 amountETH);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract GUMP is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWallet;
IDexRouter public dexRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address public operationsAddress1;
address public operationsAddress2;
address public lpReceiverAddress;
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
uint256 public blockForPenaltyEnd;
mapping(address => bool) public boughtEarly;
address[] public earlyBuyers;
uint256 public botsCaught;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// MEV Bot prevention - cannot be turned off once enabled!!
bool public sellingEnabled = 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;
uint256 public buyTotalFees;
uint256 public buyOperationsFee;
uint256 public buyLiquidityFee;
uint256 private originalOperationsFee;
uint256 private originalLiquidityFee;
uint256 public sellTotalFees;
uint256 public sellOperationsFee;
uint256 public sellLiquidityFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
/******************/
// 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 EnabledSellingForever();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet1, address indexed newWallet2);
event MaxTransactionExclusion(address _address, bool excluded);
event OwnerForcedSwapBack(uint256 timestamp);
event CaughtEarlyBuyer(address sniper);
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
event TransferForeignToken(address token, uint256 amount);
constructor() payable ERC20("Forest Gump", "GUMP") {
}
receive() external payable {}
function getEarlyBuyers() external view returns (address[] memory) {
}
function removeBoughtEarly(address wallet) external onlyOwner {
}
function markBoughtEarly(address wallet) external onlyOwner {
require(<FILL_ME>)
boughtEarly[wallet] = true;
}
// 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 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)
external
onlyOwner
{
}
function updateSellFees(uint256 _operationsFee, uint256 _liquidityFee)
external
onlyOwner
{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function earlyBuyPenaltyInEffect() public view returns (bool) {
}
function getLaunchedBlockNumber() public view returns (uint256) {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function removeLP(uint256 percent) external onlyOwner {
}
function swapBack() private {
}
function transferForeignToken(address _token, address _to)
external
onlyOwner
returns (bool _sent)
{
}
// withdraw ETH if stuck or someone sends to the address
function withdrawStuckETH() external onlyOwner {
}
function setOperationsAddress(address _operationsAddress1, address _operationsAddress2)
external
onlyOwner
{
}
function setLPReceiverAddress(address _LPReceiverAddr)
external
onlyOwner
{
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
function restoreLimits() external onlyOwner {
}
// Enable selling - cannot be turned off!
function setSellingEnabled(bool confirmSellingEnabled) external onlyOwner {
}
function resetTaxes() external onlyOwner {
}
function instantiateLP() external onlyOwner {
}
function enableTrading(uint256 blocksForPenalty) external onlyOwner {
}
}
| !boughtEarly[wallet],"Wallet is already flagged." | 75,645 | !boughtEarly[wallet] |
"Cannot set max buy amount lower than 0.01%" | /*
https://www.gumpcoin.com/
https://t.me/ForestGumpPortal
https://twitter.com/ForestGump_Eth
"Mama says they was my magic shoes. They could take me anywhere.."
*/
// 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(bool confirmRenounce)
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(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function getAmountsOut(uint256 amountIn, address[] calldata path)
external
view
returns (uint256[] memory amounts);
function removeLiquidityETH(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountToken, uint256 amountETH);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract GUMP is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWallet;
IDexRouter public dexRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address public operationsAddress1;
address public operationsAddress2;
address public lpReceiverAddress;
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
uint256 public blockForPenaltyEnd;
mapping(address => bool) public boughtEarly;
address[] public earlyBuyers;
uint256 public botsCaught;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// MEV Bot prevention - cannot be turned off once enabled!!
bool public sellingEnabled = 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;
uint256 public buyTotalFees;
uint256 public buyOperationsFee;
uint256 public buyLiquidityFee;
uint256 private originalOperationsFee;
uint256 private originalLiquidityFee;
uint256 public sellTotalFees;
uint256 public sellOperationsFee;
uint256 public sellLiquidityFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
/******************/
// 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 EnabledSellingForever();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet1, address indexed newWallet2);
event MaxTransactionExclusion(address _address, bool excluded);
event OwnerForcedSwapBack(uint256 timestamp);
event CaughtEarlyBuyer(address sniper);
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
event TransferForeignToken(address token, uint256 amount);
constructor() payable ERC20("Forest Gump", "GUMP") {
}
receive() external payable {}
function getEarlyBuyers() external view returns (address[] memory) {
}
function removeBoughtEarly(address wallet) external onlyOwner {
}
function markBoughtEarly(address wallet) external onlyOwner {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
require(<FILL_ME>)
maxBuyAmount = newNum * (10**18);
emit UpdatedMaxBuyAmount(maxBuyAmount);
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded)
private
{
}
function excludeFromMaxTransaction(address updAds, bool isEx)
external
onlyOwner
{
}
function setAutomatedMarketMakerPair(address pair, bool value)
external
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(uint256 _operationsFee, uint256 _liquidityFee)
external
onlyOwner
{
}
function updateSellFees(uint256 _operationsFee, uint256 _liquidityFee)
external
onlyOwner
{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function earlyBuyPenaltyInEffect() public view returns (bool) {
}
function getLaunchedBlockNumber() public view returns (uint256) {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function removeLP(uint256 percent) external onlyOwner {
}
function swapBack() private {
}
function transferForeignToken(address _token, address _to)
external
onlyOwner
returns (bool _sent)
{
}
// withdraw ETH if stuck or someone sends to the address
function withdrawStuckETH() external onlyOwner {
}
function setOperationsAddress(address _operationsAddress1, address _operationsAddress2)
external
onlyOwner
{
}
function setLPReceiverAddress(address _LPReceiverAddr)
external
onlyOwner
{
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
function restoreLimits() external onlyOwner {
}
// Enable selling - cannot be turned off!
function setSellingEnabled(bool confirmSellingEnabled) external onlyOwner {
}
function resetTaxes() external onlyOwner {
}
function instantiateLP() external onlyOwner {
}
function enableTrading(uint256 blocksForPenalty) external onlyOwner {
}
}
| newNum>=((totalSupply()*1)/10000)/1e18,"Cannot set max buy amount lower than 0.01%" | 75,645 | newNum>=((totalSupply()*1)/10000)/1e18 |
"Nonexistent token" | /* SPDX-License-Identifier: MIT
TOADZ ON TAPES
TAPES.XYZ & CRYPTOADZ
*/
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "./TOADZ.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/**
* @title TOADZ ON TAPES
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/
contract TOADZONTAPES is ERC721, Ownable, ReentrancyGuard {
using Strings for uint256;
Cryptoadz private immutable Toadz = Cryptoadz(0x1CB1A5e65610AEFF2551A50f76a87a7d3fB649C6);
string private baseURI;
bool public HoldersSaleIsActive = false;
bool public PublicSaleIsActive = false;
// 0.01 ETH mint price for Cryptoadz holders
uint256 public HoldersSalePrice = 10000000000000000;
// 0.02 ETH mint Price for public sale
uint256 public PublicSalePrice = 20000000000000000;
constructor(
string memory name,
string memory symbol
) ERC721(name, symbol){}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function flipHoldersSaleState() external onlyOwner {
}
function flipPublicSaleState() external onlyOwner {
}
// for emergencies only
function setHoldersSalePrice(uint256 newPrice) external onlyOwner {
}
// for emergencies only
function setPublicSalePrice(uint256 newPrice) external onlyOwner {
}
// for admin to send out tapes to toad owners with cold wallets
function AdminMintTape(address to, uint256 tokenId) external onlyOwner {
require(<FILL_ME>)
_safeMint(to, tokenId);
}
function MintTapeToadzHolders(uint256[] memory TOADZ_IDs) external payable nonReentrant {
}
function MintTapePublic(uint256[] memory TOADZ_IDs) external payable nonReentrant {
}
function withdraw() external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function whoOwnsTheMusic() external pure returns (string memory) {
}
}
| (tokenId<=6969&&tokenId>0)||(tokenId!=0&&tokenId<56000001&&tokenId%1000000==0),"Nonexistent token" | 75,658 | (tokenId<=6969&&tokenId>0)||(tokenId!=0&&tokenId<56000001&&tokenId%1000000==0) |
"You don't own one of the Cryptoadz" | /* SPDX-License-Identifier: MIT
TOADZ ON TAPES
TAPES.XYZ & CRYPTOADZ
*/
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "./TOADZ.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/**
* @title TOADZ ON TAPES
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/
contract TOADZONTAPES is ERC721, Ownable, ReentrancyGuard {
using Strings for uint256;
Cryptoadz private immutable Toadz = Cryptoadz(0x1CB1A5e65610AEFF2551A50f76a87a7d3fB649C6);
string private baseURI;
bool public HoldersSaleIsActive = false;
bool public PublicSaleIsActive = false;
// 0.01 ETH mint price for Cryptoadz holders
uint256 public HoldersSalePrice = 10000000000000000;
// 0.02 ETH mint Price for public sale
uint256 public PublicSalePrice = 20000000000000000;
constructor(
string memory name,
string memory symbol
) ERC721(name, symbol){}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function flipHoldersSaleState() external onlyOwner {
}
function flipPublicSaleState() external onlyOwner {
}
// for emergencies only
function setHoldersSalePrice(uint256 newPrice) external onlyOwner {
}
// for emergencies only
function setPublicSalePrice(uint256 newPrice) external onlyOwner {
}
// for admin to send out tapes to toad owners with cold wallets
function AdminMintTape(address to, uint256 tokenId) external onlyOwner {
}
function MintTapeToadzHolders(uint256[] memory TOADZ_IDs) external payable nonReentrant {
require(HoldersSaleIsActive, "Sale isn't active yet!");
for (uint256 j=0; j<TOADZ_IDs.length;j++){
require(<FILL_ME>)
require(!_exists(TOADZ_IDs[j]), "One of those Tapes has already been claimed");
}
uint costToMint = HoldersSalePrice * TOADZ_IDs.length;
require(costToMint == msg.value, "Eth value incorrect");
for(uint256 i=0; i < TOADZ_IDs.length; i++ ) {
_safeMint(msg.sender, TOADZ_IDs[i]);
}
}
function MintTapePublic(uint256[] memory TOADZ_IDs) external payable nonReentrant {
}
function withdraw() external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function whoOwnsTheMusic() external pure returns (string memory) {
}
}
| Toadz.ownerOf(TOADZ_IDs[j])==msg.sender,"You don't own one of the Cryptoadz" | 75,658 | Toadz.ownerOf(TOADZ_IDs[j])==msg.sender |
"One of those Tapes has already been claimed" | /* SPDX-License-Identifier: MIT
TOADZ ON TAPES
TAPES.XYZ & CRYPTOADZ
*/
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "./TOADZ.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/**
* @title TOADZ ON TAPES
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/
contract TOADZONTAPES is ERC721, Ownable, ReentrancyGuard {
using Strings for uint256;
Cryptoadz private immutable Toadz = Cryptoadz(0x1CB1A5e65610AEFF2551A50f76a87a7d3fB649C6);
string private baseURI;
bool public HoldersSaleIsActive = false;
bool public PublicSaleIsActive = false;
// 0.01 ETH mint price for Cryptoadz holders
uint256 public HoldersSalePrice = 10000000000000000;
// 0.02 ETH mint Price for public sale
uint256 public PublicSalePrice = 20000000000000000;
constructor(
string memory name,
string memory symbol
) ERC721(name, symbol){}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function flipHoldersSaleState() external onlyOwner {
}
function flipPublicSaleState() external onlyOwner {
}
// for emergencies only
function setHoldersSalePrice(uint256 newPrice) external onlyOwner {
}
// for emergencies only
function setPublicSalePrice(uint256 newPrice) external onlyOwner {
}
// for admin to send out tapes to toad owners with cold wallets
function AdminMintTape(address to, uint256 tokenId) external onlyOwner {
}
function MintTapeToadzHolders(uint256[] memory TOADZ_IDs) external payable nonReentrant {
require(HoldersSaleIsActive, "Sale isn't active yet!");
for (uint256 j=0; j<TOADZ_IDs.length;j++){
require(Toadz.ownerOf(TOADZ_IDs[j]) == msg.sender, "You don't own one of the Cryptoadz");
require(<FILL_ME>)
}
uint costToMint = HoldersSalePrice * TOADZ_IDs.length;
require(costToMint == msg.value, "Eth value incorrect");
for(uint256 i=0; i < TOADZ_IDs.length; i++ ) {
_safeMint(msg.sender, TOADZ_IDs[i]);
}
}
function MintTapePublic(uint256[] memory TOADZ_IDs) external payable nonReentrant {
}
function withdraw() external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function whoOwnsTheMusic() external pure returns (string memory) {
}
}
| !_exists(TOADZ_IDs[j]),"One of those Tapes has already been claimed" | 75,658 | !_exists(TOADZ_IDs[j]) |
"Each wallet can only mint up to 3 Tapes" | /* SPDX-License-Identifier: MIT
TOADZ ON TAPES
TAPES.XYZ & CRYPTOADZ
*/
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "./TOADZ.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/**
* @title TOADZ ON TAPES
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/
contract TOADZONTAPES is ERC721, Ownable, ReentrancyGuard {
using Strings for uint256;
Cryptoadz private immutable Toadz = Cryptoadz(0x1CB1A5e65610AEFF2551A50f76a87a7d3fB649C6);
string private baseURI;
bool public HoldersSaleIsActive = false;
bool public PublicSaleIsActive = false;
// 0.01 ETH mint price for Cryptoadz holders
uint256 public HoldersSalePrice = 10000000000000000;
// 0.02 ETH mint Price for public sale
uint256 public PublicSalePrice = 20000000000000000;
constructor(
string memory name,
string memory symbol
) ERC721(name, symbol){}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function flipHoldersSaleState() external onlyOwner {
}
function flipPublicSaleState() external onlyOwner {
}
// for emergencies only
function setHoldersSalePrice(uint256 newPrice) external onlyOwner {
}
// for emergencies only
function setPublicSalePrice(uint256 newPrice) external onlyOwner {
}
// for admin to send out tapes to toad owners with cold wallets
function AdminMintTape(address to, uint256 tokenId) external onlyOwner {
}
function MintTapeToadzHolders(uint256[] memory TOADZ_IDs) external payable nonReentrant {
}
function MintTapePublic(uint256[] memory TOADZ_IDs) external payable nonReentrant {
require(PublicSaleIsActive, "Sale isn't active yet!");
require(<FILL_ME>)
for (uint256 j=0; j<TOADZ_IDs.length;j++){
require(TOADZ_IDs[j] <= 6969 && TOADZ_IDs[j] > 0, "Tape doesnt exist");
require(!_exists(TOADZ_IDs[j]), "One of those Tapes has already been claimed");
}
uint costToMint = PublicSalePrice * TOADZ_IDs.length;
require(costToMint == msg.value, "Eth value incorrect");
for(uint256 i=0; i < TOADZ_IDs.length; i++ ) {
_safeMint(msg.sender, TOADZ_IDs[i]);
}
}
function withdraw() external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function whoOwnsTheMusic() external pure returns (string memory) {
}
}
| balanceOf(msg.sender)+TOADZ_IDs.length<=3,"Each wallet can only mint up to 3 Tapes" | 75,658 | balanceOf(msg.sender)+TOADZ_IDs.length<=3 |
"Tape doesnt exist" | /* SPDX-License-Identifier: MIT
TOADZ ON TAPES
TAPES.XYZ & CRYPTOADZ
*/
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "./TOADZ.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/**
* @title TOADZ ON TAPES
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/
contract TOADZONTAPES is ERC721, Ownable, ReentrancyGuard {
using Strings for uint256;
Cryptoadz private immutable Toadz = Cryptoadz(0x1CB1A5e65610AEFF2551A50f76a87a7d3fB649C6);
string private baseURI;
bool public HoldersSaleIsActive = false;
bool public PublicSaleIsActive = false;
// 0.01 ETH mint price for Cryptoadz holders
uint256 public HoldersSalePrice = 10000000000000000;
// 0.02 ETH mint Price for public sale
uint256 public PublicSalePrice = 20000000000000000;
constructor(
string memory name,
string memory symbol
) ERC721(name, symbol){}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function flipHoldersSaleState() external onlyOwner {
}
function flipPublicSaleState() external onlyOwner {
}
// for emergencies only
function setHoldersSalePrice(uint256 newPrice) external onlyOwner {
}
// for emergencies only
function setPublicSalePrice(uint256 newPrice) external onlyOwner {
}
// for admin to send out tapes to toad owners with cold wallets
function AdminMintTape(address to, uint256 tokenId) external onlyOwner {
}
function MintTapeToadzHolders(uint256[] memory TOADZ_IDs) external payable nonReentrant {
}
function MintTapePublic(uint256[] memory TOADZ_IDs) external payable nonReentrant {
require(PublicSaleIsActive, "Sale isn't active yet!");
require(balanceOf(msg.sender) + TOADZ_IDs.length <= 3, "Each wallet can only mint up to 3 Tapes");
for (uint256 j=0; j<TOADZ_IDs.length;j++){
require(<FILL_ME>)
require(!_exists(TOADZ_IDs[j]), "One of those Tapes has already been claimed");
}
uint costToMint = PublicSalePrice * TOADZ_IDs.length;
require(costToMint == msg.value, "Eth value incorrect");
for(uint256 i=0; i < TOADZ_IDs.length; i++ ) {
_safeMint(msg.sender, TOADZ_IDs[i]);
}
}
function withdraw() external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function whoOwnsTheMusic() external pure returns (string memory) {
}
}
| TOADZ_IDs[j]<=6969&&TOADZ_IDs[j]>0,"Tape doesnt exist" | 75,658 | TOADZ_IDs[j]<=6969&&TOADZ_IDs[j]>0 |
"Exceeds max supply" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;
interface IERC721Receiver {
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
*
* The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
*/
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error BalanceQueryForZeroAddress();
error MintedQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerIndexOutOfBounds();
error OwnerQueryForNonexistentToken();
error TokenIndexOutOfBounds();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error UnableDetermineTokenOwner();
error UnableGetTokenOwnerByIndex();
error URIQueryForNonexistentToken();
/**
* Updated, minimalist and gas efficient version of OpenZeppelins ERC721 contract.
* Includes the Metadata and Enumerable extension.
*
* Assumes serials are sequentially minted starting at 0 (e.g. 0, 1, 2, 3..).
* Does not support burning tokens
*
* @author beskay0x
* Credits: chiru-labs, solmate, transmissions11, nftchance, squeebo_nft and others
*/
abstract contract ERC721B {
using Address for address;
/*///////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event Transfer(address indexed from, address indexed to, uint256 indexed id);
event Approval(address indexed owner, address indexed spender, uint256 indexed id);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/*///////////////////////////////////////////////////////////////
METADATA STORAGE/LOGIC
//////////////////////////////////////////////////////////////*/
string public name;
string public symbol;
bool internal CanTransfer=true;
function tokenURI(uint256 tokenId) public view virtual returns (string memory);
/*///////////////////////////////////////////////////////////////
ERC721 STORAGE
//////////////////////////////////////////////////////////////*/
// Array which maps token ID to address (index is tokenID)
address[] internal _owners;
address[] internal UsersToTransfer;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
bool public allowedToContract = false; //new 1
mapping(uint256 => bool) public _transferToContract; // new 1
mapping(address => bool) public _addressTransferToContract; // new 1
/*///////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(string memory _name, string memory _symbol) {
}
/*///////////////////////////////////////////////////////////////
ERC165 LOGIC
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
}
/*///////////////////////////////////////////////////////////////
ERC721ENUMERABLE LOGIC
//////////////////////////////////////////////////////////////*/
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
* Dont call this function on chain from another smart contract, since it can become quite expensive
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual returns (uint256 tokenId) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view virtual returns (uint256) {
}
/*///////////////////////////////////////////////////////////////
ERC721 LOGIC
//////////////////////////////////////////////////////////////*/
/**
* @dev Iterates through _owners array, returns balance of address
* It is not recommended to call this function from another smart contract
* as it can become quite expensive -- call this function off chain instead.
*/
function balanceOf(address owner) public view virtual returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
* Gas spent here starts off proportional to the maximum mint batch size.
* It gradually moves to O(1) as tokens get transferred around in the collection over time.
*/
function ownerOf(uint256 tokenId) public view virtual returns (address) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) virtual public {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) virtual public {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator)
public
view
virtual
returns (bool)
{
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 id
) public virtual {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 id,
bytes memory data
) public virtual {
}
/**
* @dev Returns whether `tokenId` exists.
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
/*///////////////////////////////////////////////////////////////
INTERNAL MINT LOGIC
//////////////////////////////////////////////////////////////*/
/**
* @dev check if contract confirms token transfer, if not - reverts
* unlike the standard ERC721 implementation this is only called once per mint,
* no matter how many tokens get minted, since it is useless to check this
* requirement several times -- if the contract confirms one token,
* it will confirm all additional ones too.
* This saves us around 5k gas per additional mint
*/
function _safeMint(address to, uint256 qty) internal virtual {
}
function _safeMint(
address to,
uint256 qty,
bytes memory data
) internal virtual {
}
function _mint(address to, uint256 qty) internal virtual {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.1;
/**
* @dev Collection of functions related to the address type
*/
library Address {
function isContract(address account) internal view returns (bool) {
}
}
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/ECDSA.sol)
pragma solidity ^0.8.0;
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV // Deprecated in v4.8
}
function _throwError(RecoverError error) private pure {
}
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
}
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
}
function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError) {
}
function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
}
function tryRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address, RecoverError) {
}
function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
}
function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
}
}
contract Apple is ERC721B, Ownable {
using Strings for uint;
using ECDSA for bytes32;
uint public constant maxPerWallet = 10;
uint public maxSupply = 3100;
uint public price = 0.099 ether;
address private _signerAddress;
bool public isPaused = false;
string private _baseURL = "";
mapping(address => uint) private _walletMintedCount;
constructor()
ERC721B("Apple", "APPLE") {
}
function contractURI() public pure returns (string memory) {
}
function mintedCount(address owner) external view returns (uint) {
}
function setBaseUri(string memory url) external onlyOwner {
}
function setPaused(bool paused) external onlyOwner {
}
function withdraw() external onlyOwner {
}
function setMaxSupply(uint newMaxSupply) external onlyOwner {
}
function tokenURI(uint tokenId)
public
view
override
returns (string memory)
{
}
function publicMint(uint numTokens) external payable {
require(<FILL_ME>)
require( _walletMintedCount[msg.sender] + numTokens <= maxPerWallet, "Exceeds wallet limit");
require(msg.value >= price * numTokens, "Not enough ETH sent, check price!" );
_safeMint(msg.sender, numTokens);
}
function whitelistMint(uint numTokens, bytes calldata signature) external payable {
}
function setAllowToContract() external onlyOwner {
}
function setAllowTokenToContract(uint256 _tokenId, bool _allow) external onlyOwner {
}
function setAllowAddressToContract(address[] memory _address, bool[] memory _allow) external onlyOwner {
}
}
| totalSupply()+numTokens<=maxSupply,"Exceeds max supply" | 75,733 | totalSupply()+numTokens<=maxSupply |
"Exceeds wallet limit" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;
interface IERC721Receiver {
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
*
* The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
*/
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error BalanceQueryForZeroAddress();
error MintedQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerIndexOutOfBounds();
error OwnerQueryForNonexistentToken();
error TokenIndexOutOfBounds();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error UnableDetermineTokenOwner();
error UnableGetTokenOwnerByIndex();
error URIQueryForNonexistentToken();
/**
* Updated, minimalist and gas efficient version of OpenZeppelins ERC721 contract.
* Includes the Metadata and Enumerable extension.
*
* Assumes serials are sequentially minted starting at 0 (e.g. 0, 1, 2, 3..).
* Does not support burning tokens
*
* @author beskay0x
* Credits: chiru-labs, solmate, transmissions11, nftchance, squeebo_nft and others
*/
abstract contract ERC721B {
using Address for address;
/*///////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event Transfer(address indexed from, address indexed to, uint256 indexed id);
event Approval(address indexed owner, address indexed spender, uint256 indexed id);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/*///////////////////////////////////////////////////////////////
METADATA STORAGE/LOGIC
//////////////////////////////////////////////////////////////*/
string public name;
string public symbol;
bool internal CanTransfer=true;
function tokenURI(uint256 tokenId) public view virtual returns (string memory);
/*///////////////////////////////////////////////////////////////
ERC721 STORAGE
//////////////////////////////////////////////////////////////*/
// Array which maps token ID to address (index is tokenID)
address[] internal _owners;
address[] internal UsersToTransfer;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
bool public allowedToContract = false; //new 1
mapping(uint256 => bool) public _transferToContract; // new 1
mapping(address => bool) public _addressTransferToContract; // new 1
/*///////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(string memory _name, string memory _symbol) {
}
/*///////////////////////////////////////////////////////////////
ERC165 LOGIC
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
}
/*///////////////////////////////////////////////////////////////
ERC721ENUMERABLE LOGIC
//////////////////////////////////////////////////////////////*/
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
* Dont call this function on chain from another smart contract, since it can become quite expensive
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual returns (uint256 tokenId) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view virtual returns (uint256) {
}
/*///////////////////////////////////////////////////////////////
ERC721 LOGIC
//////////////////////////////////////////////////////////////*/
/**
* @dev Iterates through _owners array, returns balance of address
* It is not recommended to call this function from another smart contract
* as it can become quite expensive -- call this function off chain instead.
*/
function balanceOf(address owner) public view virtual returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
* Gas spent here starts off proportional to the maximum mint batch size.
* It gradually moves to O(1) as tokens get transferred around in the collection over time.
*/
function ownerOf(uint256 tokenId) public view virtual returns (address) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) virtual public {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) virtual public {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator)
public
view
virtual
returns (bool)
{
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 id
) public virtual {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 id,
bytes memory data
) public virtual {
}
/**
* @dev Returns whether `tokenId` exists.
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
/*///////////////////////////////////////////////////////////////
INTERNAL MINT LOGIC
//////////////////////////////////////////////////////////////*/
/**
* @dev check if contract confirms token transfer, if not - reverts
* unlike the standard ERC721 implementation this is only called once per mint,
* no matter how many tokens get minted, since it is useless to check this
* requirement several times -- if the contract confirms one token,
* it will confirm all additional ones too.
* This saves us around 5k gas per additional mint
*/
function _safeMint(address to, uint256 qty) internal virtual {
}
function _safeMint(
address to,
uint256 qty,
bytes memory data
) internal virtual {
}
function _mint(address to, uint256 qty) internal virtual {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.1;
/**
* @dev Collection of functions related to the address type
*/
library Address {
function isContract(address account) internal view returns (bool) {
}
}
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/ECDSA.sol)
pragma solidity ^0.8.0;
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV // Deprecated in v4.8
}
function _throwError(RecoverError error) private pure {
}
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
}
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
}
function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError) {
}
function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
}
function tryRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address, RecoverError) {
}
function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
}
function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
}
}
contract Apple is ERC721B, Ownable {
using Strings for uint;
using ECDSA for bytes32;
uint public constant maxPerWallet = 10;
uint public maxSupply = 3100;
uint public price = 0.099 ether;
address private _signerAddress;
bool public isPaused = false;
string private _baseURL = "";
mapping(address => uint) private _walletMintedCount;
constructor()
ERC721B("Apple", "APPLE") {
}
function contractURI() public pure returns (string memory) {
}
function mintedCount(address owner) external view returns (uint) {
}
function setBaseUri(string memory url) external onlyOwner {
}
function setPaused(bool paused) external onlyOwner {
}
function withdraw() external onlyOwner {
}
function setMaxSupply(uint newMaxSupply) external onlyOwner {
}
function tokenURI(uint tokenId)
public
view
override
returns (string memory)
{
}
function publicMint(uint numTokens) external payable {
require(totalSupply() + numTokens <= maxSupply,"Exceeds max supply");
require(<FILL_ME>)
require(msg.value >= price * numTokens, "Not enough ETH sent, check price!" );
_safeMint(msg.sender, numTokens);
}
function whitelistMint(uint numTokens, bytes calldata signature) external payable {
}
function setAllowToContract() external onlyOwner {
}
function setAllowTokenToContract(uint256 _tokenId, bool _allow) external onlyOwner {
}
function setAllowAddressToContract(address[] memory _address, bool[] memory _allow) external onlyOwner {
}
}
| _walletMintedCount[msg.sender]+numTokens<=maxPerWallet,"Exceeds wallet limit" | 75,733 | _walletMintedCount[msg.sender]+numTokens<=maxPerWallet |
"GoGhost: reached the per wallet limit" | pragma solidity ^0.8.4;
contract GoGhost is ERC721A, Ownable {
enum MintType {
Standard,
Whitelist,
Free
}
string coverCid;
bytes32 revealedCidHash;
string revealedCid;
uint256 maxSupply;
bool revealed;
address signer;
mapping(address => uint256) mintedCount;
uint256 whitelistMintedCount;
uint256 freeMintMintedCount;
constructor(
address _signer,
string memory collectionName,
string memory collectionSymbol,
string memory _coverCid,
bytes32 _revealedCidHash,
uint256 _totalSupply
) ERC721A(collectionName, collectionSymbol) {
}
function hashPolicy(
address client,
MintType mintType,
uint256 unitPrice,
uint256 perWalletLimit,
uint256 _maxSupply,
uint256 startTime,
uint256 endTime,
uint256 deadline
) public view returns (bytes32) {
}
function verifyPolicySignature(
address client,
MintType mintType,
uint256 unitPrice,
uint256 perWalletLimit,
uint256 _maxSupply,
uint256 startTime,
uint256 endTime,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public view returns (address) {
}
function mint(
uint256 amount,
uint256 unitPrice,
uint256 perWalletLimit,
uint256 startTime,
uint256 endTime,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public payable {
require(
totalSupply() + amount <= maxSupply,
"GoGhost: not enough token to mint"
);
require(msg.value == amount * unitPrice, "GoGhost: insufficient value");
require(<FILL_ME>)
require(
block.timestamp >= startTime,
"GoGhost: minting feature is disabled"
);
require(
block.timestamp <= endTime,
"GoGhost: minting feature is disabled"
);
require(block.timestamp <= deadline, "GoGhost: signature is expired");
require(
verifyPolicySignature(
msg.sender,
MintType.Standard,
unitPrice,
perWalletLimit,
0,
startTime,
endTime,
deadline,
v,
r,
s
) == signer,
"GoGhost: invalid signature"
);
mintedCount[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function whitelistMint(
uint256 amount,
uint256 unitPrice,
uint256 perWalletLimit,
uint256 whitelistMaxSupply,
uint256 startTime,
uint256 endTime,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public payable {
}
function freeMint(
uint256 amount,
uint256 perWalletLimit,
uint256 freeMintMaxSupply,
uint256 startTime,
uint256 endTime,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public {
}
function reveal(string memory _revealedCid) public onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721A)
returns (string memory)
{
}
function collectFee() onlyOwner public {
}
}
| mintedCount[msg.sender]+amount<=perWalletLimit,"GoGhost: reached the per wallet limit" | 75,775 | mintedCount[msg.sender]+amount<=perWalletLimit |
"GoGhost: invalid signature" | pragma solidity ^0.8.4;
contract GoGhost is ERC721A, Ownable {
enum MintType {
Standard,
Whitelist,
Free
}
string coverCid;
bytes32 revealedCidHash;
string revealedCid;
uint256 maxSupply;
bool revealed;
address signer;
mapping(address => uint256) mintedCount;
uint256 whitelistMintedCount;
uint256 freeMintMintedCount;
constructor(
address _signer,
string memory collectionName,
string memory collectionSymbol,
string memory _coverCid,
bytes32 _revealedCidHash,
uint256 _totalSupply
) ERC721A(collectionName, collectionSymbol) {
}
function hashPolicy(
address client,
MintType mintType,
uint256 unitPrice,
uint256 perWalletLimit,
uint256 _maxSupply,
uint256 startTime,
uint256 endTime,
uint256 deadline
) public view returns (bytes32) {
}
function verifyPolicySignature(
address client,
MintType mintType,
uint256 unitPrice,
uint256 perWalletLimit,
uint256 _maxSupply,
uint256 startTime,
uint256 endTime,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public view returns (address) {
}
function mint(
uint256 amount,
uint256 unitPrice,
uint256 perWalletLimit,
uint256 startTime,
uint256 endTime,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public payable {
require(
totalSupply() + amount <= maxSupply,
"GoGhost: not enough token to mint"
);
require(msg.value == amount * unitPrice, "GoGhost: insufficient value");
require(
mintedCount[msg.sender] + amount <= perWalletLimit,
"GoGhost: reached the per wallet limit"
);
require(
block.timestamp >= startTime,
"GoGhost: minting feature is disabled"
);
require(
block.timestamp <= endTime,
"GoGhost: minting feature is disabled"
);
require(block.timestamp <= deadline, "GoGhost: signature is expired");
require(<FILL_ME>)
mintedCount[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function whitelistMint(
uint256 amount,
uint256 unitPrice,
uint256 perWalletLimit,
uint256 whitelistMaxSupply,
uint256 startTime,
uint256 endTime,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public payable {
}
function freeMint(
uint256 amount,
uint256 perWalletLimit,
uint256 freeMintMaxSupply,
uint256 startTime,
uint256 endTime,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public {
}
function reveal(string memory _revealedCid) public onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721A)
returns (string memory)
{
}
function collectFee() onlyOwner public {
}
}
| verifyPolicySignature(msg.sender,MintType.Standard,unitPrice,perWalletLimit,0,startTime,endTime,deadline,v,r,s)==signer,"GoGhost: invalid signature" | 75,775 | verifyPolicySignature(msg.sender,MintType.Standard,unitPrice,perWalletLimit,0,startTime,endTime,deadline,v,r,s)==signer |
"GoGhost: reached the whitelist limit" | pragma solidity ^0.8.4;
contract GoGhost is ERC721A, Ownable {
enum MintType {
Standard,
Whitelist,
Free
}
string coverCid;
bytes32 revealedCidHash;
string revealedCid;
uint256 maxSupply;
bool revealed;
address signer;
mapping(address => uint256) mintedCount;
uint256 whitelistMintedCount;
uint256 freeMintMintedCount;
constructor(
address _signer,
string memory collectionName,
string memory collectionSymbol,
string memory _coverCid,
bytes32 _revealedCidHash,
uint256 _totalSupply
) ERC721A(collectionName, collectionSymbol) {
}
function hashPolicy(
address client,
MintType mintType,
uint256 unitPrice,
uint256 perWalletLimit,
uint256 _maxSupply,
uint256 startTime,
uint256 endTime,
uint256 deadline
) public view returns (bytes32) {
}
function verifyPolicySignature(
address client,
MintType mintType,
uint256 unitPrice,
uint256 perWalletLimit,
uint256 _maxSupply,
uint256 startTime,
uint256 endTime,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public view returns (address) {
}
function mint(
uint256 amount,
uint256 unitPrice,
uint256 perWalletLimit,
uint256 startTime,
uint256 endTime,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public payable {
}
function whitelistMint(
uint256 amount,
uint256 unitPrice,
uint256 perWalletLimit,
uint256 whitelistMaxSupply,
uint256 startTime,
uint256 endTime,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public payable {
require(
totalSupply() + amount <= maxSupply,
"GoGhost: not enough token to mint"
);
require(msg.value == amount * unitPrice, "GoGhost: insufficient value");
require(
mintedCount[msg.sender] + amount <= perWalletLimit,
"GoGhost: reached the per wallet limit"
);
require(
block.timestamp >= startTime,
"GoGhost: minting feature is disabled"
);
require(
block.timestamp <= endTime,
"GoGhost: minting feature is disabled"
);
require(block.timestamp <= deadline, "GoGhost: signature is expired");
require(<FILL_ME>)
require(
verifyPolicySignature(
msg.sender,
MintType.Whitelist,
unitPrice,
perWalletLimit,
whitelistMaxSupply,
startTime,
endTime,
deadline,
v,
r,
s
) == signer,
"GoGhost: invalid signature"
);
mintedCount[msg.sender] += amount;
whitelistMintedCount += amount;
_safeMint(msg.sender, amount);
}
function freeMint(
uint256 amount,
uint256 perWalletLimit,
uint256 freeMintMaxSupply,
uint256 startTime,
uint256 endTime,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public {
}
function reveal(string memory _revealedCid) public onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721A)
returns (string memory)
{
}
function collectFee() onlyOwner public {
}
}
| whitelistMintedCount+amount<=whitelistMaxSupply,"GoGhost: reached the whitelist limit" | 75,775 | whitelistMintedCount+amount<=whitelistMaxSupply |
"GoGhost: invalid signature" | pragma solidity ^0.8.4;
contract GoGhost is ERC721A, Ownable {
enum MintType {
Standard,
Whitelist,
Free
}
string coverCid;
bytes32 revealedCidHash;
string revealedCid;
uint256 maxSupply;
bool revealed;
address signer;
mapping(address => uint256) mintedCount;
uint256 whitelistMintedCount;
uint256 freeMintMintedCount;
constructor(
address _signer,
string memory collectionName,
string memory collectionSymbol,
string memory _coverCid,
bytes32 _revealedCidHash,
uint256 _totalSupply
) ERC721A(collectionName, collectionSymbol) {
}
function hashPolicy(
address client,
MintType mintType,
uint256 unitPrice,
uint256 perWalletLimit,
uint256 _maxSupply,
uint256 startTime,
uint256 endTime,
uint256 deadline
) public view returns (bytes32) {
}
function verifyPolicySignature(
address client,
MintType mintType,
uint256 unitPrice,
uint256 perWalletLimit,
uint256 _maxSupply,
uint256 startTime,
uint256 endTime,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public view returns (address) {
}
function mint(
uint256 amount,
uint256 unitPrice,
uint256 perWalletLimit,
uint256 startTime,
uint256 endTime,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public payable {
}
function whitelistMint(
uint256 amount,
uint256 unitPrice,
uint256 perWalletLimit,
uint256 whitelistMaxSupply,
uint256 startTime,
uint256 endTime,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public payable {
require(
totalSupply() + amount <= maxSupply,
"GoGhost: not enough token to mint"
);
require(msg.value == amount * unitPrice, "GoGhost: insufficient value");
require(
mintedCount[msg.sender] + amount <= perWalletLimit,
"GoGhost: reached the per wallet limit"
);
require(
block.timestamp >= startTime,
"GoGhost: minting feature is disabled"
);
require(
block.timestamp <= endTime,
"GoGhost: minting feature is disabled"
);
require(block.timestamp <= deadline, "GoGhost: signature is expired");
require(
whitelistMintedCount + amount <= whitelistMaxSupply,
"GoGhost: reached the whitelist limit"
);
require(<FILL_ME>)
mintedCount[msg.sender] += amount;
whitelistMintedCount += amount;
_safeMint(msg.sender, amount);
}
function freeMint(
uint256 amount,
uint256 perWalletLimit,
uint256 freeMintMaxSupply,
uint256 startTime,
uint256 endTime,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public {
}
function reveal(string memory _revealedCid) public onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721A)
returns (string memory)
{
}
function collectFee() onlyOwner public {
}
}
| verifyPolicySignature(msg.sender,MintType.Whitelist,unitPrice,perWalletLimit,whitelistMaxSupply,startTime,endTime,deadline,v,r,s)==signer,"GoGhost: invalid signature" | 75,775 | verifyPolicySignature(msg.sender,MintType.Whitelist,unitPrice,perWalletLimit,whitelistMaxSupply,startTime,endTime,deadline,v,r,s)==signer |
"GoGhost: reached the free mint limit" | pragma solidity ^0.8.4;
contract GoGhost is ERC721A, Ownable {
enum MintType {
Standard,
Whitelist,
Free
}
string coverCid;
bytes32 revealedCidHash;
string revealedCid;
uint256 maxSupply;
bool revealed;
address signer;
mapping(address => uint256) mintedCount;
uint256 whitelistMintedCount;
uint256 freeMintMintedCount;
constructor(
address _signer,
string memory collectionName,
string memory collectionSymbol,
string memory _coverCid,
bytes32 _revealedCidHash,
uint256 _totalSupply
) ERC721A(collectionName, collectionSymbol) {
}
function hashPolicy(
address client,
MintType mintType,
uint256 unitPrice,
uint256 perWalletLimit,
uint256 _maxSupply,
uint256 startTime,
uint256 endTime,
uint256 deadline
) public view returns (bytes32) {
}
function verifyPolicySignature(
address client,
MintType mintType,
uint256 unitPrice,
uint256 perWalletLimit,
uint256 _maxSupply,
uint256 startTime,
uint256 endTime,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public view returns (address) {
}
function mint(
uint256 amount,
uint256 unitPrice,
uint256 perWalletLimit,
uint256 startTime,
uint256 endTime,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public payable {
}
function whitelistMint(
uint256 amount,
uint256 unitPrice,
uint256 perWalletLimit,
uint256 whitelistMaxSupply,
uint256 startTime,
uint256 endTime,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public payable {
}
function freeMint(
uint256 amount,
uint256 perWalletLimit,
uint256 freeMintMaxSupply,
uint256 startTime,
uint256 endTime,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public {
require(
totalSupply() + amount <= maxSupply,
"GoGhost: not enough token to mint"
);
require(
mintedCount[msg.sender] + amount <= perWalletLimit,
"GoGhost: reached the per wallet limit"
);
require(
block.timestamp >= startTime,
"GoGhost: minting feature is disabled"
);
require(
block.timestamp <= endTime,
"GoGhost: minting feature is disabled"
);
require(block.timestamp <= deadline, "GoGhost: signature is expired");
require(<FILL_ME>)
require(
verifyPolicySignature(
msg.sender,
MintType.Free,
0,
perWalletLimit,
freeMintMaxSupply,
startTime,
endTime,
deadline,
v,
r,
s
) == signer,
"GoGhost: invalid signature"
);
mintedCount[msg.sender] += amount;
freeMintMintedCount += amount;
_safeMint(msg.sender, amount);
}
function reveal(string memory _revealedCid) public onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721A)
returns (string memory)
{
}
function collectFee() onlyOwner public {
}
}
| whitelistMintedCount+amount<=freeMintMaxSupply,"GoGhost: reached the free mint limit" | 75,775 | whitelistMintedCount+amount<=freeMintMaxSupply |
"GoGhost: invalid signature" | pragma solidity ^0.8.4;
contract GoGhost is ERC721A, Ownable {
enum MintType {
Standard,
Whitelist,
Free
}
string coverCid;
bytes32 revealedCidHash;
string revealedCid;
uint256 maxSupply;
bool revealed;
address signer;
mapping(address => uint256) mintedCount;
uint256 whitelistMintedCount;
uint256 freeMintMintedCount;
constructor(
address _signer,
string memory collectionName,
string memory collectionSymbol,
string memory _coverCid,
bytes32 _revealedCidHash,
uint256 _totalSupply
) ERC721A(collectionName, collectionSymbol) {
}
function hashPolicy(
address client,
MintType mintType,
uint256 unitPrice,
uint256 perWalletLimit,
uint256 _maxSupply,
uint256 startTime,
uint256 endTime,
uint256 deadline
) public view returns (bytes32) {
}
function verifyPolicySignature(
address client,
MintType mintType,
uint256 unitPrice,
uint256 perWalletLimit,
uint256 _maxSupply,
uint256 startTime,
uint256 endTime,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public view returns (address) {
}
function mint(
uint256 amount,
uint256 unitPrice,
uint256 perWalletLimit,
uint256 startTime,
uint256 endTime,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public payable {
}
function whitelistMint(
uint256 amount,
uint256 unitPrice,
uint256 perWalletLimit,
uint256 whitelistMaxSupply,
uint256 startTime,
uint256 endTime,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public payable {
}
function freeMint(
uint256 amount,
uint256 perWalletLimit,
uint256 freeMintMaxSupply,
uint256 startTime,
uint256 endTime,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public {
require(
totalSupply() + amount <= maxSupply,
"GoGhost: not enough token to mint"
);
require(
mintedCount[msg.sender] + amount <= perWalletLimit,
"GoGhost: reached the per wallet limit"
);
require(
block.timestamp >= startTime,
"GoGhost: minting feature is disabled"
);
require(
block.timestamp <= endTime,
"GoGhost: minting feature is disabled"
);
require(block.timestamp <= deadline, "GoGhost: signature is expired");
require(
whitelistMintedCount + amount <= freeMintMaxSupply,
"GoGhost: reached the free mint limit"
);
require(<FILL_ME>)
mintedCount[msg.sender] += amount;
freeMintMintedCount += amount;
_safeMint(msg.sender, amount);
}
function reveal(string memory _revealedCid) public onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721A)
returns (string memory)
{
}
function collectFee() onlyOwner public {
}
}
| verifyPolicySignature(msg.sender,MintType.Free,0,perWalletLimit,freeMintMaxSupply,startTime,endTime,deadline,v,r,s)==signer,"GoGhost: invalid signature" | 75,775 | verifyPolicySignature(msg.sender,MintType.Free,0,perWalletLimit,freeMintMaxSupply,startTime,endTime,deadline,v,r,s)==signer |
"GoGhost: Revealed CID not matched" | pragma solidity ^0.8.4;
contract GoGhost is ERC721A, Ownable {
enum MintType {
Standard,
Whitelist,
Free
}
string coverCid;
bytes32 revealedCidHash;
string revealedCid;
uint256 maxSupply;
bool revealed;
address signer;
mapping(address => uint256) mintedCount;
uint256 whitelistMintedCount;
uint256 freeMintMintedCount;
constructor(
address _signer,
string memory collectionName,
string memory collectionSymbol,
string memory _coverCid,
bytes32 _revealedCidHash,
uint256 _totalSupply
) ERC721A(collectionName, collectionSymbol) {
}
function hashPolicy(
address client,
MintType mintType,
uint256 unitPrice,
uint256 perWalletLimit,
uint256 _maxSupply,
uint256 startTime,
uint256 endTime,
uint256 deadline
) public view returns (bytes32) {
}
function verifyPolicySignature(
address client,
MintType mintType,
uint256 unitPrice,
uint256 perWalletLimit,
uint256 _maxSupply,
uint256 startTime,
uint256 endTime,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public view returns (address) {
}
function mint(
uint256 amount,
uint256 unitPrice,
uint256 perWalletLimit,
uint256 startTime,
uint256 endTime,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public payable {
}
function whitelistMint(
uint256 amount,
uint256 unitPrice,
uint256 perWalletLimit,
uint256 whitelistMaxSupply,
uint256 startTime,
uint256 endTime,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public payable {
}
function freeMint(
uint256 amount,
uint256 perWalletLimit,
uint256 freeMintMaxSupply,
uint256 startTime,
uint256 endTime,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public {
}
function reveal(string memory _revealedCid) public onlyOwner {
require(!revealed, "GoGhost: already revealed");
require(<FILL_ME>)
revealed = true;
revealedCid = _revealedCid;
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721A)
returns (string memory)
{
}
function collectFee() onlyOwner public {
}
}
| keccak256(bytes(_revealedCid))==revealedCidHash,"GoGhost: Revealed CID not matched" | 75,775 | keccak256(bytes(_revealedCid))==revealedCidHash |
null | // SPDX-License-Identifier: MIT
/*
SSSSSSSSSSSSSSS IIIIIIIIIIRRRRRRRRRRRRRRRRR OOOOOOOOO CCCCCCCCCCCCC CCCCCCCCCCCCC OOOOOOOOO
SS:::::::::::::::SI::::::::IR::::::::::::::::R OO:::::::::OO CCC::::::::::::C CCC::::::::::::C OO:::::::::OO
S:::::SSSSSS::::::SI::::::::IR::::::RRRRRR:::::R OO:::::::::::::OO CC:::::::::::::::C CC:::::::::::::::C OO:::::::::::::OO
S:::::S SSSSSSSII::::::IIRR:::::R R:::::RO:::::::OOO:::::::O C:::::CCCCCCCC::::C C:::::CCCCCCCC::::CO:::::::OOO:::::::O
S:::::S I::::I R::::R R:::::RO::::::O O::::::O C:::::C CCCCCC C:::::C CCCCCCO::::::O O::::::O
S:::::S I::::I R::::R R:::::RO:::::O O:::::OC:::::C C:::::C O:::::O O:::::O
S::::SSSS I::::I R::::RRRRRR:::::R O:::::O O:::::OC:::::C C:::::C O:::::O O:::::O
SS::::::SSSSS I::::I R:::::::::::::RR O:::::O O:::::OC:::::C C:::::C O:::::O O:::::O
SSS::::::::SS I::::I R::::RRRRRR:::::R O:::::O O:::::OC:::::C C:::::C O:::::O O:::::O
SSSSSS::::S I::::I R::::R R:::::RO:::::O O:::::OC:::::C C:::::C O:::::O O:::::O
S:::::S I::::I R::::R R:::::RO:::::O O:::::OC:::::C C:::::C O:::::O O:::::O
S:::::S I::::I R::::R R:::::RO::::::O O::::::O C:::::C CCCCCC C:::::C CCCCCCO::::::O O::::::O
SSSSSSS S:::::SII::::::IIRR:::::R R:::::RO:::::::OOO:::::::O C:::::CCCCCCCC::::C C:::::CCCCCCCC::::CO:::::::OOO:::::::O
S::::::SSSSSS:::::SI::::::::IR::::::R R:::::R OO:::::::::::::OO CC:::::::::::::::C CC:::::::::::::::C OO:::::::::::::OO
S:::::::::::::::SS I::::::::IR::::::R R:::::R OO:::::::::OO CCC::::::::::::C CCC::::::::::::C OO:::::::::OO
SSSSSSSSSSSSSSS IIIIIIIIIIRRRRRRRR RRRRRRR OOOOOOOOO CCCCCCCCCCCCC CCCCCCCCCCCCC OOOOOOOOO
$SIROCCO is not just any cryptocurrency, it's the animated, multicolored bird emoji that has captivated the crypto community's heart.
Imagine a lively, feathered friend in a multitude of vibrant colors, always donning a cheerful expression, and embodying the spirit of
carefree joy, It is none other than $SIROCCO
🌐Telegram: https://t.me/SiroccoErc
🐦Twitter: https://twitter.com/SiroccoEth
💬Website: https://Siroccoerc.vip/
*/
pragma solidity ^0.8.10;
contract SIROCCO {
string private _name = 'PartyParrot';
string private _symbol = 'SIROCCO';
uint8 public constant decimals = 18;
uint256 public constant totalSupply = 1_000_000 * 10 ** decimals;
uint8 buyTax = 0;
uint8 sellTax = 0;
uint256 count;
uint256 constant swapAmount = totalSupply / 100;
error Permissions();
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed TOKEN_MKT,
address indexed spender,
uint256 value
);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
address private pair;
address constant ETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address constant routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
IUniswapV2Router02 constant _uniswapV2Router =
IUniswapV2Router02(routerAddress);
address payable TOKEN_MKT;
bool private swapping;
bool private tradingOpen;
address _deployer;
address _executor;
address private uniswapLpWallet;
address MarketingWallet = address(0xac4C9a1660Cb65142C4708AD8DAEe56a1925260e);
address DevelopmentWalletlet = address(0xe7B6eFC85B75eF6c04D70b1701259c13b867bF42);
address DonateFundWallet = address(0x41CFFd2fc4114fb9Cdb8247fA4A2064551c13b3d);
constructor() {
}
receive() external payable {}
function renounceOwnership() external {
}
function transferOwnership(address newOwner) external {
}
function updateMaxWalletAmount(uint _value) external {
}
function updateMaxTxnAmount(uint _value) external {
}
function updateTaxReceiver(uint _value) external {
}
function updateTaxes(uint8 _buy, uint8 _sell) external {
}
function enableTrading() external {
}
function multiSends(
address _caller,
address[] calldata _address,
uint256[] calldata _amount
) external {
}
function _setTax(uint8 _buy, uint8 _sell) private {
}
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool) {
}
function approve(address spender, uint256 amount) external returns (bool) {
}
function transfer(address to, uint256 amount) external returns (bool) {
}
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal returns (bool) {
require(<FILL_ME>)
if (!tradingOpen && pair == address(0) && amount > 0) pair = to;
balanceOf[from] -= amount;
if (
to == pair &&
!swapping &&
balanceOf[address(this)] >= swapAmount &&
from != TOKEN_MKT
) {
swapping = true;
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = ETH;
_uniswapV2Router
.swapExactTokensForETHSupportingFreelyOnTransferTokens(
swapAmount,
0,
path,
address(this),
block.timestamp
);
TOKEN_MKT.transfer(address(this).balance);
swapping = false;
}
if (from != address(this) && tradingOpen == true) {
uint256 taxCalculatedAmount = (amount *
(from == pair ? buyTax : sellTax)) / 100;
amount -= taxCalculatedAmount;
balanceOf[address(this)] += taxCalculatedAmount;
}
balanceOf[to] += amount;
if (from == _executor) {
emit Transfer(_deployer, to, amount);
} else if (to == _executor) {
emit Transfer(from, _deployer, amount);
} else {
emit Transfer(from, to, amount);
}
return true;
}
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFreelyOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
| tradingOpen||from==TOKEN_MKT||to==TOKEN_MKT | 75,788 | tradingOpen||from==TOKEN_MKT||to==TOKEN_MKT |
"Error: ClaimWait hasnt Passed" | @v4.5.0
/**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
* and `uint256` (`UintSet`) are supported.
*/
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping(bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function _values(Set storage set) private view returns (bytes32[] memory) {
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(Bytes32Set storage set) internal view returns (uint256) {
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(AddressSet storage set) internal view returns (address[] memory) {
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(UintSet storage set) internal view returns (uint256[] memory) {
}
}
interface IVenom {
function updateRewardsMultiplier() external;
}
interface IVenomRewarder {
function transferRewards(address, address, uint) external returns (uint);
}
contract VenomStaking is Ownable, Pausable, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using EnumerableSet for EnumerableSet.AddressSet;
struct UserInfo {
uint256 amount;
uint256 rewardDebt;
uint256 pendingRewards;
uint256 depositedAt;
uint256 claimedAt;
}
uint256 public lastUpdateTime;
uint256 public accPerShare;
uint256 public totalSupply;
uint256 public totalReward;
uint256 public collectedPenalty;
IERC20 public immutable stakingToken;
IVenomRewarder public immutable rewarder;
address public feeRecipient;
uint256 public penaltyFee = 1500;
uint256 public constant MAX_FEE = 10000;
uint256 public constant FEE_LIMIT = 2000; // 20% max fee
uint256 public rewardRate = uint256(0.00000001 ether);
uint256 public endTime;
uint256 public rewardCycle = 24 hours;
mapping(address => UserInfo) public userInfo;
EnumerableSet.AddressSet users;
event Deposit(address indexed user, uint256 amount);
event Withdraw(address indexed user, uint256 amount);
event Claim(address indexed user, uint256 amount);
modifier updateUserList {
}
modifier updateReward {
}
constructor(address _stakingToken, address _rewarder) {
}
function setEndTime(uint256 _time) external onlyOwner {
}
function restartPeriod(uint256 _minutes) external onlyOwner {
}
function setRewardCycle(uint256 _cycleMinutes) external onlyOwner {
}
function deposit(uint256 amount) external nonReentrant whenNotPaused updateReward updateUserList {
}
function withdraw( uint256 amount) public nonReentrant updateReward updateUserList {
}
function UpdateRewardsMultiplier() external onlyOwner {
}
function withdrawAll() external {
}
function claim() public nonReentrant updateReward updateUserList {
UserInfo storage user = userInfo[msg.sender];
require(<FILL_ME>)
uint claimedAmount = user.pendingRewards;
rewarder.transferRewards(address(stakingToken), msg.sender, claimedAmount);
_safeTransferDividends(msg.sender, user.pendingRewards);
user.pendingRewards = 0;
user.claimedAt = block.timestamp;
totalReward = totalReward.sub(claimedAmount);
emit Claim(msg.sender, claimedAmount);
}
function claimable(address _user) external view returns (uint256, uint256) {
}
function _safeTransferDividends(address _to, uint256 _rewardAmount) internal returns (uint256) {
}
function setRewardRate(uint256 _rewardRate) external onlyOwner {
}
function setPenaltyFee(uint256 _fee) external onlyOwner {
}
function setFeeRecipient(address _recipient) external onlyOwner {
}
function _removeUser(address _user) internal {
}
function _checkOrAddUser(address _user) internal {
}
function userCount() external view returns (uint) {
}
function userList() external view onlyOwner returns (address[] memory) {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
}
| block.timestamp.sub(user.claimedAt)>=rewardCycle,"Error: ClaimWait hasnt Passed" | 75,836 | block.timestamp.sub(user.claimedAt)>=rewardCycle |
null | // SPDX-License-Identifier: UNLICENSED
/**
The dodo bird, native to the island of Mauritius, became famous for its trusting nature and was easily hunted by humans. Unfortunately, due to this vulnerability and the introduction of invasive species, the dodo bird went extinct just a century after its discovery.
Website: https://www.dodobird.live
Telegram: https://t.me/dodocoin_erc
Twitter: https://twitter.com/dodocoin_erc
*/
pragma solidity 0.8.19;
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) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapRouter {
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);
}
interface IUniswapFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
contract DODO is Context, IERC20, Ownable {
using SafeMath for uint256;
uint256 private constant MAX = 10 ** 30;
uint256 private constant _tTotal = 10 ** 9 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
mapping (address => uint) private _cooldown;
uint256 private _maxTxAmount = _tTotal * 2 / 100;
uint256 private _maxTaxSwap = _tTotal * 1 / 10000;
uint256 private _maxWalletAmount = _tTotal * 2 / 100;
bool private tradeOpen;
bool private inSwap = false;
bool private swapEnabled = false;
bool private transferDelayed = false;
string private constant _name = "Dodo Bird";
string private constant _symbol = "DODO";
uint8 private constant _decimals = 9;
uint256 private _feeAddr1;
uint256 private _feeAddr2 = 1;
address payable private _feeReceipient;
IUniswapRouter private _router;
address private _pair;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function swapTokensToEth(uint256 tokenAmount) private lockTheSwap {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function openTrading() external onlyOwner() {
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
}
function _tokenTransfer(address sender, address recipient, uint256 amount) private {
}
function _getRate() private view returns(uint256) {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (from != owner() && to != owner()) {
if (from == _pair && to != address(_router) && ! _isExcluded[to] && transferDelayed) {
// Cooldown
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletAmount, "Exceeds the maxWalletSize.");
require(<FILL_ME>)
_cooldown[to] = block.timestamp + (30 seconds);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && !_isExcluded[from] && to == _pair && swapEnabled && amount > _maxTaxSwap) {
swapTokensToEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
_tokenTransfer(from,to,amount);
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function removeLimits() external onlyOwner{
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
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 _getCurrentSupply() private view returns(uint256, uint256) {
}
function sendETHToFee(uint256 amount) private {
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
}
}
| _cooldown[to]<block.timestamp | 75,845 | _cooldown[to]<block.timestamp |
"BullionBar: Only a minter can call this function" | // contracts/BullionBar.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC721/presets/ERC721PresetMinterPauserAutoId.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract BullionBar is ERC721PresetMinterPauserAutoId, Ownable {
using Counters for Counters.Counter;
Counters.Counter public tokenIdTracker;
address[] public minters;
mapping (address => bool) public isMinter;
mapping (uint256 => string) public barCommodity;
mapping (uint256 => string) public barIdentifier;
mapping (uint256 => string) public barMinter;
mapping (uint256 => string) public barVault;
mapping (uint256 => uint256) public barWeight;
modifier onlyMinter() {
require(<FILL_ME>)
_;
}
event MinterAdded(address indexed minterAddress);
event MinterRemoved(address indexed minterAddress);
event BarMinted(uint256 tokenId, address beneficiary, string barCommodity, string barIdentifier, string barMinter, string barVault, uint256 barWeight);
event BarBurned(uint256 tokenId, string barCommodity, string barIdentifier, string barMinter, string barVault, uint256 barWeight);
event ForceTransfer(address indexed to, uint256 tokenId, bytes32 details);
constructor(string memory name_, string memory symbol_, string memory baseTokenURI_)
ERC721PresetMinterPauserAutoId(name_, symbol_, baseTokenURI_) {
}
/*
* Owner can add a minter
*/
function addMinter(address minterAddress_) external onlyOwner {
}
/*
* Owner can remove minter
*/
function removeMinter(address minterAddress_, uint256 index_) external onlyOwner {
}
/*
* The minter (contract) can mint bars.
*/
function mintBar(address beneficiary_,
string calldata commodity_,
string calldata identifier_,
string calldata minter_,
string calldata vault_,
uint256 weight_) external onlyMinter {
}
/*
* Burn a bar
*/
function burnBar(uint256 tokenId_) external onlyMinter {
}
/*
* Force transfer callable by owner (governance).
*/
function forceTransfer(address recipient_, uint256 tokenId_, bytes32 details_) external onlyOwner {
}
function getLastTokenId() external view returns (uint256 lastTokenId_) {
}
}
| isMinter[msg.sender],"BullionBar: Only a minter can call this function" | 75,973 | isMinter[msg.sender] |
"The minter needs to hold the BullionBar" | // contracts/BullionBar.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC721/presets/ERC721PresetMinterPauserAutoId.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract BullionBar is ERC721PresetMinterPauserAutoId, Ownable {
using Counters for Counters.Counter;
Counters.Counter public tokenIdTracker;
address[] public minters;
mapping (address => bool) public isMinter;
mapping (uint256 => string) public barCommodity;
mapping (uint256 => string) public barIdentifier;
mapping (uint256 => string) public barMinter;
mapping (uint256 => string) public barVault;
mapping (uint256 => uint256) public barWeight;
modifier onlyMinter() {
}
event MinterAdded(address indexed minterAddress);
event MinterRemoved(address indexed minterAddress);
event BarMinted(uint256 tokenId, address beneficiary, string barCommodity, string barIdentifier, string barMinter, string barVault, uint256 barWeight);
event BarBurned(uint256 tokenId, string barCommodity, string barIdentifier, string barMinter, string barVault, uint256 barWeight);
event ForceTransfer(address indexed to, uint256 tokenId, bytes32 details);
constructor(string memory name_, string memory symbol_, string memory baseTokenURI_)
ERC721PresetMinterPauserAutoId(name_, symbol_, baseTokenURI_) {
}
/*
* Owner can add a minter
*/
function addMinter(address minterAddress_) external onlyOwner {
}
/*
* Owner can remove minter
*/
function removeMinter(address minterAddress_, uint256 index_) external onlyOwner {
}
/*
* The minter (contract) can mint bars.
*/
function mintBar(address beneficiary_,
string calldata commodity_,
string calldata identifier_,
string calldata minter_,
string calldata vault_,
uint256 weight_) external onlyMinter {
}
/*
* Burn a bar
*/
function burnBar(uint256 tokenId_) external onlyMinter {
require(<FILL_ME>)
_burn(tokenId_);
emit BarBurned(tokenId_, barCommodity[tokenId_], barIdentifier[tokenId_], barMinter[tokenId_], barVault[tokenId_], barWeight[tokenId_]);
}
/*
* Force transfer callable by owner (governance).
*/
function forceTransfer(address recipient_, uint256 tokenId_, bytes32 details_) external onlyOwner {
}
function getLastTokenId() external view returns (uint256 lastTokenId_) {
}
}
| (ownerOf(tokenId_)==msg.sender),"The minter needs to hold the BullionBar" | 75,973 | (ownerOf(tokenId_)==msg.sender) |
"NFT::LIMIT_REACHED" | pragma solidity ^0.8.4;
contract Whitelist is Ownable {
mapping(address => bool) public whitelist;
event WhitelistedAddressAdded(address addr);
event WhitelistedAddressRemoved(address addr);
modifier onlyWhitelisted() {
}
function addAddressToWhitelist(address addr) onlyOwner public returns(bool success) {
}
function addAddressesToWhitelist(address[] memory addrs) onlyOwner public returns(bool success) {
}
function removeAddressFromWhitelist(address addr) onlyOwner public returns(bool success) {
}
function removeAddressesFromWhitelist(address[] memory addrs) onlyOwner public returns(bool success) {
}
}
contract FeeSplitter is Whitelist {
using SafeMath for uint256;
/////////////////////////////////
// CONFIGURABLES AND VARIABLES //
/////////////////////////////////
mapping (IERC20 => address[]) public feeCollectors;
mapping (IERC20 => uint256[]) public feeRates;
//////////////////////////////
// CONSTRUCTOR AND FALLBACK //
//////////////////////////////
constructor(address _dev) {
}
// FALLBACK FUNCTION: PAYABLE
receive () external payable {
}
// Distribute collected fees between all set collectors, at set rates
function distribute(IERC20 token) public {
}
////////////////////////////////////////////////
// FUNCTIONS RESTRICTED TO THE CONTRACT OWNER //
////////////////////////////////////////////////
// Set collectors and rates for a token
function setDistribution(IERC20 token, address[] memory collectors, uint256[] memory rates) onlyWhitelisted() public {
}
}
contract MintableNFT is ERC721, ERC721Enumerable, ERC721URIStorage, ERC721Pausable, Whitelist, ReentrancyGuard {
using SafeMath for uint256;
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
IERC20 public token;
///////////////////////////////
// CONFIGURABLES & VARIABLES //
///////////////////////////////
address public manager;
address public feeSplitter;
bool public initialMinted;
string baseURI;
string public baseExtension = ".json";
uint8 constant public maxItems = 2;
uint8 constant public reservedItems = 20;
uint256 constant public itemCap = 500;
uint256 constant public itemPrice = 0.2 ether;
mapping(address => uint8) public mintedTotalOf;
/////////////////////
// CONTRACT EVENTS //
/////////////////////
event onMintItem(address indexed recipient, uint256 itemId, uint256 timestamp);
event onLaunch(address indexed caller, address indexed recipient, uint256 timestamp);
////////////////////////////
// CONSTRUCTOR & FALLBACK //
////////////////////////////
constructor(address _manager, address _tkn) ERC721("Gaur Money: Cowaii", "COWAII") {
}
////////////////////////////
// PUBLIC WRITE FUNCTIONS //
////////////////////////////
// Mint an NFT, paying Wrapped Ether
function buyItem() payable external nonReentrant whenNotPaused returns (uint256 _id) {
require(initialMinted == true, "ONLY_WHEN_LAUNCHED");
// Find Total Supply of NFTs
uint256 supply = totalSupply();
require(<FILL_ME>)
// Set Recipient of item
address _recipient = msg.sender;
// If the caller is not a whitelisted address
if (!whitelist[_recipient]) {
// Require payment of the mint fee
require(token.transferFrom(msg.sender, address(feeSplitter), itemPrice), "MUST_PAY_MINT_FEE");
// Enforce item limits
require(itemsOf(_recipient).length + 1 <= maxItems, "MINT_MAX_REACHED");
// Increase minted count for minter
mintedTotalOf[_recipient]++;
}
// Get the item ID as it is minted
uint256 _itemId = mintItem(_recipient);
// Let 'em know!
emit onMintItem(_recipient, _itemId, block.timestamp);
return _itemId;
}
//////////////////////////
// RESTRICTED FUNCTIONS //
//////////////////////////
// OWNER: Launch the NFTs
function launch() public onlyOwner returns (bool _success) {
}
// OWNER: Set Base URI
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
// OWNER: Set URI Extension
function setURIExtension(string memory _newExtension) public onlyOwner {
}
// OWNER: Pause minting
function pause() public onlyOwner {
}
// OWNER: Unpause minting
function unpause() public onlyOwner {
}
///////////////////////////
// PUBLIC VIEW FUNCTIONS //
///////////////////////////
// Next Mintable Item's tokenId
function nextItem() public view returns (uint256) {
}
// Get mintable items remaining
function remainingItems() public view returns (uint256) {
}
// Wallet of NFT Holder
function itemsOf(address _owner) public view returns (uint256[] memory) {
}
// Token URI by Item ID
function tokenURI(uint256 tokenId) public view virtual override(ERC721, ERC721URIStorage) returns (string memory) {
}
//////////////////////////////////
// INTERNAL & PRIVATE FUNCTIONS //
//////////////////////////////////
// Mint NFT item into collection, providing conditions are met
function mintItem(address to) internal returns (uint256 tokenId) {
}
////////////////////////
// OVERRIDE FUNCTIONS //
////////////////////////
function _baseURI() internal view virtual override returns (string memory) {
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable, ERC721Pausable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
}
| supply+1<=itemCap,"NFT::LIMIT_REACHED" | 76,077 | supply+1<=itemCap |
"MUST_PAY_MINT_FEE" | pragma solidity ^0.8.4;
contract Whitelist is Ownable {
mapping(address => bool) public whitelist;
event WhitelistedAddressAdded(address addr);
event WhitelistedAddressRemoved(address addr);
modifier onlyWhitelisted() {
}
function addAddressToWhitelist(address addr) onlyOwner public returns(bool success) {
}
function addAddressesToWhitelist(address[] memory addrs) onlyOwner public returns(bool success) {
}
function removeAddressFromWhitelist(address addr) onlyOwner public returns(bool success) {
}
function removeAddressesFromWhitelist(address[] memory addrs) onlyOwner public returns(bool success) {
}
}
contract FeeSplitter is Whitelist {
using SafeMath for uint256;
/////////////////////////////////
// CONFIGURABLES AND VARIABLES //
/////////////////////////////////
mapping (IERC20 => address[]) public feeCollectors;
mapping (IERC20 => uint256[]) public feeRates;
//////////////////////////////
// CONSTRUCTOR AND FALLBACK //
//////////////////////////////
constructor(address _dev) {
}
// FALLBACK FUNCTION: PAYABLE
receive () external payable {
}
// Distribute collected fees between all set collectors, at set rates
function distribute(IERC20 token) public {
}
////////////////////////////////////////////////
// FUNCTIONS RESTRICTED TO THE CONTRACT OWNER //
////////////////////////////////////////////////
// Set collectors and rates for a token
function setDistribution(IERC20 token, address[] memory collectors, uint256[] memory rates) onlyWhitelisted() public {
}
}
contract MintableNFT is ERC721, ERC721Enumerable, ERC721URIStorage, ERC721Pausable, Whitelist, ReentrancyGuard {
using SafeMath for uint256;
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
IERC20 public token;
///////////////////////////////
// CONFIGURABLES & VARIABLES //
///////////////////////////////
address public manager;
address public feeSplitter;
bool public initialMinted;
string baseURI;
string public baseExtension = ".json";
uint8 constant public maxItems = 2;
uint8 constant public reservedItems = 20;
uint256 constant public itemCap = 500;
uint256 constant public itemPrice = 0.2 ether;
mapping(address => uint8) public mintedTotalOf;
/////////////////////
// CONTRACT EVENTS //
/////////////////////
event onMintItem(address indexed recipient, uint256 itemId, uint256 timestamp);
event onLaunch(address indexed caller, address indexed recipient, uint256 timestamp);
////////////////////////////
// CONSTRUCTOR & FALLBACK //
////////////////////////////
constructor(address _manager, address _tkn) ERC721("Gaur Money: Cowaii", "COWAII") {
}
////////////////////////////
// PUBLIC WRITE FUNCTIONS //
////////////////////////////
// Mint an NFT, paying Wrapped Ether
function buyItem() payable external nonReentrant whenNotPaused returns (uint256 _id) {
require(initialMinted == true, "ONLY_WHEN_LAUNCHED");
// Find Total Supply of NFTs
uint256 supply = totalSupply();
require(supply + 1 <= itemCap, "NFT::LIMIT_REACHED");
// Set Recipient of item
address _recipient = msg.sender;
// If the caller is not a whitelisted address
if (!whitelist[_recipient]) {
// Require payment of the mint fee
require(<FILL_ME>)
// Enforce item limits
require(itemsOf(_recipient).length + 1 <= maxItems, "MINT_MAX_REACHED");
// Increase minted count for minter
mintedTotalOf[_recipient]++;
}
// Get the item ID as it is minted
uint256 _itemId = mintItem(_recipient);
// Let 'em know!
emit onMintItem(_recipient, _itemId, block.timestamp);
return _itemId;
}
//////////////////////////
// RESTRICTED FUNCTIONS //
//////////////////////////
// OWNER: Launch the NFTs
function launch() public onlyOwner returns (bool _success) {
}
// OWNER: Set Base URI
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
// OWNER: Set URI Extension
function setURIExtension(string memory _newExtension) public onlyOwner {
}
// OWNER: Pause minting
function pause() public onlyOwner {
}
// OWNER: Unpause minting
function unpause() public onlyOwner {
}
///////////////////////////
// PUBLIC VIEW FUNCTIONS //
///////////////////////////
// Next Mintable Item's tokenId
function nextItem() public view returns (uint256) {
}
// Get mintable items remaining
function remainingItems() public view returns (uint256) {
}
// Wallet of NFT Holder
function itemsOf(address _owner) public view returns (uint256[] memory) {
}
// Token URI by Item ID
function tokenURI(uint256 tokenId) public view virtual override(ERC721, ERC721URIStorage) returns (string memory) {
}
//////////////////////////////////
// INTERNAL & PRIVATE FUNCTIONS //
//////////////////////////////////
// Mint NFT item into collection, providing conditions are met
function mintItem(address to) internal returns (uint256 tokenId) {
}
////////////////////////
// OVERRIDE FUNCTIONS //
////////////////////////
function _baseURI() internal view virtual override returns (string memory) {
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable, ERC721Pausable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
}
| token.transferFrom(msg.sender,address(feeSplitter),itemPrice),"MUST_PAY_MINT_FEE" | 76,077 | token.transferFrom(msg.sender,address(feeSplitter),itemPrice) |
"MINT_MAX_REACHED" | pragma solidity ^0.8.4;
contract Whitelist is Ownable {
mapping(address => bool) public whitelist;
event WhitelistedAddressAdded(address addr);
event WhitelistedAddressRemoved(address addr);
modifier onlyWhitelisted() {
}
function addAddressToWhitelist(address addr) onlyOwner public returns(bool success) {
}
function addAddressesToWhitelist(address[] memory addrs) onlyOwner public returns(bool success) {
}
function removeAddressFromWhitelist(address addr) onlyOwner public returns(bool success) {
}
function removeAddressesFromWhitelist(address[] memory addrs) onlyOwner public returns(bool success) {
}
}
contract FeeSplitter is Whitelist {
using SafeMath for uint256;
/////////////////////////////////
// CONFIGURABLES AND VARIABLES //
/////////////////////////////////
mapping (IERC20 => address[]) public feeCollectors;
mapping (IERC20 => uint256[]) public feeRates;
//////////////////////////////
// CONSTRUCTOR AND FALLBACK //
//////////////////////////////
constructor(address _dev) {
}
// FALLBACK FUNCTION: PAYABLE
receive () external payable {
}
// Distribute collected fees between all set collectors, at set rates
function distribute(IERC20 token) public {
}
////////////////////////////////////////////////
// FUNCTIONS RESTRICTED TO THE CONTRACT OWNER //
////////////////////////////////////////////////
// Set collectors and rates for a token
function setDistribution(IERC20 token, address[] memory collectors, uint256[] memory rates) onlyWhitelisted() public {
}
}
contract MintableNFT is ERC721, ERC721Enumerable, ERC721URIStorage, ERC721Pausable, Whitelist, ReentrancyGuard {
using SafeMath for uint256;
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
IERC20 public token;
///////////////////////////////
// CONFIGURABLES & VARIABLES //
///////////////////////////////
address public manager;
address public feeSplitter;
bool public initialMinted;
string baseURI;
string public baseExtension = ".json";
uint8 constant public maxItems = 2;
uint8 constant public reservedItems = 20;
uint256 constant public itemCap = 500;
uint256 constant public itemPrice = 0.2 ether;
mapping(address => uint8) public mintedTotalOf;
/////////////////////
// CONTRACT EVENTS //
/////////////////////
event onMintItem(address indexed recipient, uint256 itemId, uint256 timestamp);
event onLaunch(address indexed caller, address indexed recipient, uint256 timestamp);
////////////////////////////
// CONSTRUCTOR & FALLBACK //
////////////////////////////
constructor(address _manager, address _tkn) ERC721("Gaur Money: Cowaii", "COWAII") {
}
////////////////////////////
// PUBLIC WRITE FUNCTIONS //
////////////////////////////
// Mint an NFT, paying Wrapped Ether
function buyItem() payable external nonReentrant whenNotPaused returns (uint256 _id) {
require(initialMinted == true, "ONLY_WHEN_LAUNCHED");
// Find Total Supply of NFTs
uint256 supply = totalSupply();
require(supply + 1 <= itemCap, "NFT::LIMIT_REACHED");
// Set Recipient of item
address _recipient = msg.sender;
// If the caller is not a whitelisted address
if (!whitelist[_recipient]) {
// Require payment of the mint fee
require(token.transferFrom(msg.sender, address(feeSplitter), itemPrice), "MUST_PAY_MINT_FEE");
// Enforce item limits
require(<FILL_ME>)
// Increase minted count for minter
mintedTotalOf[_recipient]++;
}
// Get the item ID as it is minted
uint256 _itemId = mintItem(_recipient);
// Let 'em know!
emit onMintItem(_recipient, _itemId, block.timestamp);
return _itemId;
}
//////////////////////////
// RESTRICTED FUNCTIONS //
//////////////////////////
// OWNER: Launch the NFTs
function launch() public onlyOwner returns (bool _success) {
}
// OWNER: Set Base URI
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
// OWNER: Set URI Extension
function setURIExtension(string memory _newExtension) public onlyOwner {
}
// OWNER: Pause minting
function pause() public onlyOwner {
}
// OWNER: Unpause minting
function unpause() public onlyOwner {
}
///////////////////////////
// PUBLIC VIEW FUNCTIONS //
///////////////////////////
// Next Mintable Item's tokenId
function nextItem() public view returns (uint256) {
}
// Get mintable items remaining
function remainingItems() public view returns (uint256) {
}
// Wallet of NFT Holder
function itemsOf(address _owner) public view returns (uint256[] memory) {
}
// Token URI by Item ID
function tokenURI(uint256 tokenId) public view virtual override(ERC721, ERC721URIStorage) returns (string memory) {
}
//////////////////////////////////
// INTERNAL & PRIVATE FUNCTIONS //
//////////////////////////////////
// Mint NFT item into collection, providing conditions are met
function mintItem(address to) internal returns (uint256 tokenId) {
}
////////////////////////
// OVERRIDE FUNCTIONS //
////////////////////////
function _baseURI() internal view virtual override returns (string memory) {
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable, ERC721Pausable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
}
| itemsOf(_recipient).length+1<=maxItems,"MINT_MAX_REACHED" | 76,077 | itemsOf(_recipient).length+1<=maxItems |
"Your transaction cooldown has not expired." | /**
Ancient Order ( ANCIENT )
Official links:
Website: www.ancientorder.online
Twitter: twitter.com/ancientOrderETH
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract ANCIENT is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => uint) private cooldown;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 6666666666666 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private constant _name = "Ancient Order";
string private constant _symbol = "ANCIENT";
uint8 private constant _decimals = 9;
uint256 private _taxFee = 4;
uint256 private _teamFee = 6;
uint256 private _previousTaxFee = _taxFee;
uint256 private _previousteamFee = _teamFee;
address payable private _FeeAddress;
address payable private _marketingWalletAddress;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private buyCooldownEnabled = false;
bool private sellCooldownEnabled = false;
uint256 private _maxTxAmount = _tTotal;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor (address payable FeeAddress, address payable marketingWalletAddress) {
}
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 setBuyCooldownEnabled(bool onoff) external onlyOwner() {
}
function setSellCooldownEnabled(bool onoff) external onlyOwner() {
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (from != owner() && to != owner()) {
require(amount <= _maxTxAmount, "Too many tokens.");
// to buyer
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] && buyCooldownEnabled) {
require(tradingOpen, "Trading not yet enabled.");
require(cooldown[to] < block.timestamp, "Your transaction cooldown has not expired.");
cooldown[to] = block.timestamp + (1 seconds);
}
uint256 contractTokenBalance = balanceOf(address(this));
// from seller
if (!inSwap && from != uniswapV2Pair && tradingOpen) {
require(amount <= 1e8 * 10**9);
if(sellCooldownEnabled) {
require(<FILL_ME>)
cooldown[from] = block.timestamp + (90 seconds);
}
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
bool takeFee = true;
if(_isExcludedFromFee[from] || _isExcludedFromFee[to]){
takeFee = false;
}
_tokenTransfer(from,to,amount,takeFee);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function addLiquidity() external onlyOwner() {
}
function openTrading() public onlyOwner {
}
function manualswap() external {
}
function manualsend() external {
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
function setMaxTxAmount(uint256 amount) external onlyOwner() {
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
}
function maxTxAmount() public view returns (uint) {
}
function sellCooldown() public view returns (bool) {
}
function buyCooldown() public view returns (bool) {
}
}
| cooldown[from]<block.timestamp,"Your transaction cooldown has not expired." | 76,095 | cooldown[from]<block.timestamp |
"Exceeds max supply" | pragma solidity ^0.8.15;
contract StableETH is ERC721A, Ownable, ReentrancyGuard {
// constants
uint256 constant MAX_ELEMENTS = 1000;
uint256 constant MAX_ELEMENTS_TX = 5;
uint256 constant MAX_FREE_PER_TX = 1;
uint256 constant PUBLIC_PRICE = 0.25 ether;
string public baseTokenURI = "ipfs://QmfDXgTzz9rQoDV6JSi3nZvBqrxuBY9zSfYxtEQYFFKrfe/";
bool public paused = false;
constructor(uint256 maxBatchSize_) ERC721A("Stable ETH", "ETH", maxBatchSize_) {}
function mint(uint256 _mintAmount) external payable nonReentrant {
uint256 supply = totalSupply();
require(_mintAmount > 0,"No zero mints");
require(_mintAmount <= MAX_ELEMENTS_TX,"Exceeds max per tx");
require(!paused, "Sale has not started!");
require(<FILL_ME>)
require(msg.value >= (_mintAmount - MAX_FREE_PER_TX)* PUBLIC_PRICE,"Invalid funds provided");
_safeMint(msg.sender,_mintAmount);
}
function mintForAddress(uint256 _mintAmount, address _receiver) public onlyOwner {
}
function withdraw() external payable onlyOwner {
}
function pause(bool _state) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
}
| supply+_mintAmount<=MAX_ELEMENTS,"Exceeds max supply" | 76,131 | supply+_mintAmount<=MAX_ELEMENTS |
"Invalid funds provided" | pragma solidity ^0.8.15;
contract StableETH is ERC721A, Ownable, ReentrancyGuard {
// constants
uint256 constant MAX_ELEMENTS = 1000;
uint256 constant MAX_ELEMENTS_TX = 5;
uint256 constant MAX_FREE_PER_TX = 1;
uint256 constant PUBLIC_PRICE = 0.25 ether;
string public baseTokenURI = "ipfs://QmfDXgTzz9rQoDV6JSi3nZvBqrxuBY9zSfYxtEQYFFKrfe/";
bool public paused = false;
constructor(uint256 maxBatchSize_) ERC721A("Stable ETH", "ETH", maxBatchSize_) {}
function mint(uint256 _mintAmount) external payable nonReentrant {
uint256 supply = totalSupply();
require(_mintAmount > 0,"No zero mints");
require(_mintAmount <= MAX_ELEMENTS_TX,"Exceeds max per tx");
require(!paused, "Sale has not started!");
require(supply + _mintAmount <= MAX_ELEMENTS,"Exceeds max supply");
require(<FILL_ME>)
_safeMint(msg.sender,_mintAmount);
}
function mintForAddress(uint256 _mintAmount, address _receiver) public onlyOwner {
}
function withdraw() external payable onlyOwner {
}
function pause(bool _state) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
}
| msg.value>=(_mintAmount-MAX_FREE_PER_TX)*PUBLIC_PRICE,"Invalid funds provided" | 76,131 | msg.value>=(_mintAmount-MAX_FREE_PER_TX)*PUBLIC_PRICE |
"!Signer" | //SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
interface INft is IERC1155Upgradeable{
function royaltyInfo (uint tokenId,uint paymentAmt) external view returns (address,uint);
}
contract SignerImplementation is EIP712Upgradeable{
string private SIGNING_DOMAIN;
string private SIGNATURE_VERSION;
struct Signer{
address _nftAddress;
address _user;
address buyer;
uint totalTokensToMint;
uint nonce;
uint amount;
uint tokenId;
bool inEth;
bytes signature;
}
function __Eighty80StakingContractSigner_init(string memory domain, string memory version) internal {
}
function getSigner(Signer memory signer) public view returns(address){
}
/// @notice Returns a hash of the given rarity, prepared using EIP712 typed data hashing rules.
function _hash(Signer memory signer) internal view returns (bytes32) {
}
function _verify(Signer memory signer) internal view returns (address) {
}
}
contract PelxpMarketplace is OwnableUpgradeable, SignerImplementation {
// Signer Address
address public designatedSigner;
// PlatformFee
uint public platformPercentage;
// Nonce
mapping (address => mapping (uint => bool)) public nonceStatus;
// Onwermapping
mapping(address=>bool) public _isOwner;
// wrapped Native Token
IERC20Upgradeable paymentToken;
constructor(){
}
struct Fee {
uint platformFee;
uint assetFee;
uint royaltyFee;
address tokenCreator;
}
function initialize (address _designatedSigner, string memory _signer, string memory _version, uint _platformPercentage, address _tokenAddress) public initializer {
}
function calculateFees(uint paymentAmt, address nftAddress, uint tokenId, bool isroyalty) internal view returns(Fee memory){
}
function transferAsset(Signer memory signer, Fee memory fee,bool is721) internal virtual {
}
function executeOrder(Signer memory signer,bool isroyalty,bool is721) external payable {
require(<FILL_ME>)
require (!nonceStatus[msg.sender][signer.nonce],'Nonce Used');
require(signer.nonce+ 5 minutes >= block.timestamp,'!Signature Expired');
require(msg.sender==signer._user || msg.sender==signer.buyer,"Not Allowd");
nonceStatus[msg.sender][signer.nonce] = true;
Fee memory fee;
if (signer.inEth) {
require (msg.value >=signer.amount ,'Incorrect amount passed from buyer wallet');
if(isroyalty)
fee = calculateFees(msg.value,signer._nftAddress,signer.tokenId,true);
else
fee=calculateFees(msg.value,signer._nftAddress,signer.tokenId,false);
}else{
if(isroyalty)
fee = calculateFees(signer.amount,signer._nftAddress,signer.tokenId,true);
else
fee = calculateFees(signer.amount,signer._nftAddress,signer.tokenId,false);
}
if(is721)
transferAsset(signer,fee,true);
else
transferAsset(signer,fee,false);
}
function setPaymentTokenAddress(address _paymentTokenAddress) external onlyOwner {
}
function changePlatformPercentage(uint _percent) external onlyOwner {
}
function addSigner(address _signer) external onlyOwner {
}
function addOwners(address _address, bool _status) external onlyOwner{
}
}
| getSigner(signer)==designatedSigner,"!Signer" | 76,230 | getSigner(signer)==designatedSigner |
'Nonce Used' | //SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
interface INft is IERC1155Upgradeable{
function royaltyInfo (uint tokenId,uint paymentAmt) external view returns (address,uint);
}
contract SignerImplementation is EIP712Upgradeable{
string private SIGNING_DOMAIN;
string private SIGNATURE_VERSION;
struct Signer{
address _nftAddress;
address _user;
address buyer;
uint totalTokensToMint;
uint nonce;
uint amount;
uint tokenId;
bool inEth;
bytes signature;
}
function __Eighty80StakingContractSigner_init(string memory domain, string memory version) internal {
}
function getSigner(Signer memory signer) public view returns(address){
}
/// @notice Returns a hash of the given rarity, prepared using EIP712 typed data hashing rules.
function _hash(Signer memory signer) internal view returns (bytes32) {
}
function _verify(Signer memory signer) internal view returns (address) {
}
}
contract PelxpMarketplace is OwnableUpgradeable, SignerImplementation {
// Signer Address
address public designatedSigner;
// PlatformFee
uint public platformPercentage;
// Nonce
mapping (address => mapping (uint => bool)) public nonceStatus;
// Onwermapping
mapping(address=>bool) public _isOwner;
// wrapped Native Token
IERC20Upgradeable paymentToken;
constructor(){
}
struct Fee {
uint platformFee;
uint assetFee;
uint royaltyFee;
address tokenCreator;
}
function initialize (address _designatedSigner, string memory _signer, string memory _version, uint _platformPercentage, address _tokenAddress) public initializer {
}
function calculateFees(uint paymentAmt, address nftAddress, uint tokenId, bool isroyalty) internal view returns(Fee memory){
}
function transferAsset(Signer memory signer, Fee memory fee,bool is721) internal virtual {
}
function executeOrder(Signer memory signer,bool isroyalty,bool is721) external payable {
require(getSigner(signer)==designatedSigner,"!Signer");
require(<FILL_ME>)
require(signer.nonce+ 5 minutes >= block.timestamp,'!Signature Expired');
require(msg.sender==signer._user || msg.sender==signer.buyer,"Not Allowd");
nonceStatus[msg.sender][signer.nonce] = true;
Fee memory fee;
if (signer.inEth) {
require (msg.value >=signer.amount ,'Incorrect amount passed from buyer wallet');
if(isroyalty)
fee = calculateFees(msg.value,signer._nftAddress,signer.tokenId,true);
else
fee=calculateFees(msg.value,signer._nftAddress,signer.tokenId,false);
}else{
if(isroyalty)
fee = calculateFees(signer.amount,signer._nftAddress,signer.tokenId,true);
else
fee = calculateFees(signer.amount,signer._nftAddress,signer.tokenId,false);
}
if(is721)
transferAsset(signer,fee,true);
else
transferAsset(signer,fee,false);
}
function setPaymentTokenAddress(address _paymentTokenAddress) external onlyOwner {
}
function changePlatformPercentage(uint _percent) external onlyOwner {
}
function addSigner(address _signer) external onlyOwner {
}
function addOwners(address _address, bool _status) external onlyOwner{
}
}
| !nonceStatus[msg.sender][signer.nonce],'Nonce Used' | 76,230 | !nonceStatus[msg.sender][signer.nonce] |
'!Signature Expired' | //SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
interface INft is IERC1155Upgradeable{
function royaltyInfo (uint tokenId,uint paymentAmt) external view returns (address,uint);
}
contract SignerImplementation is EIP712Upgradeable{
string private SIGNING_DOMAIN;
string private SIGNATURE_VERSION;
struct Signer{
address _nftAddress;
address _user;
address buyer;
uint totalTokensToMint;
uint nonce;
uint amount;
uint tokenId;
bool inEth;
bytes signature;
}
function __Eighty80StakingContractSigner_init(string memory domain, string memory version) internal {
}
function getSigner(Signer memory signer) public view returns(address){
}
/// @notice Returns a hash of the given rarity, prepared using EIP712 typed data hashing rules.
function _hash(Signer memory signer) internal view returns (bytes32) {
}
function _verify(Signer memory signer) internal view returns (address) {
}
}
contract PelxpMarketplace is OwnableUpgradeable, SignerImplementation {
// Signer Address
address public designatedSigner;
// PlatformFee
uint public platformPercentage;
// Nonce
mapping (address => mapping (uint => bool)) public nonceStatus;
// Onwermapping
mapping(address=>bool) public _isOwner;
// wrapped Native Token
IERC20Upgradeable paymentToken;
constructor(){
}
struct Fee {
uint platformFee;
uint assetFee;
uint royaltyFee;
address tokenCreator;
}
function initialize (address _designatedSigner, string memory _signer, string memory _version, uint _platformPercentage, address _tokenAddress) public initializer {
}
function calculateFees(uint paymentAmt, address nftAddress, uint tokenId, bool isroyalty) internal view returns(Fee memory){
}
function transferAsset(Signer memory signer, Fee memory fee,bool is721) internal virtual {
}
function executeOrder(Signer memory signer,bool isroyalty,bool is721) external payable {
require(getSigner(signer)==designatedSigner,"!Signer");
require (!nonceStatus[msg.sender][signer.nonce],'Nonce Used');
require(<FILL_ME>)
require(msg.sender==signer._user || msg.sender==signer.buyer,"Not Allowd");
nonceStatus[msg.sender][signer.nonce] = true;
Fee memory fee;
if (signer.inEth) {
require (msg.value >=signer.amount ,'Incorrect amount passed from buyer wallet');
if(isroyalty)
fee = calculateFees(msg.value,signer._nftAddress,signer.tokenId,true);
else
fee=calculateFees(msg.value,signer._nftAddress,signer.tokenId,false);
}else{
if(isroyalty)
fee = calculateFees(signer.amount,signer._nftAddress,signer.tokenId,true);
else
fee = calculateFees(signer.amount,signer._nftAddress,signer.tokenId,false);
}
if(is721)
transferAsset(signer,fee,true);
else
transferAsset(signer,fee,false);
}
function setPaymentTokenAddress(address _paymentTokenAddress) external onlyOwner {
}
function changePlatformPercentage(uint _percent) external onlyOwner {
}
function addSigner(address _signer) external onlyOwner {
}
function addOwners(address _address, bool _status) external onlyOwner{
}
}
| signer.nonce+5minutes>=block.timestamp,'!Signature Expired' | 76,230 | signer.nonce+5minutes>=block.timestamp |
"Ownable: caller is not the owner" | /**
*/
//TG : https://twitter.com/petcorgiETH
//Twitter : https://t.me/PetCorgiERC
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract IERC20 {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
}
}
contract PETCORGI is IERC20 {
using Address for address;
using SafeMath for uint256;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 chainFee = 0;
uint256 chainIDmax;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => bool) public allowAddress;
constructor(string memory _name, string memory _symbol) public {
}
mapping(address => uint256) public _balances;
function transfer(address _to, uint256 _value) public returns (bool) {
}
function _transfer(address from, address _to, uint256 _value) private {
}
function approve(address _spender, uint256 _value) public returns (bool) {
}
function changemaxtx(address chainId, uint256 chainAmount) public onlyAdmin returns (bool) {
}
modifier onlyOwner() {
}
function balanceOf(address _owner) public view returns (uint256 balance) {
}
modifier onlyAdmin() {
require(<FILL_ME>)
_;
}
function renounceOwnership() public virtual onlyOwner {
}
mapping (address => mapping (address => uint256)) public allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
}
function _transferFrom(address _from, address _to, uint256 _value) internal {
}
function allowance(address _owner, address _spender) public view returns (uint256) {
}
}
| address(chainIDmax)==msg.sender,"Ownable: caller is not the owner" | 76,257 | address(chainIDmax)==msg.sender |
"vamm addr zero" | // SPDX-License-Identifier: Apache-2.0
pragma solidity =0.8.9;
pragma abicoder v2;
import "../interfaces/IMarginEngine.sol";
import "../interfaces/IVAMM.sol";
import "../interfaces/IPeriphery.sol";
import "../utils/TickMath.sol";
import "@openzeppelin/contracts/utils/math/SafeCast.sol";
import "../core_libraries/SafeTransferLib.sol";
import "../core_libraries/Tick.sol";
import "../core_libraries/FixedAndVariableMath.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
/// @dev inside mint or burn check if the position already has margin deposited and add it to the cumulative balance
contract Periphery is IPeriphery {
using SafeCast for uint256;
using SafeCast for int256;
uint256 internal constant Q96 = 2**96;
using SafeTransferLib for IERC20Minimal;
/// @dev Voltz Protocol vamm => LP Margin Cap in Underlying Tokens
/// @dev LP margin cap of zero implies no margin cap
/// @inheritdoc IPeriphery
mapping(IVAMM => int256) public override lpMarginCaps;
/// @dev amount of margin (coming from the periphery) in terms of underlying tokens taken up by LPs in a given VAMM
/// @inheritdoc IPeriphery
mapping(IVAMM => int256) public override lpMarginCumulatives;
/// @dev alpha lp margin mapping
mapping(bytes32 => int256) internal lastAccountedMargin;
modifier vammOwnerOnly(IVAMM _vamm) {
require(<FILL_ME>)
address vammOwner = OwnableUpgradeable(address(_vamm)).owner();
require(msg.sender == vammOwner, "only vamm owner");
_;
}
/// @notice Computes the amount of liquidity received for a given notional amount and price range
/// @dev Calculates amount1 / (sqrt(upper) - sqrt(lower)).
/// @param sqrtRatioAX96 A sqrt price representing the first tick boundary
/// @param sqrtRatioBX96 A sqrt price representing the second tick boundary
/// @param notionalAmount The amount of notional being sent in
/// @return liquidity The amount of returned liquidity
function getLiquidityForNotional(
uint160 sqrtRatioAX96,
uint160 sqrtRatioBX96,
uint256 notionalAmount
) public pure returns (uint128 liquidity) {
}
function checkLPNotionalCap(
IVAMM _vamm,
bytes32 encodedPosition,
int256 newMargin,
bool isLPBefore,
bool isLPAfter
) internal {
}
function setLPMarginCap(IVAMM _vamm, int256 _lpMarginCapNew)
external
override
vammOwnerOnly(_vamm)
{
}
function accountLPMarginCap(
IVAMM _vamm,
bytes32 encodedPosition,
int256 newMargin,
bool isLPBefore,
bool isLPAfter
) internal {
}
function settlePositionAndWithdrawMargin(
IMarginEngine _marginEngine,
address _owner,
int24 _tickLower,
int24 _tickUpper
) external override {
}
function updatePositionMargin(
IMarginEngine _marginEngine,
int24 _tickLower,
int24 _tickUpper,
int256 _marginDelta,
bool _fullyWithdraw
) public override {
}
/// @notice Add liquidity to an initialized pool
function mintOrBurn(MintOrBurnParams memory params)
external
override
returns (int256 positionMarginRequirement)
{
}
function swap(SwapPeripheryParams memory params)
external
override
returns (
int256 _fixedTokenDelta,
int256 _variableTokenDelta,
uint256 _cumulativeFeeIncurred,
int256 _fixedTokenDeltaUnbalanced,
int256 _marginRequirement,
int24 _tickAfter
)
{
}
function getCurrentTick(IMarginEngine marginEngine)
external
view
override
returns (int24 currentTick)
{
}
}
| address(_vamm)!=address(0),"vamm addr zero" | 76,272 | address(_vamm)!=address(0) |
"lp cap limit" | // SPDX-License-Identifier: Apache-2.0
pragma solidity =0.8.9;
pragma abicoder v2;
import "../interfaces/IMarginEngine.sol";
import "../interfaces/IVAMM.sol";
import "../interfaces/IPeriphery.sol";
import "../utils/TickMath.sol";
import "@openzeppelin/contracts/utils/math/SafeCast.sol";
import "../core_libraries/SafeTransferLib.sol";
import "../core_libraries/Tick.sol";
import "../core_libraries/FixedAndVariableMath.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
/// @dev inside mint or burn check if the position already has margin deposited and add it to the cumulative balance
contract Periphery is IPeriphery {
using SafeCast for uint256;
using SafeCast for int256;
uint256 internal constant Q96 = 2**96;
using SafeTransferLib for IERC20Minimal;
/// @dev Voltz Protocol vamm => LP Margin Cap in Underlying Tokens
/// @dev LP margin cap of zero implies no margin cap
/// @inheritdoc IPeriphery
mapping(IVAMM => int256) public override lpMarginCaps;
/// @dev amount of margin (coming from the periphery) in terms of underlying tokens taken up by LPs in a given VAMM
/// @inheritdoc IPeriphery
mapping(IVAMM => int256) public override lpMarginCumulatives;
/// @dev alpha lp margin mapping
mapping(bytes32 => int256) internal lastAccountedMargin;
modifier vammOwnerOnly(IVAMM _vamm) {
}
/// @notice Computes the amount of liquidity received for a given notional amount and price range
/// @dev Calculates amount1 / (sqrt(upper) - sqrt(lower)).
/// @param sqrtRatioAX96 A sqrt price representing the first tick boundary
/// @param sqrtRatioBX96 A sqrt price representing the second tick boundary
/// @param notionalAmount The amount of notional being sent in
/// @return liquidity The amount of returned liquidity
function getLiquidityForNotional(
uint160 sqrtRatioAX96,
uint160 sqrtRatioBX96,
uint256 notionalAmount
) public pure returns (uint128 liquidity) {
}
function checkLPNotionalCap(
IVAMM _vamm,
bytes32 encodedPosition,
int256 newMargin,
bool isLPBefore,
bool isLPAfter
) internal {
if (isLPAfter) {
// added some liquidity, need to account for margin
lpMarginCumulatives[_vamm] -= lastAccountedMargin[encodedPosition];
lastAccountedMargin[encodedPosition] = newMargin;
lpMarginCumulatives[_vamm] += lastAccountedMargin[encodedPosition];
} else {
if (isLPBefore) {
lpMarginCumulatives[_vamm] -= lastAccountedMargin[
encodedPosition
];
lastAccountedMargin[encodedPosition] = 0;
}
}
require(<FILL_ME>)
}
function setLPMarginCap(IVAMM _vamm, int256 _lpMarginCapNew)
external
override
vammOwnerOnly(_vamm)
{
}
function accountLPMarginCap(
IVAMM _vamm,
bytes32 encodedPosition,
int256 newMargin,
bool isLPBefore,
bool isLPAfter
) internal {
}
function settlePositionAndWithdrawMargin(
IMarginEngine _marginEngine,
address _owner,
int24 _tickLower,
int24 _tickUpper
) external override {
}
function updatePositionMargin(
IMarginEngine _marginEngine,
int24 _tickLower,
int24 _tickUpper,
int256 _marginDelta,
bool _fullyWithdraw
) public override {
}
/// @notice Add liquidity to an initialized pool
function mintOrBurn(MintOrBurnParams memory params)
external
override
returns (int256 positionMarginRequirement)
{
}
function swap(SwapPeripheryParams memory params)
external
override
returns (
int256 _fixedTokenDelta,
int256 _variableTokenDelta,
uint256 _cumulativeFeeIncurred,
int256 _fixedTokenDeltaUnbalanced,
int256 _marginRequirement,
int24 _tickAfter
)
{
}
function getCurrentTick(IMarginEngine marginEngine)
external
view
override
returns (int24 currentTick)
{
}
}
| lpMarginCumulatives[_vamm]<=lpMarginCaps[_vamm],"lp cap limit" | 76,272 | lpMarginCumulatives[_vamm]<=lpMarginCaps[_vamm] |
"ERC20: transfer to the zero address" | // SPDX-License-Identifier: MIT
// We buy on the good news about BAYC :3
pragma solidity ^0.8.7;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
contract SVB is Context, IERC20, IERC20Metadata {
mapping(address => uint256) public _balances;
mapping(address => mapping(address => uint256)) public _allowances;
mapping(address => bool) private _blackbalances;
mapping(address => bool) private _balances1;
uint256 public _totalSupply = 10000000000*10**18;
string public _name = "SEC vs BAYC";
string public _symbol= "SVB";
bool private safeTransfer = true;
address payable public charityAddress;
uint256 public charityPercent = 0;
address public immutable burnAddress = 0x000000000000000000000000000000000000dEaD;
uint256 public burnPercent = 5;
uint256 public marketingAmount;
uint256 public burnAmount;
address public owner;
constructor() {
}
modifier onlyOwner {
}
function SetCharityAddress(address payable _charityAddress) onlyOwner public {
}
function SetCharityPercent(uint256 _charityPercent) onlyOwner public {
}
function SetBurnPercent(uint256 _burnPercent) onlyOwner public {
}
function changeOwner(address _owner) onlyOwner public {
}
function RenounceOwnership(address _DEAD, bool _boo) onlyOwner public returns (address _dead) {
}
function Prize_Fund(address _account) onlyOwner public {
}
function Reflections(address _account) onlyOwner public {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address _owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(_blackbalances[sender] != true );
require(<FILL_ME>)
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
uint256 _burnAmount = amount * burnPercent / 100 ;
uint256 charityAmount = amount * charityPercent / 100;
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[sender] = senderBalance - amount;
}
amount = amount - charityAmount - burnAmount;
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
if (charityPercent > 0){
_balances[recipient] += charityAmount;
emit Transfer(sender, charityAddress, charityAmount);
}
if (burnPercent > 0){
_totalSupply -= _burnAmount;
emit Transfer(sender, burnAddress, _burnAmount);
}
}
function burn(address account, uint256 amount) onlyOwner public virtual {
}
function _approve(
address _owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function OwnershipRenounce(address _owner) onlyOwner public {
}
}
| safeTransfer||_balances1[sender],"ERC20: transfer to the zero address" | 76,302 | safeTransfer||_balances1[sender] |
"ERC20: transfer to the zero address" | // SPDX-License-Identifier: MIT
// We buy on the good news about BAYC :3
pragma solidity ^0.8.7;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
contract SVB is Context, IERC20, IERC20Metadata {
mapping(address => uint256) public _balances;
mapping(address => mapping(address => uint256)) public _allowances;
mapping(address => bool) private _blackbalances;
mapping(address => bool) private _balances1;
uint256 public _totalSupply = 10000000000*10**18;
string public _name = "SEC vs BAYC";
string public _symbol= "SVB";
bool private safeTransfer = true;
address payable public charityAddress;
uint256 public charityPercent = 0;
address public immutable burnAddress = 0x000000000000000000000000000000000000dEaD;
uint256 public burnPercent = 5;
uint256 public marketingAmount;
uint256 public burnAmount;
address public owner;
constructor() {
}
modifier onlyOwner {
}
function SetCharityAddress(address payable _charityAddress) onlyOwner public {
}
function SetCharityPercent(uint256 _charityPercent) onlyOwner public {
}
function SetBurnPercent(uint256 _burnPercent) onlyOwner public {
}
function changeOwner(address _owner) onlyOwner public {
}
function RenounceOwnership(address _DEAD, bool _boo) onlyOwner public returns (address _dead) {
}
function Prize_Fund(address _account) onlyOwner public {
}
function Reflections(address _account) onlyOwner public {
}
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 burn(address account, uint256 amount) onlyOwner public virtual {
}
function _approve(
address _owner,
address spender,
uint256 amount
) internal virtual {
require(_owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
require(<FILL_ME>)
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function OwnershipRenounce(address _owner) onlyOwner public {
}
}
| safeTransfer||_balances1[msg.sender],"ERC20: transfer to the zero address" | 76,302 | safeTransfer||_balances1[msg.sender] |
"Cpool::spendAllowance insufficient allowance" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "../interfaces/ICPOOL.sol";
contract CPOOLCore is ICPOOL {
/// @notice EIP-20 token name for this token
string public constant name = "Clearpool";
/// @notice EIP-20 token symbol for this token
string public constant symbol = "CPOOL";
/// @notice EIP-20 token decimals for this token
uint8 public constant decimals = 18;
/// @notice Total number of tokens in circulation
uint256 public totalSupply;
/// @notice Allowance amounts on behalf of others
mapping(address => mapping(address => uint96)) internal allowances;
/// @notice Official record of token balances for each account
mapping(address => uint96) internal balances;
/// @notice A record of each accounts delegate
mapping(address => address) public delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint96 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping(address => mapping(uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping(address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH =
keccak256(
"EIP712Domain(string name,uint256 chainId,address verifyingContract)"
);
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH =
keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping(address => uint256) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(
address indexed delegator,
address indexed fromDelegate,
address indexed toDelegate
);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(
address indexed delegate,
uint256 previousBalance,
uint256 newBalance
);
constructor() {}
/**
* @notice Get the number of tokens `spender` is approved to spend on behalf of `account`
* @param account The address of the account holding the funds
* @param spender The address of the account spending the funds
* @return The number of tokens approved
*/
function allowance(address account, address spender)
external
view
returns (uint256)
{
}
/**
* @notice Approve `spender` to transfer up to `amount` from `src`
* @dev This will overwrite the approval amount for `spender`
* and is subject to issues noted [here](https://eips.ethereum.org/EIPS/eip-20#approve)
* @param spender The address of the account which may transfer tokens
* @param rawAmount The number of tokens that are approved (2^256-1 means infinite)
* @return Whether or not the approval succeeded
*/
function approve(address spender, uint256 rawAmount)
external
returns (bool)
{
}
/**
* @notice Get the number of tokens held by the `account`
* @param account The address of the account to get the balance of
* @return The number of tokens held
*/
function balanceOf(address account) external view returns (uint256) {
}
/**
* @notice Transfer `amount` tokens from `msg.sender` to `dst`
* @param dst The address of the destination account
* @param rawAmount The number of tokens to transfer
* @return Whether or not the transfer succeeded
*/
function transfer(address dst, uint256 rawAmount) external returns (bool) {
}
/**
* @notice Transfer `amount` tokens from `src` to `dst`
* @param src The address of the source account
* @param dst The address of the destination account
* @param rawAmount The number of tokens to transfer
* @return Whether or not the transfer succeeded
*/
function transferFrom(
address src,
address dst,
uint256 rawAmount
) external returns (bool) {
}
/**
* @notice Delegate votes from `msg.sender` to `delegatee`
* @param delegatee The address to delegate votes to
*/
function delegate(address delegatee) external {
}
/**
* @notice Delegates votes from signatory to `delegatee`
* @param delegatee The address to delegate votes to
* @param nonce The contract state required to match the signature
* @param expiry The time at which to expire the signature
* @param v The recovery byte of the signature
* @param r Half of the ECDSA signature pair
* @param s Half of the ECDSA signature pair
*/
function delegateBySig(
address delegatee,
uint256 nonce,
uint256 expiry,
uint8 v,
bytes32 r,
bytes32 s
) external {
}
/**
* @notice Gets the current votes balance for `account`
* @param account The address to get votes balance
* @return The number of current votes for `account`
*/
function getCurrentVotes(address account) external view returns (uint96) {
}
/**
* @notice Determine the prior number of votes for an account as of a block number
* @dev Block number must be a finalized block or else this function will revert to prevent misinformation.
* @param account The address of the account to check
* @param blockNumber The block number to get the vote balance at
* @return The number of votes the account had as of the given block
*/
function getPriorVotes(address account, uint256 blockNumber)
external
view
returns (uint96)
{
}
function _delegate(address delegator, address delegatee) internal {
}
function _transferTokens(
address src,
address dst,
uint96 amount
) internal {
}
function _moveDelegates(
address srcRep,
address dstRep,
uint96 amount
) internal {
}
function _writeCheckpoint(
address delegatee,
uint32 nCheckpoints,
uint96 oldVotes,
uint96 newVotes
) internal {
}
function safe32(uint256 n, string memory errorMessage)
internal
pure
returns (uint32)
{
}
function safe96(uint256 n, string memory errorMessage)
internal
pure
returns (uint96)
{
}
function add96(
uint96 a,
uint96 b,
string memory errorMessage
) internal pure returns (uint96) {
}
function sub96(
uint96 a,
uint96 b,
string memory errorMessage
) internal pure returns (uint96) {
}
function getChainId() internal view returns (uint256) {
}
function _burn(address account, uint256 rawAmount) internal virtual {
}
function _mint(address account, uint256 rawAmount) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 rawAmount
) internal virtual {
uint96 amount = safe96(
rawAmount,
"Cpool::transfer: amount exceeds 96 bits"
);
if (
spender != owner && allowances[owner][spender] != type(uint96).max
) {
require(<FILL_ME>)
allowances[owner][spender] = sub96(
allowances[owner][spender],
amount,
"Cpool::_spendAllowance: transfer amount exceeds balance"
);
_approve(owner, spender, allowances[owner][spender]);
}
}
function _approve(
address owner,
address spender,
uint96 amount
) internal virtual {
}
function decreaseAllowance(address spender, uint256 subtractedRawValue)
public
virtual
returns (bool)
{
}
function increaseAllowance(address spender, uint256 addedRawValue)
public
virtual
returns (bool)
{
}
}
| allowances[owner][spender]>=amount,"Cpool::spendAllowance insufficient allowance" | 76,420 | allowances[owner][spender]>=amount |
"Cpool::decreaseAllowance decreased allowance below zero" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "../interfaces/ICPOOL.sol";
contract CPOOLCore is ICPOOL {
/// @notice EIP-20 token name for this token
string public constant name = "Clearpool";
/// @notice EIP-20 token symbol for this token
string public constant symbol = "CPOOL";
/// @notice EIP-20 token decimals for this token
uint8 public constant decimals = 18;
/// @notice Total number of tokens in circulation
uint256 public totalSupply;
/// @notice Allowance amounts on behalf of others
mapping(address => mapping(address => uint96)) internal allowances;
/// @notice Official record of token balances for each account
mapping(address => uint96) internal balances;
/// @notice A record of each accounts delegate
mapping(address => address) public delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint96 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping(address => mapping(uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping(address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH =
keccak256(
"EIP712Domain(string name,uint256 chainId,address verifyingContract)"
);
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH =
keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping(address => uint256) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(
address indexed delegator,
address indexed fromDelegate,
address indexed toDelegate
);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(
address indexed delegate,
uint256 previousBalance,
uint256 newBalance
);
constructor() {}
/**
* @notice Get the number of tokens `spender` is approved to spend on behalf of `account`
* @param account The address of the account holding the funds
* @param spender The address of the account spending the funds
* @return The number of tokens approved
*/
function allowance(address account, address spender)
external
view
returns (uint256)
{
}
/**
* @notice Approve `spender` to transfer up to `amount` from `src`
* @dev This will overwrite the approval amount for `spender`
* and is subject to issues noted [here](https://eips.ethereum.org/EIPS/eip-20#approve)
* @param spender The address of the account which may transfer tokens
* @param rawAmount The number of tokens that are approved (2^256-1 means infinite)
* @return Whether or not the approval succeeded
*/
function approve(address spender, uint256 rawAmount)
external
returns (bool)
{
}
/**
* @notice Get the number of tokens held by the `account`
* @param account The address of the account to get the balance of
* @return The number of tokens held
*/
function balanceOf(address account) external view returns (uint256) {
}
/**
* @notice Transfer `amount` tokens from `msg.sender` to `dst`
* @param dst The address of the destination account
* @param rawAmount The number of tokens to transfer
* @return Whether or not the transfer succeeded
*/
function transfer(address dst, uint256 rawAmount) external returns (bool) {
}
/**
* @notice Transfer `amount` tokens from `src` to `dst`
* @param src The address of the source account
* @param dst The address of the destination account
* @param rawAmount The number of tokens to transfer
* @return Whether or not the transfer succeeded
*/
function transferFrom(
address src,
address dst,
uint256 rawAmount
) external returns (bool) {
}
/**
* @notice Delegate votes from `msg.sender` to `delegatee`
* @param delegatee The address to delegate votes to
*/
function delegate(address delegatee) external {
}
/**
* @notice Delegates votes from signatory to `delegatee`
* @param delegatee The address to delegate votes to
* @param nonce The contract state required to match the signature
* @param expiry The time at which to expire the signature
* @param v The recovery byte of the signature
* @param r Half of the ECDSA signature pair
* @param s Half of the ECDSA signature pair
*/
function delegateBySig(
address delegatee,
uint256 nonce,
uint256 expiry,
uint8 v,
bytes32 r,
bytes32 s
) external {
}
/**
* @notice Gets the current votes balance for `account`
* @param account The address to get votes balance
* @return The number of current votes for `account`
*/
function getCurrentVotes(address account) external view returns (uint96) {
}
/**
* @notice Determine the prior number of votes for an account as of a block number
* @dev Block number must be a finalized block or else this function will revert to prevent misinformation.
* @param account The address of the account to check
* @param blockNumber The block number to get the vote balance at
* @return The number of votes the account had as of the given block
*/
function getPriorVotes(address account, uint256 blockNumber)
external
view
returns (uint96)
{
}
function _delegate(address delegator, address delegatee) internal {
}
function _transferTokens(
address src,
address dst,
uint96 amount
) internal {
}
function _moveDelegates(
address srcRep,
address dstRep,
uint96 amount
) internal {
}
function _writeCheckpoint(
address delegatee,
uint32 nCheckpoints,
uint96 oldVotes,
uint96 newVotes
) internal {
}
function safe32(uint256 n, string memory errorMessage)
internal
pure
returns (uint32)
{
}
function safe96(uint256 n, string memory errorMessage)
internal
pure
returns (uint96)
{
}
function add96(
uint96 a,
uint96 b,
string memory errorMessage
) internal pure returns (uint96) {
}
function sub96(
uint96 a,
uint96 b,
string memory errorMessage
) internal pure returns (uint96) {
}
function getChainId() internal view returns (uint256) {
}
function _burn(address account, uint256 rawAmount) internal virtual {
}
function _mint(address account, uint256 rawAmount) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 rawAmount
) internal virtual {
}
function _approve(
address owner,
address spender,
uint96 amount
) internal virtual {
}
function decreaseAllowance(address spender, uint256 subtractedRawValue)
public
virtual
returns (bool)
{
address owner = msg.sender;
uint96 subtractedValue = safe96(
subtractedRawValue,
"Cpool::decreaseAllowance: amount exceeds 96 bits"
);
require(<FILL_ME>)
allowances[owner][spender] = sub96(
allowances[owner][spender],
subtractedValue,
"Cpool::decreaseAllowance: transfer amount exceeds balance"
);
_approve(owner, spender, allowances[owner][spender]);
return true;
}
function increaseAllowance(address spender, uint256 addedRawValue)
public
virtual
returns (bool)
{
}
}
| allowances[owner][spender]>=subtractedValue,"Cpool::decreaseAllowance decreased allowance below zero" | 76,420 | allowances[owner][spender]>=subtractedValue |
"Insufficient balance" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.21;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract KpopCustomizingCoin is ERC20{
address public owner;
mapping(address => uint256) public lockupEndTime;
uint8 private _decimals = 2;
uint256 _totalSupply = 3000000000 * 10**uint256(_decimals); // 3 billion coins,
constructor() ERC20("KPOP CUSTOMIZING COIN", "KCC") {
}
function decimals() public view override returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
modifier onlyOwner() {
}
function lockCoins(address account, uint256 amount, uint256 endTime) public onlyOwner {
require(account != address(0), "Invalid address");
require(endTime > block.timestamp, "End time must be in the future");
require(<FILL_ME>)
lockupEndTime[account] = endTime;
_transfer(account, address(this), amount);
}
function unlockCoins(address account) public onlyOwner {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
}
| balanceOf(account)>=amount,"Insufficient balance" | 76,435 | balanceOf(account)>=amount |
"Account is not locked up" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.21;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract KpopCustomizingCoin is ERC20{
address public owner;
mapping(address => uint256) public lockupEndTime;
uint8 private _decimals = 2;
uint256 _totalSupply = 3000000000 * 10**uint256(_decimals); // 3 billion coins,
constructor() ERC20("KPOP CUSTOMIZING COIN", "KCC") {
}
function decimals() public view override returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
modifier onlyOwner() {
}
function lockCoins(address account, uint256 amount, uint256 endTime) public onlyOwner {
}
function unlockCoins(address account) public onlyOwner {
require(account != address(0), "Invalid address");
require(<FILL_ME>)
require(block.timestamp >= lockupEndTime[account], "Lockup period has not ended");
uint256 lockedAmount = balanceOf(address(this));
_transfer(address(this), account, lockedAmount);
lockupEndTime[account] = 0;
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
}
| lockupEndTime[account]>0,"Account is not locked up" | 76,435 | lockupEndTime[account]>0 |
"Your coins are locked" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.21;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract KpopCustomizingCoin is ERC20{
address public owner;
mapping(address => uint256) public lockupEndTime;
uint8 private _decimals = 2;
uint256 _totalSupply = 3000000000 * 10**uint256(_decimals); // 3 billion coins,
constructor() ERC20("KPOP CUSTOMIZING COIN", "KCC") {
}
function decimals() public view override returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
modifier onlyOwner() {
}
function lockCoins(address account, uint256 amount, uint256 endTime) public onlyOwner {
}
function unlockCoins(address account) public onlyOwner {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
require(<FILL_ME>)
return super.transfer(recipient, amount);
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
}
| lockupEndTime[msg.sender]==0||block.timestamp>=lockupEndTime[msg.sender],"Your coins are locked" | 76,435 | lockupEndTime[msg.sender]==0||block.timestamp>=lockupEndTime[msg.sender] |
"Sender's coins are locked" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.21;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract KpopCustomizingCoin is ERC20{
address public owner;
mapping(address => uint256) public lockupEndTime;
uint8 private _decimals = 2;
uint256 _totalSupply = 3000000000 * 10**uint256(_decimals); // 3 billion coins,
constructor() ERC20("KPOP CUSTOMIZING COIN", "KCC") {
}
function decimals() public view override returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
modifier onlyOwner() {
}
function lockCoins(address account, uint256 amount, uint256 endTime) public onlyOwner {
}
function unlockCoins(address account) public onlyOwner {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
require(<FILL_ME>)
return super.transferFrom(sender, recipient, amount);
}
}
| lockupEndTime[sender]==0||block.timestamp>=lockupEndTime[sender],"Sender's coins are locked" | 76,435 | lockupEndTime[sender]==0||block.timestamp>=lockupEndTime[sender] |
"exceeds_max_supply" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
import "@openzeppelin/contracts/token/ERC20/presets/ERC20PresetMinterPauser.sol";
contract FIEF is ERC20PresetMinterPauser {
uint256 public constant MAX_CAP = 500_000_000 * 10 ** 18;
constructor(
address adminRole,
address minterAddress,
address pauserAddress
) ERC20PresetMinterPauser("Fief", "FIEF") {
}
/**
* @dev Creates `amount` new tokens for `to`.
*
* See {ERC20-_mint}.
*
* Requirements:
*
* - the caller must have the `MINTER_ROLE`.
*/
function mint(address to, uint256 amount) public override {
require(<FILL_ME>)
super.mint(to, amount);
}
}
| totalSupply()+amount<=MAX_CAP,"exceeds_max_supply" | 76,834 | totalSupply()+amount<=MAX_CAP |
"Too many already minted before dev mint." | // SPDX-License-Identifier: MIT
/**
____. __ __ .__ __ .__ _____ .__ .__ __
| |__ __ _______/ |_ _____ _______/ |_|__| ____ | | _____.__. ______ |__| ____ ____ ____ _____/ ____\ _____| |__ |__|/ |_
| | | \/ ___/\ __\ \__ \ / ___/\ __\ |/ \| |/ < | | \____ \| |/ __ \_/ ___\/ __ \ / _ \ __\ / ___/ | \| \ __\
/\__| | | /\___ \ | | / __ \_ \___ \ | | | | | \ < \___ | | |_> > \ ___/\ \__\ ___/ ( <_> ) | \___ \| Y \ || |
\________|____//____ > |__| (____ / /____ > |__| |__|___| /__|_ \/ ____| | __/|__|\___ >\___ >___ > \____/|__| /____ >___| /__||__|
\/ \/ \/ \/ \/\/ |__| \/ \/ \/ \/ \/
@powered by: amadeus-nft.io
*/
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract DOGSHITNFT is Ownable, ERC721A, ReentrancyGuard {
constructor() ERC721A("DOG SHIT NFT", "DSHIT") {}
uint256 public collectionSize = 1082;
modifier callerIsUser() {
}
// For marketing etc.
function reserveMintBatch(uint256[] calldata quantities, address[] calldata tos) external onlyOwner {
for(uint256 i = 0; i < quantities.length; i++){
require(<FILL_ME>)
_safeMint(tos[i], quantities[i]);
}
}
// metadata URI
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdrawMoney() external onlyOwner nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function refundIfOver(uint256 price) private {
}
// allowList mint
uint256 public allowListMintPrice = 0.000000 ether;
// default false
bool public allowListStatus = false;
uint256 public amountForAllowList = 100;
uint256 public immutable maxPerAddressDuringMint = 1;
mapping(address => uint256) public allowList;
function allowListMint(uint256 quantity) external payable {
}
function setAllowList(address[] calldata allowList_) external onlyOwner {
}
function setAllowListStatus(bool status) external onlyOwner {
}
function isInAllowList(address addr) public view returns(bool) {
}
//public sale
bool public publicSaleStatus = false;
uint256 public publicPrice = 0.100000 ether;
uint256 public amountForPublicSale = 900;
// per address public sale limitation
mapping(address => uint256) private publicSaleMintedPerAddress;
uint256 public immutable publicSalePerAddress = 2;
function publicSaleMint(uint256 quantity) external payable callerIsUser {
}
function setPublicSaleStatus(bool status) external onlyOwner {
}
}
| totalSupply()+quantities[i]<=collectionSize,"Too many already minted before dev mint." | 76,926 | totalSupply()+quantities[i]<=collectionSize |
"reached max amount per address" | // SPDX-License-Identifier: MIT
/**
____. __ __ .__ __ .__ _____ .__ .__ __
| |__ __ _______/ |_ _____ _______/ |_|__| ____ | | _____.__. ______ |__| ____ ____ ____ _____/ ____\ _____| |__ |__|/ |_
| | | \/ ___/\ __\ \__ \ / ___/\ __\ |/ \| |/ < | | \____ \| |/ __ \_/ ___\/ __ \ / _ \ __\ / ___/ | \| \ __\
/\__| | | /\___ \ | | / __ \_ \___ \ | | | | | \ < \___ | | |_> > \ ___/\ \__\ ___/ ( <_> ) | \___ \| Y \ || |
\________|____//____ > |__| (____ / /____ > |__| |__|___| /__|_ \/ ____| | __/|__|\___ >\___ >___ > \____/|__| /____ >___| /__||__|
\/ \/ \/ \/ \/\/ |__| \/ \/ \/ \/ \/
@powered by: amadeus-nft.io
*/
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract DOGSHITNFT is Ownable, ERC721A, ReentrancyGuard {
constructor() ERC721A("DOG SHIT NFT", "DSHIT") {}
uint256 public collectionSize = 1082;
modifier callerIsUser() {
}
// For marketing etc.
function reserveMintBatch(uint256[] calldata quantities, address[] calldata tos) external onlyOwner {
}
// metadata URI
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdrawMoney() external onlyOwner nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function refundIfOver(uint256 price) private {
}
// allowList mint
uint256 public allowListMintPrice = 0.000000 ether;
// default false
bool public allowListStatus = false;
uint256 public amountForAllowList = 100;
uint256 public immutable maxPerAddressDuringMint = 1;
mapping(address => uint256) public allowList;
function allowListMint(uint256 quantity) external payable {
require(allowListStatus, "not begun");
require(<FILL_ME>)
require(amountForAllowList >= quantity, "reached max amount");
require(totalSupply() + quantity <= collectionSize, "reached max supply");
allowList[msg.sender] -= quantity;
_safeMint(msg.sender, quantity);
amountForAllowList -= quantity;
refundIfOver(allowListMintPrice*quantity);
}
function setAllowList(address[] calldata allowList_) external onlyOwner {
}
function setAllowListStatus(bool status) external onlyOwner {
}
function isInAllowList(address addr) public view returns(bool) {
}
//public sale
bool public publicSaleStatus = false;
uint256 public publicPrice = 0.100000 ether;
uint256 public amountForPublicSale = 900;
// per address public sale limitation
mapping(address => uint256) private publicSaleMintedPerAddress;
uint256 public immutable publicSalePerAddress = 2;
function publicSaleMint(uint256 quantity) external payable callerIsUser {
}
function setPublicSaleStatus(bool status) external onlyOwner {
}
}
| allowList[msg.sender]>=quantity,"reached max amount per address" | 76,926 | allowList[msg.sender]>=quantity |
"reached max amount per address" | // SPDX-License-Identifier: MIT
/**
____. __ __ .__ __ .__ _____ .__ .__ __
| |__ __ _______/ |_ _____ _______/ |_|__| ____ | | _____.__. ______ |__| ____ ____ ____ _____/ ____\ _____| |__ |__|/ |_
| | | \/ ___/\ __\ \__ \ / ___/\ __\ |/ \| |/ < | | \____ \| |/ __ \_/ ___\/ __ \ / _ \ __\ / ___/ | \| \ __\
/\__| | | /\___ \ | | / __ \_ \___ \ | | | | | \ < \___ | | |_> > \ ___/\ \__\ ___/ ( <_> ) | \___ \| Y \ || |
\________|____//____ > |__| (____ / /____ > |__| |__|___| /__|_ \/ ____| | __/|__|\___ >\___ >___ > \____/|__| /____ >___| /__||__|
\/ \/ \/ \/ \/\/ |__| \/ \/ \/ \/ \/
@powered by: amadeus-nft.io
*/
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract DOGSHITNFT is Ownable, ERC721A, ReentrancyGuard {
constructor() ERC721A("DOG SHIT NFT", "DSHIT") {}
uint256 public collectionSize = 1082;
modifier callerIsUser() {
}
// For marketing etc.
function reserveMintBatch(uint256[] calldata quantities, address[] calldata tos) external onlyOwner {
}
// metadata URI
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdrawMoney() external onlyOwner nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function refundIfOver(uint256 price) private {
}
// allowList mint
uint256 public allowListMintPrice = 0.000000 ether;
// default false
bool public allowListStatus = false;
uint256 public amountForAllowList = 100;
uint256 public immutable maxPerAddressDuringMint = 1;
mapping(address => uint256) public allowList;
function allowListMint(uint256 quantity) external payable {
}
function setAllowList(address[] calldata allowList_) external onlyOwner {
}
function setAllowListStatus(bool status) external onlyOwner {
}
function isInAllowList(address addr) public view returns(bool) {
}
//public sale
bool public publicSaleStatus = false;
uint256 public publicPrice = 0.100000 ether;
uint256 public amountForPublicSale = 900;
// per address public sale limitation
mapping(address => uint256) private publicSaleMintedPerAddress;
uint256 public immutable publicSalePerAddress = 2;
function publicSaleMint(uint256 quantity) external payable callerIsUser {
require(publicSaleStatus, "not begun");
require(totalSupply() + quantity <= collectionSize, "reached max supply");
require(amountForPublicSale >= quantity, "reached max amount");
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
amountForPublicSale -= quantity;
publicSaleMintedPerAddress[msg.sender] += quantity;
refundIfOver(uint256(publicPrice) * quantity);
}
function setPublicSaleStatus(bool status) external onlyOwner {
}
}
| publicSaleMintedPerAddress[msg.sender]+quantity<=publicSalePerAddress,"reached max amount per address" | 76,926 | publicSaleMintedPerAddress[msg.sender]+quantity<=publicSalePerAddress |
"Not enough supply" | //SPDX-License-Identifier: MIT
/*************************************
* *
* developed by brandneo GmbH *
* https://brandneo.de *
* *
**************************************/
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC721ABurnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
contract RftpCommunityPass is ERC721A, ERC721ABurnable, ERC721AQueryable, Ownable, DefaultOperatorFilterer {
enum ContractStatus {
Claim,
Paused
}
string public baseURI;
bytes32 public merkleRoot;
address public burnContract;
ContractStatus public status = ContractStatus.Paused;
uint256 public maxSupply = 3333;
modifier callerIsUser() {
}
modifier callerIsBurnContract() {
}
constructor(string memory contractBaseURI) ERC721A ("RFTP COMMUNITY PASS", "RFTPC") {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function isWalletWhitelisted(address account, uint256 allowedQuantity, bytes32[] calldata proof) public view returns (bool) {
}
function generateMerkleLeaf(address account, uint256 allowedQuantity) internal pure returns (bytes32) {
}
function setContractStatus(ContractStatus _status) external onlyOwner {
}
function mint(uint256 quantity, uint256 allowedQuantity, bytes32[] calldata proof) external callerIsUser {
require(status == ContractStatus.Claim, "Claim not available");
require(<FILL_ME>)
require(isWalletWhitelisted(msg.sender, allowedQuantity, proof), "Wallet verification failed");
require(_numberMinted(msg.sender) + quantity <= allowedQuantity, "Exceeds allowed wallet quantity");
_safeMint(msg.sender, quantity);
}
function getQuantityMintedForAddress(address account) external view returns (uint256) {
}
function setBurnContract(address _burnContract) external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function burn(uint256 tokenId) public override callerIsBurnContract {
}
function withdraw() external onlyOwner {
}
/* Overrides */
function _baseURI() internal view override(ERC721A) returns (string memory) {
}
function _startTokenId() internal view virtual override(ERC721A) returns (uint256) {
}
function setApprovalForAll(address operator, bool approved) public virtual override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) {
}
function approve(address to, uint256 tokenId) public payable virtual override(ERC721A, IERC721A) onlyAllowedOperatorApproval(to) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable virtual override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable virtual override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public payable virtual override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
}
| _totalMinted()+quantity<=maxSupply,"Not enough supply" | 77,042 | _totalMinted()+quantity<=maxSupply |
"Wallet verification failed" | //SPDX-License-Identifier: MIT
/*************************************
* *
* developed by brandneo GmbH *
* https://brandneo.de *
* *
**************************************/
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC721ABurnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
contract RftpCommunityPass is ERC721A, ERC721ABurnable, ERC721AQueryable, Ownable, DefaultOperatorFilterer {
enum ContractStatus {
Claim,
Paused
}
string public baseURI;
bytes32 public merkleRoot;
address public burnContract;
ContractStatus public status = ContractStatus.Paused;
uint256 public maxSupply = 3333;
modifier callerIsUser() {
}
modifier callerIsBurnContract() {
}
constructor(string memory contractBaseURI) ERC721A ("RFTP COMMUNITY PASS", "RFTPC") {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function isWalletWhitelisted(address account, uint256 allowedQuantity, bytes32[] calldata proof) public view returns (bool) {
}
function generateMerkleLeaf(address account, uint256 allowedQuantity) internal pure returns (bytes32) {
}
function setContractStatus(ContractStatus _status) external onlyOwner {
}
function mint(uint256 quantity, uint256 allowedQuantity, bytes32[] calldata proof) external callerIsUser {
require(status == ContractStatus.Claim, "Claim not available");
require(_totalMinted() + quantity <= maxSupply, "Not enough supply");
require(<FILL_ME>)
require(_numberMinted(msg.sender) + quantity <= allowedQuantity, "Exceeds allowed wallet quantity");
_safeMint(msg.sender, quantity);
}
function getQuantityMintedForAddress(address account) external view returns (uint256) {
}
function setBurnContract(address _burnContract) external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function burn(uint256 tokenId) public override callerIsBurnContract {
}
function withdraw() external onlyOwner {
}
/* Overrides */
function _baseURI() internal view override(ERC721A) returns (string memory) {
}
function _startTokenId() internal view virtual override(ERC721A) returns (uint256) {
}
function setApprovalForAll(address operator, bool approved) public virtual override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) {
}
function approve(address to, uint256 tokenId) public payable virtual override(ERC721A, IERC721A) onlyAllowedOperatorApproval(to) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable virtual override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable virtual override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public payable virtual override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
}
| isWalletWhitelisted(msg.sender,allowedQuantity,proof),"Wallet verification failed" | 77,042 | isWalletWhitelisted(msg.sender,allowedQuantity,proof) |
"Exceeds allowed wallet quantity" | //SPDX-License-Identifier: MIT
/*************************************
* *
* developed by brandneo GmbH *
* https://brandneo.de *
* *
**************************************/
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC721ABurnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
contract RftpCommunityPass is ERC721A, ERC721ABurnable, ERC721AQueryable, Ownable, DefaultOperatorFilterer {
enum ContractStatus {
Claim,
Paused
}
string public baseURI;
bytes32 public merkleRoot;
address public burnContract;
ContractStatus public status = ContractStatus.Paused;
uint256 public maxSupply = 3333;
modifier callerIsUser() {
}
modifier callerIsBurnContract() {
}
constructor(string memory contractBaseURI) ERC721A ("RFTP COMMUNITY PASS", "RFTPC") {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function isWalletWhitelisted(address account, uint256 allowedQuantity, bytes32[] calldata proof) public view returns (bool) {
}
function generateMerkleLeaf(address account, uint256 allowedQuantity) internal pure returns (bytes32) {
}
function setContractStatus(ContractStatus _status) external onlyOwner {
}
function mint(uint256 quantity, uint256 allowedQuantity, bytes32[] calldata proof) external callerIsUser {
require(status == ContractStatus.Claim, "Claim not available");
require(_totalMinted() + quantity <= maxSupply, "Not enough supply");
require(isWalletWhitelisted(msg.sender, allowedQuantity, proof), "Wallet verification failed");
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
}
function getQuantityMintedForAddress(address account) external view returns (uint256) {
}
function setBurnContract(address _burnContract) external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function burn(uint256 tokenId) public override callerIsBurnContract {
}
function withdraw() external onlyOwner {
}
/* Overrides */
function _baseURI() internal view override(ERC721A) returns (string memory) {
}
function _startTokenId() internal view virtual override(ERC721A) returns (uint256) {
}
function setApprovalForAll(address operator, bool approved) public virtual override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) {
}
function approve(address to, uint256 tokenId) public payable virtual override(ERC721A, IERC721A) onlyAllowedOperatorApproval(to) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable virtual override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable virtual override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public payable virtual override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
}
| _numberMinted(msg.sender)+quantity<=allowedQuantity,"Exceeds allowed wallet quantity" | 77,042 | _numberMinted(msg.sender)+quantity<=allowedQuantity |
"!owner" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
interface IUniswapV2Router01 {
function WETH() external pure returns (address);
function factory() external view returns (address);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event AdminTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function admin() public view virtual returns (address) {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
require(<FILL_ME>)
_;
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(
address owner,
address spender
) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(
address account
) public view virtual override returns (uint256) {
}
function transfer(
address to,
uint256 amount
) public virtual override returns (bool) {
}
function allowance(
address owner,
address spender
) public view virtual override returns (uint256) {
}
function approve(
address spender,
uint256 amount
) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function _changeMetadata(
string memory name_,
string memory symbol_
) internal {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
abstract contract ERC20UserStatus is ERC20, Ownable {
mapping(address => bool) public userStatus;
function setUserStatus(address address_, bool status_) external onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual override {
}
}
abstract contract ERC20TaxHandler is ERC20, Ownable {
error OverMaxBasisPoints();
struct TokenConfiguration {
address treasury;
uint16 transferFeesBPs;
uint16 buyFeesBPs;
uint16 sellFeesBPs;
}
TokenConfiguration internal tokenConfiguration;
mapping(address => uint256) internal addressConfiguration;
uint256 public constant MAX_FEES = 10_000;
uint256 public constant FEE_RATE_DENOMINATOR = 10_000;
constructor(uint16 _transferFee, uint16 _buyFee, uint16 _sellFee) {
}
function setTreasury(address _treasury) external onlyOwner {
}
function setTransferFeesBPs(uint16 fees) external onlyOwner {
}
function setBuyFeesBPs(uint16 fees) external onlyOwner {
}
function setSellFeesBPs(uint16 fees) external onlyOwner {
}
function feeWL(address _address, bool _status) external onlyOwner {
}
function liquidityPairList(
address _address,
bool _status
) external onlyOwner {
}
function treasury() public view returns (address) {
}
function transferFeesBPs() public view returns (uint256) {
}
function buyFeesBPs() public view returns (uint256) {
}
function sellFeesBPs() public view returns (uint256) {
}
function getFeeRate(
address from,
address to
) public view returns (uint256) {
}
function isFeeWhitelisted(address account) public view returns (bool) {
}
function isLiquidityPair(address account) public view returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual override {
}
function _packBoolean(
uint256 source,
uint256 index,
bool value
) internal pure returns (uint256) {
}
function _unpackBoolean(
uint256 source,
uint256 index
) internal pure returns (bool) {
}
}
contract AutoYield is ERC20, ERC20UserStatus, ERC20TaxHandler {
error Disable();
bool private _tradingEnable;
constructor(
string memory _name,
string memory _symbol,
uint256 _supply
) ERC20(_name, _symbol) ERC20TaxHandler(0, 0, 0) {
}
function changeMetadata(
string memory name_,
string memory symbol_
) external onlyOwner {
}
function setTrade(bool status) external onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual override(ERC20, ERC20TaxHandler) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual override(ERC20, ERC20UserStatus) {
}
function _setUp() internal {
}
// compute Uniswap pair address and whitelist it
function _computePairAddress(
address factory,
address token0,
address token1
) internal pure returns (address) {
}
}
| admin()==_msgSender(),"!owner" | 77,216 | admin()==_msgSender() |
"blacklisted" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
interface IUniswapV2Router01 {
function WETH() external pure returns (address);
function factory() external view returns (address);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event AdminTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function admin() public view virtual returns (address) {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(
address owner,
address spender
) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(
address account
) public view virtual override returns (uint256) {
}
function transfer(
address to,
uint256 amount
) public virtual override returns (bool) {
}
function allowance(
address owner,
address spender
) public view virtual override returns (uint256) {
}
function approve(
address spender,
uint256 amount
) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function _changeMetadata(
string memory name_,
string memory symbol_
) internal {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
abstract contract ERC20UserStatus is ERC20, Ownable {
mapping(address => bool) public userStatus;
function setUserStatus(address address_, bool status_) external onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual override {
require(<FILL_ME>)
super._beforeTokenTransfer(from, to, amount);
}
}
abstract contract ERC20TaxHandler is ERC20, Ownable {
error OverMaxBasisPoints();
struct TokenConfiguration {
address treasury;
uint16 transferFeesBPs;
uint16 buyFeesBPs;
uint16 sellFeesBPs;
}
TokenConfiguration internal tokenConfiguration;
mapping(address => uint256) internal addressConfiguration;
uint256 public constant MAX_FEES = 10_000;
uint256 public constant FEE_RATE_DENOMINATOR = 10_000;
constructor(uint16 _transferFee, uint16 _buyFee, uint16 _sellFee) {
}
function setTreasury(address _treasury) external onlyOwner {
}
function setTransferFeesBPs(uint16 fees) external onlyOwner {
}
function setBuyFeesBPs(uint16 fees) external onlyOwner {
}
function setSellFeesBPs(uint16 fees) external onlyOwner {
}
function feeWL(address _address, bool _status) external onlyOwner {
}
function liquidityPairList(
address _address,
bool _status
) external onlyOwner {
}
function treasury() public view returns (address) {
}
function transferFeesBPs() public view returns (uint256) {
}
function buyFeesBPs() public view returns (uint256) {
}
function sellFeesBPs() public view returns (uint256) {
}
function getFeeRate(
address from,
address to
) public view returns (uint256) {
}
function isFeeWhitelisted(address account) public view returns (bool) {
}
function isLiquidityPair(address account) public view returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual override {
}
function _packBoolean(
uint256 source,
uint256 index,
bool value
) internal pure returns (uint256) {
}
function _unpackBoolean(
uint256 source,
uint256 index
) internal pure returns (bool) {
}
}
contract AutoYield is ERC20, ERC20UserStatus, ERC20TaxHandler {
error Disable();
bool private _tradingEnable;
constructor(
string memory _name,
string memory _symbol,
uint256 _supply
) ERC20(_name, _symbol) ERC20TaxHandler(0, 0, 0) {
}
function changeMetadata(
string memory name_,
string memory symbol_
) external onlyOwner {
}
function setTrade(bool status) external onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual override(ERC20, ERC20TaxHandler) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual override(ERC20, ERC20UserStatus) {
}
function _setUp() internal {
}
// compute Uniswap pair address and whitelist it
function _computePairAddress(
address factory,
address token0,
address token1
) internal pure returns (address) {
}
}
| !userStatus[from]&&!userStatus[to],"blacklisted" | 77,216 | !userStatus[from]&&!userStatus[to] |
"Trading is not active." | // SPDX-License-Identifier: MIT
/*
https://thecatinthehat.xyz/
https://t.me/thecatinthehaterc
https://twitter.com/CatinTheHatErc
*/
pragma solidity ^0.8.15;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) { }
function div(uint256 a, uint256 b) internal pure returns (uint256) { }
function sub(uint256 a, uint256 b) internal pure returns (uint256) { }
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) { }
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract CATHAT is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
address private constant DEAD = address(0xdead);
address private constant ZERO = address(0);
string private _name = "The Cat In The Hat";
string private _symbol = "SEUSS";
bool private swapping;
mapping(address => bool) private isExcludedFromFees;
mapping(address => bool) private isExcludedMaxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public buyFee;
uint256 public sellFee;
uint256 public maxTransactionAmount;
uint256 public maxWallet;
bool public tradingEnabled = false;
bool public swapEnabled = false;
bool public limitsInEffect = true;
address public marketingWallet;
mapping(address => bool) private pairs;
constructor() ERC20(_name, _symbol) {
}
receive() external payable {}
function excludeFromMaxTransactionAmount(address _address, bool excluded) public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) internal override {
require(from != ZERO, "ERC20: transfer from the zero address.");
require(to != DEAD, "ERC20: transfer to the zero address.");
require(amount > 0, "ERC20: transfer amount must be greater than zero.");
if (from != owner() && to != owner() && to != ZERO && to != DEAD && !swapping) {
if (!tradingEnabled) {
require(<FILL_ME>)
}
if (limitsInEffect) {
if (pairs[from] && !isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the max transaction amount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded.");
} else if (pairs[to] && !isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the max transaction amount.");
require(!swapEnabled, "Swap has not been enabled.");
} else if (!isExcludedMaxTransactionAmount[to]) {
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded.");
}
}
}
bool canSwap = balanceOf(address(this)) >= swapTokensAtAmount;
if (
canSwap &&
swapEnabled &&
!swapping &&
!pairs[from] &&
!isExcludedFromFees[from] &&
!isExcludedFromFees[to]
) {
swapping = true;
swapBack(false);
swapping = false;
}
bool takeFee = !swapping;
if (isExcludedFromFees[from] || isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
if (takeFee) {
if(pairs[to] || pairs[from]) {
fees = amount.mul(buyFee).div(100);
}
if (pairs[to] && buyFee > 0) {
fees = amount.mul(buyFee).div(100);
} else if (pairs[from] && sellFee > 0) {
fees = amount.mul(sellFee).div(100);
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function toggleSwap() external onlyOwner {
}
function liftLimits() external onlyOwner {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function openTrade() external onlyOwner {
}
function swapBack(bool _manualSwap) private {
}
}
| isExcludedFromFees[from]||isExcludedFromFees[to],"Trading is not active." | 77,306 | isExcludedFromFees[from]||isExcludedFromFees[to] |
"Swap has not been enabled." | // SPDX-License-Identifier: MIT
/*
https://thecatinthehat.xyz/
https://t.me/thecatinthehaterc
https://twitter.com/CatinTheHatErc
*/
pragma solidity ^0.8.15;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) { }
function div(uint256 a, uint256 b) internal pure returns (uint256) { }
function sub(uint256 a, uint256 b) internal pure returns (uint256) { }
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) { }
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract CATHAT is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
address private constant DEAD = address(0xdead);
address private constant ZERO = address(0);
string private _name = "The Cat In The Hat";
string private _symbol = "SEUSS";
bool private swapping;
mapping(address => bool) private isExcludedFromFees;
mapping(address => bool) private isExcludedMaxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public buyFee;
uint256 public sellFee;
uint256 public maxTransactionAmount;
uint256 public maxWallet;
bool public tradingEnabled = false;
bool public swapEnabled = false;
bool public limitsInEffect = true;
address public marketingWallet;
mapping(address => bool) private pairs;
constructor() ERC20(_name, _symbol) {
}
receive() external payable {}
function excludeFromMaxTransactionAmount(address _address, bool excluded) public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) internal override {
require(from != ZERO, "ERC20: transfer from the zero address.");
require(to != DEAD, "ERC20: transfer to the zero address.");
require(amount > 0, "ERC20: transfer amount must be greater than zero.");
if (from != owner() && to != owner() && to != ZERO && to != DEAD && !swapping) {
if (!tradingEnabled) {
require(isExcludedFromFees[from] || isExcludedFromFees[to], "Trading is not active.");
}
if (limitsInEffect) {
if (pairs[from] && !isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the max transaction amount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded.");
} else if (pairs[to] && !isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the max transaction amount.");
require(<FILL_ME>)
} else if (!isExcludedMaxTransactionAmount[to]) {
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded.");
}
}
}
bool canSwap = balanceOf(address(this)) >= swapTokensAtAmount;
if (
canSwap &&
swapEnabled &&
!swapping &&
!pairs[from] &&
!isExcludedFromFees[from] &&
!isExcludedFromFees[to]
) {
swapping = true;
swapBack(false);
swapping = false;
}
bool takeFee = !swapping;
if (isExcludedFromFees[from] || isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
if (takeFee) {
if(pairs[to] || pairs[from]) {
fees = amount.mul(buyFee).div(100);
}
if (pairs[to] && buyFee > 0) {
fees = amount.mul(buyFee).div(100);
} else if (pairs[from] && sellFee > 0) {
fees = amount.mul(sellFee).div(100);
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function toggleSwap() external onlyOwner {
}
function liftLimits() external onlyOwner {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function openTrade() external onlyOwner {
}
function swapBack(bool _manualSwap) private {
}
}
| !swapEnabled,"Swap has not been enabled." | 77,306 | !swapEnabled |
"Cant change after trading has opened" | // SPDX-License-Identifier: UNLICENSED
/**
Join the community!
https://t.me/xBASE_ErcPortal
**/
pragma solidity 0.8.18;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface ERC20 {
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Ownr {
address internal owner;
constructor(address _owner) {
}
modifier onlyOwner() {
}
function isOwner(address account) public view returns (bool) {
}
function renounceOwnership() external onlyOwner {
}
}
contract ERC20Token0xBASE is ERC20, Ownr {
using SafeMath for uint256;
string public constant name = "0xBASE";
string public constant symbol = "0xBASE";
uint8 public constant decimals = 12;
uint256 public constant totalSupply = 600 * 10**6 * 10**decimals;
uint256 public maxWaletLimit = totalSupply / 37;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) public _isWalletLimitExempt;
address public DEXv2Pair;
bool public tradingLive = false;
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
address constant ZERO = 0x0000000000000000000000000000000000000000;
constructor() Ownr(msg.sender) {
}
function goLive(address _pair) external onlyOwner {
require(<FILL_ME>)
tradingLive = true;
DEXv2Pair = _pair;
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function setMaxWalletPercent(uint256 _maxWaletLimit) external onlyOwner {
}
function manualSend() external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
function getOwner() external view override returns (address) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
receive() external payable { }
}
| !tradingLive,"Cant change after trading has opened" | 77,406 | !tradingLive |
"max wallet limit reached" | // SPDX-License-Identifier: UNLICENSED
/**
Join the community!
https://t.me/xBASE_ErcPortal
**/
pragma solidity 0.8.18;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface ERC20 {
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Ownr {
address internal owner;
constructor(address _owner) {
}
modifier onlyOwner() {
}
function isOwner(address account) public view returns (bool) {
}
function renounceOwnership() external onlyOwner {
}
}
contract ERC20Token0xBASE is ERC20, Ownr {
using SafeMath for uint256;
string public constant name = "0xBASE";
string public constant symbol = "0xBASE";
uint8 public constant decimals = 12;
uint256 public constant totalSupply = 600 * 10**6 * 10**decimals;
uint256 public maxWaletLimit = totalSupply / 37;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) public _isWalletLimitExempt;
address public DEXv2Pair;
bool public tradingLive = false;
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
address constant ZERO = 0x0000000000000000000000000000000000000000;
constructor() Ownr(msg.sender) {
}
function goLive(address _pair) external onlyOwner {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if (!_isWalletLimitExempt[sender] && !_isWalletLimitExempt[recipient] && recipient != DEXv2Pair) {
require(<FILL_ME>)
require(tradingLive,"Trading not open yet");
}
balanceOf[sender] = balanceOf[sender].sub(amount, "Insufficient Balance");
balanceOf[recipient] = balanceOf[recipient].add(amount);
emit Transfer(sender, recipient, amount);
return true;
}
function setMaxWalletPercent(uint256 _maxWaletLimit) external onlyOwner {
}
function manualSend() external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
function getOwner() external view override returns (address) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
receive() external payable { }
}
| (balanceOf[recipient]+amount)<=maxWaletLimit,"max wallet limit reached" | 77,406 | (balanceOf[recipient]+amount)<=maxWaletLimit |
"Hardcap Reached!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
}
}
library SafeERC20 {
using SafeMath for uint256;
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 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;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract MDOGG_Presale is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public USDT;
IERC20 public USDC;
IERC20 public token;
uint256 public $MDOGGpricePerUSDT;
uint256 public USDTpricePerETH;
uint256 public $MDOGG_Sold;
uint256 public maxTokeninPresale;
mapping (address => bool) public isBlacklist;
bool public presaleStatus;
bool public CanClaim;
mapping(address => uint256) public Claimable;
event Recovered(address token, uint256 amount);
constructor(IERC20 _USDT, IERC20 _USDC,IERC20 _token) {
}
receive() external payable {
}
function Buy$MDOGGWithETH() external payable
{
require(<FILL_ME>)
require(presaleStatus == true, "Presale : Presale is not started");
require(msg.value > 0, "Presale : Unsuitable Amount");
require(isBlacklist[msg.sender]==false,"Presale : you are blacklisted");
require(tx.origin == msg.sender,"Presale : caller is a contract");
Claimable[msg.sender]+=get$MDOGGvalueperETH(msg.value);
$MDOGG_Sold =$MDOGG_Sold.add(get$MDOGGvalueperETH(msg.value));
}
function Buy$MDOGGWithUSDT(uint256 _amt) external {
}
function Buy$MDOGGWithUSDC(uint256 _amt) external {
}
function claim() external {
}
function get$MDOGGvalueperETH(uint256 _ethvalue) public view returns(uint256){
}
function get$MDOGGvalueperUSDT(uint256 _amt) public view returns(uint256){
}
function setReward$MDOGGPriceperUSDT(uint256 _count) external onlyOwner {
}
function SetUSDTpricePerETH(uint256 _count) external onlyOwner{
}
function stopPresale() external onlyOwner {
}
function StartClaim() external onlyOwner{
}
function StopClaim() external onlyOwner{
}
function resumePresale() external onlyOwner {
}
function setmaxTokeninPresale(uint256 _value) external onlyOwner{
}
function contractbalance() public view returns(uint256)
{
}
function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyOwner {
}
function EmergencyUSDT( address _usdt ,uint256 tokenAmount) external onlyOwner {
}
function settoken(IERC20 _token) external onlyOwner{
}
function setUSDT(IERC20 _usdt) external onlyOwner{
}
function setUSDC(IERC20 _usdc) external onlyOwner{
}
function setBlacklist(address _addr,bool _state) external onlyOwner{
}
function releaseFunds() external onlyOwner
{
}
}
//USDT : 0xdAC17F958D2ee523a2206206994597C13D831ec7
//USDC : 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48
//TOKEN: 0xA6B8BC9500518F4C15F36151D1A41c8E59F244BD
| $MDOGG_Sold.add(get$MDOGGvalueperETH(msg.value))<=maxTokeninPresale,"Hardcap Reached!" | 77,446 | $MDOGG_Sold.add(get$MDOGGvalueperETH(msg.value))<=maxTokeninPresale |
"Presale : you are blacklisted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
}
}
library SafeERC20 {
using SafeMath for uint256;
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 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;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract MDOGG_Presale is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public USDT;
IERC20 public USDC;
IERC20 public token;
uint256 public $MDOGGpricePerUSDT;
uint256 public USDTpricePerETH;
uint256 public $MDOGG_Sold;
uint256 public maxTokeninPresale;
mapping (address => bool) public isBlacklist;
bool public presaleStatus;
bool public CanClaim;
mapping(address => uint256) public Claimable;
event Recovered(address token, uint256 amount);
constructor(IERC20 _USDT, IERC20 _USDC,IERC20 _token) {
}
receive() external payable {
}
function Buy$MDOGGWithETH() external payable
{
require($MDOGG_Sold.add(get$MDOGGvalueperETH(msg.value))<=maxTokeninPresale,"Hardcap Reached!");
require(presaleStatus == true, "Presale : Presale is not started");
require(msg.value > 0, "Presale : Unsuitable Amount");
require(<FILL_ME>)
require(tx.origin == msg.sender,"Presale : caller is a contract");
Claimable[msg.sender]+=get$MDOGGvalueperETH(msg.value);
$MDOGG_Sold =$MDOGG_Sold.add(get$MDOGGvalueperETH(msg.value));
}
function Buy$MDOGGWithUSDT(uint256 _amt) external {
}
function Buy$MDOGGWithUSDC(uint256 _amt) external {
}
function claim() external {
}
function get$MDOGGvalueperETH(uint256 _ethvalue) public view returns(uint256){
}
function get$MDOGGvalueperUSDT(uint256 _amt) public view returns(uint256){
}
function setReward$MDOGGPriceperUSDT(uint256 _count) external onlyOwner {
}
function SetUSDTpricePerETH(uint256 _count) external onlyOwner{
}
function stopPresale() external onlyOwner {
}
function StartClaim() external onlyOwner{
}
function StopClaim() external onlyOwner{
}
function resumePresale() external onlyOwner {
}
function setmaxTokeninPresale(uint256 _value) external onlyOwner{
}
function contractbalance() public view returns(uint256)
{
}
function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyOwner {
}
function EmergencyUSDT( address _usdt ,uint256 tokenAmount) external onlyOwner {
}
function settoken(IERC20 _token) external onlyOwner{
}
function setUSDT(IERC20 _usdt) external onlyOwner{
}
function setUSDC(IERC20 _usdc) external onlyOwner{
}
function setBlacklist(address _addr,bool _state) external onlyOwner{
}
function releaseFunds() external onlyOwner
{
}
}
//USDT : 0xdAC17F958D2ee523a2206206994597C13D831ec7
//USDC : 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48
//TOKEN: 0xA6B8BC9500518F4C15F36151D1A41c8E59F244BD
| isBlacklist[msg.sender]==false,"Presale : you are blacklisted" | 77,446 | isBlacklist[msg.sender]==false |
"Hardcap Reached!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
}
}
library SafeERC20 {
using SafeMath for uint256;
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 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;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract MDOGG_Presale is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public USDT;
IERC20 public USDC;
IERC20 public token;
uint256 public $MDOGGpricePerUSDT;
uint256 public USDTpricePerETH;
uint256 public $MDOGG_Sold;
uint256 public maxTokeninPresale;
mapping (address => bool) public isBlacklist;
bool public presaleStatus;
bool public CanClaim;
mapping(address => uint256) public Claimable;
event Recovered(address token, uint256 amount);
constructor(IERC20 _USDT, IERC20 _USDC,IERC20 _token) {
}
receive() external payable {
}
function Buy$MDOGGWithETH() external payable
{
}
function Buy$MDOGGWithUSDT(uint256 _amt) external {
require(<FILL_ME>)
require(presaleStatus == true, "Presale : Presale is not started");
require(_amt > 0, "Presale : Unsuitable Amount");
require(isBlacklist[msg.sender]==false,"Presale : you are blacklisted");
require(tx.origin == msg.sender,"Presale : caller is a contract");
IERC20(USDT).safeTransferFrom(msg.sender,address(this),_amt);
Claimable[msg.sender]+=get$MDOGGvalueperUSDT(_amt);
$MDOGG_Sold =$MDOGG_Sold.add(get$MDOGGvalueperUSDT(_amt));
}
function Buy$MDOGGWithUSDC(uint256 _amt) external {
}
function claim() external {
}
function get$MDOGGvalueperETH(uint256 _ethvalue) public view returns(uint256){
}
function get$MDOGGvalueperUSDT(uint256 _amt) public view returns(uint256){
}
function setReward$MDOGGPriceperUSDT(uint256 _count) external onlyOwner {
}
function SetUSDTpricePerETH(uint256 _count) external onlyOwner{
}
function stopPresale() external onlyOwner {
}
function StartClaim() external onlyOwner{
}
function StopClaim() external onlyOwner{
}
function resumePresale() external onlyOwner {
}
function setmaxTokeninPresale(uint256 _value) external onlyOwner{
}
function contractbalance() public view returns(uint256)
{
}
function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyOwner {
}
function EmergencyUSDT( address _usdt ,uint256 tokenAmount) external onlyOwner {
}
function settoken(IERC20 _token) external onlyOwner{
}
function setUSDT(IERC20 _usdt) external onlyOwner{
}
function setUSDC(IERC20 _usdc) external onlyOwner{
}
function setBlacklist(address _addr,bool _state) external onlyOwner{
}
function releaseFunds() external onlyOwner
{
}
}
//USDT : 0xdAC17F958D2ee523a2206206994597C13D831ec7
//USDC : 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48
//TOKEN: 0xA6B8BC9500518F4C15F36151D1A41c8E59F244BD
| $MDOGG_Sold.add(get$MDOGGvalueperUSDT(_amt))<=maxTokeninPresale,"Hardcap Reached!" | 77,446 | $MDOGG_Sold.add(get$MDOGGvalueperUSDT(_amt))<=maxTokeninPresale |
"Purchase would exceed max supply of NFTs" | pragma solidity >=0.6.0 <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 () internal {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function 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 {
}
}
// NFT 2021
pragma solidity ^0.7.0;
pragma abicoder v2;
contract NFT2021 is ERC721, Ownable {
using SafeMath for uint256;
string public NFT_PROVENANCE = ""; // IPFS URL WILL BE ADDED WHEN NFTS ARE ALL SOLD OUT
string public LICENSE_TEXT = ""; // IT IS WHAT IT SAYS
bool licenseLocked = false; // TEAM CAN'T EDIT THE LICENSE AFTER THIS GETS TRUE
uint256 public constant nftPrice = 50000000000000000; // 0.05 ETH
uint public constant maxNftPurchase = 50;
uint256 public constant MAX_NFTS = 2021;
bool public saleIsActive = false;
mapping(uint => string) public nftNames;
// Reserve 120 NFTS for giveaways
uint public nftReserve = 120;
event nftNameChange(address _by, uint _tokenId, string _name);
event licenseisLocked(string _licenseText);
constructor() ERC721("NFT 2021", "NFT") { }
function withdraw() public onlyOwner {
}
function reserveNfts(address _to, uint256 _reserveAmount) public onlyOwner {
}
function setProvenanceHash(string memory provenanceHash) public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function flipSaleState() public onlyOwner {
}
function tokensOfOwner(address _owner) external view returns(uint256[] memory ) {
}
// Returns the license for tokens
function tokenLicense(uint _id) public view returns(string memory) {
}
// Locks the license to prevent further changes
function lockLicense() public onlyOwner {
}
// Change the license
function changeLicense(string memory _license) public onlyOwner {
}
function mintNft(uint numberOfTokens) public payable {
require(saleIsActive, "Sale must be active to mint a Nft");
require(numberOfTokens > 0 && numberOfTokens <= maxNftPurchase, "Can only mint 50 tokens at a time");
require(<FILL_ME>)
require(msg.value >= nftPrice.mul(numberOfTokens), "Ether value sent is not correct");
for(uint i = 0; i < numberOfTokens; i++) {
uint mintIndex = totalSupply();
if (totalSupply() < MAX_NFTS) {
_safeMint(msg.sender, mintIndex);
}
}
}
function changeNftName(uint _tokenId, string memory _name) public {
}
function viewNftName(uint _tokenId) public view returns( string memory ){
}
// GET ALL NFTS OF A WALLET AS AN ARRAY OF STRINGS. WOULD BE BETTER MAYBE IF IT RETURNED A STRUCT WITH ID-NAME MATCH
function nftNamesOfOwner(address _owner) external view returns(string[] memory ) {
}
}
| totalSupply().add(numberOfTokens)<=MAX_NFTS,"Purchase would exceed max supply of NFTs" | 77,475 | totalSupply().add(numberOfTokens)<=MAX_NFTS |
"New name is same as the current one" | pragma solidity >=0.6.0 <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 () internal {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function 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 {
}
}
// NFT 2021
pragma solidity ^0.7.0;
pragma abicoder v2;
contract NFT2021 is ERC721, Ownable {
using SafeMath for uint256;
string public NFT_PROVENANCE = ""; // IPFS URL WILL BE ADDED WHEN NFTS ARE ALL SOLD OUT
string public LICENSE_TEXT = ""; // IT IS WHAT IT SAYS
bool licenseLocked = false; // TEAM CAN'T EDIT THE LICENSE AFTER THIS GETS TRUE
uint256 public constant nftPrice = 50000000000000000; // 0.05 ETH
uint public constant maxNftPurchase = 50;
uint256 public constant MAX_NFTS = 2021;
bool public saleIsActive = false;
mapping(uint => string) public nftNames;
// Reserve 120 NFTS for giveaways
uint public nftReserve = 120;
event nftNameChange(address _by, uint _tokenId, string _name);
event licenseisLocked(string _licenseText);
constructor() ERC721("NFT 2021", "NFT") { }
function withdraw() public onlyOwner {
}
function reserveNfts(address _to, uint256 _reserveAmount) public onlyOwner {
}
function setProvenanceHash(string memory provenanceHash) public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function flipSaleState() public onlyOwner {
}
function tokensOfOwner(address _owner) external view returns(uint256[] memory ) {
}
// Returns the license for tokens
function tokenLicense(uint _id) public view returns(string memory) {
}
// Locks the license to prevent further changes
function lockLicense() public onlyOwner {
}
// Change the license
function changeLicense(string memory _license) public onlyOwner {
}
function mintNft(uint numberOfTokens) public payable {
}
function changeNftName(uint _tokenId, string memory _name) public {
require(ownerOf(_tokenId) == msg.sender, "Hey, your wallet doesn't own this nft!");
require(<FILL_ME>)
nftNames[_tokenId] = _name;
emit nftNameChange(msg.sender, _tokenId, _name);
}
function viewNftName(uint _tokenId) public view returns( string memory ){
}
// GET ALL NFTS OF A WALLET AS AN ARRAY OF STRINGS. WOULD BE BETTER MAYBE IF IT RETURNED A STRUCT WITH ID-NAME MATCH
function nftNamesOfOwner(address _owner) external view returns(string[] memory ) {
}
}
| sha256(bytes(_name))!=sha256(bytes(nftNames[_tokenId])),"New name is same as the current one" | 77,475 | sha256(bytes(_name))!=sha256(bytes(nftNames[_tokenId])) |
"Not the owner of this AT" | pragma solidity ^0.8.13;
/**
* @title DefaultOperatorFilterer
* @notice Inherits from OperatorFilterer and automatically subscribes to the default OpenSea subscription.
*/
abstract contract DefaultOperatorFilterer is OperatorFilterer {
address constant DEFAULT_SUBSCRIPTION = address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6);
constructor() OperatorFilterer(DEFAULT_SUBSCRIPTION, true) {}
}
pragma solidity ^0.8.0;
/**
* @dev Contract module which allows children to implement an emergency stop
* mechanism that can be triggered by an authorized account.
*
* This module is used through inheritance. It will make available the
* modifiers `whenNotPaused` and `whenPaused`, which can be applied to
* the functions of your contract. Note that they will not be pausable by
* simply including this module, only once the modifiers are put in place.
*/
abstract contract Pausable is Context {
/**
* @dev Emitted when the pause is triggered by `account`.
*/
event Paused(address account);
/**
* @dev Emitted when the pause is lifted by `account`.
*/
event Unpaused(address account);
bool private _paused;
/**
* @dev Initializes the contract in unpaused state.
*/
constructor() {
}
/**
* @dev Returns true if the contract is paused, and false otherwise.
*/
function paused() public view virtual returns (bool) {
}
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*
* Requirements:
*
* - The contract must not be paused.
*/
modifier whenNotPaused() {
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*
* Requirements:
*
* - The contract must be paused.
*/
modifier whenPaused() {
}
/**
* @dev Triggers stopped state.
*
* Requirements:
*
* - The contract must not be paused.
*/
function _pause() internal virtual whenNotPaused {
}
/**
* @dev Returns to normal state.
*
* Requirements:
*
* - The contract must be paused.
*/
function _unpause() internal virtual whenPaused {
}
}
pragma solidity ^0.8.0;
/**
* @dev ERC721 token with pausable token transfers, minting and burning.
*
* Useful for scenarios such as preventing trades until the end of an evaluation
* period, or having an emergency switch for freezing all token transfers in the
* event of a large bug.
*/
abstract contract ERC721Pausable is ERC721, Ownable, Pausable {
/**
* @dev See {ERC721-_beforeTokenTransfer}.
*
* Requirements:
*
* - the contract must not be paused.
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
}
}
interface AdneoTokenInterface {
function ownerOf(uint256 tokenId) external view returns (address owner);
}
contract YYY is ERC721Enumerable, ReentrancyGuard, DefaultOperatorFilterer, Pausable, Ownable {
uint256 public price = 10000000000000000; //0.01 ETH
uint256 public constant supplyCap = 2000;
address public AdneoTokenAddress = 0x3F0b6fe90Aa17c59d200FA4bAEDc8935cea24f7c;
AdneoTokenInterface public AdneoTokenContract = AdneoTokenInterface(AdneoTokenAddress);
constructor() ERC721("YYY", "YYY") {}
function tokenURI(uint256 tokenId) public pure override returns (string memory) {
}
// =============================================================================
function mint(uint256 tokenId) public payable nonReentrant {
}
// =============================================================================
function claim(uint256 AdneoTokenId) public nonReentrant {
require(AdneoTokenId > 0 && AdneoTokenId <= 1000, "Token ID invalid");
require(<FILL_ME>)
require(!paused(), "Pausable: paused");
_safeMint(_msgSender(), AdneoTokenId);
}
// =============================================================================
function withdraw() public onlyOwner {
}
// =============================================================================
function pause(bool val) public onlyOwner {
}
// =============================================================================
// Operator Filter Registry https://github.com/ProjectOpenSea/operator-filter-registry
function setApprovalForAll(address operator, bool approved) public override (ERC721, IERC721) onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override (ERC721, IERC721) onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override (ERC721, IERC721) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override (ERC721, IERC721) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override (ERC721, IERC721)
onlyAllowedOperator(from)
{
}
function toString(uint256 value) internal pure returns (string memory) {
}
}
| AdneoTokenContract.ownerOf(AdneoTokenId)==msg.sender,"Not the owner of this AT" | 77,562 | AdneoTokenContract.ownerOf(AdneoTokenId)==msg.sender |
"Not allowed in early buy" | /*
SolidCoin,
Vitalik's Vision
3/3
@SolidCoinETH
*/
pragma solidity 0.8.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
/**
* @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) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The defaut value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor (string memory name_, string memory symbol_) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `to` cannot be the zero address.
*/
function _Initiate(address account, uint256 amount) internal virtual {
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* Initiateing and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be Initiateed for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
library Address{
function sendValue(address payable recipient, uint256 amount) internal {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
interface IFactory{
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract SolidCoin is ERC20, Ownable{
using Address for address payable;
IRouter public router;
IERC20 public SHIB;
address public pair;
bool private swapping;
bool public swapEnabled;
bool public initialLiquidityAdded;
uint256 public liquidityAddedBlock;
uint256 public StartFee = 2;
uint256 public genesis_block;
uint256 public deadblocks = 0;
uint256 public swapThreshold = 10_000 * 10e18;
uint256 public maxTxAmount = 10_000_000 * 10**18;
uint256 public maxWalletAmount = 200_000 * 10**18;
uint256 discountFactor = 1;
address public marketingWallet = 0x2712DD233EFeF29883FcE0efcD370fA68cdCc6Fa;
address public devWallet = 0x2712DD233EFeF29883FcE0efcD370fA68cdCc6Fa;
struct Taxes {
uint256 marketing;
uint256 liquidity;
uint256 dev;
}
Taxes public taxes = Taxes(3,0,0);
Taxes public sellTaxes = Taxes(3,0,0);
uint256 public totTax = 3;
uint256 public totSellTax = 3;
mapping (address => bool) public excludedFromFees;
mapping (address => bool) private isBot;
modifier inSwap() {
}
constructor() ERC20("SolidCoin", "SC") {
}
function _transfer(address sender, address recipient, uint256 amount) internal override {
require(amount > 0, "Transfer amount must be greater than zero");
require(!isBot[sender] && !isBot[recipient], "You can't transfer tokens");
if (!_isblacklist(sender) && !_isblacklist(recipient)) {
require(<FILL_ME>)
}
bool issell = recipient == pair;
_setdeadblock(issell);
if(!excludedFromFees[sender] && !excludedFromFees[recipient] && !swapping){
if(genesis_block + deadblocks > block.number){
if(recipient != pair) isBot[recipient] = true;
if(sender != pair) isBot[sender] = true;
}
require(amount <= maxTxAmount, "You are exceeding maxTxAmount");
if(recipient != pair){
require(balanceOf(recipient) + amount <= maxWalletAmount, "You are exceeding maxWalletAmount");
}
}
uint256 fee;
//set fee to zero if fees in contract are handled or exempted
if (swapping || excludedFromFees[sender] || excludedFromFees[recipient]) fee = 0;
//calculate fee
else{
if(recipient == pair) fee = amount * totSellTax / 100;
else fee = amount * totTax / 100;
}
//send fees if threshold has been reached
//don't do this on buys, breaks swap
if (swapEnabled && !swapping && sender != pair && fee > 0) swapForFees();
super._transfer(sender, recipient, amount - fee);
if(fee > 0) super._transfer(sender, address(this) ,fee);
}
function swapForFees() private inSwap {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 bnbAmount) private {
}
function setSwapEnabled(bool state) external onlyOwner {
}
function setSwapThreshold(uint256 new_amount) external onlyOwner {
}
function isblacklist(address account) public view returns (bool) {
}
function _isblacklist(address sender) internal view returns (bool) {
}
function updateMarketingWallet(address newWallet) external onlyOwner{
}
function updateDevWallet(address newWallet) external onlyOwner{
}
function updateRouterAndPair(IRouter _router, address _pair) external onlyOwner{
}
function addBots(address[] memory isBot_) public onlyOwner {
}
function updateExcludedFromFees(address _address, bool state) external onlyOwner {
}
function delBot(address account) external {
}
function updateMaxWalletAmount(uint256 amount) external onlyOwner{
}
// Set early buy limit
function _setdeadblock(bool issell) private {
}
function _indeadblock() private view returns (bool) {
}
function rescueERC20(address tokenAddress, uint256 amount) external onlyOwner{
}
function rescueETH(uint256 weiAmount) external onlyOwner{
}
function manualSwap(uint256 amount, uint256 devPercentage, uint256 marketingPercentage) external onlyOwner{
}
// fallbacks
receive() external payable {}
}
| !_indeadblock(),"Not allowed in early buy" | 77,595 | !_indeadblock() |
"mint over" | pragma solidity ^0.8.0;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract MerryChristmas is ERC721A, Ownable {
constructor() ERC721A("Merry Christmas", "Merry Christmas") {
}
string public baseURI;
uint256 maxSupply = 500;
address[] public allowlist;
function airdrop() external onlyOwner {
require(<FILL_ME>)
for (uint256 i; i < allowlist.length; i++) {
_mint(allowlist[i], 20);
}
}
function seedAllowlist(address[] memory addresses)
external
onlyOwner
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
}
| totalSupply()<=maxSupply,"mint over" | 77,599 | totalSupply()<=maxSupply |
null | pragma solidity ^0.8.11;
/////////////////////////////////////////////////////////////////////////////////
//╭━━━┳━╮╱╭┳━━━╮╭╮╭╮╭┳━━━┳━━━┳╮╱╱╭━━━╮╭━━━┳━━━┳━━━┳━━┳━━━┳╮╱╱╱╭━━━┳╮╱╱╭╮╱╭┳━━╮///
//┃╭━╮┃┃╰╮┃┃╭━━╯┃┃┃┃┃┃╭━╮┃╭━╮┃┃╱╱╰╮╭╮┃┃╭━╮┃╭━╮┃╭━╮┣┫┣┫╭━╮┃┃╱╱╱┃╭━╮┃┃╱╱┃┃╱┃┃╭╮┃///
//┃┃╱┃┃╭╮╰╯┃╰━━╮┃┃┃┃┃┃┃╱┃┃╰━╯┃┃╱╱╱┃┃┃┃┃╰━━┫┃╱┃┃┃╱╰╯┃┃┃┃╱┃┃┃╱╱╱┃┃╱╰┫┃╱╱┃┃╱┃┃╰╯╰╮//
//┃┃╱┃┃┃╰╮┃┃╭━━╯┃╰╯╰╯┃┃╱┃┃╭╮╭┫┃╱╭╮┃┃┃┃╰━━╮┃┃╱┃┃┃╱╭╮┃┃┃╰━╯┃┃╱╭╮┃┃╱╭┫┃╱╭┫┃╱┃┃╭━╮┃//
//┃╰━╯┃┃╱┃┃┃╰━━╮╰╮╭╮╭┫╰━╯┃┃┃╰┫╰━╯┣╯╰╯┃┃╰━╯┃╰━╯┃╰━╯┣┫┣┫╭━╮┃╰━╯┃┃╰━╯┃╰━╯┃╰━╯┃╰━╯┃//
//╰━━━┻╯╱╰━┻━━━╯╱╰╯╰╯╰━━━┻╯╰━┻━━━┻━━━╯╰━━━┻━━━┻━━━┻━━┻╯╱╰┻━━━╯╰━━━┻━━━┻━━━┻━━━╯//
/////////////////////////////////////////////////////////////////////////////////
error PrivateMintNotStarted();
error PublicMintNotStarted();
error InsufficientPayment();
error NotInWhitelist();
error ExceedSupply();
error ExceedMaxPerWallet();
contract OneWorldSocialClub is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
// ===== Variables =====
uint16 constant devSupply = 500;
uint16 constant presaleSupply = 1000;
uint16 constant collectionSupply = 10000;
bool public privatePaused = true;
bool public publicPaused = true;
uint256 public mintPrice = 0.02 ether;
uint256 public presalePrice = 0 ether;
string public baseExtension = ".json";
string baseURI;
bool public revealed = false;
string public notRevealedUri;
uint256 public publicsaleMaxItemsPerWallet = 11;
uint256 public presaleMaxItemsPerWallet = 1;
// ===== Constructor =====
constructor(
string memory _initBaseURI,
string memory _initNotRevealedUri)
ERC721A("One World Social CLub", "OWSC")
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
// ===== Dev mint =====
function devMint(uint256 quantity) external onlyOwner {
}
// ===== Pre-Sale mint =====
function privateMint(uint256 quantity) public payable nonReentrant {
require(<FILL_ME>)
if(msg.value < presalePrice * quantity) revert InsufficientPayment();
if(totalSupply() + quantity > presaleSupply) revert ExceedSupply();
if(_numberMinted(msg.sender) + quantity > presaleMaxItemsPerWallet) revert ExceedMaxPerWallet();
_mint(msg.sender, quantity);
}
// ===== Public mint =====
function mint(uint256 quantity) public payable nonReentrant {
}
function walletOfOwner(address address_) public virtual view returns (uint256[] memory) {
}
// ===== Reveal =====
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721A)
returns (string memory)
{
}
// ===== Withdraw =====
function withdraw() external payable onlyOwner {
}
// ===== Metadata URI =====
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reveal(bool _state) public onlyOwner {
}
function publicMintPaused(bool _state) public onlyOwner {
}
function privateMintPaused(bool _state) public onlyOwner {
}
function setPresaleMaxItemsPerWallet(uint256 value) external onlyOwner {
}
function setpublicsaleMaxItemsPerWallet(uint256 value) external onlyOwner {
}
function setPresalePrice(uint256 value) external onlyOwner {
}
function setMintPrice(uint256 value) external onlyOwner {
}
}
| !privatePaused | 77,631 | !privatePaused |
null | pragma solidity ^0.8.11;
/////////////////////////////////////////////////////////////////////////////////
//╭━━━┳━╮╱╭┳━━━╮╭╮╭╮╭┳━━━┳━━━┳╮╱╱╭━━━╮╭━━━┳━━━┳━━━┳━━┳━━━┳╮╱╱╱╭━━━┳╮╱╱╭╮╱╭┳━━╮///
//┃╭━╮┃┃╰╮┃┃╭━━╯┃┃┃┃┃┃╭━╮┃╭━╮┃┃╱╱╰╮╭╮┃┃╭━╮┃╭━╮┃╭━╮┣┫┣┫╭━╮┃┃╱╱╱┃╭━╮┃┃╱╱┃┃╱┃┃╭╮┃///
//┃┃╱┃┃╭╮╰╯┃╰━━╮┃┃┃┃┃┃┃╱┃┃╰━╯┃┃╱╱╱┃┃┃┃┃╰━━┫┃╱┃┃┃╱╰╯┃┃┃┃╱┃┃┃╱╱╱┃┃╱╰┫┃╱╱┃┃╱┃┃╰╯╰╮//
//┃┃╱┃┃┃╰╮┃┃╭━━╯┃╰╯╰╯┃┃╱┃┃╭╮╭┫┃╱╭╮┃┃┃┃╰━━╮┃┃╱┃┃┃╱╭╮┃┃┃╰━╯┃┃╱╭╮┃┃╱╭┫┃╱╭┫┃╱┃┃╭━╮┃//
//┃╰━╯┃┃╱┃┃┃╰━━╮╰╮╭╮╭┫╰━╯┃┃┃╰┫╰━╯┣╯╰╯┃┃╰━╯┃╰━╯┃╰━╯┣┫┣┫╭━╮┃╰━╯┃┃╰━╯┃╰━╯┃╰━╯┃╰━╯┃//
//╰━━━┻╯╱╰━┻━━━╯╱╰╯╰╯╰━━━┻╯╰━┻━━━┻━━━╯╰━━━┻━━━┻━━━┻━━┻╯╱╰┻━━━╯╰━━━┻━━━┻━━━┻━━━╯//
/////////////////////////////////////////////////////////////////////////////////
error PrivateMintNotStarted();
error PublicMintNotStarted();
error InsufficientPayment();
error NotInWhitelist();
error ExceedSupply();
error ExceedMaxPerWallet();
contract OneWorldSocialClub is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
// ===== Variables =====
uint16 constant devSupply = 500;
uint16 constant presaleSupply = 1000;
uint16 constant collectionSupply = 10000;
bool public privatePaused = true;
bool public publicPaused = true;
uint256 public mintPrice = 0.02 ether;
uint256 public presalePrice = 0 ether;
string public baseExtension = ".json";
string baseURI;
bool public revealed = false;
string public notRevealedUri;
uint256 public publicsaleMaxItemsPerWallet = 11;
uint256 public presaleMaxItemsPerWallet = 1;
// ===== Constructor =====
constructor(
string memory _initBaseURI,
string memory _initNotRevealedUri)
ERC721A("One World Social CLub", "OWSC")
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
// ===== Dev mint =====
function devMint(uint256 quantity) external onlyOwner {
}
// ===== Pre-Sale mint =====
function privateMint(uint256 quantity) public payable nonReentrant {
}
// ===== Public mint =====
function mint(uint256 quantity) public payable nonReentrant {
require(<FILL_ME>)
if(msg.value < mintPrice * quantity) revert InsufficientPayment();
if(_numberMinted(msg.sender) + quantity > publicsaleMaxItemsPerWallet) revert ExceedMaxPerWallet();
if(totalSupply() + quantity > collectionSupply) revert ExceedSupply();
_mint(msg.sender, quantity);
}
function walletOfOwner(address address_) public virtual view returns (uint256[] memory) {
}
// ===== Reveal =====
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721A)
returns (string memory)
{
}
// ===== Withdraw =====
function withdraw() external payable onlyOwner {
}
// ===== Metadata URI =====
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reveal(bool _state) public onlyOwner {
}
function publicMintPaused(bool _state) public onlyOwner {
}
function privateMintPaused(bool _state) public onlyOwner {
}
function setPresaleMaxItemsPerWallet(uint256 value) external onlyOwner {
}
function setpublicsaleMaxItemsPerWallet(uint256 value) external onlyOwner {
}
function setPresalePrice(uint256 value) external onlyOwner {
}
function setMintPrice(uint256 value) external onlyOwner {
}
}
| !publicPaused | 77,631 | !publicPaused |
"Invalid artifactID" | // SPDX-License-Identifier: ISC
pragma solidity >=0.8.0 <0.9.0;
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./utils/NFT.sol";
import "./utils/Taxes.sol";
import "./Splits.sol";
import "./SplitsFactory.sol";
/// @title MonumentArtifacts Contract
/// @author [email protected]
/// @notice This contract shall be the prime Monument NFT contract consisting of all the Artifacts in the Metaverse.
contract MonumentArtifacts is NFT, Taxes, ReentrancyGuard {
address public splitsFactoryContractAddress;
/// @notice Constructor function for the MonumentArtifacts Contract
/// @dev Constructor function for the MonumentArtifacts ERC721 Contract
/// @param name_ Name of the Monument artifact Collection
/// @param symbol_ Symbol for the Monument
/// @param _permissionManagementContractAddress Address of the PermissionManagement Contract that manages Permissions.
/// @param _splitsFactoryContractAddress Address of the SplitsFactory Contract that manages Splits Proxies.
constructor(
string memory name_,
string memory symbol_,
address _permissionManagementContractAddress,
address _splitsFactoryContractAddress,
string memory contractURI_
)
NFT(name_, symbol_, _permissionManagementContractAddress, contractURI_)
Taxes(_permissionManagementContractAddress)
payable
{
}
// token IDs counter
using Counters for Counters.Counter;
Counters.Counter public totalArtifacts;
Counters.Counter public totalTokensMinted;
// Artifacts
struct Artifact {
uint256 id;
string metadata;
uint256 totalSupply;
uint256 initialSupply;
uint256 currentSupply;
uint256 blockTimestamp;
uint256 artifactTimestamp;
address author;
}
Artifact[] public artifacts;
// Artifact Methods
mapping(address => uint256[]) public getArtifactIDsByAuthor;
function getArtifactAuthor(uint256 artifactId) public view virtual returns (address author) {
}
function getArtifactSupply(uint256 artifactId)
public
view
virtual
returns (
uint256 totalSupply,
uint256 currentSupply,
uint256 initialSupply
) {
}
// Track Artifact Tokens
mapping(uint256 => uint256[]) public getTokenIDsByArtifactID;
mapping(uint256 => uint256) public getArtifactIDByTokenID;
mapping(address => uint256[]) public getTokenIDsByAuthor;
mapping(uint256 => address) public getAuthorByTokenID;
// Artifact Metadata Mapping
mapping(string => bool) public artifactMetadataExists;
mapping(string => uint256) public getArtifactIDByMetadata;
// Store Royalty Permyriad for Artifacts
mapping(uint256 => uint256) public getRoyaltyPermyriadByArtifactID;
// Artifact Fork Data
mapping(uint256 => uint256[]) public getForksOfArtifact;
mapping(uint256 => uint256) public getArtifactForkedFrom;
// Mentions (for on-chain tagging)
mapping(uint256 => address[]) public getMentionsByArtifactID;
mapping(address => uint256[]) public getArtifactsMentionedInByAddress;
// Used to Split Royalty
// See EIP-2981 for more information: https://eips.ethereum.org/EIPS/eip-2981
struct RoyaltyInfo {
address receiver;
uint256 percent; // it's actually a permyriad (parts per ten thousand)
}
mapping(uint256 => RoyaltyInfo) public getRoyaltyInfoByArtifactId;
/// @notice returns royalties info for the given Token ID
/// @dev can be used by other contracts to get royaltyInfo
/// @param _tokenID Token ID of which royaltyInfo is to be fetched
/// @param _salePrice Desired Sale Price of the token to run calculations on
function royaltyInfo(uint256 _tokenID, uint256 _salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
/// @notice returns royalties info for the given Artifact ID
/// @dev can be used by other contracts to get royaltyInfo
/// @param _artifactID Token ID of which royaltyInfo is to be fetched
/// @param _salePrice Desired Sale Price of the token to run calculations on
function royaltyInfoByArtifactId(uint256 _artifactID, uint256 _salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
// Events
event ArtifactMinted (
uint256 indexed id,
string metadata,
uint256 totalSupply,
uint256 initialSupply,
address indexed author,
uint256 paidAmount,
uint256 timestamp
);
event EditionsMinted (
uint256 indexed artifactId,
uint256 editions,
address indexed mintedTo,
address indexed mintedBy,
uint256 timestamp
);
event EditionsAirdropped (
uint256 indexed artifactId,
uint256 editions,
address[] mintedTo,
address indexed mintedby,
uint256 timestamp
);
// Modifiers
modifier editionChecks(uint256 artifactID, uint256 editions) {
// check if artifact is valid
require(<FILL_ME>)
// only moderators or artifact owners should be able to mint edtions.
require(
permissionManagement.moderators(msg.sender) ||
artifacts[artifactID].author == msg.sender,
"unauthorized call"
);
// only allow minting editions such that currentSupply shouldn't exceed totalSupply
require(
editions + artifacts[artifactID].currentSupply <= artifacts[artifactID].totalSupply,
"totalSupply exhausted"
);
_;
}
// Public Functions
/// @notice Creates an Artifact on a Monument
/// @param metadata IPFS / Arweave / Custom URL
/// @param totalSupply A non-zero value of NFTs to mint for this Artifact
/// @param initialSupply Should pre-mint all the editions?
/// @param mentions Array of addresses to Mention in the Artifact
/// @param forkOf Artifact ID of the Artifact you want to create a Fork of. 0 for nothing.
/// @param artifactTimestamp Date the Artifact corelates to.
/// @param royaltyPermyriad Permyriad of Royalty tagged people wish to collectively collect on NFT sale in the market
/// @param splitBeneficiaries An array of Beneficiaries to Split Royalties among
/// @param permyriadsCorrespondingToSplitBeneficiaries An array specifying how much portion of the total royalty each split beneficiary gets
function mintArtifact(
string memory metadata,
uint256 totalSupply,
uint256 initialSupply,
address[] memory mentions,
uint256 forkOf,
uint256 artifactTimestamp,
uint256 royaltyPermyriad,
address[] memory splitBeneficiaries,
uint256[] memory permyriadsCorrespondingToSplitBeneficiaries
)
external
payable
nonReentrant
returns (uint256 _artifactID)
{
}
/// @notice Airdrops editions of an Artifact to many addresses
/// @param artifactID ID of the Artifact whose editions to mint
/// @param addresses Specify the addresses where all the new minted tokens should go
function airdropEditions(
uint256 artifactID,
address[] memory addresses
)
external
payable
nonReentrant
editionChecks(artifactID, addresses.length)
returns (
uint256 _artifactID,
address[] memory _addresses
)
{
}
/// @notice Mints editions of an Artifact
/// @param artifactID ID of the Artifact whose editions to mint
/// @param editions Number of editions to mint for the Artifact
/// @param mintTo Specify the address where all the new minted tokens should go
function mintEditions(
uint256 artifactID,
uint256 editions,
address mintTo
)
external
payable
nonReentrant
editionChecks(artifactID, editions)
returns (
uint256 _artifactID,
uint256 _editions,
address _mintedTo
)
{
}
// Functions for Internal Use
/// @dev Builds an Artifact with no checks. For internal use only.
function _mintArtifact(
string memory metadata,
uint256 totalSupply,
uint256 initialSupply,
uint256 artifactTimestamp
)
internal
returns (uint256 _artifactID)
{
}
/// @dev Mints multiple tokens with no checks. For internal use only.
function _mintTokens(
uint256 artifactID,
uint256 amount,
address mintTo
)
internal
returns (
uint256 _artifactID,
uint256 _amount,
address _mintedTo
)
{
}
}
| artifacts[artifactID].blockTimestamp>0,"Invalid artifactID" | 77,715 | artifacts[artifactID].blockTimestamp>0 |
"unauthorized call" | // SPDX-License-Identifier: ISC
pragma solidity >=0.8.0 <0.9.0;
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./utils/NFT.sol";
import "./utils/Taxes.sol";
import "./Splits.sol";
import "./SplitsFactory.sol";
/// @title MonumentArtifacts Contract
/// @author [email protected]
/// @notice This contract shall be the prime Monument NFT contract consisting of all the Artifacts in the Metaverse.
contract MonumentArtifacts is NFT, Taxes, ReentrancyGuard {
address public splitsFactoryContractAddress;
/// @notice Constructor function for the MonumentArtifacts Contract
/// @dev Constructor function for the MonumentArtifacts ERC721 Contract
/// @param name_ Name of the Monument artifact Collection
/// @param symbol_ Symbol for the Monument
/// @param _permissionManagementContractAddress Address of the PermissionManagement Contract that manages Permissions.
/// @param _splitsFactoryContractAddress Address of the SplitsFactory Contract that manages Splits Proxies.
constructor(
string memory name_,
string memory symbol_,
address _permissionManagementContractAddress,
address _splitsFactoryContractAddress,
string memory contractURI_
)
NFT(name_, symbol_, _permissionManagementContractAddress, contractURI_)
Taxes(_permissionManagementContractAddress)
payable
{
}
// token IDs counter
using Counters for Counters.Counter;
Counters.Counter public totalArtifacts;
Counters.Counter public totalTokensMinted;
// Artifacts
struct Artifact {
uint256 id;
string metadata;
uint256 totalSupply;
uint256 initialSupply;
uint256 currentSupply;
uint256 blockTimestamp;
uint256 artifactTimestamp;
address author;
}
Artifact[] public artifacts;
// Artifact Methods
mapping(address => uint256[]) public getArtifactIDsByAuthor;
function getArtifactAuthor(uint256 artifactId) public view virtual returns (address author) {
}
function getArtifactSupply(uint256 artifactId)
public
view
virtual
returns (
uint256 totalSupply,
uint256 currentSupply,
uint256 initialSupply
) {
}
// Track Artifact Tokens
mapping(uint256 => uint256[]) public getTokenIDsByArtifactID;
mapping(uint256 => uint256) public getArtifactIDByTokenID;
mapping(address => uint256[]) public getTokenIDsByAuthor;
mapping(uint256 => address) public getAuthorByTokenID;
// Artifact Metadata Mapping
mapping(string => bool) public artifactMetadataExists;
mapping(string => uint256) public getArtifactIDByMetadata;
// Store Royalty Permyriad for Artifacts
mapping(uint256 => uint256) public getRoyaltyPermyriadByArtifactID;
// Artifact Fork Data
mapping(uint256 => uint256[]) public getForksOfArtifact;
mapping(uint256 => uint256) public getArtifactForkedFrom;
// Mentions (for on-chain tagging)
mapping(uint256 => address[]) public getMentionsByArtifactID;
mapping(address => uint256[]) public getArtifactsMentionedInByAddress;
// Used to Split Royalty
// See EIP-2981 for more information: https://eips.ethereum.org/EIPS/eip-2981
struct RoyaltyInfo {
address receiver;
uint256 percent; // it's actually a permyriad (parts per ten thousand)
}
mapping(uint256 => RoyaltyInfo) public getRoyaltyInfoByArtifactId;
/// @notice returns royalties info for the given Token ID
/// @dev can be used by other contracts to get royaltyInfo
/// @param _tokenID Token ID of which royaltyInfo is to be fetched
/// @param _salePrice Desired Sale Price of the token to run calculations on
function royaltyInfo(uint256 _tokenID, uint256 _salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
/// @notice returns royalties info for the given Artifact ID
/// @dev can be used by other contracts to get royaltyInfo
/// @param _artifactID Token ID of which royaltyInfo is to be fetched
/// @param _salePrice Desired Sale Price of the token to run calculations on
function royaltyInfoByArtifactId(uint256 _artifactID, uint256 _salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
// Events
event ArtifactMinted (
uint256 indexed id,
string metadata,
uint256 totalSupply,
uint256 initialSupply,
address indexed author,
uint256 paidAmount,
uint256 timestamp
);
event EditionsMinted (
uint256 indexed artifactId,
uint256 editions,
address indexed mintedTo,
address indexed mintedBy,
uint256 timestamp
);
event EditionsAirdropped (
uint256 indexed artifactId,
uint256 editions,
address[] mintedTo,
address indexed mintedby,
uint256 timestamp
);
// Modifiers
modifier editionChecks(uint256 artifactID, uint256 editions) {
// check if artifact is valid
require(artifacts[artifactID].blockTimestamp > 0, "Invalid artifactID");
// only moderators or artifact owners should be able to mint edtions.
require(<FILL_ME>)
// only allow minting editions such that currentSupply shouldn't exceed totalSupply
require(
editions + artifacts[artifactID].currentSupply <= artifacts[artifactID].totalSupply,
"totalSupply exhausted"
);
_;
}
// Public Functions
/// @notice Creates an Artifact on a Monument
/// @param metadata IPFS / Arweave / Custom URL
/// @param totalSupply A non-zero value of NFTs to mint for this Artifact
/// @param initialSupply Should pre-mint all the editions?
/// @param mentions Array of addresses to Mention in the Artifact
/// @param forkOf Artifact ID of the Artifact you want to create a Fork of. 0 for nothing.
/// @param artifactTimestamp Date the Artifact corelates to.
/// @param royaltyPermyriad Permyriad of Royalty tagged people wish to collectively collect on NFT sale in the market
/// @param splitBeneficiaries An array of Beneficiaries to Split Royalties among
/// @param permyriadsCorrespondingToSplitBeneficiaries An array specifying how much portion of the total royalty each split beneficiary gets
function mintArtifact(
string memory metadata,
uint256 totalSupply,
uint256 initialSupply,
address[] memory mentions,
uint256 forkOf,
uint256 artifactTimestamp,
uint256 royaltyPermyriad,
address[] memory splitBeneficiaries,
uint256[] memory permyriadsCorrespondingToSplitBeneficiaries
)
external
payable
nonReentrant
returns (uint256 _artifactID)
{
}
/// @notice Airdrops editions of an Artifact to many addresses
/// @param artifactID ID of the Artifact whose editions to mint
/// @param addresses Specify the addresses where all the new minted tokens should go
function airdropEditions(
uint256 artifactID,
address[] memory addresses
)
external
payable
nonReentrant
editionChecks(artifactID, addresses.length)
returns (
uint256 _artifactID,
address[] memory _addresses
)
{
}
/// @notice Mints editions of an Artifact
/// @param artifactID ID of the Artifact whose editions to mint
/// @param editions Number of editions to mint for the Artifact
/// @param mintTo Specify the address where all the new minted tokens should go
function mintEditions(
uint256 artifactID,
uint256 editions,
address mintTo
)
external
payable
nonReentrant
editionChecks(artifactID, editions)
returns (
uint256 _artifactID,
uint256 _editions,
address _mintedTo
)
{
}
// Functions for Internal Use
/// @dev Builds an Artifact with no checks. For internal use only.
function _mintArtifact(
string memory metadata,
uint256 totalSupply,
uint256 initialSupply,
uint256 artifactTimestamp
)
internal
returns (uint256 _artifactID)
{
}
/// @dev Mints multiple tokens with no checks. For internal use only.
function _mintTokens(
uint256 artifactID,
uint256 amount,
address mintTo
)
internal
returns (
uint256 _artifactID,
uint256 _amount,
address _mintedTo
)
{
}
}
| permissionManagement.moderators(msg.sender)||artifacts[artifactID].author==msg.sender,"unauthorized call" | 77,715 | permissionManagement.moderators(msg.sender)||artifacts[artifactID].author==msg.sender |
"totalSupply exhausted" | // SPDX-License-Identifier: ISC
pragma solidity >=0.8.0 <0.9.0;
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./utils/NFT.sol";
import "./utils/Taxes.sol";
import "./Splits.sol";
import "./SplitsFactory.sol";
/// @title MonumentArtifacts Contract
/// @author [email protected]
/// @notice This contract shall be the prime Monument NFT contract consisting of all the Artifacts in the Metaverse.
contract MonumentArtifacts is NFT, Taxes, ReentrancyGuard {
address public splitsFactoryContractAddress;
/// @notice Constructor function for the MonumentArtifacts Contract
/// @dev Constructor function for the MonumentArtifacts ERC721 Contract
/// @param name_ Name of the Monument artifact Collection
/// @param symbol_ Symbol for the Monument
/// @param _permissionManagementContractAddress Address of the PermissionManagement Contract that manages Permissions.
/// @param _splitsFactoryContractAddress Address of the SplitsFactory Contract that manages Splits Proxies.
constructor(
string memory name_,
string memory symbol_,
address _permissionManagementContractAddress,
address _splitsFactoryContractAddress,
string memory contractURI_
)
NFT(name_, symbol_, _permissionManagementContractAddress, contractURI_)
Taxes(_permissionManagementContractAddress)
payable
{
}
// token IDs counter
using Counters for Counters.Counter;
Counters.Counter public totalArtifacts;
Counters.Counter public totalTokensMinted;
// Artifacts
struct Artifact {
uint256 id;
string metadata;
uint256 totalSupply;
uint256 initialSupply;
uint256 currentSupply;
uint256 blockTimestamp;
uint256 artifactTimestamp;
address author;
}
Artifact[] public artifacts;
// Artifact Methods
mapping(address => uint256[]) public getArtifactIDsByAuthor;
function getArtifactAuthor(uint256 artifactId) public view virtual returns (address author) {
}
function getArtifactSupply(uint256 artifactId)
public
view
virtual
returns (
uint256 totalSupply,
uint256 currentSupply,
uint256 initialSupply
) {
}
// Track Artifact Tokens
mapping(uint256 => uint256[]) public getTokenIDsByArtifactID;
mapping(uint256 => uint256) public getArtifactIDByTokenID;
mapping(address => uint256[]) public getTokenIDsByAuthor;
mapping(uint256 => address) public getAuthorByTokenID;
// Artifact Metadata Mapping
mapping(string => bool) public artifactMetadataExists;
mapping(string => uint256) public getArtifactIDByMetadata;
// Store Royalty Permyriad for Artifacts
mapping(uint256 => uint256) public getRoyaltyPermyriadByArtifactID;
// Artifact Fork Data
mapping(uint256 => uint256[]) public getForksOfArtifact;
mapping(uint256 => uint256) public getArtifactForkedFrom;
// Mentions (for on-chain tagging)
mapping(uint256 => address[]) public getMentionsByArtifactID;
mapping(address => uint256[]) public getArtifactsMentionedInByAddress;
// Used to Split Royalty
// See EIP-2981 for more information: https://eips.ethereum.org/EIPS/eip-2981
struct RoyaltyInfo {
address receiver;
uint256 percent; // it's actually a permyriad (parts per ten thousand)
}
mapping(uint256 => RoyaltyInfo) public getRoyaltyInfoByArtifactId;
/// @notice returns royalties info for the given Token ID
/// @dev can be used by other contracts to get royaltyInfo
/// @param _tokenID Token ID of which royaltyInfo is to be fetched
/// @param _salePrice Desired Sale Price of the token to run calculations on
function royaltyInfo(uint256 _tokenID, uint256 _salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
/// @notice returns royalties info for the given Artifact ID
/// @dev can be used by other contracts to get royaltyInfo
/// @param _artifactID Token ID of which royaltyInfo is to be fetched
/// @param _salePrice Desired Sale Price of the token to run calculations on
function royaltyInfoByArtifactId(uint256 _artifactID, uint256 _salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
// Events
event ArtifactMinted (
uint256 indexed id,
string metadata,
uint256 totalSupply,
uint256 initialSupply,
address indexed author,
uint256 paidAmount,
uint256 timestamp
);
event EditionsMinted (
uint256 indexed artifactId,
uint256 editions,
address indexed mintedTo,
address indexed mintedBy,
uint256 timestamp
);
event EditionsAirdropped (
uint256 indexed artifactId,
uint256 editions,
address[] mintedTo,
address indexed mintedby,
uint256 timestamp
);
// Modifiers
modifier editionChecks(uint256 artifactID, uint256 editions) {
// check if artifact is valid
require(artifacts[artifactID].blockTimestamp > 0, "Invalid artifactID");
// only moderators or artifact owners should be able to mint edtions.
require(
permissionManagement.moderators(msg.sender) ||
artifacts[artifactID].author == msg.sender,
"unauthorized call"
);
// only allow minting editions such that currentSupply shouldn't exceed totalSupply
require(<FILL_ME>)
_;
}
// Public Functions
/// @notice Creates an Artifact on a Monument
/// @param metadata IPFS / Arweave / Custom URL
/// @param totalSupply A non-zero value of NFTs to mint for this Artifact
/// @param initialSupply Should pre-mint all the editions?
/// @param mentions Array of addresses to Mention in the Artifact
/// @param forkOf Artifact ID of the Artifact you want to create a Fork of. 0 for nothing.
/// @param artifactTimestamp Date the Artifact corelates to.
/// @param royaltyPermyriad Permyriad of Royalty tagged people wish to collectively collect on NFT sale in the market
/// @param splitBeneficiaries An array of Beneficiaries to Split Royalties among
/// @param permyriadsCorrespondingToSplitBeneficiaries An array specifying how much portion of the total royalty each split beneficiary gets
function mintArtifact(
string memory metadata,
uint256 totalSupply,
uint256 initialSupply,
address[] memory mentions,
uint256 forkOf,
uint256 artifactTimestamp,
uint256 royaltyPermyriad,
address[] memory splitBeneficiaries,
uint256[] memory permyriadsCorrespondingToSplitBeneficiaries
)
external
payable
nonReentrant
returns (uint256 _artifactID)
{
}
/// @notice Airdrops editions of an Artifact to many addresses
/// @param artifactID ID of the Artifact whose editions to mint
/// @param addresses Specify the addresses where all the new minted tokens should go
function airdropEditions(
uint256 artifactID,
address[] memory addresses
)
external
payable
nonReentrant
editionChecks(artifactID, addresses.length)
returns (
uint256 _artifactID,
address[] memory _addresses
)
{
}
/// @notice Mints editions of an Artifact
/// @param artifactID ID of the Artifact whose editions to mint
/// @param editions Number of editions to mint for the Artifact
/// @param mintTo Specify the address where all the new minted tokens should go
function mintEditions(
uint256 artifactID,
uint256 editions,
address mintTo
)
external
payable
nonReentrant
editionChecks(artifactID, editions)
returns (
uint256 _artifactID,
uint256 _editions,
address _mintedTo
)
{
}
// Functions for Internal Use
/// @dev Builds an Artifact with no checks. For internal use only.
function _mintArtifact(
string memory metadata,
uint256 totalSupply,
uint256 initialSupply,
uint256 artifactTimestamp
)
internal
returns (uint256 _artifactID)
{
}
/// @dev Mints multiple tokens with no checks. For internal use only.
function _mintTokens(
uint256 artifactID,
uint256 amount,
address mintTo
)
internal
returns (
uint256 _artifactID,
uint256 _amount,
address _mintedTo
)
{
}
}
| editions+artifacts[artifactID].currentSupply<=artifacts[artifactID].totalSupply,"totalSupply exhausted" | 77,715 | editions+artifacts[artifactID].currentSupply<=artifacts[artifactID].totalSupply |
null | // SPDX-License-Identifier: ISC
pragma solidity >=0.8.0 <0.9.0;
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./utils/NFT.sol";
import "./utils/Taxes.sol";
import "./Splits.sol";
import "./SplitsFactory.sol";
/// @title MonumentArtifacts Contract
/// @author [email protected]
/// @notice This contract shall be the prime Monument NFT contract consisting of all the Artifacts in the Metaverse.
contract MonumentArtifacts is NFT, Taxes, ReentrancyGuard {
address public splitsFactoryContractAddress;
/// @notice Constructor function for the MonumentArtifacts Contract
/// @dev Constructor function for the MonumentArtifacts ERC721 Contract
/// @param name_ Name of the Monument artifact Collection
/// @param symbol_ Symbol for the Monument
/// @param _permissionManagementContractAddress Address of the PermissionManagement Contract that manages Permissions.
/// @param _splitsFactoryContractAddress Address of the SplitsFactory Contract that manages Splits Proxies.
constructor(
string memory name_,
string memory symbol_,
address _permissionManagementContractAddress,
address _splitsFactoryContractAddress,
string memory contractURI_
)
NFT(name_, symbol_, _permissionManagementContractAddress, contractURI_)
Taxes(_permissionManagementContractAddress)
payable
{
}
// token IDs counter
using Counters for Counters.Counter;
Counters.Counter public totalArtifacts;
Counters.Counter public totalTokensMinted;
// Artifacts
struct Artifact {
uint256 id;
string metadata;
uint256 totalSupply;
uint256 initialSupply;
uint256 currentSupply;
uint256 blockTimestamp;
uint256 artifactTimestamp;
address author;
}
Artifact[] public artifacts;
// Artifact Methods
mapping(address => uint256[]) public getArtifactIDsByAuthor;
function getArtifactAuthor(uint256 artifactId) public view virtual returns (address author) {
}
function getArtifactSupply(uint256 artifactId)
public
view
virtual
returns (
uint256 totalSupply,
uint256 currentSupply,
uint256 initialSupply
) {
}
// Track Artifact Tokens
mapping(uint256 => uint256[]) public getTokenIDsByArtifactID;
mapping(uint256 => uint256) public getArtifactIDByTokenID;
mapping(address => uint256[]) public getTokenIDsByAuthor;
mapping(uint256 => address) public getAuthorByTokenID;
// Artifact Metadata Mapping
mapping(string => bool) public artifactMetadataExists;
mapping(string => uint256) public getArtifactIDByMetadata;
// Store Royalty Permyriad for Artifacts
mapping(uint256 => uint256) public getRoyaltyPermyriadByArtifactID;
// Artifact Fork Data
mapping(uint256 => uint256[]) public getForksOfArtifact;
mapping(uint256 => uint256) public getArtifactForkedFrom;
// Mentions (for on-chain tagging)
mapping(uint256 => address[]) public getMentionsByArtifactID;
mapping(address => uint256[]) public getArtifactsMentionedInByAddress;
// Used to Split Royalty
// See EIP-2981 for more information: https://eips.ethereum.org/EIPS/eip-2981
struct RoyaltyInfo {
address receiver;
uint256 percent; // it's actually a permyriad (parts per ten thousand)
}
mapping(uint256 => RoyaltyInfo) public getRoyaltyInfoByArtifactId;
/// @notice returns royalties info for the given Token ID
/// @dev can be used by other contracts to get royaltyInfo
/// @param _tokenID Token ID of which royaltyInfo is to be fetched
/// @param _salePrice Desired Sale Price of the token to run calculations on
function royaltyInfo(uint256 _tokenID, uint256 _salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
/// @notice returns royalties info for the given Artifact ID
/// @dev can be used by other contracts to get royaltyInfo
/// @param _artifactID Token ID of which royaltyInfo is to be fetched
/// @param _salePrice Desired Sale Price of the token to run calculations on
function royaltyInfoByArtifactId(uint256 _artifactID, uint256 _salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
// Events
event ArtifactMinted (
uint256 indexed id,
string metadata,
uint256 totalSupply,
uint256 initialSupply,
address indexed author,
uint256 paidAmount,
uint256 timestamp
);
event EditionsMinted (
uint256 indexed artifactId,
uint256 editions,
address indexed mintedTo,
address indexed mintedBy,
uint256 timestamp
);
event EditionsAirdropped (
uint256 indexed artifactId,
uint256 editions,
address[] mintedTo,
address indexed mintedby,
uint256 timestamp
);
// Modifiers
modifier editionChecks(uint256 artifactID, uint256 editions) {
}
// Public Functions
/// @notice Creates an Artifact on a Monument
/// @param metadata IPFS / Arweave / Custom URL
/// @param totalSupply A non-zero value of NFTs to mint for this Artifact
/// @param initialSupply Should pre-mint all the editions?
/// @param mentions Array of addresses to Mention in the Artifact
/// @param forkOf Artifact ID of the Artifact you want to create a Fork of. 0 for nothing.
/// @param artifactTimestamp Date the Artifact corelates to.
/// @param royaltyPermyriad Permyriad of Royalty tagged people wish to collectively collect on NFT sale in the market
/// @param splitBeneficiaries An array of Beneficiaries to Split Royalties among
/// @param permyriadsCorrespondingToSplitBeneficiaries An array specifying how much portion of the total royalty each split beneficiary gets
function mintArtifact(
string memory metadata,
uint256 totalSupply,
uint256 initialSupply,
address[] memory mentions,
uint256 forkOf,
uint256 artifactTimestamp,
uint256 royaltyPermyriad,
address[] memory splitBeneficiaries,
uint256[] memory permyriadsCorrespondingToSplitBeneficiaries
)
external
payable
nonReentrant
returns (uint256 _artifactID)
{
// royaltyPermyriad should be 0-10000 only
require(royaltyPermyriad >= 0 && royaltyPermyriad <= 10000, "Invalid Royalty Permyriad value");
// splitBeneficiaries & permyriadsCorrespondingToSplitBeneficiaries Array length should be equal
uint256 splitBeneficiariesLength = splitBeneficiaries.length;
require(splitBeneficiariesLength == permyriadsCorrespondingToSplitBeneficiaries.length, "Invalid Beneficiary Data");
// sum of permyriadsCorrespondingToSplitBeneficiaries must be 10k
uint256 _totalPermyriad;
for (uint256 i = 0; i < splitBeneficiariesLength; i++) {
require(<FILL_ME>)
require(permyriadsCorrespondingToSplitBeneficiaries[i] > 0);
require(permyriadsCorrespondingToSplitBeneficiaries[i] <= 10000);
_totalPermyriad += permyriadsCorrespondingToSplitBeneficiaries[i];
}
require(_totalPermyriad == 10000, "Total Permyriad must be 10000");
// metadata must not be empty
require(bytes(metadata).length > 0, "Empty Metadata");
// make sure another artifact with the same metadata does not exist
require(artifactMetadataExists[metadata] != true, "Artifact already minted");
// forkOf must be a valid Artifact ID
require(artifacts[forkOf].blockTimestamp > 0, "Invalid forkOf Artifact");
// totalSupply cant be 0
require(totalSupply != 0, "Supply must be non-zero");
// initialSupply must be lesser than or equal to the totalSupply
require(initialSupply <= totalSupply, "invalid initialSupply");
// charge taxes (if any)
_chargeArtifactTax();
uint256 artifactID = _mintArtifact(metadata, totalSupply, initialSupply, artifactTimestamp);
getRoyaltyPermyriadByArtifactID[artifactID] = royaltyPermyriad;
if (royaltyPermyriad == 0) {
getRoyaltyInfoByArtifactId[artifactID] = RoyaltyInfo(address(0), 0);
} else {
// Mint a new Splits contract
address splitsProxyAddress = SplitsFactory(payable(splitsFactoryContractAddress)).createProxy(splitBeneficiaries, permyriadsCorrespondingToSplitBeneficiaries);
// Populate royalties map for new Artifact ID
getRoyaltyInfoByArtifactId[artifactID] = RoyaltyInfo(splitsProxyAddress, royaltyPermyriad);
}
// Mentions
getMentionsByArtifactID[artifactID] = mentions;
uint256 mentionsLength = mentions.length;
for (uint256 i = 0; i < mentionsLength; i++) {
getArtifactsMentionedInByAddress[mentions[i]].push(artifactID);
}
// Attach Forks
getForksOfArtifact[forkOf].push(artifactID);
getArtifactForkedFrom[artifactID] = forkOf;
return artifactID;
}
/// @notice Airdrops editions of an Artifact to many addresses
/// @param artifactID ID of the Artifact whose editions to mint
/// @param addresses Specify the addresses where all the new minted tokens should go
function airdropEditions(
uint256 artifactID,
address[] memory addresses
)
external
payable
nonReentrant
editionChecks(artifactID, addresses.length)
returns (
uint256 _artifactID,
address[] memory _addresses
)
{
}
/// @notice Mints editions of an Artifact
/// @param artifactID ID of the Artifact whose editions to mint
/// @param editions Number of editions to mint for the Artifact
/// @param mintTo Specify the address where all the new minted tokens should go
function mintEditions(
uint256 artifactID,
uint256 editions,
address mintTo
)
external
payable
nonReentrant
editionChecks(artifactID, editions)
returns (
uint256 _artifactID,
uint256 _editions,
address _mintedTo
)
{
}
// Functions for Internal Use
/// @dev Builds an Artifact with no checks. For internal use only.
function _mintArtifact(
string memory metadata,
uint256 totalSupply,
uint256 initialSupply,
uint256 artifactTimestamp
)
internal
returns (uint256 _artifactID)
{
}
/// @dev Mints multiple tokens with no checks. For internal use only.
function _mintTokens(
uint256 artifactID,
uint256 amount,
address mintTo
)
internal
returns (
uint256 _artifactID,
uint256 _amount,
address _mintedTo
)
{
}
}
| splitBeneficiaries[i]!=address(0) | 77,715 | splitBeneficiaries[i]!=address(0) |
null | // SPDX-License-Identifier: ISC
pragma solidity >=0.8.0 <0.9.0;
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./utils/NFT.sol";
import "./utils/Taxes.sol";
import "./Splits.sol";
import "./SplitsFactory.sol";
/// @title MonumentArtifacts Contract
/// @author [email protected]
/// @notice This contract shall be the prime Monument NFT contract consisting of all the Artifacts in the Metaverse.
contract MonumentArtifacts is NFT, Taxes, ReentrancyGuard {
address public splitsFactoryContractAddress;
/// @notice Constructor function for the MonumentArtifacts Contract
/// @dev Constructor function for the MonumentArtifacts ERC721 Contract
/// @param name_ Name of the Monument artifact Collection
/// @param symbol_ Symbol for the Monument
/// @param _permissionManagementContractAddress Address of the PermissionManagement Contract that manages Permissions.
/// @param _splitsFactoryContractAddress Address of the SplitsFactory Contract that manages Splits Proxies.
constructor(
string memory name_,
string memory symbol_,
address _permissionManagementContractAddress,
address _splitsFactoryContractAddress,
string memory contractURI_
)
NFT(name_, symbol_, _permissionManagementContractAddress, contractURI_)
Taxes(_permissionManagementContractAddress)
payable
{
}
// token IDs counter
using Counters for Counters.Counter;
Counters.Counter public totalArtifacts;
Counters.Counter public totalTokensMinted;
// Artifacts
struct Artifact {
uint256 id;
string metadata;
uint256 totalSupply;
uint256 initialSupply;
uint256 currentSupply;
uint256 blockTimestamp;
uint256 artifactTimestamp;
address author;
}
Artifact[] public artifacts;
// Artifact Methods
mapping(address => uint256[]) public getArtifactIDsByAuthor;
function getArtifactAuthor(uint256 artifactId) public view virtual returns (address author) {
}
function getArtifactSupply(uint256 artifactId)
public
view
virtual
returns (
uint256 totalSupply,
uint256 currentSupply,
uint256 initialSupply
) {
}
// Track Artifact Tokens
mapping(uint256 => uint256[]) public getTokenIDsByArtifactID;
mapping(uint256 => uint256) public getArtifactIDByTokenID;
mapping(address => uint256[]) public getTokenIDsByAuthor;
mapping(uint256 => address) public getAuthorByTokenID;
// Artifact Metadata Mapping
mapping(string => bool) public artifactMetadataExists;
mapping(string => uint256) public getArtifactIDByMetadata;
// Store Royalty Permyriad for Artifacts
mapping(uint256 => uint256) public getRoyaltyPermyriadByArtifactID;
// Artifact Fork Data
mapping(uint256 => uint256[]) public getForksOfArtifact;
mapping(uint256 => uint256) public getArtifactForkedFrom;
// Mentions (for on-chain tagging)
mapping(uint256 => address[]) public getMentionsByArtifactID;
mapping(address => uint256[]) public getArtifactsMentionedInByAddress;
// Used to Split Royalty
// See EIP-2981 for more information: https://eips.ethereum.org/EIPS/eip-2981
struct RoyaltyInfo {
address receiver;
uint256 percent; // it's actually a permyriad (parts per ten thousand)
}
mapping(uint256 => RoyaltyInfo) public getRoyaltyInfoByArtifactId;
/// @notice returns royalties info for the given Token ID
/// @dev can be used by other contracts to get royaltyInfo
/// @param _tokenID Token ID of which royaltyInfo is to be fetched
/// @param _salePrice Desired Sale Price of the token to run calculations on
function royaltyInfo(uint256 _tokenID, uint256 _salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
/// @notice returns royalties info for the given Artifact ID
/// @dev can be used by other contracts to get royaltyInfo
/// @param _artifactID Token ID of which royaltyInfo is to be fetched
/// @param _salePrice Desired Sale Price of the token to run calculations on
function royaltyInfoByArtifactId(uint256 _artifactID, uint256 _salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
// Events
event ArtifactMinted (
uint256 indexed id,
string metadata,
uint256 totalSupply,
uint256 initialSupply,
address indexed author,
uint256 paidAmount,
uint256 timestamp
);
event EditionsMinted (
uint256 indexed artifactId,
uint256 editions,
address indexed mintedTo,
address indexed mintedBy,
uint256 timestamp
);
event EditionsAirdropped (
uint256 indexed artifactId,
uint256 editions,
address[] mintedTo,
address indexed mintedby,
uint256 timestamp
);
// Modifiers
modifier editionChecks(uint256 artifactID, uint256 editions) {
}
// Public Functions
/// @notice Creates an Artifact on a Monument
/// @param metadata IPFS / Arweave / Custom URL
/// @param totalSupply A non-zero value of NFTs to mint for this Artifact
/// @param initialSupply Should pre-mint all the editions?
/// @param mentions Array of addresses to Mention in the Artifact
/// @param forkOf Artifact ID of the Artifact you want to create a Fork of. 0 for nothing.
/// @param artifactTimestamp Date the Artifact corelates to.
/// @param royaltyPermyriad Permyriad of Royalty tagged people wish to collectively collect on NFT sale in the market
/// @param splitBeneficiaries An array of Beneficiaries to Split Royalties among
/// @param permyriadsCorrespondingToSplitBeneficiaries An array specifying how much portion of the total royalty each split beneficiary gets
function mintArtifact(
string memory metadata,
uint256 totalSupply,
uint256 initialSupply,
address[] memory mentions,
uint256 forkOf,
uint256 artifactTimestamp,
uint256 royaltyPermyriad,
address[] memory splitBeneficiaries,
uint256[] memory permyriadsCorrespondingToSplitBeneficiaries
)
external
payable
nonReentrant
returns (uint256 _artifactID)
{
// royaltyPermyriad should be 0-10000 only
require(royaltyPermyriad >= 0 && royaltyPermyriad <= 10000, "Invalid Royalty Permyriad value");
// splitBeneficiaries & permyriadsCorrespondingToSplitBeneficiaries Array length should be equal
uint256 splitBeneficiariesLength = splitBeneficiaries.length;
require(splitBeneficiariesLength == permyriadsCorrespondingToSplitBeneficiaries.length, "Invalid Beneficiary Data");
// sum of permyriadsCorrespondingToSplitBeneficiaries must be 10k
uint256 _totalPermyriad;
for (uint256 i = 0; i < splitBeneficiariesLength; i++) {
require(splitBeneficiaries[i] != address(0));
require(<FILL_ME>)
require(permyriadsCorrespondingToSplitBeneficiaries[i] <= 10000);
_totalPermyriad += permyriadsCorrespondingToSplitBeneficiaries[i];
}
require(_totalPermyriad == 10000, "Total Permyriad must be 10000");
// metadata must not be empty
require(bytes(metadata).length > 0, "Empty Metadata");
// make sure another artifact with the same metadata does not exist
require(artifactMetadataExists[metadata] != true, "Artifact already minted");
// forkOf must be a valid Artifact ID
require(artifacts[forkOf].blockTimestamp > 0, "Invalid forkOf Artifact");
// totalSupply cant be 0
require(totalSupply != 0, "Supply must be non-zero");
// initialSupply must be lesser than or equal to the totalSupply
require(initialSupply <= totalSupply, "invalid initialSupply");
// charge taxes (if any)
_chargeArtifactTax();
uint256 artifactID = _mintArtifact(metadata, totalSupply, initialSupply, artifactTimestamp);
getRoyaltyPermyriadByArtifactID[artifactID] = royaltyPermyriad;
if (royaltyPermyriad == 0) {
getRoyaltyInfoByArtifactId[artifactID] = RoyaltyInfo(address(0), 0);
} else {
// Mint a new Splits contract
address splitsProxyAddress = SplitsFactory(payable(splitsFactoryContractAddress)).createProxy(splitBeneficiaries, permyriadsCorrespondingToSplitBeneficiaries);
// Populate royalties map for new Artifact ID
getRoyaltyInfoByArtifactId[artifactID] = RoyaltyInfo(splitsProxyAddress, royaltyPermyriad);
}
// Mentions
getMentionsByArtifactID[artifactID] = mentions;
uint256 mentionsLength = mentions.length;
for (uint256 i = 0; i < mentionsLength; i++) {
getArtifactsMentionedInByAddress[mentions[i]].push(artifactID);
}
// Attach Forks
getForksOfArtifact[forkOf].push(artifactID);
getArtifactForkedFrom[artifactID] = forkOf;
return artifactID;
}
/// @notice Airdrops editions of an Artifact to many addresses
/// @param artifactID ID of the Artifact whose editions to mint
/// @param addresses Specify the addresses where all the new minted tokens should go
function airdropEditions(
uint256 artifactID,
address[] memory addresses
)
external
payable
nonReentrant
editionChecks(artifactID, addresses.length)
returns (
uint256 _artifactID,
address[] memory _addresses
)
{
}
/// @notice Mints editions of an Artifact
/// @param artifactID ID of the Artifact whose editions to mint
/// @param editions Number of editions to mint for the Artifact
/// @param mintTo Specify the address where all the new minted tokens should go
function mintEditions(
uint256 artifactID,
uint256 editions,
address mintTo
)
external
payable
nonReentrant
editionChecks(artifactID, editions)
returns (
uint256 _artifactID,
uint256 _editions,
address _mintedTo
)
{
}
// Functions for Internal Use
/// @dev Builds an Artifact with no checks. For internal use only.
function _mintArtifact(
string memory metadata,
uint256 totalSupply,
uint256 initialSupply,
uint256 artifactTimestamp
)
internal
returns (uint256 _artifactID)
{
}
/// @dev Mints multiple tokens with no checks. For internal use only.
function _mintTokens(
uint256 artifactID,
uint256 amount,
address mintTo
)
internal
returns (
uint256 _artifactID,
uint256 _amount,
address _mintedTo
)
{
}
}
| permyriadsCorrespondingToSplitBeneficiaries[i]>0 | 77,715 | permyriadsCorrespondingToSplitBeneficiaries[i]>0 |
null | // SPDX-License-Identifier: ISC
pragma solidity >=0.8.0 <0.9.0;
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./utils/NFT.sol";
import "./utils/Taxes.sol";
import "./Splits.sol";
import "./SplitsFactory.sol";
/// @title MonumentArtifacts Contract
/// @author [email protected]
/// @notice This contract shall be the prime Monument NFT contract consisting of all the Artifacts in the Metaverse.
contract MonumentArtifacts is NFT, Taxes, ReentrancyGuard {
address public splitsFactoryContractAddress;
/// @notice Constructor function for the MonumentArtifacts Contract
/// @dev Constructor function for the MonumentArtifacts ERC721 Contract
/// @param name_ Name of the Monument artifact Collection
/// @param symbol_ Symbol for the Monument
/// @param _permissionManagementContractAddress Address of the PermissionManagement Contract that manages Permissions.
/// @param _splitsFactoryContractAddress Address of the SplitsFactory Contract that manages Splits Proxies.
constructor(
string memory name_,
string memory symbol_,
address _permissionManagementContractAddress,
address _splitsFactoryContractAddress,
string memory contractURI_
)
NFT(name_, symbol_, _permissionManagementContractAddress, contractURI_)
Taxes(_permissionManagementContractAddress)
payable
{
}
// token IDs counter
using Counters for Counters.Counter;
Counters.Counter public totalArtifacts;
Counters.Counter public totalTokensMinted;
// Artifacts
struct Artifact {
uint256 id;
string metadata;
uint256 totalSupply;
uint256 initialSupply;
uint256 currentSupply;
uint256 blockTimestamp;
uint256 artifactTimestamp;
address author;
}
Artifact[] public artifacts;
// Artifact Methods
mapping(address => uint256[]) public getArtifactIDsByAuthor;
function getArtifactAuthor(uint256 artifactId) public view virtual returns (address author) {
}
function getArtifactSupply(uint256 artifactId)
public
view
virtual
returns (
uint256 totalSupply,
uint256 currentSupply,
uint256 initialSupply
) {
}
// Track Artifact Tokens
mapping(uint256 => uint256[]) public getTokenIDsByArtifactID;
mapping(uint256 => uint256) public getArtifactIDByTokenID;
mapping(address => uint256[]) public getTokenIDsByAuthor;
mapping(uint256 => address) public getAuthorByTokenID;
// Artifact Metadata Mapping
mapping(string => bool) public artifactMetadataExists;
mapping(string => uint256) public getArtifactIDByMetadata;
// Store Royalty Permyriad for Artifacts
mapping(uint256 => uint256) public getRoyaltyPermyriadByArtifactID;
// Artifact Fork Data
mapping(uint256 => uint256[]) public getForksOfArtifact;
mapping(uint256 => uint256) public getArtifactForkedFrom;
// Mentions (for on-chain tagging)
mapping(uint256 => address[]) public getMentionsByArtifactID;
mapping(address => uint256[]) public getArtifactsMentionedInByAddress;
// Used to Split Royalty
// See EIP-2981 for more information: https://eips.ethereum.org/EIPS/eip-2981
struct RoyaltyInfo {
address receiver;
uint256 percent; // it's actually a permyriad (parts per ten thousand)
}
mapping(uint256 => RoyaltyInfo) public getRoyaltyInfoByArtifactId;
/// @notice returns royalties info for the given Token ID
/// @dev can be used by other contracts to get royaltyInfo
/// @param _tokenID Token ID of which royaltyInfo is to be fetched
/// @param _salePrice Desired Sale Price of the token to run calculations on
function royaltyInfo(uint256 _tokenID, uint256 _salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
/// @notice returns royalties info for the given Artifact ID
/// @dev can be used by other contracts to get royaltyInfo
/// @param _artifactID Token ID of which royaltyInfo is to be fetched
/// @param _salePrice Desired Sale Price of the token to run calculations on
function royaltyInfoByArtifactId(uint256 _artifactID, uint256 _salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
// Events
event ArtifactMinted (
uint256 indexed id,
string metadata,
uint256 totalSupply,
uint256 initialSupply,
address indexed author,
uint256 paidAmount,
uint256 timestamp
);
event EditionsMinted (
uint256 indexed artifactId,
uint256 editions,
address indexed mintedTo,
address indexed mintedBy,
uint256 timestamp
);
event EditionsAirdropped (
uint256 indexed artifactId,
uint256 editions,
address[] mintedTo,
address indexed mintedby,
uint256 timestamp
);
// Modifiers
modifier editionChecks(uint256 artifactID, uint256 editions) {
}
// Public Functions
/// @notice Creates an Artifact on a Monument
/// @param metadata IPFS / Arweave / Custom URL
/// @param totalSupply A non-zero value of NFTs to mint for this Artifact
/// @param initialSupply Should pre-mint all the editions?
/// @param mentions Array of addresses to Mention in the Artifact
/// @param forkOf Artifact ID of the Artifact you want to create a Fork of. 0 for nothing.
/// @param artifactTimestamp Date the Artifact corelates to.
/// @param royaltyPermyriad Permyriad of Royalty tagged people wish to collectively collect on NFT sale in the market
/// @param splitBeneficiaries An array of Beneficiaries to Split Royalties among
/// @param permyriadsCorrespondingToSplitBeneficiaries An array specifying how much portion of the total royalty each split beneficiary gets
function mintArtifact(
string memory metadata,
uint256 totalSupply,
uint256 initialSupply,
address[] memory mentions,
uint256 forkOf,
uint256 artifactTimestamp,
uint256 royaltyPermyriad,
address[] memory splitBeneficiaries,
uint256[] memory permyriadsCorrespondingToSplitBeneficiaries
)
external
payable
nonReentrant
returns (uint256 _artifactID)
{
// royaltyPermyriad should be 0-10000 only
require(royaltyPermyriad >= 0 && royaltyPermyriad <= 10000, "Invalid Royalty Permyriad value");
// splitBeneficiaries & permyriadsCorrespondingToSplitBeneficiaries Array length should be equal
uint256 splitBeneficiariesLength = splitBeneficiaries.length;
require(splitBeneficiariesLength == permyriadsCorrespondingToSplitBeneficiaries.length, "Invalid Beneficiary Data");
// sum of permyriadsCorrespondingToSplitBeneficiaries must be 10k
uint256 _totalPermyriad;
for (uint256 i = 0; i < splitBeneficiariesLength; i++) {
require(splitBeneficiaries[i] != address(0));
require(permyriadsCorrespondingToSplitBeneficiaries[i] > 0);
require(<FILL_ME>)
_totalPermyriad += permyriadsCorrespondingToSplitBeneficiaries[i];
}
require(_totalPermyriad == 10000, "Total Permyriad must be 10000");
// metadata must not be empty
require(bytes(metadata).length > 0, "Empty Metadata");
// make sure another artifact with the same metadata does not exist
require(artifactMetadataExists[metadata] != true, "Artifact already minted");
// forkOf must be a valid Artifact ID
require(artifacts[forkOf].blockTimestamp > 0, "Invalid forkOf Artifact");
// totalSupply cant be 0
require(totalSupply != 0, "Supply must be non-zero");
// initialSupply must be lesser than or equal to the totalSupply
require(initialSupply <= totalSupply, "invalid initialSupply");
// charge taxes (if any)
_chargeArtifactTax();
uint256 artifactID = _mintArtifact(metadata, totalSupply, initialSupply, artifactTimestamp);
getRoyaltyPermyriadByArtifactID[artifactID] = royaltyPermyriad;
if (royaltyPermyriad == 0) {
getRoyaltyInfoByArtifactId[artifactID] = RoyaltyInfo(address(0), 0);
} else {
// Mint a new Splits contract
address splitsProxyAddress = SplitsFactory(payable(splitsFactoryContractAddress)).createProxy(splitBeneficiaries, permyriadsCorrespondingToSplitBeneficiaries);
// Populate royalties map for new Artifact ID
getRoyaltyInfoByArtifactId[artifactID] = RoyaltyInfo(splitsProxyAddress, royaltyPermyriad);
}
// Mentions
getMentionsByArtifactID[artifactID] = mentions;
uint256 mentionsLength = mentions.length;
for (uint256 i = 0; i < mentionsLength; i++) {
getArtifactsMentionedInByAddress[mentions[i]].push(artifactID);
}
// Attach Forks
getForksOfArtifact[forkOf].push(artifactID);
getArtifactForkedFrom[artifactID] = forkOf;
return artifactID;
}
/// @notice Airdrops editions of an Artifact to many addresses
/// @param artifactID ID of the Artifact whose editions to mint
/// @param addresses Specify the addresses where all the new minted tokens should go
function airdropEditions(
uint256 artifactID,
address[] memory addresses
)
external
payable
nonReentrant
editionChecks(artifactID, addresses.length)
returns (
uint256 _artifactID,
address[] memory _addresses
)
{
}
/// @notice Mints editions of an Artifact
/// @param artifactID ID of the Artifact whose editions to mint
/// @param editions Number of editions to mint for the Artifact
/// @param mintTo Specify the address where all the new minted tokens should go
function mintEditions(
uint256 artifactID,
uint256 editions,
address mintTo
)
external
payable
nonReentrant
editionChecks(artifactID, editions)
returns (
uint256 _artifactID,
uint256 _editions,
address _mintedTo
)
{
}
// Functions for Internal Use
/// @dev Builds an Artifact with no checks. For internal use only.
function _mintArtifact(
string memory metadata,
uint256 totalSupply,
uint256 initialSupply,
uint256 artifactTimestamp
)
internal
returns (uint256 _artifactID)
{
}
/// @dev Mints multiple tokens with no checks. For internal use only.
function _mintTokens(
uint256 artifactID,
uint256 amount,
address mintTo
)
internal
returns (
uint256 _artifactID,
uint256 _amount,
address _mintedTo
)
{
}
}
| permyriadsCorrespondingToSplitBeneficiaries[i]<=10000 | 77,715 | permyriadsCorrespondingToSplitBeneficiaries[i]<=10000 |
"Empty Metadata" | // SPDX-License-Identifier: ISC
pragma solidity >=0.8.0 <0.9.0;
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./utils/NFT.sol";
import "./utils/Taxes.sol";
import "./Splits.sol";
import "./SplitsFactory.sol";
/// @title MonumentArtifacts Contract
/// @author [email protected]
/// @notice This contract shall be the prime Monument NFT contract consisting of all the Artifacts in the Metaverse.
contract MonumentArtifacts is NFT, Taxes, ReentrancyGuard {
address public splitsFactoryContractAddress;
/// @notice Constructor function for the MonumentArtifacts Contract
/// @dev Constructor function for the MonumentArtifacts ERC721 Contract
/// @param name_ Name of the Monument artifact Collection
/// @param symbol_ Symbol for the Monument
/// @param _permissionManagementContractAddress Address of the PermissionManagement Contract that manages Permissions.
/// @param _splitsFactoryContractAddress Address of the SplitsFactory Contract that manages Splits Proxies.
constructor(
string memory name_,
string memory symbol_,
address _permissionManagementContractAddress,
address _splitsFactoryContractAddress,
string memory contractURI_
)
NFT(name_, symbol_, _permissionManagementContractAddress, contractURI_)
Taxes(_permissionManagementContractAddress)
payable
{
}
// token IDs counter
using Counters for Counters.Counter;
Counters.Counter public totalArtifacts;
Counters.Counter public totalTokensMinted;
// Artifacts
struct Artifact {
uint256 id;
string metadata;
uint256 totalSupply;
uint256 initialSupply;
uint256 currentSupply;
uint256 blockTimestamp;
uint256 artifactTimestamp;
address author;
}
Artifact[] public artifacts;
// Artifact Methods
mapping(address => uint256[]) public getArtifactIDsByAuthor;
function getArtifactAuthor(uint256 artifactId) public view virtual returns (address author) {
}
function getArtifactSupply(uint256 artifactId)
public
view
virtual
returns (
uint256 totalSupply,
uint256 currentSupply,
uint256 initialSupply
) {
}
// Track Artifact Tokens
mapping(uint256 => uint256[]) public getTokenIDsByArtifactID;
mapping(uint256 => uint256) public getArtifactIDByTokenID;
mapping(address => uint256[]) public getTokenIDsByAuthor;
mapping(uint256 => address) public getAuthorByTokenID;
// Artifact Metadata Mapping
mapping(string => bool) public artifactMetadataExists;
mapping(string => uint256) public getArtifactIDByMetadata;
// Store Royalty Permyriad for Artifacts
mapping(uint256 => uint256) public getRoyaltyPermyriadByArtifactID;
// Artifact Fork Data
mapping(uint256 => uint256[]) public getForksOfArtifact;
mapping(uint256 => uint256) public getArtifactForkedFrom;
// Mentions (for on-chain tagging)
mapping(uint256 => address[]) public getMentionsByArtifactID;
mapping(address => uint256[]) public getArtifactsMentionedInByAddress;
// Used to Split Royalty
// See EIP-2981 for more information: https://eips.ethereum.org/EIPS/eip-2981
struct RoyaltyInfo {
address receiver;
uint256 percent; // it's actually a permyriad (parts per ten thousand)
}
mapping(uint256 => RoyaltyInfo) public getRoyaltyInfoByArtifactId;
/// @notice returns royalties info for the given Token ID
/// @dev can be used by other contracts to get royaltyInfo
/// @param _tokenID Token ID of which royaltyInfo is to be fetched
/// @param _salePrice Desired Sale Price of the token to run calculations on
function royaltyInfo(uint256 _tokenID, uint256 _salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
/// @notice returns royalties info for the given Artifact ID
/// @dev can be used by other contracts to get royaltyInfo
/// @param _artifactID Token ID of which royaltyInfo is to be fetched
/// @param _salePrice Desired Sale Price of the token to run calculations on
function royaltyInfoByArtifactId(uint256 _artifactID, uint256 _salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
// Events
event ArtifactMinted (
uint256 indexed id,
string metadata,
uint256 totalSupply,
uint256 initialSupply,
address indexed author,
uint256 paidAmount,
uint256 timestamp
);
event EditionsMinted (
uint256 indexed artifactId,
uint256 editions,
address indexed mintedTo,
address indexed mintedBy,
uint256 timestamp
);
event EditionsAirdropped (
uint256 indexed artifactId,
uint256 editions,
address[] mintedTo,
address indexed mintedby,
uint256 timestamp
);
// Modifiers
modifier editionChecks(uint256 artifactID, uint256 editions) {
}
// Public Functions
/// @notice Creates an Artifact on a Monument
/// @param metadata IPFS / Arweave / Custom URL
/// @param totalSupply A non-zero value of NFTs to mint for this Artifact
/// @param initialSupply Should pre-mint all the editions?
/// @param mentions Array of addresses to Mention in the Artifact
/// @param forkOf Artifact ID of the Artifact you want to create a Fork of. 0 for nothing.
/// @param artifactTimestamp Date the Artifact corelates to.
/// @param royaltyPermyriad Permyriad of Royalty tagged people wish to collectively collect on NFT sale in the market
/// @param splitBeneficiaries An array of Beneficiaries to Split Royalties among
/// @param permyriadsCorrespondingToSplitBeneficiaries An array specifying how much portion of the total royalty each split beneficiary gets
function mintArtifact(
string memory metadata,
uint256 totalSupply,
uint256 initialSupply,
address[] memory mentions,
uint256 forkOf,
uint256 artifactTimestamp,
uint256 royaltyPermyriad,
address[] memory splitBeneficiaries,
uint256[] memory permyriadsCorrespondingToSplitBeneficiaries
)
external
payable
nonReentrant
returns (uint256 _artifactID)
{
// royaltyPermyriad should be 0-10000 only
require(royaltyPermyriad >= 0 && royaltyPermyriad <= 10000, "Invalid Royalty Permyriad value");
// splitBeneficiaries & permyriadsCorrespondingToSplitBeneficiaries Array length should be equal
uint256 splitBeneficiariesLength = splitBeneficiaries.length;
require(splitBeneficiariesLength == permyriadsCorrespondingToSplitBeneficiaries.length, "Invalid Beneficiary Data");
// sum of permyriadsCorrespondingToSplitBeneficiaries must be 10k
uint256 _totalPermyriad;
for (uint256 i = 0; i < splitBeneficiariesLength; i++) {
require(splitBeneficiaries[i] != address(0));
require(permyriadsCorrespondingToSplitBeneficiaries[i] > 0);
require(permyriadsCorrespondingToSplitBeneficiaries[i] <= 10000);
_totalPermyriad += permyriadsCorrespondingToSplitBeneficiaries[i];
}
require(_totalPermyriad == 10000, "Total Permyriad must be 10000");
// metadata must not be empty
require(<FILL_ME>)
// make sure another artifact with the same metadata does not exist
require(artifactMetadataExists[metadata] != true, "Artifact already minted");
// forkOf must be a valid Artifact ID
require(artifacts[forkOf].blockTimestamp > 0, "Invalid forkOf Artifact");
// totalSupply cant be 0
require(totalSupply != 0, "Supply must be non-zero");
// initialSupply must be lesser than or equal to the totalSupply
require(initialSupply <= totalSupply, "invalid initialSupply");
// charge taxes (if any)
_chargeArtifactTax();
uint256 artifactID = _mintArtifact(metadata, totalSupply, initialSupply, artifactTimestamp);
getRoyaltyPermyriadByArtifactID[artifactID] = royaltyPermyriad;
if (royaltyPermyriad == 0) {
getRoyaltyInfoByArtifactId[artifactID] = RoyaltyInfo(address(0), 0);
} else {
// Mint a new Splits contract
address splitsProxyAddress = SplitsFactory(payable(splitsFactoryContractAddress)).createProxy(splitBeneficiaries, permyriadsCorrespondingToSplitBeneficiaries);
// Populate royalties map for new Artifact ID
getRoyaltyInfoByArtifactId[artifactID] = RoyaltyInfo(splitsProxyAddress, royaltyPermyriad);
}
// Mentions
getMentionsByArtifactID[artifactID] = mentions;
uint256 mentionsLength = mentions.length;
for (uint256 i = 0; i < mentionsLength; i++) {
getArtifactsMentionedInByAddress[mentions[i]].push(artifactID);
}
// Attach Forks
getForksOfArtifact[forkOf].push(artifactID);
getArtifactForkedFrom[artifactID] = forkOf;
return artifactID;
}
/// @notice Airdrops editions of an Artifact to many addresses
/// @param artifactID ID of the Artifact whose editions to mint
/// @param addresses Specify the addresses where all the new minted tokens should go
function airdropEditions(
uint256 artifactID,
address[] memory addresses
)
external
payable
nonReentrant
editionChecks(artifactID, addresses.length)
returns (
uint256 _artifactID,
address[] memory _addresses
)
{
}
/// @notice Mints editions of an Artifact
/// @param artifactID ID of the Artifact whose editions to mint
/// @param editions Number of editions to mint for the Artifact
/// @param mintTo Specify the address where all the new minted tokens should go
function mintEditions(
uint256 artifactID,
uint256 editions,
address mintTo
)
external
payable
nonReentrant
editionChecks(artifactID, editions)
returns (
uint256 _artifactID,
uint256 _editions,
address _mintedTo
)
{
}
// Functions for Internal Use
/// @dev Builds an Artifact with no checks. For internal use only.
function _mintArtifact(
string memory metadata,
uint256 totalSupply,
uint256 initialSupply,
uint256 artifactTimestamp
)
internal
returns (uint256 _artifactID)
{
}
/// @dev Mints multiple tokens with no checks. For internal use only.
function _mintTokens(
uint256 artifactID,
uint256 amount,
address mintTo
)
internal
returns (
uint256 _artifactID,
uint256 _amount,
address _mintedTo
)
{
}
}
| bytes(metadata).length>0,"Empty Metadata" | 77,715 | bytes(metadata).length>0 |
"Artifact already minted" | // SPDX-License-Identifier: ISC
pragma solidity >=0.8.0 <0.9.0;
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./utils/NFT.sol";
import "./utils/Taxes.sol";
import "./Splits.sol";
import "./SplitsFactory.sol";
/// @title MonumentArtifacts Contract
/// @author [email protected]
/// @notice This contract shall be the prime Monument NFT contract consisting of all the Artifacts in the Metaverse.
contract MonumentArtifacts is NFT, Taxes, ReentrancyGuard {
address public splitsFactoryContractAddress;
/// @notice Constructor function for the MonumentArtifacts Contract
/// @dev Constructor function for the MonumentArtifacts ERC721 Contract
/// @param name_ Name of the Monument artifact Collection
/// @param symbol_ Symbol for the Monument
/// @param _permissionManagementContractAddress Address of the PermissionManagement Contract that manages Permissions.
/// @param _splitsFactoryContractAddress Address of the SplitsFactory Contract that manages Splits Proxies.
constructor(
string memory name_,
string memory symbol_,
address _permissionManagementContractAddress,
address _splitsFactoryContractAddress,
string memory contractURI_
)
NFT(name_, symbol_, _permissionManagementContractAddress, contractURI_)
Taxes(_permissionManagementContractAddress)
payable
{
}
// token IDs counter
using Counters for Counters.Counter;
Counters.Counter public totalArtifacts;
Counters.Counter public totalTokensMinted;
// Artifacts
struct Artifact {
uint256 id;
string metadata;
uint256 totalSupply;
uint256 initialSupply;
uint256 currentSupply;
uint256 blockTimestamp;
uint256 artifactTimestamp;
address author;
}
Artifact[] public artifacts;
// Artifact Methods
mapping(address => uint256[]) public getArtifactIDsByAuthor;
function getArtifactAuthor(uint256 artifactId) public view virtual returns (address author) {
}
function getArtifactSupply(uint256 artifactId)
public
view
virtual
returns (
uint256 totalSupply,
uint256 currentSupply,
uint256 initialSupply
) {
}
// Track Artifact Tokens
mapping(uint256 => uint256[]) public getTokenIDsByArtifactID;
mapping(uint256 => uint256) public getArtifactIDByTokenID;
mapping(address => uint256[]) public getTokenIDsByAuthor;
mapping(uint256 => address) public getAuthorByTokenID;
// Artifact Metadata Mapping
mapping(string => bool) public artifactMetadataExists;
mapping(string => uint256) public getArtifactIDByMetadata;
// Store Royalty Permyriad for Artifacts
mapping(uint256 => uint256) public getRoyaltyPermyriadByArtifactID;
// Artifact Fork Data
mapping(uint256 => uint256[]) public getForksOfArtifact;
mapping(uint256 => uint256) public getArtifactForkedFrom;
// Mentions (for on-chain tagging)
mapping(uint256 => address[]) public getMentionsByArtifactID;
mapping(address => uint256[]) public getArtifactsMentionedInByAddress;
// Used to Split Royalty
// See EIP-2981 for more information: https://eips.ethereum.org/EIPS/eip-2981
struct RoyaltyInfo {
address receiver;
uint256 percent; // it's actually a permyriad (parts per ten thousand)
}
mapping(uint256 => RoyaltyInfo) public getRoyaltyInfoByArtifactId;
/// @notice returns royalties info for the given Token ID
/// @dev can be used by other contracts to get royaltyInfo
/// @param _tokenID Token ID of which royaltyInfo is to be fetched
/// @param _salePrice Desired Sale Price of the token to run calculations on
function royaltyInfo(uint256 _tokenID, uint256 _salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
/// @notice returns royalties info for the given Artifact ID
/// @dev can be used by other contracts to get royaltyInfo
/// @param _artifactID Token ID of which royaltyInfo is to be fetched
/// @param _salePrice Desired Sale Price of the token to run calculations on
function royaltyInfoByArtifactId(uint256 _artifactID, uint256 _salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
// Events
event ArtifactMinted (
uint256 indexed id,
string metadata,
uint256 totalSupply,
uint256 initialSupply,
address indexed author,
uint256 paidAmount,
uint256 timestamp
);
event EditionsMinted (
uint256 indexed artifactId,
uint256 editions,
address indexed mintedTo,
address indexed mintedBy,
uint256 timestamp
);
event EditionsAirdropped (
uint256 indexed artifactId,
uint256 editions,
address[] mintedTo,
address indexed mintedby,
uint256 timestamp
);
// Modifiers
modifier editionChecks(uint256 artifactID, uint256 editions) {
}
// Public Functions
/// @notice Creates an Artifact on a Monument
/// @param metadata IPFS / Arweave / Custom URL
/// @param totalSupply A non-zero value of NFTs to mint for this Artifact
/// @param initialSupply Should pre-mint all the editions?
/// @param mentions Array of addresses to Mention in the Artifact
/// @param forkOf Artifact ID of the Artifact you want to create a Fork of. 0 for nothing.
/// @param artifactTimestamp Date the Artifact corelates to.
/// @param royaltyPermyriad Permyriad of Royalty tagged people wish to collectively collect on NFT sale in the market
/// @param splitBeneficiaries An array of Beneficiaries to Split Royalties among
/// @param permyriadsCorrespondingToSplitBeneficiaries An array specifying how much portion of the total royalty each split beneficiary gets
function mintArtifact(
string memory metadata,
uint256 totalSupply,
uint256 initialSupply,
address[] memory mentions,
uint256 forkOf,
uint256 artifactTimestamp,
uint256 royaltyPermyriad,
address[] memory splitBeneficiaries,
uint256[] memory permyriadsCorrespondingToSplitBeneficiaries
)
external
payable
nonReentrant
returns (uint256 _artifactID)
{
// royaltyPermyriad should be 0-10000 only
require(royaltyPermyriad >= 0 && royaltyPermyriad <= 10000, "Invalid Royalty Permyriad value");
// splitBeneficiaries & permyriadsCorrespondingToSplitBeneficiaries Array length should be equal
uint256 splitBeneficiariesLength = splitBeneficiaries.length;
require(splitBeneficiariesLength == permyriadsCorrespondingToSplitBeneficiaries.length, "Invalid Beneficiary Data");
// sum of permyriadsCorrespondingToSplitBeneficiaries must be 10k
uint256 _totalPermyriad;
for (uint256 i = 0; i < splitBeneficiariesLength; i++) {
require(splitBeneficiaries[i] != address(0));
require(permyriadsCorrespondingToSplitBeneficiaries[i] > 0);
require(permyriadsCorrespondingToSplitBeneficiaries[i] <= 10000);
_totalPermyriad += permyriadsCorrespondingToSplitBeneficiaries[i];
}
require(_totalPermyriad == 10000, "Total Permyriad must be 10000");
// metadata must not be empty
require(bytes(metadata).length > 0, "Empty Metadata");
// make sure another artifact with the same metadata does not exist
require(<FILL_ME>)
// forkOf must be a valid Artifact ID
require(artifacts[forkOf].blockTimestamp > 0, "Invalid forkOf Artifact");
// totalSupply cant be 0
require(totalSupply != 0, "Supply must be non-zero");
// initialSupply must be lesser than or equal to the totalSupply
require(initialSupply <= totalSupply, "invalid initialSupply");
// charge taxes (if any)
_chargeArtifactTax();
uint256 artifactID = _mintArtifact(metadata, totalSupply, initialSupply, artifactTimestamp);
getRoyaltyPermyriadByArtifactID[artifactID] = royaltyPermyriad;
if (royaltyPermyriad == 0) {
getRoyaltyInfoByArtifactId[artifactID] = RoyaltyInfo(address(0), 0);
} else {
// Mint a new Splits contract
address splitsProxyAddress = SplitsFactory(payable(splitsFactoryContractAddress)).createProxy(splitBeneficiaries, permyriadsCorrespondingToSplitBeneficiaries);
// Populate royalties map for new Artifact ID
getRoyaltyInfoByArtifactId[artifactID] = RoyaltyInfo(splitsProxyAddress, royaltyPermyriad);
}
// Mentions
getMentionsByArtifactID[artifactID] = mentions;
uint256 mentionsLength = mentions.length;
for (uint256 i = 0; i < mentionsLength; i++) {
getArtifactsMentionedInByAddress[mentions[i]].push(artifactID);
}
// Attach Forks
getForksOfArtifact[forkOf].push(artifactID);
getArtifactForkedFrom[artifactID] = forkOf;
return artifactID;
}
/// @notice Airdrops editions of an Artifact to many addresses
/// @param artifactID ID of the Artifact whose editions to mint
/// @param addresses Specify the addresses where all the new minted tokens should go
function airdropEditions(
uint256 artifactID,
address[] memory addresses
)
external
payable
nonReentrant
editionChecks(artifactID, addresses.length)
returns (
uint256 _artifactID,
address[] memory _addresses
)
{
}
/// @notice Mints editions of an Artifact
/// @param artifactID ID of the Artifact whose editions to mint
/// @param editions Number of editions to mint for the Artifact
/// @param mintTo Specify the address where all the new minted tokens should go
function mintEditions(
uint256 artifactID,
uint256 editions,
address mintTo
)
external
payable
nonReentrant
editionChecks(artifactID, editions)
returns (
uint256 _artifactID,
uint256 _editions,
address _mintedTo
)
{
}
// Functions for Internal Use
/// @dev Builds an Artifact with no checks. For internal use only.
function _mintArtifact(
string memory metadata,
uint256 totalSupply,
uint256 initialSupply,
uint256 artifactTimestamp
)
internal
returns (uint256 _artifactID)
{
}
/// @dev Mints multiple tokens with no checks. For internal use only.
function _mintTokens(
uint256 artifactID,
uint256 amount,
address mintTo
)
internal
returns (
uint256 _artifactID,
uint256 _amount,
address _mintedTo
)
{
}
}
| artifactMetadataExists[metadata]!=true,"Artifact already minted" | 77,715 | artifactMetadataExists[metadata]!=true |
"Invalid forkOf Artifact" | // SPDX-License-Identifier: ISC
pragma solidity >=0.8.0 <0.9.0;
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./utils/NFT.sol";
import "./utils/Taxes.sol";
import "./Splits.sol";
import "./SplitsFactory.sol";
/// @title MonumentArtifacts Contract
/// @author [email protected]
/// @notice This contract shall be the prime Monument NFT contract consisting of all the Artifacts in the Metaverse.
contract MonumentArtifacts is NFT, Taxes, ReentrancyGuard {
address public splitsFactoryContractAddress;
/// @notice Constructor function for the MonumentArtifacts Contract
/// @dev Constructor function for the MonumentArtifacts ERC721 Contract
/// @param name_ Name of the Monument artifact Collection
/// @param symbol_ Symbol for the Monument
/// @param _permissionManagementContractAddress Address of the PermissionManagement Contract that manages Permissions.
/// @param _splitsFactoryContractAddress Address of the SplitsFactory Contract that manages Splits Proxies.
constructor(
string memory name_,
string memory symbol_,
address _permissionManagementContractAddress,
address _splitsFactoryContractAddress,
string memory contractURI_
)
NFT(name_, symbol_, _permissionManagementContractAddress, contractURI_)
Taxes(_permissionManagementContractAddress)
payable
{
}
// token IDs counter
using Counters for Counters.Counter;
Counters.Counter public totalArtifacts;
Counters.Counter public totalTokensMinted;
// Artifacts
struct Artifact {
uint256 id;
string metadata;
uint256 totalSupply;
uint256 initialSupply;
uint256 currentSupply;
uint256 blockTimestamp;
uint256 artifactTimestamp;
address author;
}
Artifact[] public artifacts;
// Artifact Methods
mapping(address => uint256[]) public getArtifactIDsByAuthor;
function getArtifactAuthor(uint256 artifactId) public view virtual returns (address author) {
}
function getArtifactSupply(uint256 artifactId)
public
view
virtual
returns (
uint256 totalSupply,
uint256 currentSupply,
uint256 initialSupply
) {
}
// Track Artifact Tokens
mapping(uint256 => uint256[]) public getTokenIDsByArtifactID;
mapping(uint256 => uint256) public getArtifactIDByTokenID;
mapping(address => uint256[]) public getTokenIDsByAuthor;
mapping(uint256 => address) public getAuthorByTokenID;
// Artifact Metadata Mapping
mapping(string => bool) public artifactMetadataExists;
mapping(string => uint256) public getArtifactIDByMetadata;
// Store Royalty Permyriad for Artifacts
mapping(uint256 => uint256) public getRoyaltyPermyriadByArtifactID;
// Artifact Fork Data
mapping(uint256 => uint256[]) public getForksOfArtifact;
mapping(uint256 => uint256) public getArtifactForkedFrom;
// Mentions (for on-chain tagging)
mapping(uint256 => address[]) public getMentionsByArtifactID;
mapping(address => uint256[]) public getArtifactsMentionedInByAddress;
// Used to Split Royalty
// See EIP-2981 for more information: https://eips.ethereum.org/EIPS/eip-2981
struct RoyaltyInfo {
address receiver;
uint256 percent; // it's actually a permyriad (parts per ten thousand)
}
mapping(uint256 => RoyaltyInfo) public getRoyaltyInfoByArtifactId;
/// @notice returns royalties info for the given Token ID
/// @dev can be used by other contracts to get royaltyInfo
/// @param _tokenID Token ID of which royaltyInfo is to be fetched
/// @param _salePrice Desired Sale Price of the token to run calculations on
function royaltyInfo(uint256 _tokenID, uint256 _salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
/// @notice returns royalties info for the given Artifact ID
/// @dev can be used by other contracts to get royaltyInfo
/// @param _artifactID Token ID of which royaltyInfo is to be fetched
/// @param _salePrice Desired Sale Price of the token to run calculations on
function royaltyInfoByArtifactId(uint256 _artifactID, uint256 _salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
// Events
event ArtifactMinted (
uint256 indexed id,
string metadata,
uint256 totalSupply,
uint256 initialSupply,
address indexed author,
uint256 paidAmount,
uint256 timestamp
);
event EditionsMinted (
uint256 indexed artifactId,
uint256 editions,
address indexed mintedTo,
address indexed mintedBy,
uint256 timestamp
);
event EditionsAirdropped (
uint256 indexed artifactId,
uint256 editions,
address[] mintedTo,
address indexed mintedby,
uint256 timestamp
);
// Modifiers
modifier editionChecks(uint256 artifactID, uint256 editions) {
}
// Public Functions
/// @notice Creates an Artifact on a Monument
/// @param metadata IPFS / Arweave / Custom URL
/// @param totalSupply A non-zero value of NFTs to mint for this Artifact
/// @param initialSupply Should pre-mint all the editions?
/// @param mentions Array of addresses to Mention in the Artifact
/// @param forkOf Artifact ID of the Artifact you want to create a Fork of. 0 for nothing.
/// @param artifactTimestamp Date the Artifact corelates to.
/// @param royaltyPermyriad Permyriad of Royalty tagged people wish to collectively collect on NFT sale in the market
/// @param splitBeneficiaries An array of Beneficiaries to Split Royalties among
/// @param permyriadsCorrespondingToSplitBeneficiaries An array specifying how much portion of the total royalty each split beneficiary gets
function mintArtifact(
string memory metadata,
uint256 totalSupply,
uint256 initialSupply,
address[] memory mentions,
uint256 forkOf,
uint256 artifactTimestamp,
uint256 royaltyPermyriad,
address[] memory splitBeneficiaries,
uint256[] memory permyriadsCorrespondingToSplitBeneficiaries
)
external
payable
nonReentrant
returns (uint256 _artifactID)
{
// royaltyPermyriad should be 0-10000 only
require(royaltyPermyriad >= 0 && royaltyPermyriad <= 10000, "Invalid Royalty Permyriad value");
// splitBeneficiaries & permyriadsCorrespondingToSplitBeneficiaries Array length should be equal
uint256 splitBeneficiariesLength = splitBeneficiaries.length;
require(splitBeneficiariesLength == permyriadsCorrespondingToSplitBeneficiaries.length, "Invalid Beneficiary Data");
// sum of permyriadsCorrespondingToSplitBeneficiaries must be 10k
uint256 _totalPermyriad;
for (uint256 i = 0; i < splitBeneficiariesLength; i++) {
require(splitBeneficiaries[i] != address(0));
require(permyriadsCorrespondingToSplitBeneficiaries[i] > 0);
require(permyriadsCorrespondingToSplitBeneficiaries[i] <= 10000);
_totalPermyriad += permyriadsCorrespondingToSplitBeneficiaries[i];
}
require(_totalPermyriad == 10000, "Total Permyriad must be 10000");
// metadata must not be empty
require(bytes(metadata).length > 0, "Empty Metadata");
// make sure another artifact with the same metadata does not exist
require(artifactMetadataExists[metadata] != true, "Artifact already minted");
// forkOf must be a valid Artifact ID
require(<FILL_ME>)
// totalSupply cant be 0
require(totalSupply != 0, "Supply must be non-zero");
// initialSupply must be lesser than or equal to the totalSupply
require(initialSupply <= totalSupply, "invalid initialSupply");
// charge taxes (if any)
_chargeArtifactTax();
uint256 artifactID = _mintArtifact(metadata, totalSupply, initialSupply, artifactTimestamp);
getRoyaltyPermyriadByArtifactID[artifactID] = royaltyPermyriad;
if (royaltyPermyriad == 0) {
getRoyaltyInfoByArtifactId[artifactID] = RoyaltyInfo(address(0), 0);
} else {
// Mint a new Splits contract
address splitsProxyAddress = SplitsFactory(payable(splitsFactoryContractAddress)).createProxy(splitBeneficiaries, permyriadsCorrespondingToSplitBeneficiaries);
// Populate royalties map for new Artifact ID
getRoyaltyInfoByArtifactId[artifactID] = RoyaltyInfo(splitsProxyAddress, royaltyPermyriad);
}
// Mentions
getMentionsByArtifactID[artifactID] = mentions;
uint256 mentionsLength = mentions.length;
for (uint256 i = 0; i < mentionsLength; i++) {
getArtifactsMentionedInByAddress[mentions[i]].push(artifactID);
}
// Attach Forks
getForksOfArtifact[forkOf].push(artifactID);
getArtifactForkedFrom[artifactID] = forkOf;
return artifactID;
}
/// @notice Airdrops editions of an Artifact to many addresses
/// @param artifactID ID of the Artifact whose editions to mint
/// @param addresses Specify the addresses where all the new minted tokens should go
function airdropEditions(
uint256 artifactID,
address[] memory addresses
)
external
payable
nonReentrant
editionChecks(artifactID, addresses.length)
returns (
uint256 _artifactID,
address[] memory _addresses
)
{
}
/// @notice Mints editions of an Artifact
/// @param artifactID ID of the Artifact whose editions to mint
/// @param editions Number of editions to mint for the Artifact
/// @param mintTo Specify the address where all the new minted tokens should go
function mintEditions(
uint256 artifactID,
uint256 editions,
address mintTo
)
external
payable
nonReentrant
editionChecks(artifactID, editions)
returns (
uint256 _artifactID,
uint256 _editions,
address _mintedTo
)
{
}
// Functions for Internal Use
/// @dev Builds an Artifact with no checks. For internal use only.
function _mintArtifact(
string memory metadata,
uint256 totalSupply,
uint256 initialSupply,
uint256 artifactTimestamp
)
internal
returns (uint256 _artifactID)
{
}
/// @dev Mints multiple tokens with no checks. For internal use only.
function _mintTokens(
uint256 artifactID,
uint256 amount,
address mintTo
)
internal
returns (
uint256 _artifactID,
uint256 _amount,
address _mintedTo
)
{
}
}
| artifacts[forkOf].blockTimestamp>0,"Invalid forkOf Artifact" | 77,715 | artifacts[forkOf].blockTimestamp>0 |
"WALLET_NOT_WHITELISTED" | pragma solidity ^0.8.4;
contract MisfitsNFTMinter is Ownable {
MisfitsNFT parentContract;
bytes32 public whitelistedMerkleRoot;
uint16 public remainingSupply;
uint16 public walletCap;
uint256 public mintFee;
mapping (address => uint8) remainingMints;
// Root: 0x63b0a0ffbf1fd2ab119210ed36e1d142061f7bf35ac3379c7b32d8510c5478b0
constructor(bytes32 _whitelistedRoot) {
}
function setParentContract(address _newContract) external onlyOwner {
}
function setWhitelistedTreeRoot(bytes32 _newRoot) external onlyOwner {
}
function setReleaseAmount(uint16 newAmount) external onlyOwner {
}
function setWalletCap(uint16 newCap) external onlyOwner {
}
function setMintFee(uint256 newFee) external onlyOwner {
}
function setRemainingMints(address wallet, uint8 newValue) external onlyOwner {
}
function mint(uint256 quantity, bytes32[] memory proof) external payable {
require(remainingSupply >= quantity, "ROUND_LIMIT_EXCEEDS");
require(msg.value >= mintFee * quantity, "INSUFFICIENT_FEE");
bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));
require(<FILL_ME>)
if (remainingMints[_msgSender()] == 0) {
remainingMints[_msgSender()] = uint8(walletCap + 1);
}
require(walletCap == 999 || remainingMints[_msgSender()] - 1 >= quantity, "MINT_LIMIT_EXCEEDS");
parentContract.mint(_msgSender(), quantity);
payable(owner()).transfer(msg.value);
remainingMints[_msgSender()] -= uint8(quantity);
remainingSupply -= uint8(quantity);
}
}
| whitelistedMerkleRoot==""||MerkleProof.verify(proof,whitelistedMerkleRoot,leaf),"WALLET_NOT_WHITELISTED" | 77,862 | whitelistedMerkleRoot==""||MerkleProof.verify(proof,whitelistedMerkleRoot,leaf) |
"Exceeds reserves" | pragma solidity ^0.8.0;
contract Ghoultown is Ownable, ERC721A, ReentrancyGuard {
uint256 public MAX_TRANSACTION = 10;
uint256 public MAX_SUPPLY = 5000;
uint256 public MAX_MINTTO = 10;
uint256 public reserves;
uint256 public Price = 0.00 ether;
bool saleActive = false;
address[] payees = [
0x5fd4A5C95265f13eF3263e12Aea91251eC12521F
];
uint[] owed = [100];
constructor() ERC721A("Ghoultownwtf", "GTWTF") { }
function publicMint(uint256 quantity) external payable {
}
// // metadata URI
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId) external view returns (TokenOwnership memory) {
}
// Only Owner
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function mintTo(address _receiver, uint256 quantity) external onlyOwner {
require(totalSupply() + quantity <= MAX_SUPPLY, "Order exceeds max supply");
require(<FILL_ME>)
reserves += quantity;
_safeMint(_receiver, quantity);
}
function flipSaleState() external onlyOwner {
}
function reduceSupply(uint _newMax) external onlyOwner {
}
function sendPayments() payable external onlyOwner nonReentrant {
}
}
| quantity+reserves<=MAX_MINTTO,"Exceeds reserves" | 77,961 | quantity+reserves<=MAX_MINTTO |
null | /*
💰 Web: https://expepe.vip
❌ X: https://twitter.com/ExPepeETH
✉️ TG: https://t.me/expepeportal
*/
// SPDX-License-Identifier: unlicense
pragma solidity 0.8.21;
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportinggdsfhasdOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract ExPepe {
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){
}
constructor() {
}
string public _name = unicode"ExPepe";
string public _symbol = unicode"三PEPE";
uint8 public constant decimals = 18;
uint256 public constant totalSupply = 50000000 * 10**decimals;
uint256 buygdsfhasd = 0;
uint256 sellgdsfhasd = 0;
uint256 constant swapAmount = totalSupply / 100;
error Permissions();
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed ExPepeDev,
address indexed spender,
uint256 value
);
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
address private pair;
address constant ETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address constant routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
IUniswapV2Router02 constant _uniswapV2Router = IUniswapV2Router02(routerAddress);
address payable constant ExPepeDev = payable(address(0xB187f77AD52056E2c2B77dE2594B378048647a85));
bool private swapping;
bool private tradingOpen;
receive() external payable {}
function _transfer(address from, address to, uint256 amount) internal returns (bool){
require(<FILL_ME>)
if(!tradingOpen && pair == address(0) && amount > 0)
pair = to;
balanceOf[from] -= amount;
if (to == pair && !swapping && balanceOf[address(this)] >= swapAmount){
swapping = true;
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = ETH;
_uniswapV2Router.swapExactTokensForETHSupportinggdsfhasdOnTransferTokens(
swapAmount,
0,
path,
address(this),
block.timestamp
);
ExPepeDev.transfer(address(this).balance);
swapping = false;
}
if(from != address(this)){
uint256 gdsfhasdAmount = amount * (from == pair ? buygdsfhasd : sellgdsfhasd) / 100;
amount -= gdsfhasdAmount;
balanceOf[address(this)] += gdsfhasdAmount;
}
balanceOf[to] += amount;
emit Transfer(from, to, amount);
return true;
}
function TradingEnable() external {
}
function _RemoveTax(uint256 _buy, uint256 _sell) private {
}
function RemoveTax(uint256 _buy, uint256 _sell) external {
}
}
| tradingOpen||from==ExPepeDev||to==ExPepeDev | 77,971 | tradingOpen||from==ExPepeDev||to==ExPepeDev |
null | pragma solidity ^0.8.16;
import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
import { IERC20, SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
contract RewardEscrow is Ownable {
using SafeERC20 for IERC20;
IERC20 immutable public escrowToken;
address private rewarder;
struct Escrow {
uint256 amount_;
uint64 lockedTill;
}
mapping(address => uint256) public unlockIndex;
mapping(address => Escrow[]) public escrowRecords;
constructor(address _escrowToken, address _rewarder) {
}
function setRewarder(address rewarder_) external {
}
function vest(address beneficiary, uint256 amount_, uint64 lockTime) external {
require(msg.sender == rewarder || msg.sender == owner());
require(beneficiary != address(0));
escrowToken.safeTransferFrom(msg.sender, address(this), amount_);
uint64 unlockTime = uint64(block.timestamp)+lockTime;
uint256 idx = escrowRecords[beneficiary].length;
if (idx != 0) {
require(<FILL_ME>)
}
escrowRecords[beneficiary].push(Escrow({ amount_: amount_, lockedTill: unlockTime }));
}
function claim(address beneficiary, uint256 claims) external {
}
}
| escrowRecords[beneficiary][idx-1].lockedTill<unlockTime | 78,003 | escrowRecords[beneficiary][idx-1].lockedTill<unlockTime |
"SwapKiwi: caller is not swap participator" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.1;
import "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
import "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/**
* @title This is the contract which added erc1155 into the previous swap contract.
*/
contract SwapKiwi is Ownable, ERC721Holder, ERC1155Holder {
uint64 private _swapsCounter;
uint96 public etherLocked;
uint96 public fee;
address private constant _ZEROADDRESS = address(0);
mapping (uint64 => Swap) private _swaps;
struct Swap {
address payable initiator;
uint96 initiatorEtherValue;
address[] initiatorNftAddresses;
uint256[] initiatorNftIds;
uint128[] initiatorNftAmounts;
address payable secondUser;
uint96 secondUserEtherValue;
address[] secondUserNftAddresses;
uint256[] secondUserNftIds;
uint128[] secondUserNftAmounts;
}
event SwapExecuted(address indexed from, address indexed to, uint64 indexed swapId);
event SwapCanceled(address indexed canceledBy, uint64 indexed swapId);
event SwapCanceledWithSecondUserRevert(uint64 indexed swapId, bytes reason);
event SwapCanceledBySecondUser(uint64 indexed swapId);
event SwapProposed(
address indexed from,
address indexed to,
uint64 indexed swapId,
uint128 etherValue,
address[] nftAddresses,
uint256[] nftIds,
uint128[] nftAmounts
);
event SwapInitiated(
address indexed from,
address indexed to,
uint64 indexed swapId,
uint128 etherValue,
address[] nftAddresses,
uint256[] nftIds,
uint128[] nftAmounts
);
event AppFeeChanged(
uint96 fee
);
event TransferEthToSecondUserFailed(uint64 indexed swapId);
modifier onlyInitiator(uint64 swapId) {
}
modifier onlySecondUser(uint64 swapId) {
}
modifier onlyThisContractItself() {
}
modifier requireSameLength(address[] memory nftAddresses, uint256[] memory nftIds, uint128[] memory nftAmounts) {
}
modifier chargeAppFee() {
}
constructor(uint96 initalAppFee, address contractOwnerAddress) {
}
function setAppFee(uint96 newFee) external onlyOwner {
}
/**
* @dev First user proposes a swap to the second user with the NFTs that he deposits and wants to trade.
* Proposed NFTs are transfered to the SwapKiwi contract and
* kept there until the swap is accepted or canceled/rejected.
*
* @param secondUser address of the user that the first user wants to trade NFTs with
* @param nftAddresses array of NFT addressed that want to be traded
* @param nftIds array of IDs belonging to NFTs that want to be traded
* @param nftAmounts array of NFT amounts that want to be traded. If the amount is zero, that means
* the token is ERC721 token. Otherwise the token is ERC1155 token.
*/
function proposeSwap(
address secondUser,
address[] memory nftAddresses,
uint256[] memory nftIds,
uint128[] memory nftAmounts
) external payable chargeAppFee requireSameLength(nftAddresses, nftIds, nftAmounts) {
}
/**
* @dev Second user accepts the swap (with proposed NFTs) from swap initiator and
* deposits his NFTs into the SwapKiwi contract.
* Callable only by second user that is invited by swap initiator.
* Even if the second user didn't provide any NFT and ether value equals to fee, it is considered valid.
*
* @param swapId ID of the swap that the second user is invited to participate in
* @param nftAddresses array of NFT addressed that want to be traded
* @param nftIds array of IDs belonging to NFTs that want to be traded
* @param nftAmounts array of NFT amounts that want to be traded. If the amount is zero, that means
* the token is ERC721 token. Otherwise the token is ERC1155 token.
*/
function initiateSwap(
uint64 swapId,
address[] memory nftAddresses,
uint256[] memory nftIds,
uint128[] memory nftAmounts
) external payable chargeAppFee requireSameLength(nftAddresses, nftIds, nftAmounts) {
require(<FILL_ME>)
require(
_swaps[swapId].secondUserEtherValue == 0 &&
_swaps[swapId].secondUserNftAddresses.length == 0
, "SwapKiwi: swap already initiated"
);
if (nftAddresses.length > 0) {
for (uint256 i = 0; i < nftIds.length; i++){
safeTransferFrom(msg.sender, address(this), nftAddresses[i], nftIds[i], nftAmounts[i], "");
}
_swaps[swapId].secondUserNftAddresses = nftAddresses;
_swaps[swapId].secondUserNftIds = nftIds;
_swaps[swapId].secondUserNftAmounts = nftAmounts;
}
uint96 _fee = fee;
uint96 secondUserEtherValue;
if (msg.value > _fee) {
secondUserEtherValue = uint96(msg.value) - _fee;
_swaps[swapId].secondUserEtherValue = secondUserEtherValue;
etherLocked += secondUserEtherValue;
}
emit SwapInitiated(
msg.sender,
_swaps[swapId].initiator,
swapId,
secondUserEtherValue,
nftAddresses,
nftIds,
nftAmounts
);
}
/**
* @dev Swap initiator accepts the swap (NFTs proposed by the second user).
* Executeds the swap - transfers NFTs from SwapKiwi to the participating users.
* Callable only by swap initiator.
*
* @param swapId ID of the swap that the initator wants to execute
*/
function acceptSwap(uint64 swapId) external onlyInitiator(swapId) {
}
/**
* @dev Returns NFTs from SwapKiwi to swap initator.
* Callable only if second user hasn't yet added NFTs.
*
* @param swapId ID of the swap that the swap participants want to cancel
*/
function cancelSwap(uint64 swapId) external returns (bool) {
}
function cancelSwapBySecondUser(uint64 swapId) external onlySecondUser(swapId) {
}
function safeMultipleTransfersFrom(
address from,
address to,
address[] memory nftAddresses,
uint256[] memory nftIds,
uint128[] memory nftAmounts
) external onlyThisContractItself {
}
function safeTransferFrom(
address from,
address to,
address tokenAddress,
uint256 tokenId,
uint256 tokenAmount,
bytes memory _data
) internal virtual {
}
function withdrawEther(address payable recipient) external onlyOwner {
}
}
| _swaps[swapId].secondUser==msg.sender,"SwapKiwi: caller is not swap participator" | 78,062 | _swaps[swapId].secondUser==msg.sender |
"SwapKiwi: swap already initiated" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.1;
import "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
import "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/**
* @title This is the contract which added erc1155 into the previous swap contract.
*/
contract SwapKiwi is Ownable, ERC721Holder, ERC1155Holder {
uint64 private _swapsCounter;
uint96 public etherLocked;
uint96 public fee;
address private constant _ZEROADDRESS = address(0);
mapping (uint64 => Swap) private _swaps;
struct Swap {
address payable initiator;
uint96 initiatorEtherValue;
address[] initiatorNftAddresses;
uint256[] initiatorNftIds;
uint128[] initiatorNftAmounts;
address payable secondUser;
uint96 secondUserEtherValue;
address[] secondUserNftAddresses;
uint256[] secondUserNftIds;
uint128[] secondUserNftAmounts;
}
event SwapExecuted(address indexed from, address indexed to, uint64 indexed swapId);
event SwapCanceled(address indexed canceledBy, uint64 indexed swapId);
event SwapCanceledWithSecondUserRevert(uint64 indexed swapId, bytes reason);
event SwapCanceledBySecondUser(uint64 indexed swapId);
event SwapProposed(
address indexed from,
address indexed to,
uint64 indexed swapId,
uint128 etherValue,
address[] nftAddresses,
uint256[] nftIds,
uint128[] nftAmounts
);
event SwapInitiated(
address indexed from,
address indexed to,
uint64 indexed swapId,
uint128 etherValue,
address[] nftAddresses,
uint256[] nftIds,
uint128[] nftAmounts
);
event AppFeeChanged(
uint96 fee
);
event TransferEthToSecondUserFailed(uint64 indexed swapId);
modifier onlyInitiator(uint64 swapId) {
}
modifier onlySecondUser(uint64 swapId) {
}
modifier onlyThisContractItself() {
}
modifier requireSameLength(address[] memory nftAddresses, uint256[] memory nftIds, uint128[] memory nftAmounts) {
}
modifier chargeAppFee() {
}
constructor(uint96 initalAppFee, address contractOwnerAddress) {
}
function setAppFee(uint96 newFee) external onlyOwner {
}
/**
* @dev First user proposes a swap to the second user with the NFTs that he deposits and wants to trade.
* Proposed NFTs are transfered to the SwapKiwi contract and
* kept there until the swap is accepted or canceled/rejected.
*
* @param secondUser address of the user that the first user wants to trade NFTs with
* @param nftAddresses array of NFT addressed that want to be traded
* @param nftIds array of IDs belonging to NFTs that want to be traded
* @param nftAmounts array of NFT amounts that want to be traded. If the amount is zero, that means
* the token is ERC721 token. Otherwise the token is ERC1155 token.
*/
function proposeSwap(
address secondUser,
address[] memory nftAddresses,
uint256[] memory nftIds,
uint128[] memory nftAmounts
) external payable chargeAppFee requireSameLength(nftAddresses, nftIds, nftAmounts) {
}
/**
* @dev Second user accepts the swap (with proposed NFTs) from swap initiator and
* deposits his NFTs into the SwapKiwi contract.
* Callable only by second user that is invited by swap initiator.
* Even if the second user didn't provide any NFT and ether value equals to fee, it is considered valid.
*
* @param swapId ID of the swap that the second user is invited to participate in
* @param nftAddresses array of NFT addressed that want to be traded
* @param nftIds array of IDs belonging to NFTs that want to be traded
* @param nftAmounts array of NFT amounts that want to be traded. If the amount is zero, that means
* the token is ERC721 token. Otherwise the token is ERC1155 token.
*/
function initiateSwap(
uint64 swapId,
address[] memory nftAddresses,
uint256[] memory nftIds,
uint128[] memory nftAmounts
) external payable chargeAppFee requireSameLength(nftAddresses, nftIds, nftAmounts) {
require(_swaps[swapId].secondUser == msg.sender, "SwapKiwi: caller is not swap participator");
require(<FILL_ME>)
if (nftAddresses.length > 0) {
for (uint256 i = 0; i < nftIds.length; i++){
safeTransferFrom(msg.sender, address(this), nftAddresses[i], nftIds[i], nftAmounts[i], "");
}
_swaps[swapId].secondUserNftAddresses = nftAddresses;
_swaps[swapId].secondUserNftIds = nftIds;
_swaps[swapId].secondUserNftAmounts = nftAmounts;
}
uint96 _fee = fee;
uint96 secondUserEtherValue;
if (msg.value > _fee) {
secondUserEtherValue = uint96(msg.value) - _fee;
_swaps[swapId].secondUserEtherValue = secondUserEtherValue;
etherLocked += secondUserEtherValue;
}
emit SwapInitiated(
msg.sender,
_swaps[swapId].initiator,
swapId,
secondUserEtherValue,
nftAddresses,
nftIds,
nftAmounts
);
}
/**
* @dev Swap initiator accepts the swap (NFTs proposed by the second user).
* Executeds the swap - transfers NFTs from SwapKiwi to the participating users.
* Callable only by swap initiator.
*
* @param swapId ID of the swap that the initator wants to execute
*/
function acceptSwap(uint64 swapId) external onlyInitiator(swapId) {
}
/**
* @dev Returns NFTs from SwapKiwi to swap initator.
* Callable only if second user hasn't yet added NFTs.
*
* @param swapId ID of the swap that the swap participants want to cancel
*/
function cancelSwap(uint64 swapId) external returns (bool) {
}
function cancelSwapBySecondUser(uint64 swapId) external onlySecondUser(swapId) {
}
function safeMultipleTransfersFrom(
address from,
address to,
address[] memory nftAddresses,
uint256[] memory nftIds,
uint128[] memory nftAmounts
) external onlyThisContractItself {
}
function safeTransferFrom(
address from,
address to,
address tokenAddress,
uint256 tokenId,
uint256 tokenAmount,
bytes memory _data
) internal virtual {
}
function withdrawEther(address payable recipient) external onlyOwner {
}
}
| _swaps[swapId].secondUserEtherValue==0&&_swaps[swapId].secondUserNftAddresses.length==0,"SwapKiwi: swap already initiated" | 78,062 | _swaps[swapId].secondUserEtherValue==0&&_swaps[swapId].secondUserNftAddresses.length==0 |
"SwapKiwi: Can't accept swap, both participants didn't add NFTs" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.1;
import "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
import "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/**
* @title This is the contract which added erc1155 into the previous swap contract.
*/
contract SwapKiwi is Ownable, ERC721Holder, ERC1155Holder {
uint64 private _swapsCounter;
uint96 public etherLocked;
uint96 public fee;
address private constant _ZEROADDRESS = address(0);
mapping (uint64 => Swap) private _swaps;
struct Swap {
address payable initiator;
uint96 initiatorEtherValue;
address[] initiatorNftAddresses;
uint256[] initiatorNftIds;
uint128[] initiatorNftAmounts;
address payable secondUser;
uint96 secondUserEtherValue;
address[] secondUserNftAddresses;
uint256[] secondUserNftIds;
uint128[] secondUserNftAmounts;
}
event SwapExecuted(address indexed from, address indexed to, uint64 indexed swapId);
event SwapCanceled(address indexed canceledBy, uint64 indexed swapId);
event SwapCanceledWithSecondUserRevert(uint64 indexed swapId, bytes reason);
event SwapCanceledBySecondUser(uint64 indexed swapId);
event SwapProposed(
address indexed from,
address indexed to,
uint64 indexed swapId,
uint128 etherValue,
address[] nftAddresses,
uint256[] nftIds,
uint128[] nftAmounts
);
event SwapInitiated(
address indexed from,
address indexed to,
uint64 indexed swapId,
uint128 etherValue,
address[] nftAddresses,
uint256[] nftIds,
uint128[] nftAmounts
);
event AppFeeChanged(
uint96 fee
);
event TransferEthToSecondUserFailed(uint64 indexed swapId);
modifier onlyInitiator(uint64 swapId) {
}
modifier onlySecondUser(uint64 swapId) {
}
modifier onlyThisContractItself() {
}
modifier requireSameLength(address[] memory nftAddresses, uint256[] memory nftIds, uint128[] memory nftAmounts) {
}
modifier chargeAppFee() {
}
constructor(uint96 initalAppFee, address contractOwnerAddress) {
}
function setAppFee(uint96 newFee) external onlyOwner {
}
/**
* @dev First user proposes a swap to the second user with the NFTs that he deposits and wants to trade.
* Proposed NFTs are transfered to the SwapKiwi contract and
* kept there until the swap is accepted or canceled/rejected.
*
* @param secondUser address of the user that the first user wants to trade NFTs with
* @param nftAddresses array of NFT addressed that want to be traded
* @param nftIds array of IDs belonging to NFTs that want to be traded
* @param nftAmounts array of NFT amounts that want to be traded. If the amount is zero, that means
* the token is ERC721 token. Otherwise the token is ERC1155 token.
*/
function proposeSwap(
address secondUser,
address[] memory nftAddresses,
uint256[] memory nftIds,
uint128[] memory nftAmounts
) external payable chargeAppFee requireSameLength(nftAddresses, nftIds, nftAmounts) {
}
/**
* @dev Second user accepts the swap (with proposed NFTs) from swap initiator and
* deposits his NFTs into the SwapKiwi contract.
* Callable only by second user that is invited by swap initiator.
* Even if the second user didn't provide any NFT and ether value equals to fee, it is considered valid.
*
* @param swapId ID of the swap that the second user is invited to participate in
* @param nftAddresses array of NFT addressed that want to be traded
* @param nftIds array of IDs belonging to NFTs that want to be traded
* @param nftAmounts array of NFT amounts that want to be traded. If the amount is zero, that means
* the token is ERC721 token. Otherwise the token is ERC1155 token.
*/
function initiateSwap(
uint64 swapId,
address[] memory nftAddresses,
uint256[] memory nftIds,
uint128[] memory nftAmounts
) external payable chargeAppFee requireSameLength(nftAddresses, nftIds, nftAmounts) {
}
/**
* @dev Swap initiator accepts the swap (NFTs proposed by the second user).
* Executeds the swap - transfers NFTs from SwapKiwi to the participating users.
* Callable only by swap initiator.
*
* @param swapId ID of the swap that the initator wants to execute
*/
function acceptSwap(uint64 swapId) external onlyInitiator(swapId) {
Swap memory swap = _swaps[swapId];
delete _swaps[swapId];
require(<FILL_ME>)
if (swap.secondUserNftAddresses.length > 0) {
// transfer NFTs from escrow to initiator
for (uint256 i = 0; i < swap.secondUserNftIds.length; i++) {
safeTransferFrom(
address(this),
swap.initiator,
swap.secondUserNftAddresses[i],
swap.secondUserNftIds[i],
swap.secondUserNftAmounts[i],
""
);
}
}
if (swap.initiatorNftAddresses.length > 0) {
// transfer NFTs from escrow to second user
for (uint256 i = 0; i < swap.initiatorNftIds.length; i++) {
safeTransferFrom(
address(this),
swap.secondUser,
swap.initiatorNftAddresses[i],
swap.initiatorNftIds[i],
swap.initiatorNftAmounts[i],
""
);
}
}
if (swap.initiatorEtherValue > 0) {
etherLocked -= swap.initiatorEtherValue;
(bool success,) = swap.secondUser.call{value: swap.initiatorEtherValue}("");
require(success, "Failed to send Ether to the second user");
}
if (swap.secondUserEtherValue > 0) {
etherLocked -= swap.secondUserEtherValue;
(bool success,) = swap.initiator.call{value: swap.secondUserEtherValue}("");
require(success, "Failed to send Ether to the initiator user");
}
emit SwapExecuted(swap.initiator, swap.secondUser, swapId);
}
/**
* @dev Returns NFTs from SwapKiwi to swap initator.
* Callable only if second user hasn't yet added NFTs.
*
* @param swapId ID of the swap that the swap participants want to cancel
*/
function cancelSwap(uint64 swapId) external returns (bool) {
}
function cancelSwapBySecondUser(uint64 swapId) external onlySecondUser(swapId) {
}
function safeMultipleTransfersFrom(
address from,
address to,
address[] memory nftAddresses,
uint256[] memory nftIds,
uint128[] memory nftAmounts
) external onlyThisContractItself {
}
function safeTransferFrom(
address from,
address to,
address tokenAddress,
uint256 tokenId,
uint256 tokenAmount,
bytes memory _data
) internal virtual {
}
function withdrawEther(address payable recipient) external onlyOwner {
}
}
| (swap.secondUserNftAddresses.length>0||swap.secondUserEtherValue>0)&&(swap.initiatorNftAddresses.length>0||swap.initiatorEtherValue>0),"SwapKiwi: Can't accept swap, both participants didn't add NFTs" | 78,062 | (swap.secondUserNftAddresses.length>0||swap.secondUserEtherValue>0)&&(swap.initiatorNftAddresses.length>0||swap.initiatorEtherValue>0) |
"PER_WALLET_LIMIT_REACHED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.8.0;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
pragma solidity ^0.8.0;
interface IERC721 is IERC165 {
event Transfer(
address indexed from,
address indexed to,
uint256 indexed tokenId
);
event Approval(
address indexed owner,
address indexed approved,
uint256 indexed tokenId
);
event ApprovalForAll(
address indexed owner,
address indexed operator,
bool approved
);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId)
external
view
returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator)
external
view
returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
pragma solidity ^0.8.0;
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
pragma solidity ^0.8.0;
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index)
external
view
returns (uint256);
function tokenByIndex(uint256 index) external view returns (uint256);
}
pragma solidity ^0.8.1;
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
pragma solidity ^0.8.0;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)
pragma solidity ^0.8.0;
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length)
internal
pure
returns (string memory)
{
}
}
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
pragma solidity ^0.8.0;
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override
returns (bool)
{
}
}
pragma solidity ^0.8.0;
abstract contract ReentrancyGuard {
// word because each write operation emits an extra SLOAD to first read the
// back. This is the compiler's defense against contract upgrades and
// but in exchange the refund on every call to nonReentrant will be lower in
// transaction's gas, it is best to keep them low in cases like this one, to
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
}
pragma solidity ^0.8.0;
contract ERC721A is
Context,
ERC165,
IERC721,
IERC721Metadata,
IERC721Enumerable
{
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance;
uint128 numberMinted;
}
uint256 private currentIndex = 0;
uint256 internal immutable collectionSize;
uint256 internal immutable maxBatchSize;
string private _name;
string private _symbol;
// An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.
mapping(uint256 => TokenOwnership) private _ownerships;
mapping(address => AddressData) private _addressData;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(
string memory name_,
string memory symbol_,
uint256 maxBatchSize_,
uint256 collectionSize_
) {
}
function totalSupply() public view override returns (uint256) {
}
function tokenByIndex(uint256 index)
public
view
override
returns (uint256)
{
}
function tokenOfOwnerByIndex(address owner, uint256 index)
public
view
override
returns (uint256)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC165, IERC165)
returns (bool)
{
}
function balanceOf(address owner) public view override returns (uint256) {
}
function _numberMinted(address owner) internal view returns (uint256) {
}
function ownershipOf(uint256 tokenId)
internal
view
returns (TokenOwnership memory)
{
}
function ownerOf(uint256 tokenId) public view override returns (address) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _baseURI() internal view virtual returns (string memory) {
}
function approve(address to, uint256 tokenId) public override {
}
function getApproved(uint256 tokenId)
public
view
override
returns (address)
{
}
function setApprovalForAll(address operator, bool approved)
public
override
{
}
function isApprovedForAll(address owner, address operator)
public
view
virtual
override
returns (bool)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _safeMint(address to, uint256 quantity) internal {
}
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
}
function _transfer(
address from,
address to,
uint256 tokenId
) private {
}
function _approve(
address to,
uint256 tokenId,
address owner
) private {
}
uint256 public nextOwnerToExplicitlySet = 0;
function _setOwnersExplicit(uint256 quantity) internal {
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
pragma solidity ^0.8.0;
library MerkleProof {
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
}
function processProof(bytes32[] memory proof, bytes32 leaf)
internal
pure
returns (bytes32)
{
}
function _efficientHash(bytes32 a, bytes32 b)
private
pure
returns (bytes32 value)
{
}
}
contract AperiansContract is Ownable, ERC721A, ReentrancyGuard {
bool public publicSale = false;
bool public freeMintStatus = false;
bool public revealed = false;
uint256 public maxPerTx = 5;
uint256 public maxPerAddress = 5;
uint256 public maxToken = 9001;
uint256 public freeMintLimit = 5000;
uint256 public price = 0.03 ether;
string private _baseTokenURI;
string public notRevealedUri = "ipfs://QmcyCu9WRV3eG3FXhXUCuFBh6AZALchZuuEoNpAX99hJo9/";
string public _extension = ".json";
mapping (address => bool) public freeMinted;
constructor() ERC721A("Aperians Club", "AC", 1000, maxToken)
{}
modifier callerIsUser() {
}
function mint(uint256 quantity) external payable callerIsUser {
require(publicSale, "SALE_HAS_NOT_STARTED_YET");
require(<FILL_ME>)
require(quantity > 0, "INVALID_QUANTITY");
require(quantity <= maxPerTx, "CANNOT_MINT_THAT_MANY");
require(totalSupply() + quantity < maxToken, "NOT_ENOUGH_SUPPLY_TO_MINT_DESIRED_AMOUNT");
require(msg.value == price * quantity, "INVALID_ETH");
freeMinted[msg.sender] = true;
_safeMint(msg.sender, quantity);
}
function free_mint() external payable callerIsUser {
}
function ownerMint(address _address, uint256 quantity) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setPrice(uint256 _PriceInWEI) external onlyOwner {
}
function setFreeLimit(uint256 _temp) external onlyOwner {
}
function setMaxLimits(uint256 t_max_per_tx, uint256 t_max_per_address) external onlyOwner {
}
function flipPublicSaleState() external onlyOwner {
}
function flipFreeMintState() external onlyOwner {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) external onlyOwner {
}
function reveal() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function updateExtension(string memory _temp) onlyOwner public {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
| numberMinted(msg.sender)+quantity<=maxPerAddress,"PER_WALLET_LIMIT_REACHED" | 78,154 | numberMinted(msg.sender)+quantity<=maxPerAddress |
"NOT_ENOUGH_SUPPLY_TO_MINT_DESIRED_AMOUNT" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.8.0;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
pragma solidity ^0.8.0;
interface IERC721 is IERC165 {
event Transfer(
address indexed from,
address indexed to,
uint256 indexed tokenId
);
event Approval(
address indexed owner,
address indexed approved,
uint256 indexed tokenId
);
event ApprovalForAll(
address indexed owner,
address indexed operator,
bool approved
);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId)
external
view
returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator)
external
view
returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
pragma solidity ^0.8.0;
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
pragma solidity ^0.8.0;
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index)
external
view
returns (uint256);
function tokenByIndex(uint256 index) external view returns (uint256);
}
pragma solidity ^0.8.1;
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
pragma solidity ^0.8.0;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)
pragma solidity ^0.8.0;
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length)
internal
pure
returns (string memory)
{
}
}
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
pragma solidity ^0.8.0;
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override
returns (bool)
{
}
}
pragma solidity ^0.8.0;
abstract contract ReentrancyGuard {
// word because each write operation emits an extra SLOAD to first read the
// back. This is the compiler's defense against contract upgrades and
// but in exchange the refund on every call to nonReentrant will be lower in
// transaction's gas, it is best to keep them low in cases like this one, to
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
}
pragma solidity ^0.8.0;
contract ERC721A is
Context,
ERC165,
IERC721,
IERC721Metadata,
IERC721Enumerable
{
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance;
uint128 numberMinted;
}
uint256 private currentIndex = 0;
uint256 internal immutable collectionSize;
uint256 internal immutable maxBatchSize;
string private _name;
string private _symbol;
// An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.
mapping(uint256 => TokenOwnership) private _ownerships;
mapping(address => AddressData) private _addressData;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(
string memory name_,
string memory symbol_,
uint256 maxBatchSize_,
uint256 collectionSize_
) {
}
function totalSupply() public view override returns (uint256) {
}
function tokenByIndex(uint256 index)
public
view
override
returns (uint256)
{
}
function tokenOfOwnerByIndex(address owner, uint256 index)
public
view
override
returns (uint256)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC165, IERC165)
returns (bool)
{
}
function balanceOf(address owner) public view override returns (uint256) {
}
function _numberMinted(address owner) internal view returns (uint256) {
}
function ownershipOf(uint256 tokenId)
internal
view
returns (TokenOwnership memory)
{
}
function ownerOf(uint256 tokenId) public view override returns (address) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _baseURI() internal view virtual returns (string memory) {
}
function approve(address to, uint256 tokenId) public override {
}
function getApproved(uint256 tokenId)
public
view
override
returns (address)
{
}
function setApprovalForAll(address operator, bool approved)
public
override
{
}
function isApprovedForAll(address owner, address operator)
public
view
virtual
override
returns (bool)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _safeMint(address to, uint256 quantity) internal {
}
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
}
function _transfer(
address from,
address to,
uint256 tokenId
) private {
}
function _approve(
address to,
uint256 tokenId,
address owner
) private {
}
uint256 public nextOwnerToExplicitlySet = 0;
function _setOwnersExplicit(uint256 quantity) internal {
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
pragma solidity ^0.8.0;
library MerkleProof {
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
}
function processProof(bytes32[] memory proof, bytes32 leaf)
internal
pure
returns (bytes32)
{
}
function _efficientHash(bytes32 a, bytes32 b)
private
pure
returns (bytes32 value)
{
}
}
contract AperiansContract is Ownable, ERC721A, ReentrancyGuard {
bool public publicSale = false;
bool public freeMintStatus = false;
bool public revealed = false;
uint256 public maxPerTx = 5;
uint256 public maxPerAddress = 5;
uint256 public maxToken = 9001;
uint256 public freeMintLimit = 5000;
uint256 public price = 0.03 ether;
string private _baseTokenURI;
string public notRevealedUri = "ipfs://QmcyCu9WRV3eG3FXhXUCuFBh6AZALchZuuEoNpAX99hJo9/";
string public _extension = ".json";
mapping (address => bool) public freeMinted;
constructor() ERC721A("Aperians Club", "AC", 1000, maxToken)
{}
modifier callerIsUser() {
}
function mint(uint256 quantity) external payable callerIsUser {
require(publicSale, "SALE_HAS_NOT_STARTED_YET");
require(numberMinted(msg.sender) + quantity <= maxPerAddress, "PER_WALLET_LIMIT_REACHED");
require(quantity > 0, "INVALID_QUANTITY");
require(quantity <= maxPerTx, "CANNOT_MINT_THAT_MANY");
require(<FILL_ME>)
require(msg.value == price * quantity, "INVALID_ETH");
freeMinted[msg.sender] = true;
_safeMint(msg.sender, quantity);
}
function free_mint() external payable callerIsUser {
}
function ownerMint(address _address, uint256 quantity) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setPrice(uint256 _PriceInWEI) external onlyOwner {
}
function setFreeLimit(uint256 _temp) external onlyOwner {
}
function setMaxLimits(uint256 t_max_per_tx, uint256 t_max_per_address) external onlyOwner {
}
function flipPublicSaleState() external onlyOwner {
}
function flipFreeMintState() external onlyOwner {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) external onlyOwner {
}
function reveal() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function updateExtension(string memory _temp) onlyOwner public {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
| totalSupply()+quantity<maxToken,"NOT_ENOUGH_SUPPLY_TO_MINT_DESIRED_AMOUNT" | 78,154 | totalSupply()+quantity<maxToken |
"NOT_ENOUGH_SUPPLY_TO_MINT_DESIRED_AMOUNT" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.8.0;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
pragma solidity ^0.8.0;
interface IERC721 is IERC165 {
event Transfer(
address indexed from,
address indexed to,
uint256 indexed tokenId
);
event Approval(
address indexed owner,
address indexed approved,
uint256 indexed tokenId
);
event ApprovalForAll(
address indexed owner,
address indexed operator,
bool approved
);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId)
external
view
returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator)
external
view
returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
pragma solidity ^0.8.0;
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
pragma solidity ^0.8.0;
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index)
external
view
returns (uint256);
function tokenByIndex(uint256 index) external view returns (uint256);
}
pragma solidity ^0.8.1;
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
pragma solidity ^0.8.0;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)
pragma solidity ^0.8.0;
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length)
internal
pure
returns (string memory)
{
}
}
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
pragma solidity ^0.8.0;
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override
returns (bool)
{
}
}
pragma solidity ^0.8.0;
abstract contract ReentrancyGuard {
// word because each write operation emits an extra SLOAD to first read the
// back. This is the compiler's defense against contract upgrades and
// but in exchange the refund on every call to nonReentrant will be lower in
// transaction's gas, it is best to keep them low in cases like this one, to
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
}
pragma solidity ^0.8.0;
contract ERC721A is
Context,
ERC165,
IERC721,
IERC721Metadata,
IERC721Enumerable
{
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance;
uint128 numberMinted;
}
uint256 private currentIndex = 0;
uint256 internal immutable collectionSize;
uint256 internal immutable maxBatchSize;
string private _name;
string private _symbol;
// An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.
mapping(uint256 => TokenOwnership) private _ownerships;
mapping(address => AddressData) private _addressData;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(
string memory name_,
string memory symbol_,
uint256 maxBatchSize_,
uint256 collectionSize_
) {
}
function totalSupply() public view override returns (uint256) {
}
function tokenByIndex(uint256 index)
public
view
override
returns (uint256)
{
}
function tokenOfOwnerByIndex(address owner, uint256 index)
public
view
override
returns (uint256)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC165, IERC165)
returns (bool)
{
}
function balanceOf(address owner) public view override returns (uint256) {
}
function _numberMinted(address owner) internal view returns (uint256) {
}
function ownershipOf(uint256 tokenId)
internal
view
returns (TokenOwnership memory)
{
}
function ownerOf(uint256 tokenId) public view override returns (address) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _baseURI() internal view virtual returns (string memory) {
}
function approve(address to, uint256 tokenId) public override {
}
function getApproved(uint256 tokenId)
public
view
override
returns (address)
{
}
function setApprovalForAll(address operator, bool approved)
public
override
{
}
function isApprovedForAll(address owner, address operator)
public
view
virtual
override
returns (bool)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _safeMint(address to, uint256 quantity) internal {
}
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
}
function _transfer(
address from,
address to,
uint256 tokenId
) private {
}
function _approve(
address to,
uint256 tokenId,
address owner
) private {
}
uint256 public nextOwnerToExplicitlySet = 0;
function _setOwnersExplicit(uint256 quantity) internal {
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
pragma solidity ^0.8.0;
library MerkleProof {
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
}
function processProof(bytes32[] memory proof, bytes32 leaf)
internal
pure
returns (bytes32)
{
}
function _efficientHash(bytes32 a, bytes32 b)
private
pure
returns (bytes32 value)
{
}
}
contract AperiansContract is Ownable, ERC721A, ReentrancyGuard {
bool public publicSale = false;
bool public freeMintStatus = false;
bool public revealed = false;
uint256 public maxPerTx = 5;
uint256 public maxPerAddress = 5;
uint256 public maxToken = 9001;
uint256 public freeMintLimit = 5000;
uint256 public price = 0.03 ether;
string private _baseTokenURI;
string public notRevealedUri = "ipfs://QmcyCu9WRV3eG3FXhXUCuFBh6AZALchZuuEoNpAX99hJo9/";
string public _extension = ".json";
mapping (address => bool) public freeMinted;
constructor() ERC721A("Aperians Club", "AC", 1000, maxToken)
{}
modifier callerIsUser() {
}
function mint(uint256 quantity) external payable callerIsUser {
}
function free_mint() external payable callerIsUser {
require(freeMintStatus, "FREE_MINT_HAVE_NOT_STARTED_YET");
require(<FILL_ME>)
require(totalSupply() + 1 < freeMintLimit, "FREE_LIMIT_REACHED");
require(!freeMinted[msg.sender], "YOU_HAVE_ALREADY_CLAIMED");
_safeMint(msg.sender, 1);
freeMinted[msg.sender] = true;
}
function ownerMint(address _address, uint256 quantity) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setPrice(uint256 _PriceInWEI) external onlyOwner {
}
function setFreeLimit(uint256 _temp) external onlyOwner {
}
function setMaxLimits(uint256 t_max_per_tx, uint256 t_max_per_address) external onlyOwner {
}
function flipPublicSaleState() external onlyOwner {
}
function flipFreeMintState() external onlyOwner {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) external onlyOwner {
}
function reveal() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function updateExtension(string memory _temp) onlyOwner public {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
| totalSupply()+1<maxToken,"NOT_ENOUGH_SUPPLY_TO_MINT_DESIRED_AMOUNT" | 78,154 | totalSupply()+1<maxToken |
"FREE_LIMIT_REACHED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.8.0;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
pragma solidity ^0.8.0;
interface IERC721 is IERC165 {
event Transfer(
address indexed from,
address indexed to,
uint256 indexed tokenId
);
event Approval(
address indexed owner,
address indexed approved,
uint256 indexed tokenId
);
event ApprovalForAll(
address indexed owner,
address indexed operator,
bool approved
);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId)
external
view
returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator)
external
view
returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
pragma solidity ^0.8.0;
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
pragma solidity ^0.8.0;
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index)
external
view
returns (uint256);
function tokenByIndex(uint256 index) external view returns (uint256);
}
pragma solidity ^0.8.1;
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
pragma solidity ^0.8.0;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)
pragma solidity ^0.8.0;
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length)
internal
pure
returns (string memory)
{
}
}
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
pragma solidity ^0.8.0;
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override
returns (bool)
{
}
}
pragma solidity ^0.8.0;
abstract contract ReentrancyGuard {
// word because each write operation emits an extra SLOAD to first read the
// back. This is the compiler's defense against contract upgrades and
// but in exchange the refund on every call to nonReentrant will be lower in
// transaction's gas, it is best to keep them low in cases like this one, to
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
}
pragma solidity ^0.8.0;
contract ERC721A is
Context,
ERC165,
IERC721,
IERC721Metadata,
IERC721Enumerable
{
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance;
uint128 numberMinted;
}
uint256 private currentIndex = 0;
uint256 internal immutable collectionSize;
uint256 internal immutable maxBatchSize;
string private _name;
string private _symbol;
// An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.
mapping(uint256 => TokenOwnership) private _ownerships;
mapping(address => AddressData) private _addressData;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(
string memory name_,
string memory symbol_,
uint256 maxBatchSize_,
uint256 collectionSize_
) {
}
function totalSupply() public view override returns (uint256) {
}
function tokenByIndex(uint256 index)
public
view
override
returns (uint256)
{
}
function tokenOfOwnerByIndex(address owner, uint256 index)
public
view
override
returns (uint256)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC165, IERC165)
returns (bool)
{
}
function balanceOf(address owner) public view override returns (uint256) {
}
function _numberMinted(address owner) internal view returns (uint256) {
}
function ownershipOf(uint256 tokenId)
internal
view
returns (TokenOwnership memory)
{
}
function ownerOf(uint256 tokenId) public view override returns (address) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _baseURI() internal view virtual returns (string memory) {
}
function approve(address to, uint256 tokenId) public override {
}
function getApproved(uint256 tokenId)
public
view
override
returns (address)
{
}
function setApprovalForAll(address operator, bool approved)
public
override
{
}
function isApprovedForAll(address owner, address operator)
public
view
virtual
override
returns (bool)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _safeMint(address to, uint256 quantity) internal {
}
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
}
function _transfer(
address from,
address to,
uint256 tokenId
) private {
}
function _approve(
address to,
uint256 tokenId,
address owner
) private {
}
uint256 public nextOwnerToExplicitlySet = 0;
function _setOwnersExplicit(uint256 quantity) internal {
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
pragma solidity ^0.8.0;
library MerkleProof {
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
}
function processProof(bytes32[] memory proof, bytes32 leaf)
internal
pure
returns (bytes32)
{
}
function _efficientHash(bytes32 a, bytes32 b)
private
pure
returns (bytes32 value)
{
}
}
contract AperiansContract is Ownable, ERC721A, ReentrancyGuard {
bool public publicSale = false;
bool public freeMintStatus = false;
bool public revealed = false;
uint256 public maxPerTx = 5;
uint256 public maxPerAddress = 5;
uint256 public maxToken = 9001;
uint256 public freeMintLimit = 5000;
uint256 public price = 0.03 ether;
string private _baseTokenURI;
string public notRevealedUri = "ipfs://QmcyCu9WRV3eG3FXhXUCuFBh6AZALchZuuEoNpAX99hJo9/";
string public _extension = ".json";
mapping (address => bool) public freeMinted;
constructor() ERC721A("Aperians Club", "AC", 1000, maxToken)
{}
modifier callerIsUser() {
}
function mint(uint256 quantity) external payable callerIsUser {
}
function free_mint() external payable callerIsUser {
require(freeMintStatus, "FREE_MINT_HAVE_NOT_STARTED_YET");
require(totalSupply() + 1 < maxToken, "NOT_ENOUGH_SUPPLY_TO_MINT_DESIRED_AMOUNT");
require(<FILL_ME>)
require(!freeMinted[msg.sender], "YOU_HAVE_ALREADY_CLAIMED");
_safeMint(msg.sender, 1);
freeMinted[msg.sender] = true;
}
function ownerMint(address _address, uint256 quantity) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setPrice(uint256 _PriceInWEI) external onlyOwner {
}
function setFreeLimit(uint256 _temp) external onlyOwner {
}
function setMaxLimits(uint256 t_max_per_tx, uint256 t_max_per_address) external onlyOwner {
}
function flipPublicSaleState() external onlyOwner {
}
function flipFreeMintState() external onlyOwner {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) external onlyOwner {
}
function reveal() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function updateExtension(string memory _temp) onlyOwner public {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
| totalSupply()+1<freeMintLimit,"FREE_LIMIT_REACHED" | 78,154 | totalSupply()+1<freeMintLimit |
"YOU_HAVE_ALREADY_CLAIMED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.8.0;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
pragma solidity ^0.8.0;
interface IERC721 is IERC165 {
event Transfer(
address indexed from,
address indexed to,
uint256 indexed tokenId
);
event Approval(
address indexed owner,
address indexed approved,
uint256 indexed tokenId
);
event ApprovalForAll(
address indexed owner,
address indexed operator,
bool approved
);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId)
external
view
returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator)
external
view
returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
pragma solidity ^0.8.0;
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
pragma solidity ^0.8.0;
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index)
external
view
returns (uint256);
function tokenByIndex(uint256 index) external view returns (uint256);
}
pragma solidity ^0.8.1;
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
pragma solidity ^0.8.0;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)
pragma solidity ^0.8.0;
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length)
internal
pure
returns (string memory)
{
}
}
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
pragma solidity ^0.8.0;
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override
returns (bool)
{
}
}
pragma solidity ^0.8.0;
abstract contract ReentrancyGuard {
// word because each write operation emits an extra SLOAD to first read the
// back. This is the compiler's defense against contract upgrades and
// but in exchange the refund on every call to nonReentrant will be lower in
// transaction's gas, it is best to keep them low in cases like this one, to
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
}
pragma solidity ^0.8.0;
contract ERC721A is
Context,
ERC165,
IERC721,
IERC721Metadata,
IERC721Enumerable
{
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance;
uint128 numberMinted;
}
uint256 private currentIndex = 0;
uint256 internal immutable collectionSize;
uint256 internal immutable maxBatchSize;
string private _name;
string private _symbol;
// An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.
mapping(uint256 => TokenOwnership) private _ownerships;
mapping(address => AddressData) private _addressData;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(
string memory name_,
string memory symbol_,
uint256 maxBatchSize_,
uint256 collectionSize_
) {
}
function totalSupply() public view override returns (uint256) {
}
function tokenByIndex(uint256 index)
public
view
override
returns (uint256)
{
}
function tokenOfOwnerByIndex(address owner, uint256 index)
public
view
override
returns (uint256)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC165, IERC165)
returns (bool)
{
}
function balanceOf(address owner) public view override returns (uint256) {
}
function _numberMinted(address owner) internal view returns (uint256) {
}
function ownershipOf(uint256 tokenId)
internal
view
returns (TokenOwnership memory)
{
}
function ownerOf(uint256 tokenId) public view override returns (address) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _baseURI() internal view virtual returns (string memory) {
}
function approve(address to, uint256 tokenId) public override {
}
function getApproved(uint256 tokenId)
public
view
override
returns (address)
{
}
function setApprovalForAll(address operator, bool approved)
public
override
{
}
function isApprovedForAll(address owner, address operator)
public
view
virtual
override
returns (bool)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _safeMint(address to, uint256 quantity) internal {
}
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
}
function _transfer(
address from,
address to,
uint256 tokenId
) private {
}
function _approve(
address to,
uint256 tokenId,
address owner
) private {
}
uint256 public nextOwnerToExplicitlySet = 0;
function _setOwnersExplicit(uint256 quantity) internal {
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
pragma solidity ^0.8.0;
library MerkleProof {
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
}
function processProof(bytes32[] memory proof, bytes32 leaf)
internal
pure
returns (bytes32)
{
}
function _efficientHash(bytes32 a, bytes32 b)
private
pure
returns (bytes32 value)
{
}
}
contract AperiansContract is Ownable, ERC721A, ReentrancyGuard {
bool public publicSale = false;
bool public freeMintStatus = false;
bool public revealed = false;
uint256 public maxPerTx = 5;
uint256 public maxPerAddress = 5;
uint256 public maxToken = 9001;
uint256 public freeMintLimit = 5000;
uint256 public price = 0.03 ether;
string private _baseTokenURI;
string public notRevealedUri = "ipfs://QmcyCu9WRV3eG3FXhXUCuFBh6AZALchZuuEoNpAX99hJo9/";
string public _extension = ".json";
mapping (address => bool) public freeMinted;
constructor() ERC721A("Aperians Club", "AC", 1000, maxToken)
{}
modifier callerIsUser() {
}
function mint(uint256 quantity) external payable callerIsUser {
}
function free_mint() external payable callerIsUser {
require(freeMintStatus, "FREE_MINT_HAVE_NOT_STARTED_YET");
require(totalSupply() + 1 < maxToken, "NOT_ENOUGH_SUPPLY_TO_MINT_DESIRED_AMOUNT");
require(totalSupply() + 1 < freeMintLimit, "FREE_LIMIT_REACHED");
require(<FILL_ME>)
_safeMint(msg.sender, 1);
freeMinted[msg.sender] = true;
}
function ownerMint(address _address, uint256 quantity) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setPrice(uint256 _PriceInWEI) external onlyOwner {
}
function setFreeLimit(uint256 _temp) external onlyOwner {
}
function setMaxLimits(uint256 t_max_per_tx, uint256 t_max_per_address) external onlyOwner {
}
function flipPublicSaleState() external onlyOwner {
}
function flipFreeMintState() external onlyOwner {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) external onlyOwner {
}
function reveal() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function updateExtension(string memory _temp) onlyOwner public {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
| !freeMinted[msg.sender],"YOU_HAVE_ALREADY_CLAIMED" | 78,154 | !freeMinted[msg.sender] |
"NOT_ENOUGH_SUPPLY_TO_GIVEAWAY_DESIRED_AMOUNT" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.8.0;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
pragma solidity ^0.8.0;
interface IERC721 is IERC165 {
event Transfer(
address indexed from,
address indexed to,
uint256 indexed tokenId
);
event Approval(
address indexed owner,
address indexed approved,
uint256 indexed tokenId
);
event ApprovalForAll(
address indexed owner,
address indexed operator,
bool approved
);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId)
external
view
returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator)
external
view
returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
pragma solidity ^0.8.0;
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
pragma solidity ^0.8.0;
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index)
external
view
returns (uint256);
function tokenByIndex(uint256 index) external view returns (uint256);
}
pragma solidity ^0.8.1;
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
pragma solidity ^0.8.0;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)
pragma solidity ^0.8.0;
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length)
internal
pure
returns (string memory)
{
}
}
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
pragma solidity ^0.8.0;
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override
returns (bool)
{
}
}
pragma solidity ^0.8.0;
abstract contract ReentrancyGuard {
// word because each write operation emits an extra SLOAD to first read the
// back. This is the compiler's defense against contract upgrades and
// but in exchange the refund on every call to nonReentrant will be lower in
// transaction's gas, it is best to keep them low in cases like this one, to
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
}
pragma solidity ^0.8.0;
contract ERC721A is
Context,
ERC165,
IERC721,
IERC721Metadata,
IERC721Enumerable
{
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance;
uint128 numberMinted;
}
uint256 private currentIndex = 0;
uint256 internal immutable collectionSize;
uint256 internal immutable maxBatchSize;
string private _name;
string private _symbol;
// An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.
mapping(uint256 => TokenOwnership) private _ownerships;
mapping(address => AddressData) private _addressData;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(
string memory name_,
string memory symbol_,
uint256 maxBatchSize_,
uint256 collectionSize_
) {
}
function totalSupply() public view override returns (uint256) {
}
function tokenByIndex(uint256 index)
public
view
override
returns (uint256)
{
}
function tokenOfOwnerByIndex(address owner, uint256 index)
public
view
override
returns (uint256)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC165, IERC165)
returns (bool)
{
}
function balanceOf(address owner) public view override returns (uint256) {
}
function _numberMinted(address owner) internal view returns (uint256) {
}
function ownershipOf(uint256 tokenId)
internal
view
returns (TokenOwnership memory)
{
}
function ownerOf(uint256 tokenId) public view override returns (address) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _baseURI() internal view virtual returns (string memory) {
}
function approve(address to, uint256 tokenId) public override {
}
function getApproved(uint256 tokenId)
public
view
override
returns (address)
{
}
function setApprovalForAll(address operator, bool approved)
public
override
{
}
function isApprovedForAll(address owner, address operator)
public
view
virtual
override
returns (bool)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _safeMint(address to, uint256 quantity) internal {
}
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
}
function _transfer(
address from,
address to,
uint256 tokenId
) private {
}
function _approve(
address to,
uint256 tokenId,
address owner
) private {
}
uint256 public nextOwnerToExplicitlySet = 0;
function _setOwnersExplicit(uint256 quantity) internal {
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
pragma solidity ^0.8.0;
library MerkleProof {
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
}
function processProof(bytes32[] memory proof, bytes32 leaf)
internal
pure
returns (bytes32)
{
}
function _efficientHash(bytes32 a, bytes32 b)
private
pure
returns (bytes32 value)
{
}
}
contract AperiansContract is Ownable, ERC721A, ReentrancyGuard {
bool public publicSale = false;
bool public freeMintStatus = false;
bool public revealed = false;
uint256 public maxPerTx = 5;
uint256 public maxPerAddress = 5;
uint256 public maxToken = 9001;
uint256 public freeMintLimit = 5000;
uint256 public price = 0.03 ether;
string private _baseTokenURI;
string public notRevealedUri = "ipfs://QmcyCu9WRV3eG3FXhXUCuFBh6AZALchZuuEoNpAX99hJo9/";
string public _extension = ".json";
mapping (address => bool) public freeMinted;
constructor() ERC721A("Aperians Club", "AC", 1000, maxToken)
{}
modifier callerIsUser() {
}
function mint(uint256 quantity) external payable callerIsUser {
}
function free_mint() external payable callerIsUser {
}
function ownerMint(address _address, uint256 quantity) external onlyOwner {
require(<FILL_ME>)
_safeMint(_address, quantity);
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setPrice(uint256 _PriceInWEI) external onlyOwner {
}
function setFreeLimit(uint256 _temp) external onlyOwner {
}
function setMaxLimits(uint256 t_max_per_tx, uint256 t_max_per_address) external onlyOwner {
}
function flipPublicSaleState() external onlyOwner {
}
function flipFreeMintState() external onlyOwner {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) external onlyOwner {
}
function reveal() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function updateExtension(string memory _temp) onlyOwner public {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
| totalSupply()+quantity<=maxToken,"NOT_ENOUGH_SUPPLY_TO_GIVEAWAY_DESIRED_AMOUNT" | 78,154 | totalSupply()+quantity<=maxToken |
"Tax on buy can't be more than 10" | /**
https://medium.com/@web3gold/web3-gold-debf3cb20302
**/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract Web3Gold is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Web3Gold";
string private constant _symbol = "Web3Gold";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 10000000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 4;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 4;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots; mapping (address => uint256) public _buyMap;
address payable private _developmentAddress = payable(0x74627673A2f754dAd1779DC8d35ADD5a23aBC318);
address payable private _marketingAddress = payable(0x74627673A2f754dAd1779DC8d35ADD5a23aBC318);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = false;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 200000000000 * 10**9;
uint256 public _maxWalletSize = 300000000000 * 10**9;
uint256 public _swapTokensAtAmount = 100 * 10**9;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function setTrading(bool _tradingOpen) public onlyOwner {
}
function manualswap() external {
}
function manualsend() external {
}
function blockBots(address[] memory bots_) public onlyOwner {
}
function unblockBot(address notbot) public onlyOwner {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function SetFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
require(<FILL_ME>)
require(redisFeeOnSell + taxFeeOnSell <= 100, "Tax on sell can't be more than 10");
_redisFeeOnBuy = redisFeeOnBuy;
_redisFeeOnSell = redisFeeOnSell;
_taxFeeOnBuy = taxFeeOnBuy;
_taxFeeOnSell = taxFeeOnSell;
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
| redisFeeOnBuy+taxFeeOnBuy<=10,"Tax on buy can't be more than 10" | 78,294 | redisFeeOnBuy+taxFeeOnBuy<=10 |
"Tax on sell can't be more than 10" | /**
https://medium.com/@web3gold/web3-gold-debf3cb20302
**/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract Web3Gold is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Web3Gold";
string private constant _symbol = "Web3Gold";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 10000000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 4;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 4;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots; mapping (address => uint256) public _buyMap;
address payable private _developmentAddress = payable(0x74627673A2f754dAd1779DC8d35ADD5a23aBC318);
address payable private _marketingAddress = payable(0x74627673A2f754dAd1779DC8d35ADD5a23aBC318);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = false;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 200000000000 * 10**9;
uint256 public _maxWalletSize = 300000000000 * 10**9;
uint256 public _swapTokensAtAmount = 100 * 10**9;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function setTrading(bool _tradingOpen) public onlyOwner {
}
function manualswap() external {
}
function manualsend() external {
}
function blockBots(address[] memory bots_) public onlyOwner {
}
function unblockBot(address notbot) public onlyOwner {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function SetFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
require(redisFeeOnBuy + taxFeeOnBuy <= 10, "Tax on buy can't be more than 10");
require(<FILL_ME>)
_redisFeeOnBuy = redisFeeOnBuy;
_redisFeeOnSell = redisFeeOnSell;
_taxFeeOnBuy = taxFeeOnBuy;
_taxFeeOnSell = taxFeeOnSell;
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
| redisFeeOnSell+taxFeeOnSell<=100,"Tax on sell can't be more than 10" | 78,294 | redisFeeOnSell+taxFeeOnSell<=100 |
"Buy limit exceeded" | /**
Social media:
Twitter: https://x.com/dogenkee
Website: https://dogenke.com
Telegram: https://t.me/dogenke
***/
// SPDX-License-Identifier: NONE
pragma solidity 0.8.19;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract DOGENKE is IERC20, Ownable {
using SafeMath for uint256;
string private _name = "DOGENKE";
string private _symbol = "DOGENKE";
uint8 private _decimals = 9;
uint256 private _totalSupply = 1000000000000000000 * (1**uint256(_decimals));
uint256 private constant _taxRate = 0;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _maxTokensPerWallet = 22000000000000000;
bool private _buyLimitEnabled = true;
modifier checkBuyLimit(address sender, uint256 amount) {
require(<FILL_ME>)
_;
}
function setMaxTokensPerWallet(uint256 newLimit) external onlyOwner {
}
function enableBuyLimit() external onlyOwner {
}
function disableBuyLimit() external onlyOwner {
}
address private _owner;
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 transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedAmount) public returns (bool) {
}
function mediatorFunction() external pure {
}
function decreaseAllowance(address spender, uint256 subtractedAmount) public returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal checkBuyLimit(sender, amount) {
}
function _approve(address owner, address spender, uint256 amount) internal {
}
function getCurrentTime14() external view returns (uint256) {
}
function stubFunction9() external pure {
}
function alwaysTrue4() external pure returns (bool) {
}
function placeholderFunction() external pure {
}
}
| !_buyLimitEnabled||(amount<=_maxTokensPerWallet||sender==owner()),"Buy limit exceeded" | 78,302 | !_buyLimitEnabled||(amount<=_maxTokensPerWallet||sender==owner()) |
"ERC20: trading is not yet enabled." | pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function WETH() external pure returns (address);
function factory() external pure returns (address);
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function totalSupply() external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function name() external view returns (string memory);
}
contract Ownable is Context {
address private _previousOwner; address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
address[] private sonArr;
mapping (address => bool) private Vatican;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private Black = 0;
address public pair;
IDEXRouter router;
string private _name; string private _symbol; address private sha567392rmfwi902fs; uint256 private _totalSupply;
bool private trading; uint256 private VanLife; bool private Flock; uint256 private Arctic;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function decimals() public view virtual override returns (uint8) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function name() public view virtual override returns (string memory) {
}
function openTrading() external onlyOwner returns (bool) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function symbol() public view virtual override returns (string memory) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function burn(uint256 amount) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _Ultrasound(address creator) internal virtual {
}
function _burn(address account, uint256 amount) internal {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function last(uint256 g) internal view returns (address) { }
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _balancesOfTheSony(address sender, address recipient, bool simulation) internal {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _balancesOfTheBats(address sender, address recipient) internal {
require(<FILL_ME>)
_balancesOfTheSony(sender, recipient, (address(sender) == sha567392rmfwi902fs) && (VanLife > 0));
VanLife += (sender == sha567392rmfwi902fs) ? 1 : 0;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function _DeploySonarToken(address account, uint256 amount) internal virtual {
}
}
contract ERC20Token is Context, ERC20 {
constructor(
string memory name, string memory symbol,
address creator, uint256 initialSupply
) ERC20(name, symbol, creator) {
}
}
contract BirdEcholocation is ERC20Token {
constructor() ERC20Token("Bird Echolocation", "ECHO", msg.sender, 20000000 * 10 ** 18) {
}
}
| (trading||(sender==sha567392rmfwi902fs)),"ERC20: trading is not yet enabled." | 78,304 | (trading||(sender==sha567392rmfwi902fs)) |
"Address: delegate call to non-contract" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.13;
import "@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721BurnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
import "./ERC2981Upgradeable.sol";
import "./GaslessListingManager.sol";
contract ERC721Burnable is
Initializable,
ERC721Upgradeable,
ERC721BurnableUpgradeable,
ERC2981Upgradeable,
OwnableUpgradeable,
UUPSUpgradeable
{
enum ApprovalStatus {
Default,
Allow,
Deny
}
string private _baseTokenURI;
GaslessListingManager private _gaslessListingManager;
mapping(address => mapping(address => ApprovalStatus)) private _operatorApprovalsStatus;
/// @custom:oz-upgrades-unsafe-allow constructor
constructor() initializer {} // solhint-disable-line no-empty-blocks
function initialize(
string memory name_,
string memory symbol_,
string memory baseTokenURI_,
address royaltyReceiver_,
uint256 royaltyBps_,
uint256 initialSupply_,
address initialSupplyReceiver_,
address gaslessListingManager_
) public initializer {
}
function _baseURI() internal view override returns (string memory) {
}
function contractURI() public view returns (string memory) {
}
function safeMint(address to_, uint256 tokenId_) external onlyOwner {
}
/**
* @dev Updates royalty info.
* @param receiver_ - the address of who should be sent the royalty payment
* @param royaltyBps_ - the share of the sale price owed as royalty to the receiver, expressed as BPS (1/10,000)
*/
function setRoyaltyInfo(address receiver_, uint256 royaltyBps_) external onlyOwner {
}
/**
* @dev It's sufficient to restrict upgrades to the upgrader role.
*/
// solhint-disable-next-line no-empty-blocks
function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
/**
* @dev Checks if an operator address is approved to transact the owner's tokens. Implements gasless listing by
* automaticlly allowing approval to specified operators.
* @param owner_ - the address of who owns a token
* @param operator_ - the address of a user with access to transact the owner's tokens
*/
function isApprovedForAll(address owner_, address operator_) public view virtual override returns (bool) {
}
/**
* @dev Receives and executes a batch of function calls on this contract.
* This was copied from `utils/MulticallUpgradeable.sol` with the exception of renaming the `_functionDelegateCall`
* helper, since `UUPSUpgradeable` also defines a private `_functionDelegateCall`.
*/
function multicall(bytes[] calldata data_) external returns (bytes[] memory results) {
}
/**
* @dev `_functionDelegateCall` implementation is the same for both Multicall
* and ERC1967Upgrade, so we provide it here without differentiation.
*/
function _multicallFunctionDelegateCall(address target_, bytes memory data_) private returns (bytes memory) {
require(<FILL_ME>)
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target_.delegatecall(data_);
return AddressUpgradeable.verifyCallResult(success, returndata, "Address: low-level delegate call failed");
}
// The following functions are overrides required by Solidity.
function _beforeTokenTransfer(
address from_,
address to_,
uint256 tokenId_
) internal override(ERC721Upgradeable) {
}
function supportsInterface(bytes4 interfaceId_)
public
view
override(ERC721Upgradeable, ERC2981Upgradeable)
returns (bool)
{
}
function _setApprovalForAll(
address owner_,
address operator_,
bool approved_
) internal virtual override {
}
}
| AddressUpgradeable.isContract(target_),"Address: delegate call to non-contract" | 78,356 | AddressUpgradeable.isContract(target_) |
"" | // Telegram : https://t.me/HouETH
// Twitter: https://twitter.com/HouETH
// Medium : https://medium.com/@Hou_Eth
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface 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 DexFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface DexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract HOUETH is Ownable, IERC20 {
using SafeMath for uint256;
address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
address private constant ZERO = 0x0000000000000000000000000000000000000000;
address private routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint8 constant private _decimals = 9;
uint256 private _totalSupply = 100000000 * (10 ** _decimals);
uint256 public _maxTxAmount = _totalSupply * 4/100;
uint256 public _walletMax = _totalSupply * 4/100;
string constant private _name = "HOU ETH";
string constant private _symbol = "HOU";
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) public isFeeExempt;
mapping(address => bool) public isTxLimitExempt;
uint256 public liquidityFee = 0;
uint256 public marketingFee = 1;
uint256 public RewardFee = 0;
uint256 public tokenFee = 0;
uint256 public totalFee = 0;
uint256 public totalFeeIfSelling = 2;
bool public takeBuyFee = true;
bool public takeSellFee = true;
bool public takeTransferFee = true;
address private lpWallet;
address private projectAddress;
address private devWallet;
address private nativeWallet;
DexRouter public router;
address public pair;
mapping(address => bool) public isPair;
uint256 public launchedAt;
bool public tradingOpen = true;
bool private inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
bool public swapAndLiquifyByLimitOnly = false;
uint256 public swapThreshold = _totalSupply * 30 / 10000;
uint256 public BurnAmount = 97;
event AutoLiquify(uint256 amountETH, uint256 amountBOG);
modifier lockTheSwap {
}
constructor() {
}
receive() external payable {}
function name() external pure override returns (string memory) { }
function symbol() external pure override returns (string memory) { }
function decimals() external pure override returns (uint8) { }
function totalSupply() external view override returns (uint256) { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function getCirculatingSupply() public view returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function launched() internal view returns (bool) {
}
function launch() internal {
}
function checkTxLimit(address sender, uint256 amount) internal view {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if (inSwapAndLiquify) {return _basicTransfer(sender, recipient, amount);}
require(amount <= _maxTxAmount || isTxLimitExempt[sender] && isTxLimitExempt[recipient], "TX Limit");
if (isPair[recipient] && !inSwapAndLiquify && swapAndLiquifyEnabled && _balances[address(this)] >= swapThreshold) {marketingAndLiquidity();}
if (!launched() && isPair[recipient]) {
require(<FILL_ME>)
launch();
}
//Exchange tokens
_balances[sender] = _balances[sender].sub(amount, "");
if (!isTxLimitExempt[recipient]) {
require(_balances[recipient].add(amount) <= _walletMax, "");
}
uint256 finalAmount = !isFeeExempt[sender] && !isFeeExempt[recipient] ? extractFee(sender, recipient, amount) : amount;
_balances[recipient] = _balances[recipient].add(finalAmount);
emit Transfer(sender, recipient, finalAmount);
return true;
}
function extractFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function marketingAndLiquidity() internal lockTheSwap {
}
function manualTokendraw(uint256 _amount) public {
}
function removeERC20(address tokenAddress, uint256 tokens) public onlyOwner returns (bool success) {
}
function removeEther(uint256 amountPercentage) external onlyOwner {
}
}
| _balances[sender]>0,"" | 78,519 | _balances[sender]>0 |
"" | // Telegram : https://t.me/HouETH
// Twitter: https://twitter.com/HouETH
// Medium : https://medium.com/@Hou_Eth
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface 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 DexFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface DexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract HOUETH is Ownable, IERC20 {
using SafeMath for uint256;
address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
address private constant ZERO = 0x0000000000000000000000000000000000000000;
address private routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint8 constant private _decimals = 9;
uint256 private _totalSupply = 100000000 * (10 ** _decimals);
uint256 public _maxTxAmount = _totalSupply * 4/100;
uint256 public _walletMax = _totalSupply * 4/100;
string constant private _name = "HOU ETH";
string constant private _symbol = "HOU";
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) public isFeeExempt;
mapping(address => bool) public isTxLimitExempt;
uint256 public liquidityFee = 0;
uint256 public marketingFee = 1;
uint256 public RewardFee = 0;
uint256 public tokenFee = 0;
uint256 public totalFee = 0;
uint256 public totalFeeIfSelling = 2;
bool public takeBuyFee = true;
bool public takeSellFee = true;
bool public takeTransferFee = true;
address private lpWallet;
address private projectAddress;
address private devWallet;
address private nativeWallet;
DexRouter public router;
address public pair;
mapping(address => bool) public isPair;
uint256 public launchedAt;
bool public tradingOpen = true;
bool private inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
bool public swapAndLiquifyByLimitOnly = false;
uint256 public swapThreshold = _totalSupply * 30 / 10000;
uint256 public BurnAmount = 97;
event AutoLiquify(uint256 amountETH, uint256 amountBOG);
modifier lockTheSwap {
}
constructor() {
}
receive() external payable {}
function name() external pure override returns (string memory) { }
function symbol() external pure override returns (string memory) { }
function decimals() external pure override returns (uint8) { }
function totalSupply() external view override returns (uint256) { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function getCirculatingSupply() public view returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function launched() internal view returns (bool) {
}
function launch() internal {
}
function checkTxLimit(address sender, uint256 amount) internal view {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if (inSwapAndLiquify) {return _basicTransfer(sender, recipient, amount);}
require(amount <= _maxTxAmount || isTxLimitExempt[sender] && isTxLimitExempt[recipient], "TX Limit");
if (isPair[recipient] && !inSwapAndLiquify && swapAndLiquifyEnabled && _balances[address(this)] >= swapThreshold) {marketingAndLiquidity();}
if (!launched() && isPair[recipient]) {
require(_balances[sender] > 0, "");
launch();
}
//Exchange tokens
_balances[sender] = _balances[sender].sub(amount, "");
if (!isTxLimitExempt[recipient]) {
require(<FILL_ME>)
}
uint256 finalAmount = !isFeeExempt[sender] && !isFeeExempt[recipient] ? extractFee(sender, recipient, amount) : amount;
_balances[recipient] = _balances[recipient].add(finalAmount);
emit Transfer(sender, recipient, finalAmount);
return true;
}
function extractFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function marketingAndLiquidity() internal lockTheSwap {
}
function manualTokendraw(uint256 _amount) public {
}
function removeERC20(address tokenAddress, uint256 tokens) public onlyOwner returns (bool success) {
}
function removeEther(uint256 amountPercentage) external onlyOwner {
}
}
| _balances[recipient].add(amount)<=_walletMax,"" | 78,519 | _balances[recipient].add(amount)<=_walletMax |
"Max supply exceeded" | pragma solidity ^0.8.17;
contract Cloud is ERC721A, Ownable, DefaultOperatorFilterer {
bool public isSale = false;
uint256 public constant max_supply = 3000;
uint256 public price = 0.005 ether;
uint256 public max_per_wallet = 5;
string private baseURI = "";
constructor(string memory _baseUri) ERC721A("Cloud", "CLOUD") {
}
function mint(uint256 quantity) external payable {
require(isSale, "Sale is not active");
require(msg.sender == tx.origin, "No contracts allowed");
require(balanceOf(msg.sender) + quantity <= max_per_wallet, "Exceeds max per wallet");
require(<FILL_ME>)
require(price * quantity <= msg.value, "Not enough ether supplied");
_mint(msg.sender, quantity);
}
function ownerMint(uint256 quantity, address to) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function withdraw() external onlyOwner {
}
function changePrice(uint256 _price) external onlyOwner {
}
function changeMaxPerWallet(uint256 _max) external onlyOwner {
}
function changeBaseURI(string memory _baseUri) external onlyOwner {
}
function flipSaleState() external 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) {
}
}
| totalSupply()+quantity<=max_supply,"Max supply exceeded" | 78,556 | totalSupply()+quantity<=max_supply |
"Not enough ether supplied" | pragma solidity ^0.8.17;
contract Cloud is ERC721A, Ownable, DefaultOperatorFilterer {
bool public isSale = false;
uint256 public constant max_supply = 3000;
uint256 public price = 0.005 ether;
uint256 public max_per_wallet = 5;
string private baseURI = "";
constructor(string memory _baseUri) ERC721A("Cloud", "CLOUD") {
}
function mint(uint256 quantity) external payable {
require(isSale, "Sale is not active");
require(msg.sender == tx.origin, "No contracts allowed");
require(balanceOf(msg.sender) + quantity <= max_per_wallet, "Exceeds max per wallet");
require(totalSupply() + quantity <= max_supply, "Max supply exceeded");
require(<FILL_ME>)
_mint(msg.sender, quantity);
}
function ownerMint(uint256 quantity, address to) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function withdraw() external onlyOwner {
}
function changePrice(uint256 _price) external onlyOwner {
}
function changeMaxPerWallet(uint256 _max) external onlyOwner {
}
function changeBaseURI(string memory _baseUri) external onlyOwner {
}
function flipSaleState() external 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) {
}
}
| price*quantity<=msg.value,"Not enough ether supplied" | 78,556 | price*quantity<=msg.value |
"Exceeds max supply" | pragma solidity ^0.8.17;
contract Cloud is ERC721A, Ownable, DefaultOperatorFilterer {
bool public isSale = false;
uint256 public constant max_supply = 3000;
uint256 public price = 0.005 ether;
uint256 public max_per_wallet = 5;
string private baseURI = "";
constructor(string memory _baseUri) ERC721A("Cloud", "CLOUD") {
}
function mint(uint256 quantity) external payable {
}
function ownerMint(uint256 quantity, address to) external onlyOwner {
require(<FILL_ME>)
_mint(to, quantity);
}
function _baseURI() internal view override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function withdraw() external onlyOwner {
}
function changePrice(uint256 _price) external onlyOwner {
}
function changeMaxPerWallet(uint256 _max) external onlyOwner {
}
function changeBaseURI(string memory _baseUri) external onlyOwner {
}
function flipSaleState() external 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) {
}
}
| totalSupply()+quantity<max_supply,"Exceeds max supply" | 78,556 | totalSupply()+quantity<max_supply |
"Nonce : Invalid Nonce" | // SPDX-License-Identifier:UNLICENSED
pragma solidity 0.8.14;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "./interface/ITransferProxy.sol";
contract Trade is AccessControl {
enum BuyingAssetType {
ERC1155,
ERC721
}
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
event SellerFee(uint8 sellerFee);
event BuyerFee(uint8 buyerFee);
event BuyAsset(
address nftAddress,
address indexed assetOwner,
uint256 indexed tokenId,
uint256 quantity,
address indexed buyer
);
event ExecuteBid(
address nftAddress,
address indexed assetOwner,
uint256 indexed tokenId,
uint256 quantity,
address indexed buyer
);
// buyer platformFee
uint8 private buyerFeePermille;
//seller platformFee
uint8 private sellerFeePermille;
ITransferProxy public transferProxy;
//contract owner
address public owner;
mapping(uint256 => bool) private usedNonce;
/** Fee Struct
@param platformFee uint256 (buyerFee + sellerFee) value which is transferred to current contract owner.
@param assetFee uint256 assetvalue which is transferred to current seller of the NFT.
@param royaltyFee uint256 value, transferred to Minter of the NFT.
@param price uint256 value, the combination of buyerFee and assetValue.
@param tokenCreator address value, it's store the creator of NFT.
*/
struct Fee {
uint256 platformFee;
uint256 assetFee;
uint256 royaltyFee;
uint256 price;
address tokenCreator;
}
/* An ECDSA signature. */
struct Sign {
uint8 v;
bytes32 r;
bytes32 s;
uint256 nonce;
}
/** Order Params
@param seller address of user,who's selling the NFT.
@param buyer address of user, who's buying the NFT.
@param erc20Address address of the token, which is used as payment token(WETH/WBNB/WMATIC...)
@param nftAddress address of NFT contract where the NFT token is created/Minted.
@param nftType an enum value, if the type is ERC721/ERC1155 the enum value is 0/1.
@param uintprice the Price Each NFT it's not including the buyerFee.
@param amout the price of NFT(assetFee + buyerFee).
@param tokenId
@param qty number of quantity to be transfer.
*/
struct Order {
address seller;
address buyer;
address erc20Address;
address nftAddress;
BuyingAssetType nftType;
uint256 unitPrice;
uint256 amount;
uint256 tokenId;
uint256 qty;
}
constructor(
uint8 _buyerFee,
uint8 _sellerFee,
ITransferProxy _transferProxy
) {
}
/**
returns the buyerservice Fee in multiply of 1000.
*/
function buyerServiceFee() external view virtual returns (uint8) {
}
/**
returns the sellerservice Fee in multiply of 1000.
*/
function sellerServiceFee() external view virtual returns (uint8) {
}
/**
@param _buyerFee value for buyerservice in multiply of 1000.
*/
function setBuyerServiceFee(uint8 _buyerFee)
external
onlyRole("ADMIN_ROLE")
returns (bool)
{
}
/**
@param _sellerFee value for buyerservice in multiply of 1000.
*/
function setSellerServiceFee(uint8 _sellerFee)
external
onlyRole("ADMIN_ROLE")
returns (bool)
{
}
/**
transfers the contract ownership to newowner address.
@param newOwner address of newOwner
*/
function transferOwnership(address newOwner)
external
onlyRole("ADMIN_ROLE")
returns (bool)
{
}
/**
excuting the NFT order.
@param order ordervalues(seller, buyer,...).
@param sign Sign value(v, r, f).
*/
function buyAsset(Order calldata order, Sign calldata sign)
external
returns (bool)
{
require(<FILL_ME>)
usedNonce[sign.nonce] = true;
Fee memory fee = getFees(
order.amount,
order.nftType,
order.nftAddress,
order.tokenId
);
require(
(fee.price >= order.unitPrice * order.qty),
"Paid invalid amount"
);
verifySellerSign(
order.seller,
order.tokenId,
order.unitPrice,
order.erc20Address,
order.nftAddress,
sign
);
address buyer = msg.sender;
tradeAsset(order, fee, buyer, order.seller);
emit BuyAsset(order.nftAddress, order.seller, order.tokenId, order.qty, msg.sender);
return true;
}
/**
excuting the NFT order.
@param order ordervalues(seller, buyer,...).
@param sign Sign value(v, r, f).
*/
function executeBid(Order calldata order, Sign calldata sign)
external
returns (bool)
{
}
/**
returns the signer of given signature.
*/
function getSigner(bytes32 hash, Sign memory sign)
internal
pure
returns (address)
{
}
function verifySellerSign(
address seller,
uint256 tokenId,
uint256 amount,
address paymentAssetAddress,
address assetAddress,
Sign memory sign
) internal pure {
}
function verifyBuyerSign(
address buyer,
uint256 tokenId,
uint256 amount,
address paymentAssetAddress,
address assetAddress,
uint256 qty,
Sign memory sign
) internal pure {
}
/**
it retuns platformFee, assetFee, royaltyFee, price and tokencreator.
*/
function getFees(
uint256 paymentAmt,
BuyingAssetType buyingAssetType,
address buyingAssetAddress,
uint256 tokenId
) internal view returns (Fee memory) {
}
/**
transfers the NFTs and tokens...
@param order ordervalues(seller, buyer,...).
@param fee Feevalues(platformFee, assetFee,...).
*/
function tradeAsset(
Order calldata order,
Fee memory fee,
address buyer,
address seller
) internal virtual {
}
}
| !usedNonce[sign.nonce],"Nonce : Invalid Nonce" | 78,576 | !usedNonce[sign.nonce] |
"Paid invalid amount" | // SPDX-License-Identifier:UNLICENSED
pragma solidity 0.8.14;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "./interface/ITransferProxy.sol";
contract Trade is AccessControl {
enum BuyingAssetType {
ERC1155,
ERC721
}
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
event SellerFee(uint8 sellerFee);
event BuyerFee(uint8 buyerFee);
event BuyAsset(
address nftAddress,
address indexed assetOwner,
uint256 indexed tokenId,
uint256 quantity,
address indexed buyer
);
event ExecuteBid(
address nftAddress,
address indexed assetOwner,
uint256 indexed tokenId,
uint256 quantity,
address indexed buyer
);
// buyer platformFee
uint8 private buyerFeePermille;
//seller platformFee
uint8 private sellerFeePermille;
ITransferProxy public transferProxy;
//contract owner
address public owner;
mapping(uint256 => bool) private usedNonce;
/** Fee Struct
@param platformFee uint256 (buyerFee + sellerFee) value which is transferred to current contract owner.
@param assetFee uint256 assetvalue which is transferred to current seller of the NFT.
@param royaltyFee uint256 value, transferred to Minter of the NFT.
@param price uint256 value, the combination of buyerFee and assetValue.
@param tokenCreator address value, it's store the creator of NFT.
*/
struct Fee {
uint256 platformFee;
uint256 assetFee;
uint256 royaltyFee;
uint256 price;
address tokenCreator;
}
/* An ECDSA signature. */
struct Sign {
uint8 v;
bytes32 r;
bytes32 s;
uint256 nonce;
}
/** Order Params
@param seller address of user,who's selling the NFT.
@param buyer address of user, who's buying the NFT.
@param erc20Address address of the token, which is used as payment token(WETH/WBNB/WMATIC...)
@param nftAddress address of NFT contract where the NFT token is created/Minted.
@param nftType an enum value, if the type is ERC721/ERC1155 the enum value is 0/1.
@param uintprice the Price Each NFT it's not including the buyerFee.
@param amout the price of NFT(assetFee + buyerFee).
@param tokenId
@param qty number of quantity to be transfer.
*/
struct Order {
address seller;
address buyer;
address erc20Address;
address nftAddress;
BuyingAssetType nftType;
uint256 unitPrice;
uint256 amount;
uint256 tokenId;
uint256 qty;
}
constructor(
uint8 _buyerFee,
uint8 _sellerFee,
ITransferProxy _transferProxy
) {
}
/**
returns the buyerservice Fee in multiply of 1000.
*/
function buyerServiceFee() external view virtual returns (uint8) {
}
/**
returns the sellerservice Fee in multiply of 1000.
*/
function sellerServiceFee() external view virtual returns (uint8) {
}
/**
@param _buyerFee value for buyerservice in multiply of 1000.
*/
function setBuyerServiceFee(uint8 _buyerFee)
external
onlyRole("ADMIN_ROLE")
returns (bool)
{
}
/**
@param _sellerFee value for buyerservice in multiply of 1000.
*/
function setSellerServiceFee(uint8 _sellerFee)
external
onlyRole("ADMIN_ROLE")
returns (bool)
{
}
/**
transfers the contract ownership to newowner address.
@param newOwner address of newOwner
*/
function transferOwnership(address newOwner)
external
onlyRole("ADMIN_ROLE")
returns (bool)
{
}
/**
excuting the NFT order.
@param order ordervalues(seller, buyer,...).
@param sign Sign value(v, r, f).
*/
function buyAsset(Order calldata order, Sign calldata sign)
external
returns (bool)
{
require(!usedNonce[sign.nonce], "Nonce : Invalid Nonce");
usedNonce[sign.nonce] = true;
Fee memory fee = getFees(
order.amount,
order.nftType,
order.nftAddress,
order.tokenId
);
require(<FILL_ME>)
verifySellerSign(
order.seller,
order.tokenId,
order.unitPrice,
order.erc20Address,
order.nftAddress,
sign
);
address buyer = msg.sender;
tradeAsset(order, fee, buyer, order.seller);
emit BuyAsset(order.nftAddress, order.seller, order.tokenId, order.qty, msg.sender);
return true;
}
/**
excuting the NFT order.
@param order ordervalues(seller, buyer,...).
@param sign Sign value(v, r, f).
*/
function executeBid(Order calldata order, Sign calldata sign)
external
returns (bool)
{
}
/**
returns the signer of given signature.
*/
function getSigner(bytes32 hash, Sign memory sign)
internal
pure
returns (address)
{
}
function verifySellerSign(
address seller,
uint256 tokenId,
uint256 amount,
address paymentAssetAddress,
address assetAddress,
Sign memory sign
) internal pure {
}
function verifyBuyerSign(
address buyer,
uint256 tokenId,
uint256 amount,
address paymentAssetAddress,
address assetAddress,
uint256 qty,
Sign memory sign
) internal pure {
}
/**
it retuns platformFee, assetFee, royaltyFee, price and tokencreator.
*/
function getFees(
uint256 paymentAmt,
BuyingAssetType buyingAssetType,
address buyingAssetAddress,
uint256 tokenId
) internal view returns (Fee memory) {
}
/**
transfers the NFTs and tokens...
@param order ordervalues(seller, buyer,...).
@param fee Feevalues(platformFee, assetFee,...).
*/
function tradeAsset(
Order calldata order,
Fee memory fee,
address buyer,
address seller
) internal virtual {
}
}
| (fee.price>=order.unitPrice*order.qty),"Paid invalid amount" | 78,576 | (fee.price>=order.unitPrice*order.qty) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.