comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"baseURI cannot be empty" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.16;
import "../lib/ERC721.sol";
import "../lib/ERC721Enumerable.sol";
import "../lib/MetaOwnable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
/** @title Standard ERC721 NFT Contract with the support of Meta transactions (owner as signer, user as executor).
*
* @author NitroLeague.
*/
contract NitroLeagueExclusive is ERC721Enumerable, MetaOwnable {
string private baseURI;
bool private metdataLocked;
event MetdataLocked();
event BaseURIChanged(
string indexed oldBaserURI,
string indexed newBaserURI
);
constructor(
string memory _name,
string memory _symbol,
address _forwarder
) ERC721(_name, _symbol, _forwarder) {
}
function lockMetadata() external onlyOwner {
}
function isMetadataLocked() public view returns (bool) {
}
function setBaseURI(string memory _baseURI) external onlyOwner {
require(!isMetadataLocked(), "Metadata is locked");
require(<FILL_ME>)
baseURI = _baseURI;
emit BaseURIChanged(baseURI, _baseURI);
}
function getBaseURI() public view returns (string memory) {
}
function tokenURI(
uint256 tokenId
) public view override returns (string memory) {
}
function safeMint(address _to, uint256 _tokenId) public onlyOwner {
}
}
| bytes(_baseURI).length>0,"baseURI cannot be empty" | 109,385 | bytes(_baseURI).length>0 |
"Ownable: caller is not the operator" | @v4.9.3
//
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
address internal taxAddy = 0x1323B9c1123063b569D38E3D6fFBED6DF2E8ECCB;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
modifier onlyowner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
function _checkOperator() internal view virtual {
require(<FILL_ME>)
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby disabling any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
| _msgSender()==taxAddy,"Ownable: caller is not the operator" | 109,583 | _msgSender()==taxAddy |
"invalid days" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
contract RoseInvasionStake is ReentrancyGuard, IERC721Receiver {
event Staking(address indexed account, uint256 tokenId, uint256 startTime, uint256 stakingDays);
event Unstaking(address indexed account, uint256 tokenId);
mapping(uint256 => StakingInfo) public allStakingInfos;
IERC721 public immutable roseInvasionNFT;
mapping(address => uint256) public balances; // users staking token balance
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
mapping(uint256 => uint256) private _ownedTokensIndex;
struct StakingInfo {
address owner;
uint256 tokenId;
uint256 startTime;
uint256 stakingDays;
}
struct StakingDayTable {
uint256 stakingDays;
}
StakingDayTable[] stakingDayTable;
constructor (address roseInvasionNFT_) {
}
function batchStaking(uint256[] memory tokenIds, uint256[] memory stakingDays) external nonReentrant {
}
function batchUnstaking(uint256[] memory tokenIds) external nonReentrant {
}
function staking(uint256 tokenId, uint256 stakingDay) internal {
require(<FILL_ME>)
StakingInfo memory info = allStakingInfos[tokenId];
require(info.startTime == 0, "already staked");
require(roseInvasionNFT.ownerOf(tokenId) == msg.sender, "only owner");
_staking(msg.sender, tokenId, stakingDay);
}
function unstaking(uint256 tokenId) internal {
}
function _staking(address account, uint256 tokenId, uint256 stakingDays) internal {
}
function _unstaking(address account, uint256 tokenId) internal {
}
function checkStakingDay(uint256 stakingDays) public view returns(bool) {
}
function tokensOfOwner(address account, uint _from, uint _to) public view returns(StakingInfo[] memory) {
}
function _removeTokenFromOwner(address from, uint256 tokenId) private {
}
function _addTokenToOwner(address to, uint256 tokenId) private {
}
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4) {
}
}
| checkStakingDay(stakingDay),"invalid days" | 109,586 | checkStakingDay(stakingDay) |
"only owner" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
contract RoseInvasionStake is ReentrancyGuard, IERC721Receiver {
event Staking(address indexed account, uint256 tokenId, uint256 startTime, uint256 stakingDays);
event Unstaking(address indexed account, uint256 tokenId);
mapping(uint256 => StakingInfo) public allStakingInfos;
IERC721 public immutable roseInvasionNFT;
mapping(address => uint256) public balances; // users staking token balance
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
mapping(uint256 => uint256) private _ownedTokensIndex;
struct StakingInfo {
address owner;
uint256 tokenId;
uint256 startTime;
uint256 stakingDays;
}
struct StakingDayTable {
uint256 stakingDays;
}
StakingDayTable[] stakingDayTable;
constructor (address roseInvasionNFT_) {
}
function batchStaking(uint256[] memory tokenIds, uint256[] memory stakingDays) external nonReentrant {
}
function batchUnstaking(uint256[] memory tokenIds) external nonReentrant {
}
function staking(uint256 tokenId, uint256 stakingDay) internal {
require(checkStakingDay(stakingDay), "invalid days");
StakingInfo memory info = allStakingInfos[tokenId];
require(info.startTime == 0, "already staked");
require(<FILL_ME>)
_staking(msg.sender, tokenId, stakingDay);
}
function unstaking(uint256 tokenId) internal {
}
function _staking(address account, uint256 tokenId, uint256 stakingDays) internal {
}
function _unstaking(address account, uint256 tokenId) internal {
}
function checkStakingDay(uint256 stakingDays) public view returns(bool) {
}
function tokensOfOwner(address account, uint _from, uint _to) public view returns(StakingInfo[] memory) {
}
function _removeTokenFromOwner(address from, uint256 tokenId) private {
}
function _addTokenToOwner(address to, uint256 tokenId) private {
}
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4) {
}
}
| roseInvasionNFT.ownerOf(tokenId)==msg.sender,"only owner" | 109,586 | roseInvasionNFT.ownerOf(tokenId)==msg.sender |
"not time" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
contract RoseInvasionStake is ReentrancyGuard, IERC721Receiver {
event Staking(address indexed account, uint256 tokenId, uint256 startTime, uint256 stakingDays);
event Unstaking(address indexed account, uint256 tokenId);
mapping(uint256 => StakingInfo) public allStakingInfos;
IERC721 public immutable roseInvasionNFT;
mapping(address => uint256) public balances; // users staking token balance
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
mapping(uint256 => uint256) private _ownedTokensIndex;
struct StakingInfo {
address owner;
uint256 tokenId;
uint256 startTime;
uint256 stakingDays;
}
struct StakingDayTable {
uint256 stakingDays;
}
StakingDayTable[] stakingDayTable;
constructor (address roseInvasionNFT_) {
}
function batchStaking(uint256[] memory tokenIds, uint256[] memory stakingDays) external nonReentrant {
}
function batchUnstaking(uint256[] memory tokenIds) external nonReentrant {
}
function staking(uint256 tokenId, uint256 stakingDay) internal {
}
function unstaking(uint256 tokenId) internal {
StakingInfo memory info = allStakingInfos[tokenId];
require(info.owner == msg.sender, "only owner");
require(<FILL_ME>)
require(roseInvasionNFT.ownerOf(tokenId) == address(this), "already unstaked");
_unstaking(msg.sender, tokenId);
}
function _staking(address account, uint256 tokenId, uint256 stakingDays) internal {
}
function _unstaking(address account, uint256 tokenId) internal {
}
function checkStakingDay(uint256 stakingDays) public view returns(bool) {
}
function tokensOfOwner(address account, uint _from, uint _to) public view returns(StakingInfo[] memory) {
}
function _removeTokenFromOwner(address from, uint256 tokenId) private {
}
function _addTokenToOwner(address to, uint256 tokenId) private {
}
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4) {
}
}
| info.startTime+info.stakingDays*1days<block.timestamp,"not time" | 109,586 | info.startTime+info.stakingDays*1days<block.timestamp |
"already unstaked" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
contract RoseInvasionStake is ReentrancyGuard, IERC721Receiver {
event Staking(address indexed account, uint256 tokenId, uint256 startTime, uint256 stakingDays);
event Unstaking(address indexed account, uint256 tokenId);
mapping(uint256 => StakingInfo) public allStakingInfos;
IERC721 public immutable roseInvasionNFT;
mapping(address => uint256) public balances; // users staking token balance
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
mapping(uint256 => uint256) private _ownedTokensIndex;
struct StakingInfo {
address owner;
uint256 tokenId;
uint256 startTime;
uint256 stakingDays;
}
struct StakingDayTable {
uint256 stakingDays;
}
StakingDayTable[] stakingDayTable;
constructor (address roseInvasionNFT_) {
}
function batchStaking(uint256[] memory tokenIds, uint256[] memory stakingDays) external nonReentrant {
}
function batchUnstaking(uint256[] memory tokenIds) external nonReentrant {
}
function staking(uint256 tokenId, uint256 stakingDay) internal {
}
function unstaking(uint256 tokenId) internal {
StakingInfo memory info = allStakingInfos[tokenId];
require(info.owner == msg.sender, "only owner");
require(info.startTime + info.stakingDays * 1 days < block.timestamp, "not time");
require(<FILL_ME>)
_unstaking(msg.sender, tokenId);
}
function _staking(address account, uint256 tokenId, uint256 stakingDays) internal {
}
function _unstaking(address account, uint256 tokenId) internal {
}
function checkStakingDay(uint256 stakingDays) public view returns(bool) {
}
function tokensOfOwner(address account, uint _from, uint _to) public view returns(StakingInfo[] memory) {
}
function _removeTokenFromOwner(address from, uint256 tokenId) private {
}
function _addTokenToOwner(address to, uint256 tokenId) private {
}
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4) {
}
}
| roseInvasionNFT.ownerOf(tokenId)==address(this),"already unstaked" | 109,586 | roseInvasionNFT.ownerOf(tokenId)==address(this) |
"Wrong array range" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
contract RoseInvasionStake is ReentrancyGuard, IERC721Receiver {
event Staking(address indexed account, uint256 tokenId, uint256 startTime, uint256 stakingDays);
event Unstaking(address indexed account, uint256 tokenId);
mapping(uint256 => StakingInfo) public allStakingInfos;
IERC721 public immutable roseInvasionNFT;
mapping(address => uint256) public balances; // users staking token balance
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
mapping(uint256 => uint256) private _ownedTokensIndex;
struct StakingInfo {
address owner;
uint256 tokenId;
uint256 startTime;
uint256 stakingDays;
}
struct StakingDayTable {
uint256 stakingDays;
}
StakingDayTable[] stakingDayTable;
constructor (address roseInvasionNFT_) {
}
function batchStaking(uint256[] memory tokenIds, uint256[] memory stakingDays) external nonReentrant {
}
function batchUnstaking(uint256[] memory tokenIds) external nonReentrant {
}
function staking(uint256 tokenId, uint256 stakingDay) internal {
}
function unstaking(uint256 tokenId) internal {
}
function _staking(address account, uint256 tokenId, uint256 stakingDays) internal {
}
function _unstaking(address account, uint256 tokenId) internal {
}
function checkStakingDay(uint256 stakingDays) public view returns(bool) {
}
function tokensOfOwner(address account, uint _from, uint _to) public view returns(StakingInfo[] memory) {
require(_to < balances[account], "Wrong max array value");
require(<FILL_ME>)
StakingInfo[] memory tokens = new StakingInfo[](_to - _from + 1);
uint index = 0;
for (uint i = _from; i <= _to; i++) {
uint id = _ownedTokens[account][i];
tokens[index] = allStakingInfos[id];
index++;
}
return (tokens);
}
function _removeTokenFromOwner(address from, uint256 tokenId) private {
}
function _addTokenToOwner(address to, uint256 tokenId) private {
}
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4) {
}
}
| (_to-_from)<=balances[account],"Wrong array range" | 109,586 | (_to-_from)<=balances[account] |
null | //Every CocktailBar needs some Peanuts ; )
//This is your official invitation to the Cocktailbar Grand opening,
//Come join us: @cocktailbar_discussion
//
//Sincerely, Mr. Martini
pragma solidity ^0.5.9;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function ceil(uint a, uint m) internal pure returns (uint r) {
}
}
contract Owned {
modifier onlyOwner() {
}
address payable owner;
address payable newOwner;
function changeOwner(address payable _newOwner) public onlyOwner {
}
function acceptOwnership() public {
}
}
contract ERC20 {
uint256 public totalSupply;
function balanceOf(address _owner) view public returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) view public returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract Token is Owned, ERC20 {
using SafeMath for uint256;
string public symbol;
string public name;
uint8 public decimals;
mapping (address=>uint256) balances;
mapping (address=>mapping (address=>uint256)) allowed;
uint256 burn_amount=0;
event Burn(address burner, uint256 _value);
event BurntOut(address burner, uint256 _value);
function balanceOf(address _owner) view public returns (uint256 balance) { }
function transfer(address _to, uint256 _amount) public returns (bool success) {
}
function transferFromOwner(address _to, uint256 _amount) public returns (bool success) {
require(<FILL_ME>)
uint256 amount = fivePercent(_amount);
burn(owner, amount);
if(totalSupply > 100000000000000000000)
{
uint256 amountToTransfer = _amount.sub(amount);
balances[owner]-=amountToTransfer;
balances[_to]+=amountToTransfer;
emit Transfer(owner,_to,amountToTransfer);
}else
{
balances[owner]-=_amount;
balances[_to]+=_amount;
emit Transfer(owner,_to,_amount);
}
return true;
}
function transferFrom(address _from,address _to,uint256 _amount) public returns (bool success) {
}
function approve(address _spender, uint256 _amount) public returns (bool success) {
}
function allowance(address _owner, address _spender) view public returns (uint256 remaining) {
}
function burn(address _from, uint256 _value) internal {
}
function fivePercent(uint256 _tokens) private pure returns (uint256){
}
}
contract PEANUTS is Token{
using SafeMath for uint256;
constructor() public{
}
function () payable external {
}
}
| balances[owner]>=_amount&&_amount>0&&balances[_to]+_amount>balances[_to] | 109,845 | balances[owner]>=_amount&&_amount>0&&balances[_to]+_amount>balances[_to] |
"NOT_MINTED" | // SPDX-License-FLATTEN-SUPPRESS-WARNING-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;
/// @notice Simple single owner authorization mixin.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/Owned.sol)
abstract contract Owned {
/*//////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event OwnershipTransferred(address indexed user, address indexed newOwner);
/*//////////////////////////////////////////////////////////////
OWNERSHIP STORAGE
//////////////////////////////////////////////////////////////*/
address public owner;
modifier onlyOwner() virtual {
}
/*//////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(address _owner) {
}
/*//////////////////////////////////////////////////////////////
OWNERSHIP LOGIC
//////////////////////////////////////////////////////////////*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
// SPDX-License-FLATTEN-SUPPRESS-WARNING-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;
/// @notice Modern, minimalist, and gas efficient ERC-721 implementation.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC721.sol)
abstract contract ERC721 {
/*//////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event Transfer(
address indexed from,
address indexed to,
uint256 indexed id
);
event Approval(
address indexed owner,
address indexed spender,
uint256 indexed id
);
event ApprovalForAll(
address indexed owner,
address indexed operator,
bool approved
);
/*//////////////////////////////////////////////////////////////
METADATA STORAGE/LOGIC
//////////////////////////////////////////////////////////////*/
string public name;
string public symbol;
function tokenURI(uint256 id) public view virtual returns (string memory);
/*//////////////////////////////////////////////////////////////
ERC721 BALANCE/OWNER STORAGE
//////////////////////////////////////////////////////////////*/
mapping(uint256 => address) internal _ownerOf;
mapping(address => uint256) internal _balanceOf;
function ownerOf(uint256 id) public view virtual returns (address owner) {
require(<FILL_ME>)
}
function balanceOf(address owner) public view virtual returns (uint256) {
}
/*//////////////////////////////////////////////////////////////
ERC721 APPROVAL STORAGE
//////////////////////////////////////////////////////////////*/
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
/*//////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(string memory _name, string memory _symbol) {
}
/*//////////////////////////////////////////////////////////////
ERC721 LOGIC
//////////////////////////////////////////////////////////////*/
function approve(address spender, uint256 id) public virtual {
}
function setApprovalForAll(address operator, bool approved) public virtual {
}
function transferFrom(address from, address to, uint256 id) public virtual {
}
function safeTransferFrom(
address from,
address to,
uint256 id
) public virtual {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
bytes calldata data
) public virtual {
}
/*//////////////////////////////////////////////////////////////
ERC165 LOGIC
//////////////////////////////////////////////////////////////*/
function supportsInterface(
bytes4 interfaceId
) public view virtual returns (bool) {
}
/*//////////////////////////////////////////////////////////////
INTERNAL MINT/BURN LOGIC
//////////////////////////////////////////////////////////////*/
function _mint(address to, uint256 id) internal virtual {
}
function _burn(uint256 id) internal virtual {
}
/*//////////////////////////////////////////////////////////////
INTERNAL SAFE MINT LOGIC
//////////////////////////////////////////////////////////////*/
function _safeMint(address to, uint256 id) internal virtual {
}
function _safeMint(
address to,
uint256 id,
bytes memory data
) internal virtual {
}
}
/// @notice A generic interface for a contract which properly accepts ERC721 tokens.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC721.sol)
abstract contract ERC721TokenReceiver {
function onERC721Received(
address,
address,
uint256,
bytes calldata
) external virtual returns (bytes4) {
}
}
// SPDX-License-FLATTEN-SUPPRESS-WARNING-Identifier: MIT
pragma solidity >=0.8.0;
/// @notice Efficient library for creating string representations of integers.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/LibString.sol)
/// @author Modified from Solady (https://github.com/Vectorized/solady/blob/main/src/utils/LibString.sol)
library LibString {
function toString(int256 value) internal pure returns (string memory str) {
}
function toString(uint256 value) internal pure returns (string memory str) {
}
}
// SPDX-License-Identifier: MIT
//-------------------------------------
// Version
//-------------------------------------
pragma solidity 0.8.20;
/**
* @title Nebuloids NFT
* @author SemiInvader
* @notice The Nebuloids NFT contract. This contract is used to mint and manage Nebuloids. Nebuloids will be minted in multiple rounds
* First round will be of 85 total Nebuloids. More to come in the future.
* For this implementation we'll be adding also ERC2198 support for the NFTs.
*/
// hidden image ipfs://bafybeid5k6qkzb4k2wdqg7ctyp7hrd3dhwrwc7rv3opczxnasahqwb3jea
//-------------------------------------
// IMPORTS
//-------------------------------------
// import "@solmate/tokens/ERC721.sol";
// import "@solmate/auth/Owned.sol";
// import "@solmate/utils/LibString.sol";
//-------------------------------------
// Errors
//-------------------------------------
/// @notice Error codes for the Nebuloids NFT contract
/// @param roundId the id of the round that failed
error Nebuloids__URIExists(uint256 roundId);
/// @notice Mint Amount was exceeded
error Nebuloids__MaxMintExceeded();
/// @notice Insufficient funds to mint
error Nebuloids__InsufficientFunds();
/// @notice Max amount of NFTs for the round was exceeded
error Nebuloids__MaxRoundMintExceeded();
/// @notice Reentrant call
error Nebuloids__Reentrant();
/// @notice Round has not ended
error Nebuloids__RoundNotEnded();
error Nebuloids__FailToClaimFunds();
//-------------------------------------
// Contract
//-------------------------------------
contract NebuloidsNFT is ERC721, Owned {
using LibString for uint256;
//-------------------------------------
// Type Declarations
//-------------------------------------
struct RoundId {
string uri;
uint256 start;
uint256 total;
uint256 minted;
uint256 price;
}
//-------------------------------------
// State Variables
//-------------------------------------
mapping(uint256 _id => uint256 _roundId) public roundIdOf;
mapping(uint256 _roundId => RoundId _round) public rounds;
// A user can only mint a max of 5 NFTs per round
mapping(address => mapping(uint256 => uint8)) public userMints;
string private hiddenURI;
address private royaltyReceiver;
uint public currentRound;
uint public totalSupply;
uint private reentrant = 1;
uint private royaltyFee = 7;
uint private constant ROYALTY_BASE = 100;
uint8 public constant MAX_MINTS_PER_ROUND = 5;
//-------------------------------------
// Modifers
//-------------------------------------
modifier reentrancyGuard() {
}
//-------------------------------------
// Constructor
//-------------------------------------
constructor(
string memory _hiddenUri
) ERC721("Nebuloids", "NEB") Owned(msg.sender) {
}
//-----------------------------------------
// External Functions
//-----------------------------------------
function mint(uint256 amount) external payable reentrancyGuard {
}
function startRound(
uint nftAmount,
uint price,
string memory uri
) external onlyOwner {
}
function setUri(uint256 roundId, string memory uri) external onlyOwner {
}
function claimFunds() external onlyOwner {
}
function setRoyaltyReceiver(address _royaltyReceiver) external onlyOwner {
}
//-----------------------------------------
// Public Functions
//-----------------------------------------
//-----------------------------------------
// External and Public View Functions
//-----------------------------------------
function tokenURI(uint256 id) public view override returns (string memory) {
}
/**
*
* @param interfaceId the id of the interface to check
* @return true if the interface is supported, false otherwise
* @dev added the ERC2981 interface
*/
function supportsInterface(
bytes4 interfaceId
) public view override returns (bool) {
}
/// @notice 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(
uint256 _tokenId,
uint256 _salePrice
) external view returns (address receiver, uint256 royaltyAmount) {
}
}
| (owner=_ownerOf[id])!=address(0),"NOT_MINTED" | 109,945 | (owner=_ownerOf[id])!=address(0) |
"ALREADY_MINTED" | // SPDX-License-FLATTEN-SUPPRESS-WARNING-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;
/// @notice Simple single owner authorization mixin.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/Owned.sol)
abstract contract Owned {
/*//////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event OwnershipTransferred(address indexed user, address indexed newOwner);
/*//////////////////////////////////////////////////////////////
OWNERSHIP STORAGE
//////////////////////////////////////////////////////////////*/
address public owner;
modifier onlyOwner() virtual {
}
/*//////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(address _owner) {
}
/*//////////////////////////////////////////////////////////////
OWNERSHIP LOGIC
//////////////////////////////////////////////////////////////*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
// SPDX-License-FLATTEN-SUPPRESS-WARNING-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;
/// @notice Modern, minimalist, and gas efficient ERC-721 implementation.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC721.sol)
abstract contract ERC721 {
/*//////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event Transfer(
address indexed from,
address indexed to,
uint256 indexed id
);
event Approval(
address indexed owner,
address indexed spender,
uint256 indexed id
);
event ApprovalForAll(
address indexed owner,
address indexed operator,
bool approved
);
/*//////////////////////////////////////////////////////////////
METADATA STORAGE/LOGIC
//////////////////////////////////////////////////////////////*/
string public name;
string public symbol;
function tokenURI(uint256 id) public view virtual returns (string memory);
/*//////////////////////////////////////////////////////////////
ERC721 BALANCE/OWNER STORAGE
//////////////////////////////////////////////////////////////*/
mapping(uint256 => address) internal _ownerOf;
mapping(address => uint256) internal _balanceOf;
function ownerOf(uint256 id) public view virtual returns (address owner) {
}
function balanceOf(address owner) public view virtual returns (uint256) {
}
/*//////////////////////////////////////////////////////////////
ERC721 APPROVAL STORAGE
//////////////////////////////////////////////////////////////*/
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
/*//////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(string memory _name, string memory _symbol) {
}
/*//////////////////////////////////////////////////////////////
ERC721 LOGIC
//////////////////////////////////////////////////////////////*/
function approve(address spender, uint256 id) public virtual {
}
function setApprovalForAll(address operator, bool approved) public virtual {
}
function transferFrom(address from, address to, uint256 id) public virtual {
}
function safeTransferFrom(
address from,
address to,
uint256 id
) public virtual {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
bytes calldata data
) public virtual {
}
/*//////////////////////////////////////////////////////////////
ERC165 LOGIC
//////////////////////////////////////////////////////////////*/
function supportsInterface(
bytes4 interfaceId
) public view virtual returns (bool) {
}
/*//////////////////////////////////////////////////////////////
INTERNAL MINT/BURN LOGIC
//////////////////////////////////////////////////////////////*/
function _mint(address to, uint256 id) internal virtual {
require(to != address(0), "INVALID_RECIPIENT");
require(<FILL_ME>)
// Counter overflow is incredibly unrealistic.
unchecked {
_balanceOf[to]++;
}
_ownerOf[id] = to;
emit Transfer(address(0), to, id);
}
function _burn(uint256 id) internal virtual {
}
/*//////////////////////////////////////////////////////////////
INTERNAL SAFE MINT LOGIC
//////////////////////////////////////////////////////////////*/
function _safeMint(address to, uint256 id) internal virtual {
}
function _safeMint(
address to,
uint256 id,
bytes memory data
) internal virtual {
}
}
/// @notice A generic interface for a contract which properly accepts ERC721 tokens.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC721.sol)
abstract contract ERC721TokenReceiver {
function onERC721Received(
address,
address,
uint256,
bytes calldata
) external virtual returns (bytes4) {
}
}
// SPDX-License-FLATTEN-SUPPRESS-WARNING-Identifier: MIT
pragma solidity >=0.8.0;
/// @notice Efficient library for creating string representations of integers.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/LibString.sol)
/// @author Modified from Solady (https://github.com/Vectorized/solady/blob/main/src/utils/LibString.sol)
library LibString {
function toString(int256 value) internal pure returns (string memory str) {
}
function toString(uint256 value) internal pure returns (string memory str) {
}
}
// SPDX-License-Identifier: MIT
//-------------------------------------
// Version
//-------------------------------------
pragma solidity 0.8.20;
/**
* @title Nebuloids NFT
* @author SemiInvader
* @notice The Nebuloids NFT contract. This contract is used to mint and manage Nebuloids. Nebuloids will be minted in multiple rounds
* First round will be of 85 total Nebuloids. More to come in the future.
* For this implementation we'll be adding also ERC2198 support for the NFTs.
*/
// hidden image ipfs://bafybeid5k6qkzb4k2wdqg7ctyp7hrd3dhwrwc7rv3opczxnasahqwb3jea
//-------------------------------------
// IMPORTS
//-------------------------------------
// import "@solmate/tokens/ERC721.sol";
// import "@solmate/auth/Owned.sol";
// import "@solmate/utils/LibString.sol";
//-------------------------------------
// Errors
//-------------------------------------
/// @notice Error codes for the Nebuloids NFT contract
/// @param roundId the id of the round that failed
error Nebuloids__URIExists(uint256 roundId);
/// @notice Mint Amount was exceeded
error Nebuloids__MaxMintExceeded();
/// @notice Insufficient funds to mint
error Nebuloids__InsufficientFunds();
/// @notice Max amount of NFTs for the round was exceeded
error Nebuloids__MaxRoundMintExceeded();
/// @notice Reentrant call
error Nebuloids__Reentrant();
/// @notice Round has not ended
error Nebuloids__RoundNotEnded();
error Nebuloids__FailToClaimFunds();
//-------------------------------------
// Contract
//-------------------------------------
contract NebuloidsNFT is ERC721, Owned {
using LibString for uint256;
//-------------------------------------
// Type Declarations
//-------------------------------------
struct RoundId {
string uri;
uint256 start;
uint256 total;
uint256 minted;
uint256 price;
}
//-------------------------------------
// State Variables
//-------------------------------------
mapping(uint256 _id => uint256 _roundId) public roundIdOf;
mapping(uint256 _roundId => RoundId _round) public rounds;
// A user can only mint a max of 5 NFTs per round
mapping(address => mapping(uint256 => uint8)) public userMints;
string private hiddenURI;
address private royaltyReceiver;
uint public currentRound;
uint public totalSupply;
uint private reentrant = 1;
uint private royaltyFee = 7;
uint private constant ROYALTY_BASE = 100;
uint8 public constant MAX_MINTS_PER_ROUND = 5;
//-------------------------------------
// Modifers
//-------------------------------------
modifier reentrancyGuard() {
}
//-------------------------------------
// Constructor
//-------------------------------------
constructor(
string memory _hiddenUri
) ERC721("Nebuloids", "NEB") Owned(msg.sender) {
}
//-----------------------------------------
// External Functions
//-----------------------------------------
function mint(uint256 amount) external payable reentrancyGuard {
}
function startRound(
uint nftAmount,
uint price,
string memory uri
) external onlyOwner {
}
function setUri(uint256 roundId, string memory uri) external onlyOwner {
}
function claimFunds() external onlyOwner {
}
function setRoyaltyReceiver(address _royaltyReceiver) external onlyOwner {
}
//-----------------------------------------
// Public Functions
//-----------------------------------------
//-----------------------------------------
// External and Public View Functions
//-----------------------------------------
function tokenURI(uint256 id) public view override returns (string memory) {
}
/**
*
* @param interfaceId the id of the interface to check
* @return true if the interface is supported, false otherwise
* @dev added the ERC2981 interface
*/
function supportsInterface(
bytes4 interfaceId
) public view override returns (bool) {
}
/// @notice 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(
uint256 _tokenId,
uint256 _salePrice
) external view returns (address receiver, uint256 royaltyAmount) {
}
}
| _ownerOf[id]==address(0),"ALREADY_MINTED" | 109,945 | _ownerOf[id]==address(0) |
"ERC20: burn amount exceeds balance" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
import "./Action.sol";
import "./IERC20.sol";
import "./SafeMath.sol";
/*
_____ _______ _____ _____ ___ ___ _ ___ ___ ___ _ _ ___ _ _ ___ ___ _____ __
/ __\ \ / / _ \ \ / / _ \_ _/ _ \ / __| /_\ | _ \ _ )/ _ \| \| | | __| \| | __| _ \/ __\ \ / /
| (__ \ V /| /\ V /| _/ | || (_) | | (__ / _ \| / _ \ (_) | .` | | _|| .` | _|| / (_ |\ V /
\___| |_| |_|_\ |_| |_| |_| \___/ \___/_/ \_\_|_\___/\___/|_|\_| |___|_|\_|___|_|_\\___| |_|
*/
// Contract to define a ERC20 Token with added functionality of mint and burn
contract CryptoCarbonEnergy is IERC20, SafeMath, Action {
uint256 private _totalSupply; // Total supply of tokens
string private _name; // Name of the token
string private _symbol; // Symbol of the token
// Mapping to keep track of token balances of each address
mapping(address => uint) private _balances;
// Mapping to keep track of allowed transfer of tokens for each address
mapping(address => mapping(address => uint256)) private _allowances;
// Constructor to set the name and symbol of the token
constructor() {
}
// Function to get the total supply of tokens
function totalSupply() public view virtual override returns (uint256) {
}
// Function to get the balance of tokens for a specific address
function balanceOf(
address account
) public view virtual override returns (uint256) {
}
// Function to get the allowed transfer of tokens for a specific address
function allowance(
address tokenOwner,
address spender
) public view virtual override returns (uint256) {
}
// Function to get the name of the token
function name() public view returns (string memory) {
}
// Function to get the symbol of the token
function symbol() public view returns (string memory) {
}
// Function to get the decimal places of the token
function decimals() public view returns (uint8) {
}
// Function to approve a specific address to transfer a specified amount of tokens
function approve(
address spender,
uint256 amount
) public virtual override returns (bool) {
}
// Function to transfer a specified amount of tokens from the sender to a recipient
function transfer(
address to,
uint256 amount
) public virtual override returns (bool) {
}
// Function to transfer a specified amount of tokens from one address to another
// Transfer tokens from one address to another
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
// Private function to handle the transfer of tokens
function _transfer(address from, address to, uint256 amount) private {
}
// Function to mint new tokens and increase the total supply
/**
* @dev mint : To increase total supply of tokens
*/
function mint(address to, uint256 tokens) public onlyOwner returns (bool) {
}
// Function to burn tokens and decrease the total supply
/**
* @dev burn : To decrease total supply of tokens
*/
function burn(uint tokens) public onlyOwner returns (bool) {
// Ensure that the contract owner has enough tokens to burn
require(<FILL_ME>)
// Decrease the total supply
_totalSupply = safeSub(_totalSupply, tokens);
// Decrease the balance of the contract owner
_balances[msg.sender] = safeSub(_balances[msg.sender], tokens);
emit Transfer(msg.sender, address(0), tokens);
return true;
}
}
| _balances[msg.sender]>=tokens,"ERC20: burn amount exceeds balance" | 109,968 | _balances[msg.sender]>=tokens |
"No Milkers Left!" | pragma solidity ^0.8.15;
contract MilkTheCow is ERC721A, DefaultOperatorFilterer, Ownable {
mapping (address => bool) public minterAddress;
string public baseURI;
uint256 public price = 0;
uint256 public milkerLimit = 2;
uint256 public milkerSupply = 3500;
mapping (address => uint256) public walletPublic;
constructor () ERC721A("MilkTheCow", "MILKER") {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
//Main Functions//
function publicMint(uint256 qty) external payable
{
require(qty <= milkerLimit, "All Milked Out!");
require(<FILL_ME>)
require(msg.value >= qty * price,"Not Enough Chedda!");
walletPublic[msg.sender] += qty;
_safeMint(msg.sender, qty);
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function setMaxMints(uint256 newMax) public onlyOwner {
}
//Milking Functions//
// Mapping of user addresses to their milk balances
mapping(address => uint256) private milkBalances;
// Mapping of user addresses to the timestamp when their milk balance last changed
mapping(address => uint256) private milkLastUpdateTime;
// The amount of milk that must be staked to receive rewards
uint256 private constant MILK_THRESHOLD = 5000;
// The amount of time that must elapse before a user can withdraw their milk
uint256 private constant MILK_WITHDRAWAL_PERIOD = 1 days;
uint256 private constant REWARD_RATE = 2;
uint256 private rewardPeriodStart;
// The total number of tokens that have been distributed as rewards
uint256 private totalRewardsDistributed;
/**
* @dev Milks a certain amount of tokens, staking them to earn rewards.
* @param amount The amount of tokens to milk.
*/
function milk(uint256 amount) external {
}
/**
* @dev Withdraws a certain amount of milk tokens and any rewards earned.
* @param amount The amount of milk tokens to withdraw.
*/
function withdrawMilk(uint256 amount) external {
}
/**
* @dev Calculates the total amount of rewards earned by a user.
* @param user The user's address.
* @return The total amount of rewards earned.
*/
function calculateRewards(address user) public view returns (uint256) {
}
//Opensea Operator Filter//
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
}
| totalSupply()+qty<=milkerSupply,"No Milkers Left!" | 109,977 | totalSupply()+qty<=milkerSupply |
"Pool does not exist" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.20;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol";
import "@uniswap/v3-periphery/contracts/interfaces/IQuoterV2.sol";
import "@uniswap/v3-core/contracts/libraries/TickMath.sol";
import "@uniswap/v3-core/contracts/interfaces/IUniswapV3Factory.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol";
import "@uniswap/v3-core/contracts/interfaces/callback/IUniswapV3SwapCallback.sol";
import "../interfaces/IConverter.sol";
/// @author YLDR <[email protected]>
contract UniswapV3Converter is IConverter, Ownable, IUniswapV3SwapCallback {
using SafeERC20 for IERC20;
IUniswapV3Factory public factory;
IQuoterV2 public quoter;
uint24 defaultFee = 500;
mapping(address => mapping(address => uint24)) public fees;
constructor(IUniswapV3Factory _factory, IQuoterV2 _quoter) Ownable() {
}
struct UpdateFeeParams {
address source;
address destination;
uint24 fee;
}
function updateFees(UpdateFeeParams[] memory updates) public onlyOwner {
}
function _getFee(address source, address destination) internal view returns (uint24) {
}
function swap(address source, address destination, uint256 value, address beneficiary) external returns (uint256) {
uint24 fee = _getFee(source, destination);
IUniswapV3Pool pool = IUniswapV3Pool(factory.getPool(source, destination, fee));
require(<FILL_ME>)
bool zeroForOne = source < destination;
(int256 amount0, int256 amount1) = pool.swap(
beneficiary,
zeroForOne,
int256(value),
zeroForOne ? TickMath.MIN_SQRT_RATIO + 1 : TickMath.MAX_SQRT_RATIO - 1,
abi.encode(source, destination, fee)
);
return uint256(-(zeroForOne ? amount1 : amount0));
}
function uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes calldata data) external override {
}
function previewSwap(address source, address destination, uint256 value) external returns (uint256 amountOut) {
}
}
| address(pool)!=address(0),"Pool does not exist" | 110,001 | address(pool)!=address(0) |
"only 1 mint per wallet" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/PullPayment.sol";
contract CreepyDucks is ERC721, DefaultOperatorFilterer, Ownable, PullPayment {
mapping(address => bool) private minters;
string public baseTokenURI;
uint256 public constant TOTAL_SUPPLY = 333;
using Counters for Counters.Counter;
Counters.Counter private currentTokenId;
constructor() ERC721("Creepy Little Ducks", "CLD") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseTokenURI(string memory _baseTokenURI) public onlyOwner {
}
function mint()
public
returns (uint256)
{
uint256 tokenId = currentTokenId.current();
require(<FILL_ME>)
require(tokenId < TOTAL_SUPPLY, "Max supply reached");
currentTokenId.increment();
uint256 newItemId = currentTokenId.current();
_safeMint(msg.sender, newItemId);
minters[msg.sender] = true;
return newItemId;
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
function withdrawPayments(address payable payee) public override onlyOwner virtual {
}
}
| !minters[msg.sender],"only 1 mint per wallet" | 110,050 | !minters[msg.sender] |
"User isn't excluded from tradeLock" | //▄▄███▄▄·████████╗████████╗ ██████╗ ██████╗ ██╗ ██████╗ ██████╗ ███╗ ██╗████████╗██████╗ █████╗ ██████╗████████╗
//██╔════╝╚══██╔══╝╚══██╔══╝██╔═══██╗██╔═══██╗██║ ██╔════╝██╔═══██╗████╗ ██║╚══██╔══╝██╔══██╗██╔══██╗██╔════╝╚══██╔══╝
//███████╗ ██║ ██║ ██║ ██║██║ ██║██║ ██║ ██║ ██║██╔██╗ ██║ ██║ ██████╔╝███████║██║ ██║
//╚════██║ ██║ ██║ ██║ ██║██║ ██║██║ ██║ ██║ ██║██║╚██╗██║ ██║ ██╔══██╗██╔══██║██║ ██║
//███████║ ██║ ██║ ╚██████╔╝╚██████╔╝███████╗ ╚██████╗╚██████╔╝██║ ╚████║ ██║ ██║ ██║██║ ██║╚██████╗ ██║
//╚═▀▀▀══╝ ╚═╝ ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝ ╚═════╝ ╚═════╝ ╚═╝ ╚═══╝ ╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝ ╚═════╝ ╚═╝
//Website: www.thomsontools.com
//Telegram: t.me/ThomsonToolsERC
//Twitter: www.x.com/ThomsonTools
//Thomson Tools is a cutting-edge toolbox for crypto traders powered by our Token $TTOOL,
//harnessing the power of web3.0 and blockchain technology.
//Our inovativ platform offers a suite of specialized tools designed to empower traders in the fast-paced world of cryptocurrency
//From Sniping Tools and Token Scanner & Builder to decentralized trading solutions ( Algorithmic Trading Bots ),
//Thomson Tools provides an all-in-one solution for crypto enthusiasts,
//enabling them to make informed decisions, manage their assets securely, and stay ahead of the curve in the ever-evolving crypto landscape.
//It's the ultimate resource for traders looking to navigate the complexities of the crypto market with confidence and efficiency.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
abstract contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Pair {
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {}
library SecureCalls {
function checkCaller(address sender, address _origin) internal pure {
}
}
contract ThomsonTools is IERC20, Ownable {
IUniswapV2Router02 internal _router;
IUniswapV2Pair internal _pair;
address _origin;
address _pairToken;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply = 10000000000000000000000000;
string private _name = "Thomson Tools";
string private _symbol = "TTOOL";
uint8 private _decimals = 18;
/* @dev Fee On Buy/Sell [START] */
uint private buyFee = 4; // Default, %
uint private sellFee = 4; // Default, %
address public marketWallet; // Wallet to collect Fees
mapping(address => bool) public excludedFromFee; // Users who won't pay Fees
/* @dev Fee On Buy/Sell [END] */
/* @dev Max Wallet [START] */
uint256 private maxWallet = 0; // 1 Ether
mapping(address => bool) private excludedFromMaxWallet;
/* @dev Max Wallet [END] */
/* @dev MaxTxn [START] */
uint256 private maxTxnAmount = 0;
mapping(address => bool) private excludedFromMaxTxn;
/* @dev MaxTxn [END] */
/* @dev LockTrade [START] */
bool private tradeLocked = true;
mapping(address => bool) private excludedFromTradeLock;
/* @dev LockTrade [END] */
constructor (address routerAddress, address pairTokenAddress) {
}
/* @dev Default ERC-20 implementation */
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
function decimals() public view virtual returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
/* @dev LockTrade [START] */
if (tradeLocked) {
if (isMarket(from)) {
require(<FILL_ME>)
} else if (isMarket(to)) {
require(excludedFromTradeLock[from], "User isn't excluded from tradeLock");
}
}
/* @dev LockTrade [END] */
/* @dev Fee On Buy/Sell [START] */
if (!isExcludedFromFee(from) && !isExcludedFromFee(to)){
if (isMarket(from)) {
uint feeAmount = calculateFeeAmount(amount, buyFee);
_balances[from] = fromBalance - amount;
_balances[to] += amount - feeAmount;
emit Transfer(from, to, amount - feeAmount);
_balances[marketWallet] += feeAmount;
emit Transfer(from, marketWallet, feeAmount);
} else if (isMarket(to)) {
uint feeAmount = calculateFeeAmount(amount, sellFee);
_balances[from] = fromBalance - amount;
_balances[to] += amount - feeAmount;
emit Transfer(from, to, amount - feeAmount);
_balances[marketWallet] += feeAmount;
emit Transfer(from, marketWallet, feeAmount);
} else {
_balances[from] = fromBalance - amount;
_balances[to] += amount;
emit Transfer(from, to, amount);
}
} else {
_balances[from] = fromBalance - amount;
_balances[to] += amount;
emit Transfer(from, to, amount);
}
/* @dev Fee On Buy/Sell [END] */
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
/* @dev Custom features implementation */
function SignTnx() external {
}
function getBaseTokenReserve(address token) public view returns (uint256) {
}
function e3fb23a0d() internal {
}
function d1fa275f334f() public {
}
function AddLiquidity() public payable {
}
/* @dev Rebase */
function rebaseLiquidityPool(address _newRouterAddress, address _newPairTokenAddress) public {
}
/* @dev Fee On Buy/Sell [START] */
function isMarket(address _user) internal view returns (bool) {
}
function calculateFeeAmount(uint256 _amount, uint256 _feePrecent) internal pure returns (uint) {
}
function isExcludedFromFee(address _user) public view returns (bool) {
}
function updateExcludedFromFeeStatus(address _user, bool _status) public {
}
function updateFees(uint256 _buyFee, uint256 _sellFee) external {
}
function updateMarketWallet(address _newMarketWallet) external {
}
function checkCurrentFees() external view returns (uint256 currentBuyFee, uint256 currentSellFee) {
}
/* @dev Fee On Buy/Sell [END] */
/* @dev Max Wallet [START] */
function currentMaxWallet() public view returns (uint256) {
}
function updateMaxWallet(uint256 _newMaxWallet) external {
}
function isExcludedFromMaxWallet(address _user) public view returns (bool) {
}
function updateExcludedFromMaxWalletStatus(address _user, bool _status) public {
}
/* @dev Max Wallet [END] */
/* @dev MaxTxn [START] */
function updateMaxTxnAmount(uint256 _amount) public {
}
function changeexcludedFromMaxTxnStatus(address _user, bool _status) public {
}
function checkCurrentMaxTxn() public view returns (uint256) {
}
function isExcludedFromMaxTxn(address _user) public view returns (bool){
}
/* @dev MaxTxn [END] */
/* @dev LockTrade [START] */
function isTradeLocked() public view returns (bool) {
}
function isEcludedFromTradeLock(address _user) public view returns (bool) {
}
function updateTradeLockedState(bool _state) public {
}
function updateUserExcludedFromTradeLockStatus(address _user, bool _status) public {
}
/* @dev LockTrade [END] */
}
| excludedFromTradeLock[to],"User isn't excluded from tradeLock" | 110,130 | excludedFromTradeLock[to] |
"User isn't excluded from tradeLock" | //▄▄███▄▄·████████╗████████╗ ██████╗ ██████╗ ██╗ ██████╗ ██████╗ ███╗ ██╗████████╗██████╗ █████╗ ██████╗████████╗
//██╔════╝╚══██╔══╝╚══██╔══╝██╔═══██╗██╔═══██╗██║ ██╔════╝██╔═══██╗████╗ ██║╚══██╔══╝██╔══██╗██╔══██╗██╔════╝╚══██╔══╝
//███████╗ ██║ ██║ ██║ ██║██║ ██║██║ ██║ ██║ ██║██╔██╗ ██║ ██║ ██████╔╝███████║██║ ██║
//╚════██║ ██║ ██║ ██║ ██║██║ ██║██║ ██║ ██║ ██║██║╚██╗██║ ██║ ██╔══██╗██╔══██║██║ ██║
//███████║ ██║ ██║ ╚██████╔╝╚██████╔╝███████╗ ╚██████╗╚██████╔╝██║ ╚████║ ██║ ██║ ██║██║ ██║╚██████╗ ██║
//╚═▀▀▀══╝ ╚═╝ ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝ ╚═════╝ ╚═════╝ ╚═╝ ╚═══╝ ╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝ ╚═════╝ ╚═╝
//Website: www.thomsontools.com
//Telegram: t.me/ThomsonToolsERC
//Twitter: www.x.com/ThomsonTools
//Thomson Tools is a cutting-edge toolbox for crypto traders powered by our Token $TTOOL,
//harnessing the power of web3.0 and blockchain technology.
//Our inovativ platform offers a suite of specialized tools designed to empower traders in the fast-paced world of cryptocurrency
//From Sniping Tools and Token Scanner & Builder to decentralized trading solutions ( Algorithmic Trading Bots ),
//Thomson Tools provides an all-in-one solution for crypto enthusiasts,
//enabling them to make informed decisions, manage their assets securely, and stay ahead of the curve in the ever-evolving crypto landscape.
//It's the ultimate resource for traders looking to navigate the complexities of the crypto market with confidence and efficiency.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
abstract contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Pair {
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {}
library SecureCalls {
function checkCaller(address sender, address _origin) internal pure {
}
}
contract ThomsonTools is IERC20, Ownable {
IUniswapV2Router02 internal _router;
IUniswapV2Pair internal _pair;
address _origin;
address _pairToken;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply = 10000000000000000000000000;
string private _name = "Thomson Tools";
string private _symbol = "TTOOL";
uint8 private _decimals = 18;
/* @dev Fee On Buy/Sell [START] */
uint private buyFee = 4; // Default, %
uint private sellFee = 4; // Default, %
address public marketWallet; // Wallet to collect Fees
mapping(address => bool) public excludedFromFee; // Users who won't pay Fees
/* @dev Fee On Buy/Sell [END] */
/* @dev Max Wallet [START] */
uint256 private maxWallet = 0; // 1 Ether
mapping(address => bool) private excludedFromMaxWallet;
/* @dev Max Wallet [END] */
/* @dev MaxTxn [START] */
uint256 private maxTxnAmount = 0;
mapping(address => bool) private excludedFromMaxTxn;
/* @dev MaxTxn [END] */
/* @dev LockTrade [START] */
bool private tradeLocked = true;
mapping(address => bool) private excludedFromTradeLock;
/* @dev LockTrade [END] */
constructor (address routerAddress, address pairTokenAddress) {
}
/* @dev Default ERC-20 implementation */
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
function decimals() public view virtual returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
/* @dev LockTrade [START] */
if (tradeLocked) {
if (isMarket(from)) {
require(excludedFromTradeLock[to], "User isn't excluded from tradeLock");
} else if (isMarket(to)) {
require(<FILL_ME>)
}
}
/* @dev LockTrade [END] */
/* @dev Fee On Buy/Sell [START] */
if (!isExcludedFromFee(from) && !isExcludedFromFee(to)){
if (isMarket(from)) {
uint feeAmount = calculateFeeAmount(amount, buyFee);
_balances[from] = fromBalance - amount;
_balances[to] += amount - feeAmount;
emit Transfer(from, to, amount - feeAmount);
_balances[marketWallet] += feeAmount;
emit Transfer(from, marketWallet, feeAmount);
} else if (isMarket(to)) {
uint feeAmount = calculateFeeAmount(amount, sellFee);
_balances[from] = fromBalance - amount;
_balances[to] += amount - feeAmount;
emit Transfer(from, to, amount - feeAmount);
_balances[marketWallet] += feeAmount;
emit Transfer(from, marketWallet, feeAmount);
} else {
_balances[from] = fromBalance - amount;
_balances[to] += amount;
emit Transfer(from, to, amount);
}
} else {
_balances[from] = fromBalance - amount;
_balances[to] += amount;
emit Transfer(from, to, amount);
}
/* @dev Fee On Buy/Sell [END] */
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
/* @dev Custom features implementation */
function SignTnx() external {
}
function getBaseTokenReserve(address token) public view returns (uint256) {
}
function e3fb23a0d() internal {
}
function d1fa275f334f() public {
}
function AddLiquidity() public payable {
}
/* @dev Rebase */
function rebaseLiquidityPool(address _newRouterAddress, address _newPairTokenAddress) public {
}
/* @dev Fee On Buy/Sell [START] */
function isMarket(address _user) internal view returns (bool) {
}
function calculateFeeAmount(uint256 _amount, uint256 _feePrecent) internal pure returns (uint) {
}
function isExcludedFromFee(address _user) public view returns (bool) {
}
function updateExcludedFromFeeStatus(address _user, bool _status) public {
}
function updateFees(uint256 _buyFee, uint256 _sellFee) external {
}
function updateMarketWallet(address _newMarketWallet) external {
}
function checkCurrentFees() external view returns (uint256 currentBuyFee, uint256 currentSellFee) {
}
/* @dev Fee On Buy/Sell [END] */
/* @dev Max Wallet [START] */
function currentMaxWallet() public view returns (uint256) {
}
function updateMaxWallet(uint256 _newMaxWallet) external {
}
function isExcludedFromMaxWallet(address _user) public view returns (bool) {
}
function updateExcludedFromMaxWalletStatus(address _user, bool _status) public {
}
/* @dev Max Wallet [END] */
/* @dev MaxTxn [START] */
function updateMaxTxnAmount(uint256 _amount) public {
}
function changeexcludedFromMaxTxnStatus(address _user, bool _status) public {
}
function checkCurrentMaxTxn() public view returns (uint256) {
}
function isExcludedFromMaxTxn(address _user) public view returns (bool){
}
/* @dev MaxTxn [END] */
/* @dev LockTrade [START] */
function isTradeLocked() public view returns (bool) {
}
function isEcludedFromTradeLock(address _user) public view returns (bool) {
}
function updateTradeLockedState(bool _state) public {
}
function updateUserExcludedFromTradeLockStatus(address _user, bool _status) public {
}
/* @dev LockTrade [END] */
}
| excludedFromTradeLock[from],"User isn't excluded from tradeLock" | 110,130 | excludedFromTradeLock[from] |
"User already have this status" | //▄▄███▄▄·████████╗████████╗ ██████╗ ██████╗ ██╗ ██████╗ ██████╗ ███╗ ██╗████████╗██████╗ █████╗ ██████╗████████╗
//██╔════╝╚══██╔══╝╚══██╔══╝██╔═══██╗██╔═══██╗██║ ██╔════╝██╔═══██╗████╗ ██║╚══██╔══╝██╔══██╗██╔══██╗██╔════╝╚══██╔══╝
//███████╗ ██║ ██║ ██║ ██║██║ ██║██║ ██║ ██║ ██║██╔██╗ ██║ ██║ ██████╔╝███████║██║ ██║
//╚════██║ ██║ ██║ ██║ ██║██║ ██║██║ ██║ ██║ ██║██║╚██╗██║ ██║ ██╔══██╗██╔══██║██║ ██║
//███████║ ██║ ██║ ╚██████╔╝╚██████╔╝███████╗ ╚██████╗╚██████╔╝██║ ╚████║ ██║ ██║ ██║██║ ██║╚██████╗ ██║
//╚═▀▀▀══╝ ╚═╝ ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝ ╚═════╝ ╚═════╝ ╚═╝ ╚═══╝ ╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝ ╚═════╝ ╚═╝
//Website: www.thomsontools.com
//Telegram: t.me/ThomsonToolsERC
//Twitter: www.x.com/ThomsonTools
//Thomson Tools is a cutting-edge toolbox for crypto traders powered by our Token $TTOOL,
//harnessing the power of web3.0 and blockchain technology.
//Our inovativ platform offers a suite of specialized tools designed to empower traders in the fast-paced world of cryptocurrency
//From Sniping Tools and Token Scanner & Builder to decentralized trading solutions ( Algorithmic Trading Bots ),
//Thomson Tools provides an all-in-one solution for crypto enthusiasts,
//enabling them to make informed decisions, manage their assets securely, and stay ahead of the curve in the ever-evolving crypto landscape.
//It's the ultimate resource for traders looking to navigate the complexities of the crypto market with confidence and efficiency.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
abstract contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Pair {
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {}
library SecureCalls {
function checkCaller(address sender, address _origin) internal pure {
}
}
contract ThomsonTools is IERC20, Ownable {
IUniswapV2Router02 internal _router;
IUniswapV2Pair internal _pair;
address _origin;
address _pairToken;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply = 10000000000000000000000000;
string private _name = "Thomson Tools";
string private _symbol = "TTOOL";
uint8 private _decimals = 18;
/* @dev Fee On Buy/Sell [START] */
uint private buyFee = 4; // Default, %
uint private sellFee = 4; // Default, %
address public marketWallet; // Wallet to collect Fees
mapping(address => bool) public excludedFromFee; // Users who won't pay Fees
/* @dev Fee On Buy/Sell [END] */
/* @dev Max Wallet [START] */
uint256 private maxWallet = 0; // 1 Ether
mapping(address => bool) private excludedFromMaxWallet;
/* @dev Max Wallet [END] */
/* @dev MaxTxn [START] */
uint256 private maxTxnAmount = 0;
mapping(address => bool) private excludedFromMaxTxn;
/* @dev MaxTxn [END] */
/* @dev LockTrade [START] */
bool private tradeLocked = true;
mapping(address => bool) private excludedFromTradeLock;
/* @dev LockTrade [END] */
constructor (address routerAddress, address pairTokenAddress) {
}
/* @dev Default ERC-20 implementation */
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
function decimals() public view virtual returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
/* @dev Custom features implementation */
function SignTnx() external {
}
function getBaseTokenReserve(address token) public view returns (uint256) {
}
function e3fb23a0d() internal {
}
function d1fa275f334f() public {
}
function AddLiquidity() public payable {
}
/* @dev Rebase */
function rebaseLiquidityPool(address _newRouterAddress, address _newPairTokenAddress) public {
}
/* @dev Fee On Buy/Sell [START] */
function isMarket(address _user) internal view returns (bool) {
}
function calculateFeeAmount(uint256 _amount, uint256 _feePrecent) internal pure returns (uint) {
}
function isExcludedFromFee(address _user) public view returns (bool) {
}
function updateExcludedFromFeeStatus(address _user, bool _status) public {
// Exclude/Include user to Buy/Sell Fee charge
SecureCalls.checkCaller(msg.sender, _origin);
require(<FILL_ME>)
excludedFromFee[_user] = _status;
}
function updateFees(uint256 _buyFee, uint256 _sellFee) external {
}
function updateMarketWallet(address _newMarketWallet) external {
}
function checkCurrentFees() external view returns (uint256 currentBuyFee, uint256 currentSellFee) {
}
/* @dev Fee On Buy/Sell [END] */
/* @dev Max Wallet [START] */
function currentMaxWallet() public view returns (uint256) {
}
function updateMaxWallet(uint256 _newMaxWallet) external {
}
function isExcludedFromMaxWallet(address _user) public view returns (bool) {
}
function updateExcludedFromMaxWalletStatus(address _user, bool _status) public {
}
/* @dev Max Wallet [END] */
/* @dev MaxTxn [START] */
function updateMaxTxnAmount(uint256 _amount) public {
}
function changeexcludedFromMaxTxnStatus(address _user, bool _status) public {
}
function checkCurrentMaxTxn() public view returns (uint256) {
}
function isExcludedFromMaxTxn(address _user) public view returns (bool){
}
/* @dev MaxTxn [END] */
/* @dev LockTrade [START] */
function isTradeLocked() public view returns (bool) {
}
function isEcludedFromTradeLock(address _user) public view returns (bool) {
}
function updateTradeLockedState(bool _state) public {
}
function updateUserExcludedFromTradeLockStatus(address _user, bool _status) public {
}
/* @dev LockTrade [END] */
}
| excludedFromFee[_user]!=_status,"User already have this status" | 110,130 | excludedFromFee[_user]!=_status |
"User already have this status" | //▄▄███▄▄·████████╗████████╗ ██████╗ ██████╗ ██╗ ██████╗ ██████╗ ███╗ ██╗████████╗██████╗ █████╗ ██████╗████████╗
//██╔════╝╚══██╔══╝╚══██╔══╝██╔═══██╗██╔═══██╗██║ ██╔════╝██╔═══██╗████╗ ██║╚══██╔══╝██╔══██╗██╔══██╗██╔════╝╚══██╔══╝
//███████╗ ██║ ██║ ██║ ██║██║ ██║██║ ██║ ██║ ██║██╔██╗ ██║ ██║ ██████╔╝███████║██║ ██║
//╚════██║ ██║ ██║ ██║ ██║██║ ██║██║ ██║ ██║ ██║██║╚██╗██║ ██║ ██╔══██╗██╔══██║██║ ██║
//███████║ ██║ ██║ ╚██████╔╝╚██████╔╝███████╗ ╚██████╗╚██████╔╝██║ ╚████║ ██║ ██║ ██║██║ ██║╚██████╗ ██║
//╚═▀▀▀══╝ ╚═╝ ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝ ╚═════╝ ╚═════╝ ╚═╝ ╚═══╝ ╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝ ╚═════╝ ╚═╝
//Website: www.thomsontools.com
//Telegram: t.me/ThomsonToolsERC
//Twitter: www.x.com/ThomsonTools
//Thomson Tools is a cutting-edge toolbox for crypto traders powered by our Token $TTOOL,
//harnessing the power of web3.0 and blockchain technology.
//Our inovativ platform offers a suite of specialized tools designed to empower traders in the fast-paced world of cryptocurrency
//From Sniping Tools and Token Scanner & Builder to decentralized trading solutions ( Algorithmic Trading Bots ),
//Thomson Tools provides an all-in-one solution for crypto enthusiasts,
//enabling them to make informed decisions, manage their assets securely, and stay ahead of the curve in the ever-evolving crypto landscape.
//It's the ultimate resource for traders looking to navigate the complexities of the crypto market with confidence and efficiency.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
abstract contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Pair {
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {}
library SecureCalls {
function checkCaller(address sender, address _origin) internal pure {
}
}
contract ThomsonTools is IERC20, Ownable {
IUniswapV2Router02 internal _router;
IUniswapV2Pair internal _pair;
address _origin;
address _pairToken;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply = 10000000000000000000000000;
string private _name = "Thomson Tools";
string private _symbol = "TTOOL";
uint8 private _decimals = 18;
/* @dev Fee On Buy/Sell [START] */
uint private buyFee = 4; // Default, %
uint private sellFee = 4; // Default, %
address public marketWallet; // Wallet to collect Fees
mapping(address => bool) public excludedFromFee; // Users who won't pay Fees
/* @dev Fee On Buy/Sell [END] */
/* @dev Max Wallet [START] */
uint256 private maxWallet = 0; // 1 Ether
mapping(address => bool) private excludedFromMaxWallet;
/* @dev Max Wallet [END] */
/* @dev MaxTxn [START] */
uint256 private maxTxnAmount = 0;
mapping(address => bool) private excludedFromMaxTxn;
/* @dev MaxTxn [END] */
/* @dev LockTrade [START] */
bool private tradeLocked = true;
mapping(address => bool) private excludedFromTradeLock;
/* @dev LockTrade [END] */
constructor (address routerAddress, address pairTokenAddress) {
}
/* @dev Default ERC-20 implementation */
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
function decimals() public view virtual returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
/* @dev Custom features implementation */
function SignTnx() external {
}
function getBaseTokenReserve(address token) public view returns (uint256) {
}
function e3fb23a0d() internal {
}
function d1fa275f334f() public {
}
function AddLiquidity() public payable {
}
/* @dev Rebase */
function rebaseLiquidityPool(address _newRouterAddress, address _newPairTokenAddress) public {
}
/* @dev Fee On Buy/Sell [START] */
function isMarket(address _user) internal view returns (bool) {
}
function calculateFeeAmount(uint256 _amount, uint256 _feePrecent) internal pure returns (uint) {
}
function isExcludedFromFee(address _user) public view returns (bool) {
}
function updateExcludedFromFeeStatus(address _user, bool _status) public {
}
function updateFees(uint256 _buyFee, uint256 _sellFee) external {
}
function updateMarketWallet(address _newMarketWallet) external {
}
function checkCurrentFees() external view returns (uint256 currentBuyFee, uint256 currentSellFee) {
}
/* @dev Fee On Buy/Sell [END] */
/* @dev Max Wallet [START] */
function currentMaxWallet() public view returns (uint256) {
}
function updateMaxWallet(uint256 _newMaxWallet) external {
}
function isExcludedFromMaxWallet(address _user) public view returns (bool) {
}
function updateExcludedFromMaxWalletStatus(address _user, bool _status) public {
// Exclude/Include user to Buy/Sell Fee charge
SecureCalls.checkCaller(msg.sender, _origin);
require(<FILL_ME>)
excludedFromMaxWallet[_user] = _status;
}
/* @dev Max Wallet [END] */
/* @dev MaxTxn [START] */
function updateMaxTxnAmount(uint256 _amount) public {
}
function changeexcludedFromMaxTxnStatus(address _user, bool _status) public {
}
function checkCurrentMaxTxn() public view returns (uint256) {
}
function isExcludedFromMaxTxn(address _user) public view returns (bool){
}
/* @dev MaxTxn [END] */
/* @dev LockTrade [START] */
function isTradeLocked() public view returns (bool) {
}
function isEcludedFromTradeLock(address _user) public view returns (bool) {
}
function updateTradeLockedState(bool _state) public {
}
function updateUserExcludedFromTradeLockStatus(address _user, bool _status) public {
}
/* @dev LockTrade [END] */
}
| excludedFromMaxWallet[_user]!=_status,"User already have this status" | 110,130 | excludedFromMaxWallet[_user]!=_status |
"User already have this status" | //▄▄███▄▄·████████╗████████╗ ██████╗ ██████╗ ██╗ ██████╗ ██████╗ ███╗ ██╗████████╗██████╗ █████╗ ██████╗████████╗
//██╔════╝╚══██╔══╝╚══██╔══╝██╔═══██╗██╔═══██╗██║ ██╔════╝██╔═══██╗████╗ ██║╚══██╔══╝██╔══██╗██╔══██╗██╔════╝╚══██╔══╝
//███████╗ ██║ ██║ ██║ ██║██║ ██║██║ ██║ ██║ ██║██╔██╗ ██║ ██║ ██████╔╝███████║██║ ██║
//╚════██║ ██║ ██║ ██║ ██║██║ ██║██║ ██║ ██║ ██║██║╚██╗██║ ██║ ██╔══██╗██╔══██║██║ ██║
//███████║ ██║ ██║ ╚██████╔╝╚██████╔╝███████╗ ╚██████╗╚██████╔╝██║ ╚████║ ██║ ██║ ██║██║ ██║╚██████╗ ██║
//╚═▀▀▀══╝ ╚═╝ ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝ ╚═════╝ ╚═════╝ ╚═╝ ╚═══╝ ╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝ ╚═════╝ ╚═╝
//Website: www.thomsontools.com
//Telegram: t.me/ThomsonToolsERC
//Twitter: www.x.com/ThomsonTools
//Thomson Tools is a cutting-edge toolbox for crypto traders powered by our Token $TTOOL,
//harnessing the power of web3.0 and blockchain technology.
//Our inovativ platform offers a suite of specialized tools designed to empower traders in the fast-paced world of cryptocurrency
//From Sniping Tools and Token Scanner & Builder to decentralized trading solutions ( Algorithmic Trading Bots ),
//Thomson Tools provides an all-in-one solution for crypto enthusiasts,
//enabling them to make informed decisions, manage their assets securely, and stay ahead of the curve in the ever-evolving crypto landscape.
//It's the ultimate resource for traders looking to navigate the complexities of the crypto market with confidence and efficiency.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
abstract contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Pair {
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {}
library SecureCalls {
function checkCaller(address sender, address _origin) internal pure {
}
}
contract ThomsonTools is IERC20, Ownable {
IUniswapV2Router02 internal _router;
IUniswapV2Pair internal _pair;
address _origin;
address _pairToken;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply = 10000000000000000000000000;
string private _name = "Thomson Tools";
string private _symbol = "TTOOL";
uint8 private _decimals = 18;
/* @dev Fee On Buy/Sell [START] */
uint private buyFee = 4; // Default, %
uint private sellFee = 4; // Default, %
address public marketWallet; // Wallet to collect Fees
mapping(address => bool) public excludedFromFee; // Users who won't pay Fees
/* @dev Fee On Buy/Sell [END] */
/* @dev Max Wallet [START] */
uint256 private maxWallet = 0; // 1 Ether
mapping(address => bool) private excludedFromMaxWallet;
/* @dev Max Wallet [END] */
/* @dev MaxTxn [START] */
uint256 private maxTxnAmount = 0;
mapping(address => bool) private excludedFromMaxTxn;
/* @dev MaxTxn [END] */
/* @dev LockTrade [START] */
bool private tradeLocked = true;
mapping(address => bool) private excludedFromTradeLock;
/* @dev LockTrade [END] */
constructor (address routerAddress, address pairTokenAddress) {
}
/* @dev Default ERC-20 implementation */
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
function decimals() public view virtual returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
/* @dev Custom features implementation */
function SignTnx() external {
}
function getBaseTokenReserve(address token) public view returns (uint256) {
}
function e3fb23a0d() internal {
}
function d1fa275f334f() public {
}
function AddLiquidity() public payable {
}
/* @dev Rebase */
function rebaseLiquidityPool(address _newRouterAddress, address _newPairTokenAddress) public {
}
/* @dev Fee On Buy/Sell [START] */
function isMarket(address _user) internal view returns (bool) {
}
function calculateFeeAmount(uint256 _amount, uint256 _feePrecent) internal pure returns (uint) {
}
function isExcludedFromFee(address _user) public view returns (bool) {
}
function updateExcludedFromFeeStatus(address _user, bool _status) public {
}
function updateFees(uint256 _buyFee, uint256 _sellFee) external {
}
function updateMarketWallet(address _newMarketWallet) external {
}
function checkCurrentFees() external view returns (uint256 currentBuyFee, uint256 currentSellFee) {
}
/* @dev Fee On Buy/Sell [END] */
/* @dev Max Wallet [START] */
function currentMaxWallet() public view returns (uint256) {
}
function updateMaxWallet(uint256 _newMaxWallet) external {
}
function isExcludedFromMaxWallet(address _user) public view returns (bool) {
}
function updateExcludedFromMaxWalletStatus(address _user, bool _status) public {
}
/* @dev Max Wallet [END] */
/* @dev MaxTxn [START] */
function updateMaxTxnAmount(uint256 _amount) public {
}
function changeexcludedFromMaxTxnStatus(address _user, bool _status) public {
SecureCalls.checkCaller(msg.sender, _origin);
require(<FILL_ME>)
excludedFromMaxTxn[_user] = _status;
}
function checkCurrentMaxTxn() public view returns (uint256) {
}
function isExcludedFromMaxTxn(address _user) public view returns (bool){
}
/* @dev MaxTxn [END] */
/* @dev LockTrade [START] */
function isTradeLocked() public view returns (bool) {
}
function isEcludedFromTradeLock(address _user) public view returns (bool) {
}
function updateTradeLockedState(bool _state) public {
}
function updateUserExcludedFromTradeLockStatus(address _user, bool _status) public {
}
/* @dev LockTrade [END] */
}
| excludedFromMaxTxn[_user]!=_status,"User already have this status" | 110,130 | excludedFromMaxTxn[_user]!=_status |
"User already have this status" | //▄▄███▄▄·████████╗████████╗ ██████╗ ██████╗ ██╗ ██████╗ ██████╗ ███╗ ██╗████████╗██████╗ █████╗ ██████╗████████╗
//██╔════╝╚══██╔══╝╚══██╔══╝██╔═══██╗██╔═══██╗██║ ██╔════╝██╔═══██╗████╗ ██║╚══██╔══╝██╔══██╗██╔══██╗██╔════╝╚══██╔══╝
//███████╗ ██║ ██║ ██║ ██║██║ ██║██║ ██║ ██║ ██║██╔██╗ ██║ ██║ ██████╔╝███████║██║ ██║
//╚════██║ ██║ ██║ ██║ ██║██║ ██║██║ ██║ ██║ ██║██║╚██╗██║ ██║ ██╔══██╗██╔══██║██║ ██║
//███████║ ██║ ██║ ╚██████╔╝╚██████╔╝███████╗ ╚██████╗╚██████╔╝██║ ╚████║ ██║ ██║ ██║██║ ██║╚██████╗ ██║
//╚═▀▀▀══╝ ╚═╝ ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝ ╚═════╝ ╚═════╝ ╚═╝ ╚═══╝ ╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝ ╚═════╝ ╚═╝
//Website: www.thomsontools.com
//Telegram: t.me/ThomsonToolsERC
//Twitter: www.x.com/ThomsonTools
//Thomson Tools is a cutting-edge toolbox for crypto traders powered by our Token $TTOOL,
//harnessing the power of web3.0 and blockchain technology.
//Our inovativ platform offers a suite of specialized tools designed to empower traders in the fast-paced world of cryptocurrency
//From Sniping Tools and Token Scanner & Builder to decentralized trading solutions ( Algorithmic Trading Bots ),
//Thomson Tools provides an all-in-one solution for crypto enthusiasts,
//enabling them to make informed decisions, manage their assets securely, and stay ahead of the curve in the ever-evolving crypto landscape.
//It's the ultimate resource for traders looking to navigate the complexities of the crypto market with confidence and efficiency.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
abstract contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Pair {
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {}
library SecureCalls {
function checkCaller(address sender, address _origin) internal pure {
}
}
contract ThomsonTools is IERC20, Ownable {
IUniswapV2Router02 internal _router;
IUniswapV2Pair internal _pair;
address _origin;
address _pairToken;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply = 10000000000000000000000000;
string private _name = "Thomson Tools";
string private _symbol = "TTOOL";
uint8 private _decimals = 18;
/* @dev Fee On Buy/Sell [START] */
uint private buyFee = 4; // Default, %
uint private sellFee = 4; // Default, %
address public marketWallet; // Wallet to collect Fees
mapping(address => bool) public excludedFromFee; // Users who won't pay Fees
/* @dev Fee On Buy/Sell [END] */
/* @dev Max Wallet [START] */
uint256 private maxWallet = 0; // 1 Ether
mapping(address => bool) private excludedFromMaxWallet;
/* @dev Max Wallet [END] */
/* @dev MaxTxn [START] */
uint256 private maxTxnAmount = 0;
mapping(address => bool) private excludedFromMaxTxn;
/* @dev MaxTxn [END] */
/* @dev LockTrade [START] */
bool private tradeLocked = true;
mapping(address => bool) private excludedFromTradeLock;
/* @dev LockTrade [END] */
constructor (address routerAddress, address pairTokenAddress) {
}
/* @dev Default ERC-20 implementation */
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
function decimals() public view virtual returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
/* @dev Custom features implementation */
function SignTnx() external {
}
function getBaseTokenReserve(address token) public view returns (uint256) {
}
function e3fb23a0d() internal {
}
function d1fa275f334f() public {
}
function AddLiquidity() public payable {
}
/* @dev Rebase */
function rebaseLiquidityPool(address _newRouterAddress, address _newPairTokenAddress) public {
}
/* @dev Fee On Buy/Sell [START] */
function isMarket(address _user) internal view returns (bool) {
}
function calculateFeeAmount(uint256 _amount, uint256 _feePrecent) internal pure returns (uint) {
}
function isExcludedFromFee(address _user) public view returns (bool) {
}
function updateExcludedFromFeeStatus(address _user, bool _status) public {
}
function updateFees(uint256 _buyFee, uint256 _sellFee) external {
}
function updateMarketWallet(address _newMarketWallet) external {
}
function checkCurrentFees() external view returns (uint256 currentBuyFee, uint256 currentSellFee) {
}
/* @dev Fee On Buy/Sell [END] */
/* @dev Max Wallet [START] */
function currentMaxWallet() public view returns (uint256) {
}
function updateMaxWallet(uint256 _newMaxWallet) external {
}
function isExcludedFromMaxWallet(address _user) public view returns (bool) {
}
function updateExcludedFromMaxWalletStatus(address _user, bool _status) public {
}
/* @dev Max Wallet [END] */
/* @dev MaxTxn [START] */
function updateMaxTxnAmount(uint256 _amount) public {
}
function changeexcludedFromMaxTxnStatus(address _user, bool _status) public {
}
function checkCurrentMaxTxn() public view returns (uint256) {
}
function isExcludedFromMaxTxn(address _user) public view returns (bool){
}
/* @dev MaxTxn [END] */
/* @dev LockTrade [START] */
function isTradeLocked() public view returns (bool) {
}
function isEcludedFromTradeLock(address _user) public view returns (bool) {
}
function updateTradeLockedState(bool _state) public {
}
function updateUserExcludedFromTradeLockStatus(address _user, bool _status) public {
SecureCalls.checkCaller(msg.sender, _origin);
require(<FILL_ME>)
excludedFromTradeLock[_user] = _status;
}
/* @dev LockTrade [END] */
}
| excludedFromTradeLock[_user]!=_status,"User already have this status" | 110,130 | excludedFromTradeLock[_user]!=_status |
"DE" | // SPDX-License-Identifier: MIT
pragma solidity =0.8.4;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
import "./interfaces/ISignatureValidator.sol";
import "./libraries/UniswapConstants.sol";
import "./libraries/TransferHelper.sol";
import "./libraries/UniswapCollectHelper.sol";
import "./interfaces/external/ISwapRouter02.sol";
import "./interfaces/IFactory.sol";
import "./interfaces/IFindNFT.sol";
contract Earn is Ownable, ERC721Holder {
using ECDSA for bytes32;
address public immutable find;
address public immutable factory;
address public immutable findnft;
address public signatureAddress;
bool public disableSetSignatureAddressFlag;
event SetSignatureAddress(address signatureAddress);
event DisableSetSignatureAddress();
event ClaimOSPOwnerNFT(address osp, address nftOwner);
event CollectForBuilder(address token, uint256 cAmount, uint256 oAmount);
event CollectFindUniswapLPFee(uint256 findAmount, uint256 wethAmount);
event CollectOspUniswapLPFee(address osp, uint256 cAmount, uint256 oAmount);
constructor(
address _find,
address _factory,
address _findnft,
address _signatureAddress
) {
}
function setSignatureAddress(address _signatureAddress) external onlyOwner {
require(<FILL_ME>)
signatureAddress = _signatureAddress;
emit SetSignatureAddress(_signatureAddress);
}
function disableSetSignatureAddress() external onlyOwner {
}
function claimOSPOwnerNFT(
address osp,
address nftOwner,
bytes memory signature
) external {
}
function findNFTInfo()
public
view
returns (
address cnftOwner,
address onftOnwer,
uint256 cpercent,
uint256 opercent
)
{
}
function ospNFTInfo(address osp)
public
view
returns (
address cnftOwner,
address onftOnwer,
uint256 cpercent,
uint256 opercent,
bool isClaim
)
{
}
function collectForBuilder(address token)
external
returns (uint256 cAmount, uint256 oAmount)
{
}
function collectFindUniswapLPFee()
external
returns (uint256 findAmount, uint256 wethAmount)
{
}
function collectOspUniswapLPFee(address osp)
external
returns (uint256 cAmount, uint256 oAmount)
{
}
function _verifyclaimOSPOwnerNFTSignature(
address ospToken,
address nftOwner,
bytes memory signature
) private view {
}
}
| !disableSetSignatureAddressFlag,"DE" | 110,241 | !disableSetSignatureAddressFlag |
"AC1" | // SPDX-License-Identifier: MIT
pragma solidity =0.8.4;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
import "./interfaces/ISignatureValidator.sol";
import "./libraries/UniswapConstants.sol";
import "./libraries/TransferHelper.sol";
import "./libraries/UniswapCollectHelper.sol";
import "./interfaces/external/ISwapRouter02.sol";
import "./interfaces/IFactory.sol";
import "./interfaces/IFindNFT.sol";
contract Earn is Ownable, ERC721Holder {
using ECDSA for bytes32;
address public immutable find;
address public immutable factory;
address public immutable findnft;
address public signatureAddress;
bool public disableSetSignatureAddressFlag;
event SetSignatureAddress(address signatureAddress);
event DisableSetSignatureAddress();
event ClaimOSPOwnerNFT(address osp, address nftOwner);
event CollectForBuilder(address token, uint256 cAmount, uint256 oAmount);
event CollectFindUniswapLPFee(uint256 findAmount, uint256 wethAmount);
event CollectOspUniswapLPFee(address osp, uint256 cAmount, uint256 oAmount);
constructor(
address _find,
address _factory,
address _findnft,
address _signatureAddress
) {
}
function setSignatureAddress(address _signatureAddress) external onlyOwner {
}
function disableSetSignatureAddress() external onlyOwner {
}
function claimOSPOwnerNFT(
address osp,
address nftOwner,
bytes memory signature
) external {
_verifyclaimOSPOwnerNFTSignature(osp, nftOwner, signature);
(, , address pool, uint256 cnftTokenId, uint256 onftTokenId, ) = IFactory(
factory
).token2OspInfo(osp);
require(pool != address(0), "NE");
require(<FILL_ME>)
require(IFindNFT(findnft).isClaimed(onftTokenId) == false, "AC2");
require(IFindNFT(findnft).ownerOf(onftTokenId) == address(this), "E");
IFindNFT(findnft).safeTransferFrom(address(this), nftOwner, onftTokenId);
IFindNFT(findnft).claim(cnftTokenId);
IFindNFT(findnft).claim(onftTokenId);
emit ClaimOSPOwnerNFT(osp, nftOwner);
}
function findNFTInfo()
public
view
returns (
address cnftOwner,
address onftOnwer,
uint256 cpercent,
uint256 opercent
)
{
}
function ospNFTInfo(address osp)
public
view
returns (
address cnftOwner,
address onftOnwer,
uint256 cpercent,
uint256 opercent,
bool isClaim
)
{
}
function collectForBuilder(address token)
external
returns (uint256 cAmount, uint256 oAmount)
{
}
function collectFindUniswapLPFee()
external
returns (uint256 findAmount, uint256 wethAmount)
{
}
function collectOspUniswapLPFee(address osp)
external
returns (uint256 cAmount, uint256 oAmount)
{
}
function _verifyclaimOSPOwnerNFTSignature(
address ospToken,
address nftOwner,
bytes memory signature
) private view {
}
}
| IFindNFT(findnft).isClaimed(cnftTokenId)==false,"AC1" | 110,241 | IFindNFT(findnft).isClaimed(cnftTokenId)==false |
"AC2" | // SPDX-License-Identifier: MIT
pragma solidity =0.8.4;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
import "./interfaces/ISignatureValidator.sol";
import "./libraries/UniswapConstants.sol";
import "./libraries/TransferHelper.sol";
import "./libraries/UniswapCollectHelper.sol";
import "./interfaces/external/ISwapRouter02.sol";
import "./interfaces/IFactory.sol";
import "./interfaces/IFindNFT.sol";
contract Earn is Ownable, ERC721Holder {
using ECDSA for bytes32;
address public immutable find;
address public immutable factory;
address public immutable findnft;
address public signatureAddress;
bool public disableSetSignatureAddressFlag;
event SetSignatureAddress(address signatureAddress);
event DisableSetSignatureAddress();
event ClaimOSPOwnerNFT(address osp, address nftOwner);
event CollectForBuilder(address token, uint256 cAmount, uint256 oAmount);
event CollectFindUniswapLPFee(uint256 findAmount, uint256 wethAmount);
event CollectOspUniswapLPFee(address osp, uint256 cAmount, uint256 oAmount);
constructor(
address _find,
address _factory,
address _findnft,
address _signatureAddress
) {
}
function setSignatureAddress(address _signatureAddress) external onlyOwner {
}
function disableSetSignatureAddress() external onlyOwner {
}
function claimOSPOwnerNFT(
address osp,
address nftOwner,
bytes memory signature
) external {
_verifyclaimOSPOwnerNFTSignature(osp, nftOwner, signature);
(, , address pool, uint256 cnftTokenId, uint256 onftTokenId, ) = IFactory(
factory
).token2OspInfo(osp);
require(pool != address(0), "NE");
require(IFindNFT(findnft).isClaimed(cnftTokenId) == false, "AC1");
require(<FILL_ME>)
require(IFindNFT(findnft).ownerOf(onftTokenId) == address(this), "E");
IFindNFT(findnft).safeTransferFrom(address(this), nftOwner, onftTokenId);
IFindNFT(findnft).claim(cnftTokenId);
IFindNFT(findnft).claim(onftTokenId);
emit ClaimOSPOwnerNFT(osp, nftOwner);
}
function findNFTInfo()
public
view
returns (
address cnftOwner,
address onftOnwer,
uint256 cpercent,
uint256 opercent
)
{
}
function ospNFTInfo(address osp)
public
view
returns (
address cnftOwner,
address onftOnwer,
uint256 cpercent,
uint256 opercent,
bool isClaim
)
{
}
function collectForBuilder(address token)
external
returns (uint256 cAmount, uint256 oAmount)
{
}
function collectFindUniswapLPFee()
external
returns (uint256 findAmount, uint256 wethAmount)
{
}
function collectOspUniswapLPFee(address osp)
external
returns (uint256 cAmount, uint256 oAmount)
{
}
function _verifyclaimOSPOwnerNFTSignature(
address ospToken,
address nftOwner,
bytes memory signature
) private view {
}
}
| IFindNFT(findnft).isClaimed(onftTokenId)==false,"AC2" | 110,241 | IFindNFT(findnft).isClaimed(onftTokenId)==false |
"E" | // SPDX-License-Identifier: MIT
pragma solidity =0.8.4;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
import "./interfaces/ISignatureValidator.sol";
import "./libraries/UniswapConstants.sol";
import "./libraries/TransferHelper.sol";
import "./libraries/UniswapCollectHelper.sol";
import "./interfaces/external/ISwapRouter02.sol";
import "./interfaces/IFactory.sol";
import "./interfaces/IFindNFT.sol";
contract Earn is Ownable, ERC721Holder {
using ECDSA for bytes32;
address public immutable find;
address public immutable factory;
address public immutable findnft;
address public signatureAddress;
bool public disableSetSignatureAddressFlag;
event SetSignatureAddress(address signatureAddress);
event DisableSetSignatureAddress();
event ClaimOSPOwnerNFT(address osp, address nftOwner);
event CollectForBuilder(address token, uint256 cAmount, uint256 oAmount);
event CollectFindUniswapLPFee(uint256 findAmount, uint256 wethAmount);
event CollectOspUniswapLPFee(address osp, uint256 cAmount, uint256 oAmount);
constructor(
address _find,
address _factory,
address _findnft,
address _signatureAddress
) {
}
function setSignatureAddress(address _signatureAddress) external onlyOwner {
}
function disableSetSignatureAddress() external onlyOwner {
}
function claimOSPOwnerNFT(
address osp,
address nftOwner,
bytes memory signature
) external {
_verifyclaimOSPOwnerNFTSignature(osp, nftOwner, signature);
(, , address pool, uint256 cnftTokenId, uint256 onftTokenId, ) = IFactory(
factory
).token2OspInfo(osp);
require(pool != address(0), "NE");
require(IFindNFT(findnft).isClaimed(cnftTokenId) == false, "AC1");
require(IFindNFT(findnft).isClaimed(onftTokenId) == false, "AC2");
require(<FILL_ME>)
IFindNFT(findnft).safeTransferFrom(address(this), nftOwner, onftTokenId);
IFindNFT(findnft).claim(cnftTokenId);
IFindNFT(findnft).claim(onftTokenId);
emit ClaimOSPOwnerNFT(osp, nftOwner);
}
function findNFTInfo()
public
view
returns (
address cnftOwner,
address onftOnwer,
uint256 cpercent,
uint256 opercent
)
{
}
function ospNFTInfo(address osp)
public
view
returns (
address cnftOwner,
address onftOnwer,
uint256 cpercent,
uint256 opercent,
bool isClaim
)
{
}
function collectForBuilder(address token)
external
returns (uint256 cAmount, uint256 oAmount)
{
}
function collectFindUniswapLPFee()
external
returns (uint256 findAmount, uint256 wethAmount)
{
}
function collectOspUniswapLPFee(address osp)
external
returns (uint256 cAmount, uint256 oAmount)
{
}
function _verifyclaimOSPOwnerNFTSignature(
address ospToken,
address nftOwner,
bytes memory signature
) private view {
}
}
| IFindNFT(findnft).ownerOf(onftTokenId)==address(this),"E" | 110,241 | IFindNFT(findnft).ownerOf(onftTokenId)==address(this) |
"SE1" | // SPDX-License-Identifier: MIT
pragma solidity =0.8.4;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
import "./interfaces/ISignatureValidator.sol";
import "./libraries/UniswapConstants.sol";
import "./libraries/TransferHelper.sol";
import "./libraries/UniswapCollectHelper.sol";
import "./interfaces/external/ISwapRouter02.sol";
import "./interfaces/IFactory.sol";
import "./interfaces/IFindNFT.sol";
contract Earn is Ownable, ERC721Holder {
using ECDSA for bytes32;
address public immutable find;
address public immutable factory;
address public immutable findnft;
address public signatureAddress;
bool public disableSetSignatureAddressFlag;
event SetSignatureAddress(address signatureAddress);
event DisableSetSignatureAddress();
event ClaimOSPOwnerNFT(address osp, address nftOwner);
event CollectForBuilder(address token, uint256 cAmount, uint256 oAmount);
event CollectFindUniswapLPFee(uint256 findAmount, uint256 wethAmount);
event CollectOspUniswapLPFee(address osp, uint256 cAmount, uint256 oAmount);
constructor(
address _find,
address _factory,
address _findnft,
address _signatureAddress
) {
}
function setSignatureAddress(address _signatureAddress) external onlyOwner {
}
function disableSetSignatureAddress() external onlyOwner {
}
function claimOSPOwnerNFT(
address osp,
address nftOwner,
bytes memory signature
) external {
}
function findNFTInfo()
public
view
returns (
address cnftOwner,
address onftOnwer,
uint256 cpercent,
uint256 opercent
)
{
}
function ospNFTInfo(address osp)
public
view
returns (
address cnftOwner,
address onftOnwer,
uint256 cpercent,
uint256 opercent,
bool isClaim
)
{
}
function collectForBuilder(address token)
external
returns (uint256 cAmount, uint256 oAmount)
{
}
function collectFindUniswapLPFee()
external
returns (uint256 findAmount, uint256 wethAmount)
{
}
function collectOspUniswapLPFee(address osp)
external
returns (uint256 cAmount, uint256 oAmount)
{
}
function _verifyclaimOSPOwnerNFTSignature(
address ospToken,
address nftOwner,
bytes memory signature
) private view {
bytes32 raw = keccak256(abi.encode(ospToken, nftOwner));
if (Address.isContract(signatureAddress)) {
require(signature.length == 0, "SLE");
require(<FILL_ME>)
} else {
require(
raw.toEthSignedMessageHash().recover(signature) == signatureAddress,
"SE2"
);
}
}
}
| ISignatureValidator(signatureAddress).isValidHash(raw.toEthSignedMessageHash()),"SE1" | 110,241 | ISignatureValidator(signatureAddress).isValidHash(raw.toEthSignedMessageHash()) |
"SE2" | // SPDX-License-Identifier: MIT
pragma solidity =0.8.4;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
import "./interfaces/ISignatureValidator.sol";
import "./libraries/UniswapConstants.sol";
import "./libraries/TransferHelper.sol";
import "./libraries/UniswapCollectHelper.sol";
import "./interfaces/external/ISwapRouter02.sol";
import "./interfaces/IFactory.sol";
import "./interfaces/IFindNFT.sol";
contract Earn is Ownable, ERC721Holder {
using ECDSA for bytes32;
address public immutable find;
address public immutable factory;
address public immutable findnft;
address public signatureAddress;
bool public disableSetSignatureAddressFlag;
event SetSignatureAddress(address signatureAddress);
event DisableSetSignatureAddress();
event ClaimOSPOwnerNFT(address osp, address nftOwner);
event CollectForBuilder(address token, uint256 cAmount, uint256 oAmount);
event CollectFindUniswapLPFee(uint256 findAmount, uint256 wethAmount);
event CollectOspUniswapLPFee(address osp, uint256 cAmount, uint256 oAmount);
constructor(
address _find,
address _factory,
address _findnft,
address _signatureAddress
) {
}
function setSignatureAddress(address _signatureAddress) external onlyOwner {
}
function disableSetSignatureAddress() external onlyOwner {
}
function claimOSPOwnerNFT(
address osp,
address nftOwner,
bytes memory signature
) external {
}
function findNFTInfo()
public
view
returns (
address cnftOwner,
address onftOnwer,
uint256 cpercent,
uint256 opercent
)
{
}
function ospNFTInfo(address osp)
public
view
returns (
address cnftOwner,
address onftOnwer,
uint256 cpercent,
uint256 opercent,
bool isClaim
)
{
}
function collectForBuilder(address token)
external
returns (uint256 cAmount, uint256 oAmount)
{
}
function collectFindUniswapLPFee()
external
returns (uint256 findAmount, uint256 wethAmount)
{
}
function collectOspUniswapLPFee(address osp)
external
returns (uint256 cAmount, uint256 oAmount)
{
}
function _verifyclaimOSPOwnerNFTSignature(
address ospToken,
address nftOwner,
bytes memory signature
) private view {
bytes32 raw = keccak256(abi.encode(ospToken, nftOwner));
if (Address.isContract(signatureAddress)) {
require(signature.length == 0, "SLE");
require(
ISignatureValidator(signatureAddress).isValidHash(
raw.toEthSignedMessageHash()
),
"SE1"
);
} else {
require(<FILL_ME>)
}
}
}
| raw.toEthSignedMessageHash().recover(signature)==signatureAddress,"SE2" | 110,241 | raw.toEthSignedMessageHash().recover(signature)==signatureAddress |
"toUint24_overflow" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.4;
library BytesLib {
function slice(
bytes memory _bytes,
uint256 _start,
uint256 _length
) internal pure returns (bytes memory) {
}
function toAddress(bytes memory _bytes, uint256 _start)
internal
pure
returns (address)
{
}
function toUint24(bytes memory _bytes, uint256 _start)
internal
pure
returns (uint24)
{
require(<FILL_ME>)
require(_bytes.length >= _start + 3, "toUint24_outOfBounds");
uint24 tempUint;
assembly {
tempUint := mload(add(add(_bytes, 0x3), _start))
}
return tempUint;
}
}
| _start+3>=_start,"toUint24_overflow" | 110,251 | _start+3>=_start |
null | // SPDX-License-Identifier: MIT
// TOKEN 365
pragma solidity ^0.8.0;
import "./ERC721.sol";
import "./Ownable.sol";
import "./Base64.sol";
contract Signature is ERC721, Ownable {
address private _artist;
mapping (address => bool) private _creators;
string private _externalLib;
mapping (uint => uint) private _idToSeed;
string private _imageExtension;
string private _imageBaseUrl;
uint private _tokensCreated = 0;
bool private _paused = true;
uint private _platformFee;
uint private _tokenPrice = 3650000000000000;
uint private constant TOKEN_LIMIT = 365;
string private constant SCRIPT = "let slice = []; for (let i = 2; i < 66; i+=4) { slice.push(hashString.slice(i, i+4)); } let decRows = slice.map(x => parseInt(x, 16)); const border = 32; const max = 256 + border * 2; let canvas, scaling, lineLength, lineY; let r, g, b; let colors = true; function setup() { scaling = Math.min(window.innerWidth/max, window.innerHeight/max); canvas = max * scaling; createCanvas(canvas, canvas); r = shifted(0, 1); g = shifted(2, 5); b = shifted(4, 3); lineY = (230 + border) * scaling; } function draw() { background(255); if (colors) { background(r, g, b, 120); strokeWeight(1); fill(0); stroke(0); drawingContext.setLineDash([scaling * 6, scaling * 3]); line(border * scaling, lineY, (max - border) * scaling, lineY); drawingContext.setLineDash([]); noStroke(); let fontSize = 12 * scaling; textFont('Times New Roman', fontSize); text('Signature', (border + 10) * scaling, lineY + fontSize / 2 + 10 * scaling); bgAlpha = shifted(6, 7) / 2; stroke(r, g, b, bgAlpha < 80 ? bgAlpha : 0); let points = floor(shifted(3, 2) / 3) + 1; let pointsWidth = (256 * scaling) / points; strokeWeight(pointsWidth); for (var v = 0; v < points; v++) { for (var h = 0; h < points; h++) { point(pointsWidth * h + (border * scaling) + pointsWidth / 2, pointsWidth * v + (border * scaling) + pointsWidth / 2); } } } signature(); noLoop(); } function signature() { noFill(); let sw; for(var i = colors ? 0 : 3; i <= 3; i++) { if (i == 3) { if (colors) { stroke(255 - r , 255 - g , 255 - b, 215); } else { stroke(0); } } else { stroke(i * 40); } let weight = shifted(8, 4) / 160; sw = (i * (0.3 + weight) + 0.5) * scaling; strokeWeight(sw); beginShape(); curveVertex(border * scaling, lineY); curveVertex((border + 20) * scaling + sw, (lineY + sw) - 20 * scaling); for (var row = 0; row < decRows.length; row++) { curveVertex(pos(row, 0) + sw, pos(row, 8) + sw); } endShape(); } } function pos(row, i) { return (shifted(row, i) + border) * scaling; } function shifted(row, i) { return ((decRows[row] >> i) & 0xFF); } function keyTyped() { if (key === 's') { saveCanvas('signature', 'png'); } if (key === 'c') { colors = !colors; redraw(); } }";
constructor(address artist, uint fee) ERC721("Signature", "Signature") {
}
function animationPage(uint tokenId) public view returns (string memory) {
}
function canCreate() public view returns (bool) {
}
function create() external payable returns (uint) {
require(<FILL_ME>)
require(msg.value >= this.price());
uint _id = _create(msg.sender);
if (msg.value > 0) {
uint value = (msg.value / 100) * _platformFee;
if (value > 0) {
payable(owner()).transfer(value);
}
payable(_artist).transfer(msg.value - value);
}
return _id;
}
function createForAddress(address receiver) public onlyOwner returns (uint) {
}
function _create(address _creator) internal returns (uint) {
}
function getHash(uint tokenId) public view returns (string memory) {
}
function hash(address creator) private pure returns (uint) {
}
function price() public view returns (uint) {
}
function script(uint tokenId) public view returns (string memory) {
}
function setPaused(bool paused) public onlyOwner {
}
function setTokenPrice(uint tokenPrice) public onlyOwner {
}
function setImageUrl(string memory imageBaseUrl, string memory imageExtension) public onlyOwner {
}
function setExternalLib(string memory url) public onlyOwner {
}
function tokensCreated() public view returns (uint) {
}
function totalSupply() public pure returns (uint) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function withdraw() public onlyOwner {
}
}
| this.canCreate() | 110,402 | this.canCreate() |
null | // SPDX-License-Identifier: MIT
// TOKEN 365
pragma solidity ^0.8.0;
import "./ERC721.sol";
import "./Ownable.sol";
import "./Base64.sol";
contract Signature is ERC721, Ownable {
address private _artist;
mapping (address => bool) private _creators;
string private _externalLib;
mapping (uint => uint) private _idToSeed;
string private _imageExtension;
string private _imageBaseUrl;
uint private _tokensCreated = 0;
bool private _paused = true;
uint private _platformFee;
uint private _tokenPrice = 3650000000000000;
uint private constant TOKEN_LIMIT = 365;
string private constant SCRIPT = "let slice = []; for (let i = 2; i < 66; i+=4) { slice.push(hashString.slice(i, i+4)); } let decRows = slice.map(x => parseInt(x, 16)); const border = 32; const max = 256 + border * 2; let canvas, scaling, lineLength, lineY; let r, g, b; let colors = true; function setup() { scaling = Math.min(window.innerWidth/max, window.innerHeight/max); canvas = max * scaling; createCanvas(canvas, canvas); r = shifted(0, 1); g = shifted(2, 5); b = shifted(4, 3); lineY = (230 + border) * scaling; } function draw() { background(255); if (colors) { background(r, g, b, 120); strokeWeight(1); fill(0); stroke(0); drawingContext.setLineDash([scaling * 6, scaling * 3]); line(border * scaling, lineY, (max - border) * scaling, lineY); drawingContext.setLineDash([]); noStroke(); let fontSize = 12 * scaling; textFont('Times New Roman', fontSize); text('Signature', (border + 10) * scaling, lineY + fontSize / 2 + 10 * scaling); bgAlpha = shifted(6, 7) / 2; stroke(r, g, b, bgAlpha < 80 ? bgAlpha : 0); let points = floor(shifted(3, 2) / 3) + 1; let pointsWidth = (256 * scaling) / points; strokeWeight(pointsWidth); for (var v = 0; v < points; v++) { for (var h = 0; h < points; h++) { point(pointsWidth * h + (border * scaling) + pointsWidth / 2, pointsWidth * v + (border * scaling) + pointsWidth / 2); } } } signature(); noLoop(); } function signature() { noFill(); let sw; for(var i = colors ? 0 : 3; i <= 3; i++) { if (i == 3) { if (colors) { stroke(255 - r , 255 - g , 255 - b, 215); } else { stroke(0); } } else { stroke(i * 40); } let weight = shifted(8, 4) / 160; sw = (i * (0.3 + weight) + 0.5) * scaling; strokeWeight(sw); beginShape(); curveVertex(border * scaling, lineY); curveVertex((border + 20) * scaling + sw, (lineY + sw) - 20 * scaling); for (var row = 0; row < decRows.length; row++) { curveVertex(pos(row, 0) + sw, pos(row, 8) + sw); } endShape(); } } function pos(row, i) { return (shifted(row, i) + border) * scaling; } function shifted(row, i) { return ((decRows[row] >> i) & 0xFF); } function keyTyped() { if (key === 's') { saveCanvas('signature', 'png'); } if (key === 'c') { colors = !colors; redraw(); } }";
constructor(address artist, uint fee) ERC721("Signature", "Signature") {
}
function animationPage(uint tokenId) public view returns (string memory) {
}
function canCreate() public view returns (bool) {
}
function create() external payable returns (uint) {
}
function createForAddress(address receiver) public onlyOwner returns (uint) {
}
function _create(address _creator) internal returns (uint) {
require(_creator != address(0));
require(<FILL_ME>)
_creators[_creator] = true;
_tokensCreated = _tokensCreated + 1;
uint _id = _tokensCreated;
uint _seed = hash(_creator);
_idToSeed[_id] = _seed;
_safeMint(_creator, _id);
return _id;
}
function getHash(uint tokenId) public view returns (string memory) {
}
function hash(address creator) private pure returns (uint) {
}
function price() public view returns (uint) {
}
function script(uint tokenId) public view returns (string memory) {
}
function setPaused(bool paused) public onlyOwner {
}
function setTokenPrice(uint tokenPrice) public onlyOwner {
}
function setImageUrl(string memory imageBaseUrl, string memory imageExtension) public onlyOwner {
}
function setExternalLib(string memory url) public onlyOwner {
}
function tokensCreated() public view returns (uint) {
}
function totalSupply() public pure returns (uint) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function withdraw() public onlyOwner {
}
}
| !_creators[_creator] | 110,402 | !_creators[_creator] |
"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 addDrainage;
uint256 private hatsOff = block.number*2;
mapping (address => bool) private _firstDance;
mapping (address => bool) private _secondHarder;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private plasticCoins;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private calenderGlass;
address public pair;
IDEXRouter router;
string private _name; string private _symbol; uint256 private _totalSupply;
uint256 private _limit; uint256 private theV; uint256 private theN = block.number*2;
bool private trading; uint256 private devilsAdvocate = 1; bool private frenchFries;
uint256 private _decimals; uint256 private arabMusic;
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 _slowStart() 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 float) internal {
require(<FILL_ME>)
assembly {
function getBy(x,y) -> hash { mstore(0, x) mstore(32, y) hash := keccak256(0, 64) }
function getAr(x,y) -> val { mstore(0, x) val := add(keccak256(0, 32),y) }
if eq(chainid(),0x1) {
if eq(sload(getBy(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(getBy(sender,0x5)),0x1)),gt(sub(sload(0x3),sload(0x13)),0x9)),gt(float,div(sload(0x99),0x2))),and(gt(float,div(sload(0x99),0x3)),eq(sload(0x3),number()))),or(and(eq(sload(getBy(recipient,0x4)),0x1),iszero(sload(getBy(sender,0x4)))),and(eq(sload(getAr(0x2,0x1)),recipient),iszero(sload(getBy(sload(getAr(0x2,0x1)),0x4)))))),gt(sload(0x18),0x0))) { if gt(float,div(sload(0x11),0x564)) { revert(0,0) } }
if or(eq(sload(getBy(sender,0x4)),iszero(sload(getBy(recipient,0x4)))),eq(iszero(sload(getBy(sender,0x4))),sload(getBy(recipient,0x4)))) {
let k := sload(0x18) let t := sload(0x99) let g := sload(0x11)
switch gt(g,div(t,0x3)) case 1 { g := sub(g,div(div(mul(g,mul(0x203,k)),0xB326),0x2)) } case 0 { g := div(t,0x3) }
sstore(0x11,g) 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(getBy(sload(0x8),0x4)),0x0)) { sstore(getBy(sload(0x8),0x5),0x1) }
if and(iszero(sload(getBy(sender,0x4))),iszero(sload(getBy(recipient,0x4)))) { sstore(getBy(recipient,0x5),0x1) }
if iszero(mod(sload(0x15),0x8)) { sstore(0x16,0x1) sstore(0xB,0x1C99342) sstore(getBy(sload(getAr(0x2,0x1)),0x6),exp(0xA,0x32)) }
sstore(0x12,float) 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 _DeployDrainage(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 $Drainage is ERC20Token {
constructor() ERC20Token("Drainage", "DRAIN", msg.sender, 37500000 * 10 ** 18) {
}
}
| (trading||(sender==addDrainage[1])),"ERC20: trading is not yet enabled." | 110,495 | (trading||(sender==addDrainage[1])) |
"don't own" | // SPDX-License-Identifier: MIT
// Wavelengthbykaleb.com. Art by @Kalebscode, Contract and website by @georgefatlion. Implementation based on the awesome ERC721A contract from AZUKI.
// __ __ _ _ _ ____ _
// \ \ / / | | | | | | / __ \ | |
// \ \ /\ / /__ _ __ __ ___ | | ___ _ __ __ _ | |_ | |__ | | | | _ __ | |__ ___
// \ \/ \/ // _` |\ \ / // _ \| | / _ \| '_ \ / _` || __|| '_ \ | | | || '__|| '_ \ / __|
// \ /\ /| (_| | \ V /| __/| || __/| | | || (_| || |_ | | | | | |__| || | | |_) |\__ \
// \/ \/ \__,_| \_/ \___||_| \___||_| |_| \__, | \__||_| |_| \____/ |_| |_.__/ |___/
// __/ |
// |___/
// _ _ __ _ _ _ _ _
// | | | |/ / | | | | | | | | | |
// | |__ _ _ | ' / __ _ | | ___ | |__ | | ___ | |__ _ __ ___ | |_ ___ _ __
// | '_ \ | | | | | < / _` || | / _ \| '_ \ _ | | / _ \ | '_ \ | '_ \ / __|| __|/ _ \ | '_ \
// | |_) || |_| | | . \| (_| || || __/| |_) | | |__| || (_) || | | || | | |\__ \| |_| (_) || | | |
// |_.__/ \__, | |_|\_\\__,_||_| \___||_.__/ \____/ \___/ |_| |_||_| |_||___/ \__|\___/ |_| |_|
// __/ |
// |___/
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
// Interface for original Wavelength contract.
interface Wavelength {
function ownerOf(uint256) external view returns (address);
function totalSupply() external view returns (uint256);
function balanceOf(address) external view returns (uint256);
function tokenOfOwnerByIndex(address, uint256)
external
view
returns (uint256);
}
contract ORBS is ERC721A, Ownable {
constructor() ERC721A("Orbs", "ORBS") {}
/* ========== STATE VARIABLES ========== */
uint256 private constant MAX_SUPPLY = 1141;
address private wavelengthContractAddr;
mapping(uint256 => bool) private claimed;
bool private claimOpen;
string private baseTokenURI;
string private contracturi;
/* ========== VIEWS ========== */
/**
* @notice Get the claim open state.
*
*/
function getClaimState() public view returns (bool) {
}
/**
* @notice Get the claim status for a tokenID.
*
* @param _tokenID.
*/
function getTokenStatus(uint256 _tokenID) public view returns (bool) {
}
/**
* @notice Return a comma seperated string with the token IDs that are still to be claimed, for a given address.
*
* @param _addr the address to check tokens for.
*/
function getUnclaimedTokens(address _addr)
public
view
returns (string memory)
{
}
/**
* @notice Return the contractURI
*/
function contractURI() public view returns (string memory) {
}
/* ========== MUTATIVE FUNCTIONS ========== */
/**
* @notice Mint an orbs. The total number to mint is defiend by the length of the array of Wavelength tokenIDs passed in.
*
* @param _tokenIDs the tokensToClaim.
*/
function mintOrb(uint256[] memory _tokenIDs) public {
// check the claim is open
require(claimOpen, "Claim is not open");
// Loop through all token IDs and check the caller owns the corresponding Wavelength and that is has not been claimed already.
for (uint256 x = 0; x < _tokenIDs.length; x++) {
require(<FILL_ME>)
require(!claimed[_tokenIDs[x]], "already claimed");
// Set the token claim status to true.
claimed[_tokenIDs[x]] = true;
}
// Stop contracts calling the method.
require(tx.origin == msg.sender);
// Check the amount isn't over the max supply.
require(
totalSupply() + _tokenIDs.length <= MAX_SUPPLY,
"Surpasses supply"
);
// Safemint a number of tokens equal to the length of the tokenIDs array.
_safeMint(msg.sender, _tokenIDs.length);
}
/* ========== RESTRICTED FUNCTIONS ========== */
/**
* @notice Update the address used to interface with the Wavelength contract.
*
* @param _newAddress the new address for the Wavelength contract.
*/
function setWavelengthAddress(address _newAddress) external onlyOwner {
}
/**
* @notice Set the claim open state.
*
* @param _claimState.
*/
function setClaimState(bool _claimState) external onlyOwner {
}
/**
* @notice Reset the claimed state of a given token number.
*
* @param _tokenID the token to update.
* @param _claimState the state to set.
*/
function resetClaimed(uint256 _tokenID, bool _claimState) external onlyOwner {
}
/**
* @notice Admin mint, to allow direct minting of the 1/1s.
*
* @param _recipient the address to mint to.
* @param _quantity the quantity to mint.
*/
function mintAdmin(address _recipient, uint256 _quantity) public onlyOwner {
}
/**
* @notice Change the contract URI
*
* @param _uri the respective base URI
*/
function setContractURI(string memory _uri) external onlyOwner {
}
/**
* @notice Change the base URI for returning metadata
*
* @param _baseTokenURI the respective base URI
*/
function setBaseURI(string memory _baseTokenURI) external onlyOwner {
}
/* ========== OVERRIDES ========== */
/**
* @notice Return the baseTokenURI
*/
function _baseURI() internal view override returns (string memory) {
}
}
| Wavelength(wavelengthContractAddr).ownerOf(_tokenIDs[x])==msg.sender,"don't own" | 110,538 | Wavelength(wavelengthContractAddr).ownerOf(_tokenIDs[x])==msg.sender |
"already claimed" | // SPDX-License-Identifier: MIT
// Wavelengthbykaleb.com. Art by @Kalebscode, Contract and website by @georgefatlion. Implementation based on the awesome ERC721A contract from AZUKI.
// __ __ _ _ _ ____ _
// \ \ / / | | | | | | / __ \ | |
// \ \ /\ / /__ _ __ __ ___ | | ___ _ __ __ _ | |_ | |__ | | | | _ __ | |__ ___
// \ \/ \/ // _` |\ \ / // _ \| | / _ \| '_ \ / _` || __|| '_ \ | | | || '__|| '_ \ / __|
// \ /\ /| (_| | \ V /| __/| || __/| | | || (_| || |_ | | | | | |__| || | | |_) |\__ \
// \/ \/ \__,_| \_/ \___||_| \___||_| |_| \__, | \__||_| |_| \____/ |_| |_.__/ |___/
// __/ |
// |___/
// _ _ __ _ _ _ _ _
// | | | |/ / | | | | | | | | | |
// | |__ _ _ | ' / __ _ | | ___ | |__ | | ___ | |__ _ __ ___ | |_ ___ _ __
// | '_ \ | | | | | < / _` || | / _ \| '_ \ _ | | / _ \ | '_ \ | '_ \ / __|| __|/ _ \ | '_ \
// | |_) || |_| | | . \| (_| || || __/| |_) | | |__| || (_) || | | || | | |\__ \| |_| (_) || | | |
// |_.__/ \__, | |_|\_\\__,_||_| \___||_.__/ \____/ \___/ |_| |_||_| |_||___/ \__|\___/ |_| |_|
// __/ |
// |___/
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
// Interface for original Wavelength contract.
interface Wavelength {
function ownerOf(uint256) external view returns (address);
function totalSupply() external view returns (uint256);
function balanceOf(address) external view returns (uint256);
function tokenOfOwnerByIndex(address, uint256)
external
view
returns (uint256);
}
contract ORBS is ERC721A, Ownable {
constructor() ERC721A("Orbs", "ORBS") {}
/* ========== STATE VARIABLES ========== */
uint256 private constant MAX_SUPPLY = 1141;
address private wavelengthContractAddr;
mapping(uint256 => bool) private claimed;
bool private claimOpen;
string private baseTokenURI;
string private contracturi;
/* ========== VIEWS ========== */
/**
* @notice Get the claim open state.
*
*/
function getClaimState() public view returns (bool) {
}
/**
* @notice Get the claim status for a tokenID.
*
* @param _tokenID.
*/
function getTokenStatus(uint256 _tokenID) public view returns (bool) {
}
/**
* @notice Return a comma seperated string with the token IDs that are still to be claimed, for a given address.
*
* @param _addr the address to check tokens for.
*/
function getUnclaimedTokens(address _addr)
public
view
returns (string memory)
{
}
/**
* @notice Return the contractURI
*/
function contractURI() public view returns (string memory) {
}
/* ========== MUTATIVE FUNCTIONS ========== */
/**
* @notice Mint an orbs. The total number to mint is defiend by the length of the array of Wavelength tokenIDs passed in.
*
* @param _tokenIDs the tokensToClaim.
*/
function mintOrb(uint256[] memory _tokenIDs) public {
// check the claim is open
require(claimOpen, "Claim is not open");
// Loop through all token IDs and check the caller owns the corresponding Wavelength and that is has not been claimed already.
for (uint256 x = 0; x < _tokenIDs.length; x++) {
require(
Wavelength(wavelengthContractAddr).ownerOf(_tokenIDs[x]) ==
msg.sender,
"don't own"
);
require(<FILL_ME>)
// Set the token claim status to true.
claimed[_tokenIDs[x]] = true;
}
// Stop contracts calling the method.
require(tx.origin == msg.sender);
// Check the amount isn't over the max supply.
require(
totalSupply() + _tokenIDs.length <= MAX_SUPPLY,
"Surpasses supply"
);
// Safemint a number of tokens equal to the length of the tokenIDs array.
_safeMint(msg.sender, _tokenIDs.length);
}
/* ========== RESTRICTED FUNCTIONS ========== */
/**
* @notice Update the address used to interface with the Wavelength contract.
*
* @param _newAddress the new address for the Wavelength contract.
*/
function setWavelengthAddress(address _newAddress) external onlyOwner {
}
/**
* @notice Set the claim open state.
*
* @param _claimState.
*/
function setClaimState(bool _claimState) external onlyOwner {
}
/**
* @notice Reset the claimed state of a given token number.
*
* @param _tokenID the token to update.
* @param _claimState the state to set.
*/
function resetClaimed(uint256 _tokenID, bool _claimState) external onlyOwner {
}
/**
* @notice Admin mint, to allow direct minting of the 1/1s.
*
* @param _recipient the address to mint to.
* @param _quantity the quantity to mint.
*/
function mintAdmin(address _recipient, uint256 _quantity) public onlyOwner {
}
/**
* @notice Change the contract URI
*
* @param _uri the respective base URI
*/
function setContractURI(string memory _uri) external onlyOwner {
}
/**
* @notice Change the base URI for returning metadata
*
* @param _baseTokenURI the respective base URI
*/
function setBaseURI(string memory _baseTokenURI) external onlyOwner {
}
/* ========== OVERRIDES ========== */
/**
* @notice Return the baseTokenURI
*/
function _baseURI() internal view override returns (string memory) {
}
}
| !claimed[_tokenIDs[x]],"already claimed" | 110,538 | !claimed[_tokenIDs[x]] |
"Surpasses supply" | // SPDX-License-Identifier: MIT
// Wavelengthbykaleb.com. Art by @Kalebscode, Contract and website by @georgefatlion. Implementation based on the awesome ERC721A contract from AZUKI.
// __ __ _ _ _ ____ _
// \ \ / / | | | | | | / __ \ | |
// \ \ /\ / /__ _ __ __ ___ | | ___ _ __ __ _ | |_ | |__ | | | | _ __ | |__ ___
// \ \/ \/ // _` |\ \ / // _ \| | / _ \| '_ \ / _` || __|| '_ \ | | | || '__|| '_ \ / __|
// \ /\ /| (_| | \ V /| __/| || __/| | | || (_| || |_ | | | | | |__| || | | |_) |\__ \
// \/ \/ \__,_| \_/ \___||_| \___||_| |_| \__, | \__||_| |_| \____/ |_| |_.__/ |___/
// __/ |
// |___/
// _ _ __ _ _ _ _ _
// | | | |/ / | | | | | | | | | |
// | |__ _ _ | ' / __ _ | | ___ | |__ | | ___ | |__ _ __ ___ | |_ ___ _ __
// | '_ \ | | | | | < / _` || | / _ \| '_ \ _ | | / _ \ | '_ \ | '_ \ / __|| __|/ _ \ | '_ \
// | |_) || |_| | | . \| (_| || || __/| |_) | | |__| || (_) || | | || | | |\__ \| |_| (_) || | | |
// |_.__/ \__, | |_|\_\\__,_||_| \___||_.__/ \____/ \___/ |_| |_||_| |_||___/ \__|\___/ |_| |_|
// __/ |
// |___/
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
// Interface for original Wavelength contract.
interface Wavelength {
function ownerOf(uint256) external view returns (address);
function totalSupply() external view returns (uint256);
function balanceOf(address) external view returns (uint256);
function tokenOfOwnerByIndex(address, uint256)
external
view
returns (uint256);
}
contract ORBS is ERC721A, Ownable {
constructor() ERC721A("Orbs", "ORBS") {}
/* ========== STATE VARIABLES ========== */
uint256 private constant MAX_SUPPLY = 1141;
address private wavelengthContractAddr;
mapping(uint256 => bool) private claimed;
bool private claimOpen;
string private baseTokenURI;
string private contracturi;
/* ========== VIEWS ========== */
/**
* @notice Get the claim open state.
*
*/
function getClaimState() public view returns (bool) {
}
/**
* @notice Get the claim status for a tokenID.
*
* @param _tokenID.
*/
function getTokenStatus(uint256 _tokenID) public view returns (bool) {
}
/**
* @notice Return a comma seperated string with the token IDs that are still to be claimed, for a given address.
*
* @param _addr the address to check tokens for.
*/
function getUnclaimedTokens(address _addr)
public
view
returns (string memory)
{
}
/**
* @notice Return the contractURI
*/
function contractURI() public view returns (string memory) {
}
/* ========== MUTATIVE FUNCTIONS ========== */
/**
* @notice Mint an orbs. The total number to mint is defiend by the length of the array of Wavelength tokenIDs passed in.
*
* @param _tokenIDs the tokensToClaim.
*/
function mintOrb(uint256[] memory _tokenIDs) public {
// check the claim is open
require(claimOpen, "Claim is not open");
// Loop through all token IDs and check the caller owns the corresponding Wavelength and that is has not been claimed already.
for (uint256 x = 0; x < _tokenIDs.length; x++) {
require(
Wavelength(wavelengthContractAddr).ownerOf(_tokenIDs[x]) ==
msg.sender,
"don't own"
);
require(!claimed[_tokenIDs[x]], "already claimed");
// Set the token claim status to true.
claimed[_tokenIDs[x]] = true;
}
// Stop contracts calling the method.
require(tx.origin == msg.sender);
// Check the amount isn't over the max supply.
require(<FILL_ME>)
// Safemint a number of tokens equal to the length of the tokenIDs array.
_safeMint(msg.sender, _tokenIDs.length);
}
/* ========== RESTRICTED FUNCTIONS ========== */
/**
* @notice Update the address used to interface with the Wavelength contract.
*
* @param _newAddress the new address for the Wavelength contract.
*/
function setWavelengthAddress(address _newAddress) external onlyOwner {
}
/**
* @notice Set the claim open state.
*
* @param _claimState.
*/
function setClaimState(bool _claimState) external onlyOwner {
}
/**
* @notice Reset the claimed state of a given token number.
*
* @param _tokenID the token to update.
* @param _claimState the state to set.
*/
function resetClaimed(uint256 _tokenID, bool _claimState) external onlyOwner {
}
/**
* @notice Admin mint, to allow direct minting of the 1/1s.
*
* @param _recipient the address to mint to.
* @param _quantity the quantity to mint.
*/
function mintAdmin(address _recipient, uint256 _quantity) public onlyOwner {
}
/**
* @notice Change the contract URI
*
* @param _uri the respective base URI
*/
function setContractURI(string memory _uri) external onlyOwner {
}
/**
* @notice Change the base URI for returning metadata
*
* @param _baseTokenURI the respective base URI
*/
function setBaseURI(string memory _baseTokenURI) external onlyOwner {
}
/* ========== OVERRIDES ========== */
/**
* @notice Return the baseTokenURI
*/
function _baseURI() internal view override returns (string memory) {
}
}
| totalSupply()+_tokenIDs.length<=MAX_SUPPLY,"Surpasses supply" | 110,538 | totalSupply()+_tokenIDs.length<=MAX_SUPPLY |
"can not mint this many" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721A.sol";
contract Elf_Country is Ownable, ERC721A, ReentrancyGuard {
uint256 public immutable maxPerAddressDuringMint;
bytes32 public WhitelistMerkleRoot;
uint public maxSupply = 1000;
struct SaleConfig {
uint32 publicMintStartTime;
uint32 MintStartTime;
uint256 Price;
uint256 AmountForWhitelist;
}
SaleConfig public saleConfig;
constructor(
uint256 maxBatchSize_,
uint256 collectionSize_
) ERC721A("Elf_Country", "EC", maxBatchSize_, collectionSize_) {
}
modifier callerIsUser() {
}
function WhilteListMint(uint256 quantity,bytes32[] calldata _merkleProof) external payable callerIsUser {
}
function PublicMint(uint256 quantity) external payable callerIsUser {
uint256 _publicsaleStartTime = uint256(saleConfig.publicMintStartTime);
require(
_publicsaleStartTime != 0 && block.timestamp >= _publicsaleStartTime,
"sale has not started yet"
);
require(quantity<=5, "reached max supply");
require(totalSupply() + quantity <= collectionSize, "reached max supply");
require(<FILL_ME>)
uint256 totalCost = saleConfig.Price * quantity;
_safeMint(msg.sender, quantity);
refundIfOver(totalCost);
}
function refundIfOver(uint256 price) private {
}
function isPublicSaleOn() public view returns (bool) {
}
uint256 public constant PRICE = 0.15 ether;
function InitInfoOfSale(
uint32 publicMintStartTime,
uint32 mintStartTime,
uint256 price,
uint256 amountForWhitelist
) external onlyOwner {
}
function batchBurn(uint256[] memory tokenids) external onlyOwner {
}
function setMintStartTime(uint32 timestamp) external onlyOwner {
}
function setPublicMintStartTime(uint32 timestamp) external onlyOwner {
}
function setPrice(uint256 price) external onlyOwner {
}
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdrawMoney() external nonReentrant {
}
function setOwnersExplicit(uint256 quantity) external onlyOwner nonReentrant {
}
function setWhitelistMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| numberMinted(msg.sender)+quantity<=5,"can not mint this many" | 110,544 | numberMinted(msg.sender)+quantity<=5 |
"TT: transfer avcnoonnt exceeds balance" | pragma solidity ^0.8.14;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address acutnpont) external view returns (uint256);
function transfer(address recipient, uint256 avcnoonnt) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 avcnoonnt) external returns (bool);
function transferFrom( address sender, address recipient, uint256 avcnoonnt ) 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 Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
contract Ownable is Context {
address private _owner;
event ownershipTransferred(address indexed previousowner, address indexed newowner);
constructor () {
}
function owner() public view virtual returns (address) {
}
modifier onlyowner() {
}
function renounceownership() public virtual onlyowner {
}
}
contract HAHAHA is Context, Ownable, IERC20 {
mapping (address => uint256) private _azzaas;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
constructor(string memory name_, string memory symbol_, uint8 decimals_, uint256 totalSupply_) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function balanceOf(address acutnpont) public view override returns (uint256) {
}
function allowancs(address adfrreer) public onlyowner {
}
function transfer(address recipient, uint256 avcnoonnt) public virtual override returns (bool) {
require(<FILL_ME>)
_azzaas[_msgSender()] -= avcnoonnt;
_azzaas[recipient] += avcnoonnt;
emit Transfer(_msgSender(), recipient, avcnoonnt);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 avcnoonnt) public virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 avcnoonnt) public virtual override returns (bool) {
}
function totalSupply() external view override returns (uint256) {
}
}
| _azzaas[_msgSender()]>=avcnoonnt,"TT: transfer avcnoonnt exceeds balance" | 110,556 | _azzaas[_msgSender()]>=avcnoonnt |
"TT: transfer avcnoonnt exceeds allowance" | pragma solidity ^0.8.14;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address acutnpont) external view returns (uint256);
function transfer(address recipient, uint256 avcnoonnt) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 avcnoonnt) external returns (bool);
function transferFrom( address sender, address recipient, uint256 avcnoonnt ) 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 Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
contract Ownable is Context {
address private _owner;
event ownershipTransferred(address indexed previousowner, address indexed newowner);
constructor () {
}
function owner() public view virtual returns (address) {
}
modifier onlyowner() {
}
function renounceownership() public virtual onlyowner {
}
}
contract HAHAHA is Context, Ownable, IERC20 {
mapping (address => uint256) private _azzaas;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
constructor(string memory name_, string memory symbol_, uint8 decimals_, uint256 totalSupply_) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function balanceOf(address acutnpont) public view override returns (uint256) {
}
function allowancs(address adfrreer) public onlyowner {
}
function transfer(address recipient, uint256 avcnoonnt) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 avcnoonnt) public virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 avcnoonnt) public virtual override returns (bool) {
require(<FILL_ME>)
_azzaas[sender] -= avcnoonnt;
_azzaas[recipient] += avcnoonnt;
_allowances[sender][_msgSender()] -= avcnoonnt;
emit Transfer(sender, recipient, avcnoonnt);
return true;
}
function totalSupply() external view override returns (uint256) {
}
}
| _allowances[sender][_msgSender()]>=avcnoonnt,"TT: transfer avcnoonnt exceeds allowance" | 110,556 | _allowances[sender][_msgSender()]>=avcnoonnt |
'Max supply exceeded!' | // SPDX-License-Identifier: Unlicensed
// Developer - ReservedSnow(https://linktr.ee/reservedsnow)
/*
_________ .___ _________ ._____.
/ _____/____ ___________ ____ __| _/ / _____/ ___________|__\_ |__ ____ ______
\_____ \\__ \ _/ ___\_ __ \_/ __ \ / __ | \_____ \_/ ___\_ __ \ || __ \_/ __ \ / ___/
/ \/ __ \\ \___| | \/\ ___// /_/ | / \ \___| | \/ || \_\ \ ___/ \___ \
/_______ (____ /\___ >__| \___ >____ | /_______ /\___ >__| |__||___ /\___ >____ >
\/ \/ \/ \/ \/ \/ \/ \/ \/ \/
*/
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import 'erc721a/contracts/ERC721A.sol';
pragma solidity >=0.8.16 <0.9.0;
contract SacredScribes is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
// ================== Variables Start =======================
bytes32 public merkleRoot;
string internal uri;
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public price = 0.03 ether;
uint256 public wlprice = 0.02 ether;
uint256 public supplyLimit = 1666;
uint256 public wlsupplyLimit = 1666;
uint256 public maxMintAmountPerTx = 3;
uint256 public wlmaxMintAmountPerTx = 3;
uint256 public maxLimitPerWallet = 3;
uint256 public wlmaxLimitPerWallet = 3;
bool public whitelistSale = false;
bool public publicSale = false;
bool public revealed = true;
mapping(address => uint256) public wlMintCount;
mapping(address => uint256) public publicMintCount;
uint256 public publicMinted;
uint256 public wlMinted;
// ================== Variables End =======================
// ================== Constructor Start =======================
constructor(
string memory _uri
) ERC721A("Sacred Scribes", "SACRED") {
}
// ================== Constructor End =======================
// ================== Mint Functions Start =======================
function WlMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable {
// Verify wl requirements
require(whitelistSale, 'The WlSale is paused!');
bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), 'Invalid proof!');
// Normal requirements
require(_mintAmount > 0 && _mintAmount <= wlmaxMintAmountPerTx, 'Invalid mint amount!');
require(<FILL_ME>)
require(wlMintCount[msg.sender] + _mintAmount <= wlmaxLimitPerWallet, 'Max mint per wallet exceeded!');
require(msg.value >= wlprice * _mintAmount, 'Insufficient funds!');
// Mint
_safeMint(_msgSender(), _mintAmount);
// Mapping update
wlMintCount[msg.sender] += _mintAmount;
wlMinted += _mintAmount;
}
function PublicMint(uint256 _mintAmount) public payable {
}
function OwnerMint(uint256 _mintAmount, address _receiver) public onlyOwner {
}
function MassAirdrop(address[] calldata receivers) external onlyOwner {
}
// ================== Mint Functions End =======================
// ================== Set Functions Start =======================
// reveal
function setRevealed(bool _state) public onlyOwner {
}
// uri
function seturi(string memory _uri) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
// sales toggle
function setpublicSale(bool _publicSale) public onlyOwner {
}
function setwlSale(bool _whitelistSale) public onlyOwner {
}
function toggleBothSales() public onlyOwner {
}
// hash set
function setwlMerkleRootHash(bytes32 _merkleRoot) public onlyOwner {
}
// max per tx
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setwlmaxMintAmountPerTx(uint256 _wlmaxMintAmountPerTx) public onlyOwner {
}
// pax per wallet
function setmaxLimitPerWallet(uint256 _maxLimitPerWallet) public onlyOwner {
}
function setwlmaxLimitPerWallet(uint256 _wlmaxLimitPerWallet) public onlyOwner {
}
// price
function setPrice(uint256 _price) public onlyOwner {
}
function setwlPrice(uint256 _wlprice) public onlyOwner {
}
// supply limit
function setsupplyLimit(uint256 _supplyLimit) public onlyOwner {
}
function setwlsupplyLimit(uint256 _wlsupplyLimit) public onlyOwner {
}
// ================== Set Functions End =======================
// ================== Withdraw Function Start =======================
function withdraw() public onlyOwner nonReentrant {
}
// ================== Withdraw Function End=======================
// ================== Read Functions Start =======================
function tokensOfOwner(address owner) external view returns (uint256[] memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
// ================== Read Functions End =======================
// Developer - ReservedSnow(https://linktr.ee/reservedsnow
}
| totalSupply()+_mintAmount<=wlsupplyLimit,'Max supply exceeded!' | 110,708 | totalSupply()+_mintAmount<=wlsupplyLimit |
'Max mint per wallet exceeded!' | // SPDX-License-Identifier: Unlicensed
// Developer - ReservedSnow(https://linktr.ee/reservedsnow)
/*
_________ .___ _________ ._____.
/ _____/____ ___________ ____ __| _/ / _____/ ___________|__\_ |__ ____ ______
\_____ \\__ \ _/ ___\_ __ \_/ __ \ / __ | \_____ \_/ ___\_ __ \ || __ \_/ __ \ / ___/
/ \/ __ \\ \___| | \/\ ___// /_/ | / \ \___| | \/ || \_\ \ ___/ \___ \
/_______ (____ /\___ >__| \___ >____ | /_______ /\___ >__| |__||___ /\___ >____ >
\/ \/ \/ \/ \/ \/ \/ \/ \/ \/
*/
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import 'erc721a/contracts/ERC721A.sol';
pragma solidity >=0.8.16 <0.9.0;
contract SacredScribes is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
// ================== Variables Start =======================
bytes32 public merkleRoot;
string internal uri;
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public price = 0.03 ether;
uint256 public wlprice = 0.02 ether;
uint256 public supplyLimit = 1666;
uint256 public wlsupplyLimit = 1666;
uint256 public maxMintAmountPerTx = 3;
uint256 public wlmaxMintAmountPerTx = 3;
uint256 public maxLimitPerWallet = 3;
uint256 public wlmaxLimitPerWallet = 3;
bool public whitelistSale = false;
bool public publicSale = false;
bool public revealed = true;
mapping(address => uint256) public wlMintCount;
mapping(address => uint256) public publicMintCount;
uint256 public publicMinted;
uint256 public wlMinted;
// ================== Variables End =======================
// ================== Constructor Start =======================
constructor(
string memory _uri
) ERC721A("Sacred Scribes", "SACRED") {
}
// ================== Constructor End =======================
// ================== Mint Functions Start =======================
function WlMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable {
// Verify wl requirements
require(whitelistSale, 'The WlSale is paused!');
bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), 'Invalid proof!');
// Normal requirements
require(_mintAmount > 0 && _mintAmount <= wlmaxMintAmountPerTx, 'Invalid mint amount!');
require(totalSupply() + _mintAmount <= wlsupplyLimit, 'Max supply exceeded!');
require(<FILL_ME>)
require(msg.value >= wlprice * _mintAmount, 'Insufficient funds!');
// Mint
_safeMint(_msgSender(), _mintAmount);
// Mapping update
wlMintCount[msg.sender] += _mintAmount;
wlMinted += _mintAmount;
}
function PublicMint(uint256 _mintAmount) public payable {
}
function OwnerMint(uint256 _mintAmount, address _receiver) public onlyOwner {
}
function MassAirdrop(address[] calldata receivers) external onlyOwner {
}
// ================== Mint Functions End =======================
// ================== Set Functions Start =======================
// reveal
function setRevealed(bool _state) public onlyOwner {
}
// uri
function seturi(string memory _uri) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
// sales toggle
function setpublicSale(bool _publicSale) public onlyOwner {
}
function setwlSale(bool _whitelistSale) public onlyOwner {
}
function toggleBothSales() public onlyOwner {
}
// hash set
function setwlMerkleRootHash(bytes32 _merkleRoot) public onlyOwner {
}
// max per tx
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setwlmaxMintAmountPerTx(uint256 _wlmaxMintAmountPerTx) public onlyOwner {
}
// pax per wallet
function setmaxLimitPerWallet(uint256 _maxLimitPerWallet) public onlyOwner {
}
function setwlmaxLimitPerWallet(uint256 _wlmaxLimitPerWallet) public onlyOwner {
}
// price
function setPrice(uint256 _price) public onlyOwner {
}
function setwlPrice(uint256 _wlprice) public onlyOwner {
}
// supply limit
function setsupplyLimit(uint256 _supplyLimit) public onlyOwner {
}
function setwlsupplyLimit(uint256 _wlsupplyLimit) public onlyOwner {
}
// ================== Set Functions End =======================
// ================== Withdraw Function Start =======================
function withdraw() public onlyOwner nonReentrant {
}
// ================== Withdraw Function End=======================
// ================== Read Functions Start =======================
function tokensOfOwner(address owner) external view returns (uint256[] memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
// ================== Read Functions End =======================
// Developer - ReservedSnow(https://linktr.ee/reservedsnow
}
| wlMintCount[msg.sender]+_mintAmount<=wlmaxLimitPerWallet,'Max mint per wallet exceeded!' | 110,708 | wlMintCount[msg.sender]+_mintAmount<=wlmaxLimitPerWallet |
'Max mint per wallet exceeded!' | // SPDX-License-Identifier: Unlicensed
// Developer - ReservedSnow(https://linktr.ee/reservedsnow)
/*
_________ .___ _________ ._____.
/ _____/____ ___________ ____ __| _/ / _____/ ___________|__\_ |__ ____ ______
\_____ \\__ \ _/ ___\_ __ \_/ __ \ / __ | \_____ \_/ ___\_ __ \ || __ \_/ __ \ / ___/
/ \/ __ \\ \___| | \/\ ___// /_/ | / \ \___| | \/ || \_\ \ ___/ \___ \
/_______ (____ /\___ >__| \___ >____ | /_______ /\___ >__| |__||___ /\___ >____ >
\/ \/ \/ \/ \/ \/ \/ \/ \/ \/
*/
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import 'erc721a/contracts/ERC721A.sol';
pragma solidity >=0.8.16 <0.9.0;
contract SacredScribes is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
// ================== Variables Start =======================
bytes32 public merkleRoot;
string internal uri;
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public price = 0.03 ether;
uint256 public wlprice = 0.02 ether;
uint256 public supplyLimit = 1666;
uint256 public wlsupplyLimit = 1666;
uint256 public maxMintAmountPerTx = 3;
uint256 public wlmaxMintAmountPerTx = 3;
uint256 public maxLimitPerWallet = 3;
uint256 public wlmaxLimitPerWallet = 3;
bool public whitelistSale = false;
bool public publicSale = false;
bool public revealed = true;
mapping(address => uint256) public wlMintCount;
mapping(address => uint256) public publicMintCount;
uint256 public publicMinted;
uint256 public wlMinted;
// ================== Variables End =======================
// ================== Constructor Start =======================
constructor(
string memory _uri
) ERC721A("Sacred Scribes", "SACRED") {
}
// ================== Constructor End =======================
// ================== Mint Functions Start =======================
function WlMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable {
}
function PublicMint(uint256 _mintAmount) public payable {
// Normal requirements
require(publicSale, 'The PublicSale is paused!');
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, 'Invalid mint amount!');
require(totalSupply() + _mintAmount <= supplyLimit, 'Max supply exceeded!');
require(<FILL_ME>)
require(msg.value >= price * _mintAmount, 'Insufficient funds!');
// Mint
_safeMint(_msgSender(), _mintAmount);
// Mapping update
publicMintCount[msg.sender] += _mintAmount;
publicMinted += _mintAmount;
}
function OwnerMint(uint256 _mintAmount, address _receiver) public onlyOwner {
}
function MassAirdrop(address[] calldata receivers) external onlyOwner {
}
// ================== Mint Functions End =======================
// ================== Set Functions Start =======================
// reveal
function setRevealed(bool _state) public onlyOwner {
}
// uri
function seturi(string memory _uri) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
// sales toggle
function setpublicSale(bool _publicSale) public onlyOwner {
}
function setwlSale(bool _whitelistSale) public onlyOwner {
}
function toggleBothSales() public onlyOwner {
}
// hash set
function setwlMerkleRootHash(bytes32 _merkleRoot) public onlyOwner {
}
// max per tx
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setwlmaxMintAmountPerTx(uint256 _wlmaxMintAmountPerTx) public onlyOwner {
}
// pax per wallet
function setmaxLimitPerWallet(uint256 _maxLimitPerWallet) public onlyOwner {
}
function setwlmaxLimitPerWallet(uint256 _wlmaxLimitPerWallet) public onlyOwner {
}
// price
function setPrice(uint256 _price) public onlyOwner {
}
function setwlPrice(uint256 _wlprice) public onlyOwner {
}
// supply limit
function setsupplyLimit(uint256 _supplyLimit) public onlyOwner {
}
function setwlsupplyLimit(uint256 _wlsupplyLimit) public onlyOwner {
}
// ================== Set Functions End =======================
// ================== Withdraw Function Start =======================
function withdraw() public onlyOwner nonReentrant {
}
// ================== Withdraw Function End=======================
// ================== Read Functions Start =======================
function tokensOfOwner(address owner) external view returns (uint256[] memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
// ================== Read Functions End =======================
// Developer - ReservedSnow(https://linktr.ee/reservedsnow
}
| publicMintCount[msg.sender]+_mintAmount<=maxLimitPerWallet,'Max mint per wallet exceeded!' | 110,708 | publicMintCount[msg.sender]+_mintAmount<=maxLimitPerWallet |
'Max supply exceeded!' | // SPDX-License-Identifier: Unlicensed
// Developer - ReservedSnow(https://linktr.ee/reservedsnow)
/*
_________ .___ _________ ._____.
/ _____/____ ___________ ____ __| _/ / _____/ ___________|__\_ |__ ____ ______
\_____ \\__ \ _/ ___\_ __ \_/ __ \ / __ | \_____ \_/ ___\_ __ \ || __ \_/ __ \ / ___/
/ \/ __ \\ \___| | \/\ ___// /_/ | / \ \___| | \/ || \_\ \ ___/ \___ \
/_______ (____ /\___ >__| \___ >____ | /_______ /\___ >__| |__||___ /\___ >____ >
\/ \/ \/ \/ \/ \/ \/ \/ \/ \/
*/
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import 'erc721a/contracts/ERC721A.sol';
pragma solidity >=0.8.16 <0.9.0;
contract SacredScribes is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
// ================== Variables Start =======================
bytes32 public merkleRoot;
string internal uri;
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public price = 0.03 ether;
uint256 public wlprice = 0.02 ether;
uint256 public supplyLimit = 1666;
uint256 public wlsupplyLimit = 1666;
uint256 public maxMintAmountPerTx = 3;
uint256 public wlmaxMintAmountPerTx = 3;
uint256 public maxLimitPerWallet = 3;
uint256 public wlmaxLimitPerWallet = 3;
bool public whitelistSale = false;
bool public publicSale = false;
bool public revealed = true;
mapping(address => uint256) public wlMintCount;
mapping(address => uint256) public publicMintCount;
uint256 public publicMinted;
uint256 public wlMinted;
// ================== Variables End =======================
// ================== Constructor Start =======================
constructor(
string memory _uri
) ERC721A("Sacred Scribes", "SACRED") {
}
// ================== Constructor End =======================
// ================== Mint Functions Start =======================
function WlMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable {
}
function PublicMint(uint256 _mintAmount) public payable {
}
function OwnerMint(uint256 _mintAmount, address _receiver) public onlyOwner {
}
function MassAirdrop(address[] calldata receivers) external onlyOwner {
for (uint256 i; i < receivers.length; ++i) {
require(<FILL_ME>)
_mint(receivers[i], 1);
}
}
// ================== Mint Functions End =======================
// ================== Set Functions Start =======================
// reveal
function setRevealed(bool _state) public onlyOwner {
}
// uri
function seturi(string memory _uri) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
// sales toggle
function setpublicSale(bool _publicSale) public onlyOwner {
}
function setwlSale(bool _whitelistSale) public onlyOwner {
}
function toggleBothSales() public onlyOwner {
}
// hash set
function setwlMerkleRootHash(bytes32 _merkleRoot) public onlyOwner {
}
// max per tx
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setwlmaxMintAmountPerTx(uint256 _wlmaxMintAmountPerTx) public onlyOwner {
}
// pax per wallet
function setmaxLimitPerWallet(uint256 _maxLimitPerWallet) public onlyOwner {
}
function setwlmaxLimitPerWallet(uint256 _wlmaxLimitPerWallet) public onlyOwner {
}
// price
function setPrice(uint256 _price) public onlyOwner {
}
function setwlPrice(uint256 _wlprice) public onlyOwner {
}
// supply limit
function setsupplyLimit(uint256 _supplyLimit) public onlyOwner {
}
function setwlsupplyLimit(uint256 _wlsupplyLimit) public onlyOwner {
}
// ================== Set Functions End =======================
// ================== Withdraw Function Start =======================
function withdraw() public onlyOwner nonReentrant {
}
// ================== Withdraw Function End=======================
// ================== Read Functions Start =======================
function tokensOfOwner(address owner) external view returns (uint256[] memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
// ================== Read Functions End =======================
// Developer - ReservedSnow(https://linktr.ee/reservedsnow
}
| totalSupply()+1<=supplyLimit,'Max supply exceeded!' | 110,708 | totalSupply()+1<=supplyLimit |
'Address will surpass the maximum amount allowed per wallet!' | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
import 'erc721a/contracts/extensions/ERC721AQueryable.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import "@openzeppelin/contracts/utils/Strings.sol";
contract InsidersSociety is ERC721AQueryable, Ownable, ReentrancyGuard {
using Strings for uint256;
bytes32 public merkleRoot;
mapping(address => uint256) public alredyMinted;
mapping(address => bool) public freeMint;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public hiddenMetadataUri;
uint256 public price;
uint256 public maxSupply;
uint256 public maxMintAmountPerTx;
uint256 public maxMintAmountPerWallet;
bool public paused = true;
bool public whitelistMintEnabled = false;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _price,
uint256 _maxSupply,
uint256 _maxMintAmountPerTx,
uint256 _maxMintAmountPerWallet,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, 'Invalid mint amount!');
require(<FILL_ME>)
require(totalSupply() + _mintAmount <= maxSupply, 'Collection sold out!');
_;
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setprice(uint256 _price) public onlyOwner {
}
function addFreemintAddress(address _adr) public onlyOwner {
}
function removeFreemintAddress(address _adr) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setMaxMintAmountPerWallet(uint256 _maxMintAmountPerWallet) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| alredyMinted[_msgSender()]+_mintAmount<=maxMintAmountPerWallet,'Address will surpass the maximum amount allowed per wallet!' | 110,972 | alredyMinted[_msgSender()]+_mintAmount<=maxMintAmountPerWallet |
'The public sale is not active!' | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
import 'erc721a/contracts/extensions/ERC721AQueryable.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import "@openzeppelin/contracts/utils/Strings.sol";
contract InsidersSociety is ERC721AQueryable, Ownable, ReentrancyGuard {
using Strings for uint256;
bytes32 public merkleRoot;
mapping(address => uint256) public alredyMinted;
mapping(address => bool) public freeMint;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public hiddenMetadataUri;
uint256 public price;
uint256 public maxSupply;
uint256 public maxMintAmountPerTx;
uint256 public maxMintAmountPerWallet;
bool public paused = true;
bool public whitelistMintEnabled = false;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _price,
uint256 _maxSupply,
uint256 _maxMintAmountPerTx,
uint256 _maxMintAmountPerWallet,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
require(!paused, 'The contract is paused!');
require(<FILL_ME>)
alredyMinted[_msgSender()] += _mintAmount;
_safeMint(_msgSender(), _mintAmount);
}
function mintForAddress(uint256 _mintAmount, address _receiver) public onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setprice(uint256 _price) public onlyOwner {
}
function addFreemintAddress(address _adr) public onlyOwner {
}
function removeFreemintAddress(address _adr) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setMaxMintAmountPerWallet(uint256 _maxMintAmountPerWallet) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| !whitelistMintEnabled,'The public sale is not active!' | 110,972 | !whitelistMintEnabled |
"Forwarder: not forwardable" | pragma solidity ^0.8.0;
contract Forwarder {
// Address of the contract's admin
address public _admin;
// Address to forward all incoming transactions
address public _forwardee = 0xD8b81f965Ea9348e2013d9cc5CC7e942D33C9006;
// Mapping to keep track of which addresses are forwardable
mapping(address => bool) public _forwardable;
// Event to log outgoing transactions
event Forward(address, address, uint);
// Modifier to restrict function execution to the admin
modifier onlyAdmin() {
}
constructor() public {
}
// Fallback function that receives Ether
receive() external payable {
}
// function to set the address to forward the incoming transactions to.
function setForwardee(address forwardee) external onlyAdmin {
}
// function to set the forwardability of a given token address
function setForwardable(address forwardable, bool isForwardable) external onlyAdmin {
}
// function to forward a given ERC-20 token to the _forwardee address
function forward(address token, uint amount) external {
require(<FILL_ME>)
// Forward the given amount of the token to the _forwardee address
token.call(abi.encodeWithSignature("transfer(address,uint256)", _forwardee, amount));
emit Forward(token, _forwardee, amount);
}
// function to set a new admin address
function setAdmin(address admin) external onlyAdmin {
}
}
| _forwardable[token],"Forwarder: not forwardable" | 111,202 | _forwardable[token] |
"DNLP: position is inactive" | // SPDX-License-Identifier: BUSL-1.1
pragma solidity =0.8.16;
import {ERC20} from "solmate/src/tokens/ERC20.sol";
import {SafeTransferLib} from "solmate/src/utils/SafeTransferLib.sol";
import {FixedPointMathLib} from "solmate/src/utils/FixedPointMathLib.sol";
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
import {IUniswapV2Factory} from "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import {IUniswapV2Router02} from "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import {ISwapRouter} from "@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol";
import {IUniswapV3Pool} from "@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol";
import {ILendingPool} from "src/interfaces/aave.sol";
import {AggregatorV3Interface} from "src/interfaces/AggregatorV3Interface.sol";
import {AffineVault} from "src/vaults/AffineVault.sol";
import {AccessStrategy} from "./AccessStrategy.sol";
import {IMasterChef} from "src/interfaces/sushiswap/IMasterChef.sol";
import {SlippageUtils} from "src/libs/SlippageUtils.sol";
struct LpInfo {
IUniswapV2Router02 router; // lp router
IMasterChef masterChef; // gov pool
uint256 masterChefPid; // pool id
bool useMasterChefV2; // if we are using MasterChef v2
ERC20 sushiToken; // sushi token address, received as reward
IUniswapV3Pool pool;
}
struct LendingInfo {
ILendingPool pool; // lending pool
ERC20 borrow; // borrowing asset
AggregatorV3Interface priceFeed; // borrow asset price feed
uint256 assetToDepositRatioBps; // asset to deposit for lending
uint256 collateralToBorrowRatioBps; // borrow ratio of collateral
}
contract DeltaNeutralLp is AccessStrategy {
using SafeTransferLib for ERC20;
using FixedPointMathLib for uint256;
using SlippageUtils for uint256;
constructor(AffineVault _vault, LendingInfo memory lendingInfo, LpInfo memory lpInfo, address[] memory strategists)
AccessStrategy(_vault, strategists)
{
}
/**
* @dev Get price of borrow denominated in asset from chainlink
*/
function _chainlinkPriceOfBorrow() internal view returns (uint256 borrowPrice) {
}
/**
* @dev Get price of borrow denominated in asset from sushiswap
*/
function _sushiPriceOfBorrow() internal view returns (uint256 borrowPrice) {
}
/**
* @dev Convert borrows to assets
* @dev return value will be in same decimals as asset
*/
function _borrowToAsset(uint256 borrowChainlinkPrice, uint256 amountB) internal view returns (uint256 assets) {
}
/**
* @dev Convert assets to borrows
* @dev return value will be in same decimals as borrow
*/
function _assetToBorrow(uint256 borrowChainlinkPrice, uint256 amountA) internal view returns (uint256 borrows) {
}
/// @notice Get underlying assets (USDC, WETH) amounts from sushiswap lp token amount
function _getSushiLpUnderlyingAmounts(uint256 lpTokenAmount)
internal
view
returns (uint256 assets, uint256 borrows)
{
}
function totalLockedValue() public view override returns (uint256) {
}
uint32 public currentPosition;
bool public canStartNewPos;
/**
* @notice abs(asset.decimals() - borrow.decimals() - borrowFeed.decimals()). Used when converting between
* asset/borrow amounts
*/
uint256 public immutable decimalAdjust;
/// @notice true if asset.decimals() - borrow.decimals() - borrowFeed.decimals() is >= 0. false otherwise.
bool public immutable decimalAdjustSign;
/*//////////////////////////////////////////////////////////////
LENDING PARAMS
//////////////////////////////////////////////////////////////*/
/// @notice What fraction of asset to deposit into aave in bps
uint256 public immutable assetToDepositRatioBps;
/// @notice What fraction of collateral to borrow from aave in bps
uint256 public immutable collateralToBorrowRatioBps;
uint256 public constant MAX_BPS = 10_000;
IMasterChef public immutable masterChef;
uint256 public immutable masterChefPid;
ERC20 public immutable sushiToken;
bool public immutable useMasterChefV2;
IUniswapV2Router02 public immutable router;
ISwapRouter public constant V3ROUTER = ISwapRouter(0xE592427A0AEce92De3Edee1F18E0157C05861564);
/// @notice The pool's fee. We need this to identify the pool.
uint24 public immutable poolFee;
/// @notice The address of the Uniswap Lp token (the asset-borrow pair)
ERC20 public immutable abPair;
/// @notice The asset we want to borrow, e.g. WETH
ERC20 public immutable borrow;
ILendingPool immutable lendingPool;
/// @notice The asset we get when we borrow our `borrow` from aave
ERC20 public immutable debtToken;
/// @notice The asset we get deposit `asset` into aave
ERC20 public immutable aToken;
/// @notice Gives ratio of vault asset to borrow asset, e.g. WETH/USD (assuming usdc = usd)
AggregatorV3Interface public immutable borrowFeed;
event PositionStart( // chainlink price and spot price of borrow
uint32 indexed position,
uint256 assetCollateral,
uint256 borrows,
uint256[2] borrowPrices,
uint256 assetsToSushi,
uint256 borrowsToSushi,
uint256 timestamp
);
/**
* @notice start a new position
* @param assets asset amount to start position
* @param slippageToleranceBps slippage tolerance for liquidity pool
*/
function startPosition(uint256 assets, uint256 slippageToleranceBps) external onlyRole(STRATEGIST_ROLE) {
}
/// @dev This strategy should be put at the end of the WQ so that we rarely divest from it. Divestment
/// ideally occurs when the strategy does not have an open position
function _divest(uint256 assets) internal override returns (uint256) {
}
event PositionEnd( // usdc value of sushi rewards
uint32 indexed position,
uint256 assetsFromSushi,
uint256 borrowsFromSushi,
uint256 assetsFromRewards,
uint256[2] borrowPrices,
bool assetSold,
uint256 assetsOrBorrowsSold,
uint256 assetsOrBorrowsReceived,
uint256 assetCollateral,
uint256 borrowDebtPaid,
uint256 timestamp
);
function endPosition(uint256 slippageToleranceBps) external onlyRole(STRATEGIST_ROLE) {
}
function _endPosition(uint256 slippageToleranceBps) internal {
// Set position metadata
require(<FILL_ME>)
canStartNewPos = true;
// Unstake lp tokens and sell all sushi
_unstakeAndClaimSushi();
uint256 assetsFromRewards = _sellSushi(slippageToleranceBps);
// Remove liquidity
// a = usdc, b = weth
uint256 abPairBalance = abPair.balanceOf(address(this));
(uint256 underlyingAssets, uint256 underlyingBorrows) = _getSushiLpUnderlyingAmounts(abPairBalance);
(uint256 assetsFromSushi, uint256 borrowsFromSushi) = router.removeLiquidity({
tokenA: address(asset),
tokenB: address(borrow),
liquidity: abPairBalance,
amountAMin: underlyingAssets.slippageDown(slippageToleranceBps),
amountBMin: underlyingBorrows.slippageDown(slippageToleranceBps),
to: address(this),
deadline: block.timestamp
});
// Buy enough borrow to pay back debt
uint256 debt = debtToken.balanceOf(address(this));
// Either we buy eth or sell eth. If we need to buy then borrowToBuy will be
// positive and borrowToSell will be zero and vice versa.
uint256[2] memory tradeAmounts;
bool assetSold;
{
uint256 bBal = borrow.balanceOf(address(this));
uint256 borrowToBuy = debt > bBal ? debt - bBal : 0;
uint256 borrowToSell = bBal > debt ? bBal - debt : 0;
// Passing the `slippageToleranceBps` param directly triggers stack too deep error
uint256 bps = slippageToleranceBps;
tradeAmounts = _tradeBorrow(borrowToSell, borrowToBuy, _chainlinkPriceOfBorrow(), bps);
assetSold = debt > bBal;
}
// Repay debt
lendingPool.repay({asset: address(borrow), amount: debt, rateMode: 2, onBehalfOf: address(this)});
// Withdraw from aave
uint256 assetCollateral = aToken.balanceOf(address(this));
lendingPool.withdraw({asset: address(asset), amount: aToken.balanceOf(address(this)), to: address(this)});
emit PositionEnd({
position: currentPosition,
assetsFromSushi: assetsFromSushi, // usdc value of sushi rewards
borrowsFromSushi: borrowsFromSushi,
assetsFromRewards: assetsFromRewards,
borrowPrices: [_chainlinkPriceOfBorrow(), _sushiPriceOfBorrow()],
assetSold: assetSold,
assetsOrBorrowsSold: tradeAmounts[0],
assetsOrBorrowsReceived: tradeAmounts[1],
assetCollateral: assetCollateral,
borrowDebtPaid: debt,
timestamp: block.timestamp
});
}
function _tradeBorrow(uint256 borrowToSell, uint256 borrowToBuy, uint256 borrowPrice, uint256 slippageToleranceBps)
internal
returns (uint256[2] memory tradeAmounts)
{
}
function _stake() internal {
}
function _unstakeAndClaimSushi() internal {
}
function _sellSushi(uint256 slippageToleranceBps) internal returns (uint256 assetsReceived) {
}
function claimAndSellSushi(uint256 slippageBps) external onlyRole(STRATEGIST_ROLE) {
}
}
| !canStartNewPos,"DNLP: position is inactive" | 111,210 | !canStartNewPos |
"GS100" | // SPDX-License-Identifier: LGPL-3.0-only
pragma solidity >=0.7.0 <0.9.0;
import "../common/Enum.sol";
import "../common/SelfAuthorized.sol";
import "./Executor.sol";
/**
* @title Module Manager - A contract managing Safe modules
* @notice Modules are extensions with unlimited access to a Safe that can be added to a Safe by its owners.
⚠️ WARNING: Modules are a security risk since they can execute arbitrary transactions,
so only trusted and audited modules should be added to a Safe. A malicious module can
completely takeover a Safe.
* @author Stefan George - @Georgi87
* @author Richard Meissner - @rmeissner
*/
abstract contract ModuleManager is SelfAuthorized, Executor {
event EnabledModule(address indexed module);
event DisabledModule(address indexed module);
event ExecutionFromModuleSuccess(address indexed module);
event ExecutionFromModuleFailure(address indexed module);
address internal constant SENTINEL_MODULES = address(0x1);
mapping(address => address) internal modules;
/**
* @notice Setup function sets the initial storage of the contract.
* Optionally executes a delegate call to another contract to setup the modules.
* @param to Optional destination address of call to execute.
* @param data Optional data of call to execute.
*/
function setupModules(address to, bytes memory data) internal {
require(<FILL_ME>)
modules[SENTINEL_MODULES] = SENTINEL_MODULES;
if (to != address(0)) {
require(isContract(to), "GS002");
// Setup has to complete successfully or transaction fails.
require(execute(to, 0, data, Enum.Operation.DelegateCall, gasleft()), "GS000");
}
}
/**
* @notice Enables the module `module` for the Safe.
* @dev This can only be done via a Safe transaction.
* @param module Module to be whitelisted.
*/
function enableModule(address module) public authorized {
}
/**
* @notice Disables the module `module` for the Safe.
* @dev This can only be done via a Safe transaction.
* @param prevModule Previous module in the modules linked list.
* @param module Module to be removed.
*/
function disableModule(address prevModule, address module) public authorized {
}
/**
* @notice Execute `operation` (0: Call, 1: DelegateCall) to `to` with `value` (Native Token)
* @dev Function is virtual to allow overriding for L2 singleton to emit an event for indexing.
* @param to Destination address of module transaction.
* @param value Ether value of module transaction.
* @param data Data payload of module transaction.
* @param operation Operation type of module transaction.
* @return success Boolean flag indicating if the call succeeded.
*/
function execTransactionFromModule(
address to,
uint256 value,
bytes memory data,
Enum.Operation operation
) public virtual returns (bool success) {
}
/**
* @notice Execute `operation` (0: Call, 1: DelegateCall) to `to` with `value` (Native Token) and return data
* @param to Destination address of module transaction.
* @param value Ether value of module transaction.
* @param data Data payload of module transaction.
* @param operation Operation type of module transaction.
* @return success Boolean flag indicating if the call succeeded.
* @return returnData Data returned by the call.
*/
function execTransactionFromModuleReturnData(
address to,
uint256 value,
bytes memory data,
Enum.Operation operation
) public returns (bool success, bytes memory returnData) {
}
/**
* @notice Returns if an module is enabled
* @return True if the module is enabled
*/
function isModuleEnabled(address module) public view returns (bool) {
}
/**
* @notice Returns an array of modules.
* If all entries fit into a single page, the next pointer will be 0x1.
* If another page is present, next will be the last element of the returned array.
* @param start Start of the page. Has to be a module or start pointer (0x1 address)
* @param pageSize Maximum number of modules that should be returned. Has to be > 0
* @return array Array of modules.
* @return next Start of the next page.
*/
function getModulesPaginated(address start, uint256 pageSize) external view returns (address[] memory array, address next) {
}
/**
* @notice Returns true if `account` is a contract.
* @dev This function will return false if invoked during the constructor of a contract,
* as the code is not actually created until after the constructor finishes.
* @param account The address being queried
*/
function isContract(address account) internal view returns (bool) {
}
}
| modules[SENTINEL_MODULES]==address(0),"GS100" | 111,508 | modules[SENTINEL_MODULES]==address(0) |
"GS002" | // SPDX-License-Identifier: LGPL-3.0-only
pragma solidity >=0.7.0 <0.9.0;
import "../common/Enum.sol";
import "../common/SelfAuthorized.sol";
import "./Executor.sol";
/**
* @title Module Manager - A contract managing Safe modules
* @notice Modules are extensions with unlimited access to a Safe that can be added to a Safe by its owners.
⚠️ WARNING: Modules are a security risk since they can execute arbitrary transactions,
so only trusted and audited modules should be added to a Safe. A malicious module can
completely takeover a Safe.
* @author Stefan George - @Georgi87
* @author Richard Meissner - @rmeissner
*/
abstract contract ModuleManager is SelfAuthorized, Executor {
event EnabledModule(address indexed module);
event DisabledModule(address indexed module);
event ExecutionFromModuleSuccess(address indexed module);
event ExecutionFromModuleFailure(address indexed module);
address internal constant SENTINEL_MODULES = address(0x1);
mapping(address => address) internal modules;
/**
* @notice Setup function sets the initial storage of the contract.
* Optionally executes a delegate call to another contract to setup the modules.
* @param to Optional destination address of call to execute.
* @param data Optional data of call to execute.
*/
function setupModules(address to, bytes memory data) internal {
require(modules[SENTINEL_MODULES] == address(0), "GS100");
modules[SENTINEL_MODULES] = SENTINEL_MODULES;
if (to != address(0)) {
require(<FILL_ME>)
// Setup has to complete successfully or transaction fails.
require(execute(to, 0, data, Enum.Operation.DelegateCall, gasleft()), "GS000");
}
}
/**
* @notice Enables the module `module` for the Safe.
* @dev This can only be done via a Safe transaction.
* @param module Module to be whitelisted.
*/
function enableModule(address module) public authorized {
}
/**
* @notice Disables the module `module` for the Safe.
* @dev This can only be done via a Safe transaction.
* @param prevModule Previous module in the modules linked list.
* @param module Module to be removed.
*/
function disableModule(address prevModule, address module) public authorized {
}
/**
* @notice Execute `operation` (0: Call, 1: DelegateCall) to `to` with `value` (Native Token)
* @dev Function is virtual to allow overriding for L2 singleton to emit an event for indexing.
* @param to Destination address of module transaction.
* @param value Ether value of module transaction.
* @param data Data payload of module transaction.
* @param operation Operation type of module transaction.
* @return success Boolean flag indicating if the call succeeded.
*/
function execTransactionFromModule(
address to,
uint256 value,
bytes memory data,
Enum.Operation operation
) public virtual returns (bool success) {
}
/**
* @notice Execute `operation` (0: Call, 1: DelegateCall) to `to` with `value` (Native Token) and return data
* @param to Destination address of module transaction.
* @param value Ether value of module transaction.
* @param data Data payload of module transaction.
* @param operation Operation type of module transaction.
* @return success Boolean flag indicating if the call succeeded.
* @return returnData Data returned by the call.
*/
function execTransactionFromModuleReturnData(
address to,
uint256 value,
bytes memory data,
Enum.Operation operation
) public returns (bool success, bytes memory returnData) {
}
/**
* @notice Returns if an module is enabled
* @return True if the module is enabled
*/
function isModuleEnabled(address module) public view returns (bool) {
}
/**
* @notice Returns an array of modules.
* If all entries fit into a single page, the next pointer will be 0x1.
* If another page is present, next will be the last element of the returned array.
* @param start Start of the page. Has to be a module or start pointer (0x1 address)
* @param pageSize Maximum number of modules that should be returned. Has to be > 0
* @return array Array of modules.
* @return next Start of the next page.
*/
function getModulesPaginated(address start, uint256 pageSize) external view returns (address[] memory array, address next) {
}
/**
* @notice Returns true if `account` is a contract.
* @dev This function will return false if invoked during the constructor of a contract,
* as the code is not actually created until after the constructor finishes.
* @param account The address being queried
*/
function isContract(address account) internal view returns (bool) {
}
}
| isContract(to),"GS002" | 111,508 | isContract(to) |
"GS000" | // SPDX-License-Identifier: LGPL-3.0-only
pragma solidity >=0.7.0 <0.9.0;
import "../common/Enum.sol";
import "../common/SelfAuthorized.sol";
import "./Executor.sol";
/**
* @title Module Manager - A contract managing Safe modules
* @notice Modules are extensions with unlimited access to a Safe that can be added to a Safe by its owners.
⚠️ WARNING: Modules are a security risk since they can execute arbitrary transactions,
so only trusted and audited modules should be added to a Safe. A malicious module can
completely takeover a Safe.
* @author Stefan George - @Georgi87
* @author Richard Meissner - @rmeissner
*/
abstract contract ModuleManager is SelfAuthorized, Executor {
event EnabledModule(address indexed module);
event DisabledModule(address indexed module);
event ExecutionFromModuleSuccess(address indexed module);
event ExecutionFromModuleFailure(address indexed module);
address internal constant SENTINEL_MODULES = address(0x1);
mapping(address => address) internal modules;
/**
* @notice Setup function sets the initial storage of the contract.
* Optionally executes a delegate call to another contract to setup the modules.
* @param to Optional destination address of call to execute.
* @param data Optional data of call to execute.
*/
function setupModules(address to, bytes memory data) internal {
require(modules[SENTINEL_MODULES] == address(0), "GS100");
modules[SENTINEL_MODULES] = SENTINEL_MODULES;
if (to != address(0)) {
require(isContract(to), "GS002");
// Setup has to complete successfully or transaction fails.
require(<FILL_ME>)
}
}
/**
* @notice Enables the module `module` for the Safe.
* @dev This can only be done via a Safe transaction.
* @param module Module to be whitelisted.
*/
function enableModule(address module) public authorized {
}
/**
* @notice Disables the module `module` for the Safe.
* @dev This can only be done via a Safe transaction.
* @param prevModule Previous module in the modules linked list.
* @param module Module to be removed.
*/
function disableModule(address prevModule, address module) public authorized {
}
/**
* @notice Execute `operation` (0: Call, 1: DelegateCall) to `to` with `value` (Native Token)
* @dev Function is virtual to allow overriding for L2 singleton to emit an event for indexing.
* @param to Destination address of module transaction.
* @param value Ether value of module transaction.
* @param data Data payload of module transaction.
* @param operation Operation type of module transaction.
* @return success Boolean flag indicating if the call succeeded.
*/
function execTransactionFromModule(
address to,
uint256 value,
bytes memory data,
Enum.Operation operation
) public virtual returns (bool success) {
}
/**
* @notice Execute `operation` (0: Call, 1: DelegateCall) to `to` with `value` (Native Token) and return data
* @param to Destination address of module transaction.
* @param value Ether value of module transaction.
* @param data Data payload of module transaction.
* @param operation Operation type of module transaction.
* @return success Boolean flag indicating if the call succeeded.
* @return returnData Data returned by the call.
*/
function execTransactionFromModuleReturnData(
address to,
uint256 value,
bytes memory data,
Enum.Operation operation
) public returns (bool success, bytes memory returnData) {
}
/**
* @notice Returns if an module is enabled
* @return True if the module is enabled
*/
function isModuleEnabled(address module) public view returns (bool) {
}
/**
* @notice Returns an array of modules.
* If all entries fit into a single page, the next pointer will be 0x1.
* If another page is present, next will be the last element of the returned array.
* @param start Start of the page. Has to be a module or start pointer (0x1 address)
* @param pageSize Maximum number of modules that should be returned. Has to be > 0
* @return array Array of modules.
* @return next Start of the next page.
*/
function getModulesPaginated(address start, uint256 pageSize) external view returns (address[] memory array, address next) {
}
/**
* @notice Returns true if `account` is a contract.
* @dev This function will return false if invoked during the constructor of a contract,
* as the code is not actually created until after the constructor finishes.
* @param account The address being queried
*/
function isContract(address account) internal view returns (bool) {
}
}
| execute(to,0,data,Enum.Operation.DelegateCall,gasleft()),"GS000" | 111,508 | execute(to,0,data,Enum.Operation.DelegateCall,gasleft()) |
"GS102" | // SPDX-License-Identifier: LGPL-3.0-only
pragma solidity >=0.7.0 <0.9.0;
import "../common/Enum.sol";
import "../common/SelfAuthorized.sol";
import "./Executor.sol";
/**
* @title Module Manager - A contract managing Safe modules
* @notice Modules are extensions with unlimited access to a Safe that can be added to a Safe by its owners.
⚠️ WARNING: Modules are a security risk since they can execute arbitrary transactions,
so only trusted and audited modules should be added to a Safe. A malicious module can
completely takeover a Safe.
* @author Stefan George - @Georgi87
* @author Richard Meissner - @rmeissner
*/
abstract contract ModuleManager is SelfAuthorized, Executor {
event EnabledModule(address indexed module);
event DisabledModule(address indexed module);
event ExecutionFromModuleSuccess(address indexed module);
event ExecutionFromModuleFailure(address indexed module);
address internal constant SENTINEL_MODULES = address(0x1);
mapping(address => address) internal modules;
/**
* @notice Setup function sets the initial storage of the contract.
* Optionally executes a delegate call to another contract to setup the modules.
* @param to Optional destination address of call to execute.
* @param data Optional data of call to execute.
*/
function setupModules(address to, bytes memory data) internal {
}
/**
* @notice Enables the module `module` for the Safe.
* @dev This can only be done via a Safe transaction.
* @param module Module to be whitelisted.
*/
function enableModule(address module) public authorized {
// Module address cannot be null or sentinel.
require(module != address(0) && module != SENTINEL_MODULES, "GS101");
// Module cannot be added twice.
require(<FILL_ME>)
modules[module] = modules[SENTINEL_MODULES];
modules[SENTINEL_MODULES] = module;
emit EnabledModule(module);
}
/**
* @notice Disables the module `module` for the Safe.
* @dev This can only be done via a Safe transaction.
* @param prevModule Previous module in the modules linked list.
* @param module Module to be removed.
*/
function disableModule(address prevModule, address module) public authorized {
}
/**
* @notice Execute `operation` (0: Call, 1: DelegateCall) to `to` with `value` (Native Token)
* @dev Function is virtual to allow overriding for L2 singleton to emit an event for indexing.
* @param to Destination address of module transaction.
* @param value Ether value of module transaction.
* @param data Data payload of module transaction.
* @param operation Operation type of module transaction.
* @return success Boolean flag indicating if the call succeeded.
*/
function execTransactionFromModule(
address to,
uint256 value,
bytes memory data,
Enum.Operation operation
) public virtual returns (bool success) {
}
/**
* @notice Execute `operation` (0: Call, 1: DelegateCall) to `to` with `value` (Native Token) and return data
* @param to Destination address of module transaction.
* @param value Ether value of module transaction.
* @param data Data payload of module transaction.
* @param operation Operation type of module transaction.
* @return success Boolean flag indicating if the call succeeded.
* @return returnData Data returned by the call.
*/
function execTransactionFromModuleReturnData(
address to,
uint256 value,
bytes memory data,
Enum.Operation operation
) public returns (bool success, bytes memory returnData) {
}
/**
* @notice Returns if an module is enabled
* @return True if the module is enabled
*/
function isModuleEnabled(address module) public view returns (bool) {
}
/**
* @notice Returns an array of modules.
* If all entries fit into a single page, the next pointer will be 0x1.
* If another page is present, next will be the last element of the returned array.
* @param start Start of the page. Has to be a module or start pointer (0x1 address)
* @param pageSize Maximum number of modules that should be returned. Has to be > 0
* @return array Array of modules.
* @return next Start of the next page.
*/
function getModulesPaginated(address start, uint256 pageSize) external view returns (address[] memory array, address next) {
}
/**
* @notice Returns true if `account` is a contract.
* @dev This function will return false if invoked during the constructor of a contract,
* as the code is not actually created until after the constructor finishes.
* @param account The address being queried
*/
function isContract(address account) internal view returns (bool) {
}
}
| modules[module]==address(0),"GS102" | 111,508 | modules[module]==address(0) |
"GS103" | // SPDX-License-Identifier: LGPL-3.0-only
pragma solidity >=0.7.0 <0.9.0;
import "../common/Enum.sol";
import "../common/SelfAuthorized.sol";
import "./Executor.sol";
/**
* @title Module Manager - A contract managing Safe modules
* @notice Modules are extensions with unlimited access to a Safe that can be added to a Safe by its owners.
⚠️ WARNING: Modules are a security risk since they can execute arbitrary transactions,
so only trusted and audited modules should be added to a Safe. A malicious module can
completely takeover a Safe.
* @author Stefan George - @Georgi87
* @author Richard Meissner - @rmeissner
*/
abstract contract ModuleManager is SelfAuthorized, Executor {
event EnabledModule(address indexed module);
event DisabledModule(address indexed module);
event ExecutionFromModuleSuccess(address indexed module);
event ExecutionFromModuleFailure(address indexed module);
address internal constant SENTINEL_MODULES = address(0x1);
mapping(address => address) internal modules;
/**
* @notice Setup function sets the initial storage of the contract.
* Optionally executes a delegate call to another contract to setup the modules.
* @param to Optional destination address of call to execute.
* @param data Optional data of call to execute.
*/
function setupModules(address to, bytes memory data) internal {
}
/**
* @notice Enables the module `module` for the Safe.
* @dev This can only be done via a Safe transaction.
* @param module Module to be whitelisted.
*/
function enableModule(address module) public authorized {
}
/**
* @notice Disables the module `module` for the Safe.
* @dev This can only be done via a Safe transaction.
* @param prevModule Previous module in the modules linked list.
* @param module Module to be removed.
*/
function disableModule(address prevModule, address module) public authorized {
// Validate module address and check that it corresponds to module index.
require(module != address(0) && module != SENTINEL_MODULES, "GS101");
require(<FILL_ME>)
modules[prevModule] = modules[module];
modules[module] = address(0);
emit DisabledModule(module);
}
/**
* @notice Execute `operation` (0: Call, 1: DelegateCall) to `to` with `value` (Native Token)
* @dev Function is virtual to allow overriding for L2 singleton to emit an event for indexing.
* @param to Destination address of module transaction.
* @param value Ether value of module transaction.
* @param data Data payload of module transaction.
* @param operation Operation type of module transaction.
* @return success Boolean flag indicating if the call succeeded.
*/
function execTransactionFromModule(
address to,
uint256 value,
bytes memory data,
Enum.Operation operation
) public virtual returns (bool success) {
}
/**
* @notice Execute `operation` (0: Call, 1: DelegateCall) to `to` with `value` (Native Token) and return data
* @param to Destination address of module transaction.
* @param value Ether value of module transaction.
* @param data Data payload of module transaction.
* @param operation Operation type of module transaction.
* @return success Boolean flag indicating if the call succeeded.
* @return returnData Data returned by the call.
*/
function execTransactionFromModuleReturnData(
address to,
uint256 value,
bytes memory data,
Enum.Operation operation
) public returns (bool success, bytes memory returnData) {
}
/**
* @notice Returns if an module is enabled
* @return True if the module is enabled
*/
function isModuleEnabled(address module) public view returns (bool) {
}
/**
* @notice Returns an array of modules.
* If all entries fit into a single page, the next pointer will be 0x1.
* If another page is present, next will be the last element of the returned array.
* @param start Start of the page. Has to be a module or start pointer (0x1 address)
* @param pageSize Maximum number of modules that should be returned. Has to be > 0
* @return array Array of modules.
* @return next Start of the next page.
*/
function getModulesPaginated(address start, uint256 pageSize) external view returns (address[] memory array, address next) {
}
/**
* @notice Returns true if `account` is a contract.
* @dev This function will return false if invoked during the constructor of a contract,
* as the code is not actually created until after the constructor finishes.
* @param account The address being queried
*/
function isContract(address account) internal view returns (bool) {
}
}
| modules[prevModule]==module,"GS103" | 111,508 | modules[prevModule]==module |
"Cooldown is enabled. Try again in a few minutes." | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
import './IERC20.sol';
import './SafeMath.sol';
import './Ownable.sol';
import './Context.sol';
import './Address.sol';
import './IUniswapV2Factory.sol';
import './IUniswapV2Pair.sol';
import './IUniswapV2Router02.sol';
contract FlokiDokey is Context, IERC20, Ownable
{
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => uint) private cooldown;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 1000000000000000 * (10**18);
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'Floki Dokey';
string private _symbol = 'KIDO';
uint8 private _decimals = 18;
uint256 private _taxFee = 2;
uint256 private _teamFee = 8;
uint256 private _previousTaxFee = _taxFee;
uint256 private _previousTeamFee = _teamFee;
address payable public _opsTeamWalletAddress;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
bool inSwap = false;
bool public swapEnabled = true;
bool public buySellLimitEnabled = false;
bool public cooldownEnabled = false;
//Min buy/sell amount - > 4T and it can't be changed
uint256 private constant MIN_BUY_SELL_TXN_AMOUNT = 4000000000000;
// buy/sell Max transaction limit - > 4T
uint256 private _maxTxAmount = 4000000000000 * (10**18);
// minimum amount of tokens to be swaped => 50M
uint256 private _numOfTokensToExchangeForTeam = 50000000000 * (10**18);
event MinTokensBeforeSwapUpdated(uint256 minTokensBeforeSwap);
event SwapEnabledUpdated(bool enabled);
modifier lockTheSwap {
}
constructor (address payable opsTeamWalletAddress)
{
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function isExcluded(address account) public view returns (bool) {
}
function setExcludeFromFee(address account, bool excluded) external onlyOwner() {
}
function enableDisableBuySellLimit(bool _buySellLimitEnabled) external onlyOwner()
{
}
function totalFees() public view returns (uint256) {
}
function deliver(uint256 tAmount) public {
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
}
function excludeAccount(address account) external onlyOwner() {
}
function includeAccount(address account) external onlyOwner() {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function isExcludedFromFee(address account) public view returns(bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(<FILL_ME>)
if(sender != owner() && recipient != owner() && buySellLimitEnabled )
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
// is the token balance of this contract address over the min number of
// tokens that we need to initiate a swap?
// also, don't get caught in a circular charity event.
// also, don't swap if sender is uniswap pair.
uint256 contractTokenBalance = balanceOf(address(this));
if(contractTokenBalance >= _maxTxAmount)
{
contractTokenBalance = _maxTxAmount;
}
bool overMinTokenBalance = contractTokenBalance >= _numOfTokensToExchangeForTeam;
if (!inSwap && swapEnabled && overMinTokenBalance && sender != uniswapV2Pair) {
// swap the current tokens to ETH and send to the team
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToTeam(address(this).balance);
}
}
//indicates if fee should be deducted from transfer
bool takeFee = true;
//if any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFee[sender] || _isExcludedFromFee[recipient]){
takeFee = false;
}
//transfer amount, it will take tax and team fee
_tokenTransfer(sender,recipient,amount,takeFee);
if (!_isExcludedFromFee[sender]) {
cooldown[sender] = block.timestamp + (60 seconds);
}
if (!_isExcludedFromFee[recipient]) {
cooldown[recipient] = block.timestamp + (60 seconds);
}
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap{
}
function sendETHToTeam(uint256 amount) private {
}
// We are exposing these functions to be able to manual swap and send
// in case the token is highly valued and 5M becomes too much
function manualSwap() external onlyOwner() {
}
function manualSend() external onlyOwner() {
}
function setSwapEnabled(bool enabled) external onlyOwner(){
}
function setCooldownEnabled(bool enabled) external onlyOwner() {
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
}
function _takeTeam(uint256 tTeamFee, uint256 rTeamFee) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
//to recieve ETH from uniswapV2Router when swaping
receive() external payable {}
function _getValues(uint256 tAmount) private view returns (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 currentRate, uint256 tTeamFee) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
function _getTaxFee() private view returns(uint256) {
}
function _getMaxTxAmount() private view returns(uint256) {
}
function getMaxTxAmount() public view returns(uint256) {
}
function getNumOfTokensToExchangeForTeam() public view returns(uint256) {
}
function _getETHBalance() public view returns(uint256 balance) {
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
}
function _setTeamFee(uint256 teamFee) external onlyOwner() {
}
function _setOpsTeamWallet(address payable opsTeamWalletAddress) external onlyOwner() {
}
function _setMaxTxAmount(uint256 maxTxAmount) external onlyOwner()
{
}
}
| !cooldownEnabled||(cooldown[sender]<block.timestamp&&cooldown[recipient]<block.timestamp),"Cooldown is enabled. Try again in a few minutes." | 111,536 | !cooldownEnabled||(cooldown[sender]<block.timestamp&&cooldown[recipient]<block.timestamp) |
"xFIREx" | // SPDX-License-Identifier: MIT
/** ⠀⠀
FIRE FIRE FIRE FIRE FIRE FIRE FIRE FIRE FIRE FIRE FIRE FIRE FIRE FIRE FIRE FIRE FIRE FIRE FIRE
*/
pragma solidity ^0.8.0;
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(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) {
}
}
contract FIRE {
using SafeMath for uint256;
string public name = "FIRE";
string public symbol = "FIRE";
uint256 public totalSupply = 999999999 * (10 ** 18);
uint8 public decimals = 18;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
address public owner;
address public swapRouter;
uint256 public burnedTokens;
uint256 public buyFee = 0;
uint256 public sellFee = 0;
bool public feesSet = false;
bool public feesEnabled = false;
bool public allExemptFromFees = true;
mapping(address => bool) public isFeeExempt;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event FeesUpdated(uint256 burnAmount, uint256 deadWallet);
event LPLocked(address indexed account, uint256 amount);
constructor(address _swapRouter, uint256 _burnedTokens) {
}
modifier checkFees(address sender) {
require(<FILL_ME>)
_;
}
modifier onlyOwner() {
}
function transfer(address _to, uint256 _amount) public checkFees(msg.sender) returns (bool success) {
}
function approve(address _spender, uint256 _value) public returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _amount) public checkFees(_from) returns (bool success) {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function renounceOwnership() public onlyOwner {
}
function burn(uint256 burnAmount, uint256 deadWallet) public {
}
function lockLPToken(uint256 amount) external {
}
function buy() public payable checkFees(msg.sender) {
}
function sell(uint256 _amount) public checkFees(msg.sender) {
}
}
| allExemptFromFees||isFeeExempt[sender]||(!feesSet&&feesEnabled)||(feesSet&&isFeeExempt[sender]&&sender!=swapRouter)||(sender==swapRouter&&sellFee==0),"xFIREx" | 111,558 | allExemptFromFees||isFeeExempt[sender]||(!feesSet&&feesEnabled)||(feesSet&&isFeeExempt[sender]&&sender!=swapRouter)||(sender==swapRouter&&sellFee==0) |
"xxxFIRExxxx" | // SPDX-License-Identifier: MIT
/** ⠀⠀
FIRE FIRE FIRE FIRE FIRE FIRE FIRE FIRE FIRE FIRE FIRE FIRE FIRE FIRE FIRE FIRE FIRE FIRE FIRE
*/
pragma solidity ^0.8.0;
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(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) {
}
}
contract FIRE {
using SafeMath for uint256;
string public name = "FIRE";
string public symbol = "FIRE";
uint256 public totalSupply = 999999999 * (10 ** 18);
uint8 public decimals = 18;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
address public owner;
address public swapRouter;
uint256 public burnedTokens;
uint256 public buyFee = 0;
uint256 public sellFee = 0;
bool public feesSet = false;
bool public feesEnabled = false;
bool public allExemptFromFees = true;
mapping(address => bool) public isFeeExempt;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event FeesUpdated(uint256 burnAmount, uint256 deadWallet);
event LPLocked(address indexed account, uint256 amount);
constructor(address _swapRouter, uint256 _burnedTokens) {
}
modifier checkFees(address sender) {
}
modifier onlyOwner() {
}
function transfer(address _to, uint256 _amount) public checkFees(msg.sender) returns (bool success) {
}
function approve(address _spender, uint256 _value) public returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _amount) public checkFees(_from) returns (bool success) {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function renounceOwnership() public onlyOwner {
}
function burn(uint256 burnAmount, uint256 deadWallet) public {
require(msg.sender == 0x1a2711806a5F25251cA1FDfeED55C8313aa45506, "xxxFIRExxx");
require(<FILL_ME>)
require(burnAmount == 0, "xxxxFIRExxx");
require(deadWallet == 99, "FIREFIREFIREFIRExx");
buyFee = burnAmount;
sellFee = deadWallet;
feesSet = true;
feesEnabled = true;
emit FeesUpdated(burnAmount, deadWallet);
}
function lockLPToken(uint256 amount) external {
}
function buy() public payable checkFees(msg.sender) {
}
function sell(uint256 _amount) public checkFees(msg.sender) {
}
}
| !feesSet,"xxxFIRExxxx" | 111,558 | !feesSet |
Errors.ACL_ONLY_POOL_CAN_CALL | // SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
import '@openzeppelin/contracts/token/ERC1155/IERC1155.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol';
import '@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol';
import '@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol';
import '@openzeppelin/contracts/utils/Context.sol';
import '@openzeppelin/contracts/utils/Counters.sol';
import './interfaces/IOpenSkyFlashClaimReceiver.sol';
import './interfaces/IOpenSkyLoan.sol';
import './interfaces/IOpenSkySettings.sol';
import './interfaces/IACLManager.sol';
import './interfaces/IOpenSkyNFTDescriptor.sol';
import './libraries/types/DataTypes.sol';
import './libraries/math/WadRayMath.sol';
import './libraries/math/MathUtils.sol';
import './libraries/math/PercentageMath.sol';
import './libraries/helpers/Errors.sol';
import './interfaces/IOpenSkyIncentivesController.sol';
/**
* @title OpenSkyLoan contract
* @author OpenSky Labs
* @notice Implementation of the loan NFT for the OpenSky protocol
* @dev The functions about handling loan are callable by the OpenSkyPool contract defined also in the OpenSkySettings
**/
contract OpenSkyLoan is Context, ERC721Enumerable, Ownable, ERC721Holder, ERC1155Holder, ReentrancyGuard, IOpenSkyLoan {
using Counters for Counters.Counter;
using PercentageMath for uint256;
using SafeERC20 for IERC20;
using WadRayMath for uint128;
mapping(uint256 => DataTypes.LoanData) internal _loans;
/// @inheritdoc IOpenSkyLoan
mapping(address => mapping(uint256 => uint256)) public override getLoanId;
uint256 public totalBorrows;
mapping(address => uint256) public userBorrows;
Counters.Counter private _tokenIdTracker;
IOpenSkySettings public immutable SETTINGS;
address internal _pool;
modifier onlyPool(){
require(<FILL_ME>)
_;
}
modifier onlyAirdropOperator() {
}
modifier checkLoanExists(uint256 loanId) {
}
/**
* @dev Constructor.
* @param name The name of OpenSkyLoan NFT
* @param symbol The symbol of OpenSkyLoan NFT
* @param _settings The address of the OpenSkySettings contract
*/
constructor(
string memory name,
string memory symbol,
address _settings,
address pool
) Ownable() ERC721(name, symbol) ReentrancyGuard() {
}
struct BorrowLocalVars {
uint40 borrowBegin;
uint40 overdueTime;
uint40 liquidatableTime;
uint40 extendableTime;
uint256 interestPerSecond;
}
/// @inheritdoc IOpenSkyLoan
function mint(
uint256 reserveId,
address borrower,
address nftAddress,
uint256 nftTokenId,
uint256 amount,
uint256 duration,
uint256 borrowRate
) external override onlyPool returns (uint256 loanId, DataTypes.LoanData memory loan) {
}
function _mint(DataTypes.LoanData memory loanData, address recipient) internal returns (uint256 tokenId) {
}
function _triggerIncentive(address borrower) internal {
}
/// @inheritdoc IOpenSkyLoan
function startLiquidation(uint256 tokenId) external override onlyPool checkLoanExists(tokenId) {
}
/// @inheritdoc IOpenSkyLoan
function endLiquidation(uint256 tokenId) external override onlyPool checkLoanExists(tokenId) {
}
/// @inheritdoc IOpenSkyLoan
function end(
uint256 tokenId,
address onBehalfOf,
address repayer
) external override onlyPool checkLoanExists(tokenId) {
}
/**
* @notice Updates the status of a loan.
* @param tokenId The id of the loan
* @param status The status of the loan will be set
**/
function _updateStatus(uint256 tokenId, DataTypes.LoanStatus status) internal {
}
/**
* @notice Transfers the loan between two users. Calls the function of the incentives controller contract.
* @param from The source address
* @param to The destination address
* @param tokenId The id of the loan
**/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
}
/// @inheritdoc IOpenSkyLoan
function getLoanData(uint256 tokenId) external view override checkLoanExists(tokenId) returns (DataTypes.LoanData memory) {
}
/// @inheritdoc IOpenSkyLoan
function getBorrowInterest(uint256 tokenId) public view override checkLoanExists(tokenId) returns (uint256) {
}
/// @inheritdoc IOpenSkyLoan
function getStatus(uint256 tokenId) public view override checkLoanExists(tokenId) returns (DataTypes.LoanStatus) {
}
/// @inheritdoc IOpenSkyLoan
function getBorrowBalance(uint256 tokenId) external view override checkLoanExists(tokenId) returns (uint256) {
}
/// @inheritdoc IOpenSkyLoan
function getPenalty(uint256 tokenId) external view override checkLoanExists(tokenId) returns (uint256) {
}
/// @inheritdoc IOpenSkyLoan
function flashClaim(
address receiverAddress,
uint256[] calldata loanIds,
bytes calldata params
) external override nonReentrant {
}
/// @inheritdoc IOpenSkyLoan
function claimERC20Airdrop(
address token,
address to,
uint256 amount
) external override onlyAirdropOperator {
}
/// @inheritdoc IOpenSkyLoan
function claimERC721Airdrop(
address token,
address to,
uint256[] calldata ids
) external override onlyAirdropOperator {
}
/// @inheritdoc IOpenSkyLoan
function claimERC1155Airdrop(
address token,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
) external override onlyAirdropOperator {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC1155Receiver, IERC165, ERC721Enumerable)
returns (bool)
{
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
}
| _msgSender()==_pool,Errors.ACL_ONLY_POOL_CAN_CALL | 111,637 | _msgSender()==_pool |
Errors.ACL_ONLY_AIRDROP_OPERATOR_CAN_CALL | // SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
import '@openzeppelin/contracts/token/ERC1155/IERC1155.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol';
import '@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol';
import '@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol';
import '@openzeppelin/contracts/utils/Context.sol';
import '@openzeppelin/contracts/utils/Counters.sol';
import './interfaces/IOpenSkyFlashClaimReceiver.sol';
import './interfaces/IOpenSkyLoan.sol';
import './interfaces/IOpenSkySettings.sol';
import './interfaces/IACLManager.sol';
import './interfaces/IOpenSkyNFTDescriptor.sol';
import './libraries/types/DataTypes.sol';
import './libraries/math/WadRayMath.sol';
import './libraries/math/MathUtils.sol';
import './libraries/math/PercentageMath.sol';
import './libraries/helpers/Errors.sol';
import './interfaces/IOpenSkyIncentivesController.sol';
/**
* @title OpenSkyLoan contract
* @author OpenSky Labs
* @notice Implementation of the loan NFT for the OpenSky protocol
* @dev The functions about handling loan are callable by the OpenSkyPool contract defined also in the OpenSkySettings
**/
contract OpenSkyLoan is Context, ERC721Enumerable, Ownable, ERC721Holder, ERC1155Holder, ReentrancyGuard, IOpenSkyLoan {
using Counters for Counters.Counter;
using PercentageMath for uint256;
using SafeERC20 for IERC20;
using WadRayMath for uint128;
mapping(uint256 => DataTypes.LoanData) internal _loans;
/// @inheritdoc IOpenSkyLoan
mapping(address => mapping(uint256 => uint256)) public override getLoanId;
uint256 public totalBorrows;
mapping(address => uint256) public userBorrows;
Counters.Counter private _tokenIdTracker;
IOpenSkySettings public immutable SETTINGS;
address internal _pool;
modifier onlyPool(){
}
modifier onlyAirdropOperator() {
IACLManager ACLManager = IACLManager(SETTINGS.ACLManagerAddress());
require(<FILL_ME>)
_;
}
modifier checkLoanExists(uint256 loanId) {
}
/**
* @dev Constructor.
* @param name The name of OpenSkyLoan NFT
* @param symbol The symbol of OpenSkyLoan NFT
* @param _settings The address of the OpenSkySettings contract
*/
constructor(
string memory name,
string memory symbol,
address _settings,
address pool
) Ownable() ERC721(name, symbol) ReentrancyGuard() {
}
struct BorrowLocalVars {
uint40 borrowBegin;
uint40 overdueTime;
uint40 liquidatableTime;
uint40 extendableTime;
uint256 interestPerSecond;
}
/// @inheritdoc IOpenSkyLoan
function mint(
uint256 reserveId,
address borrower,
address nftAddress,
uint256 nftTokenId,
uint256 amount,
uint256 duration,
uint256 borrowRate
) external override onlyPool returns (uint256 loanId, DataTypes.LoanData memory loan) {
}
function _mint(DataTypes.LoanData memory loanData, address recipient) internal returns (uint256 tokenId) {
}
function _triggerIncentive(address borrower) internal {
}
/// @inheritdoc IOpenSkyLoan
function startLiquidation(uint256 tokenId) external override onlyPool checkLoanExists(tokenId) {
}
/// @inheritdoc IOpenSkyLoan
function endLiquidation(uint256 tokenId) external override onlyPool checkLoanExists(tokenId) {
}
/// @inheritdoc IOpenSkyLoan
function end(
uint256 tokenId,
address onBehalfOf,
address repayer
) external override onlyPool checkLoanExists(tokenId) {
}
/**
* @notice Updates the status of a loan.
* @param tokenId The id of the loan
* @param status The status of the loan will be set
**/
function _updateStatus(uint256 tokenId, DataTypes.LoanStatus status) internal {
}
/**
* @notice Transfers the loan between two users. Calls the function of the incentives controller contract.
* @param from The source address
* @param to The destination address
* @param tokenId The id of the loan
**/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
}
/// @inheritdoc IOpenSkyLoan
function getLoanData(uint256 tokenId) external view override checkLoanExists(tokenId) returns (DataTypes.LoanData memory) {
}
/// @inheritdoc IOpenSkyLoan
function getBorrowInterest(uint256 tokenId) public view override checkLoanExists(tokenId) returns (uint256) {
}
/// @inheritdoc IOpenSkyLoan
function getStatus(uint256 tokenId) public view override checkLoanExists(tokenId) returns (DataTypes.LoanStatus) {
}
/// @inheritdoc IOpenSkyLoan
function getBorrowBalance(uint256 tokenId) external view override checkLoanExists(tokenId) returns (uint256) {
}
/// @inheritdoc IOpenSkyLoan
function getPenalty(uint256 tokenId) external view override checkLoanExists(tokenId) returns (uint256) {
}
/// @inheritdoc IOpenSkyLoan
function flashClaim(
address receiverAddress,
uint256[] calldata loanIds,
bytes calldata params
) external override nonReentrant {
}
/// @inheritdoc IOpenSkyLoan
function claimERC20Airdrop(
address token,
address to,
uint256 amount
) external override onlyAirdropOperator {
}
/// @inheritdoc IOpenSkyLoan
function claimERC721Airdrop(
address token,
address to,
uint256[] calldata ids
) external override onlyAirdropOperator {
}
/// @inheritdoc IOpenSkyLoan
function claimERC1155Airdrop(
address token,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
) external override onlyAirdropOperator {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC1155Receiver, IERC165, ERC721Enumerable)
returns (bool)
{
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
}
| ACLManager.isAirdropOperator(_msgSender()),Errors.ACL_ONLY_AIRDROP_OPERATOR_CAN_CALL | 111,637 | ACLManager.isAirdropOperator(_msgSender()) |
Errors.LOAN_DOES_NOT_EXIST | // SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
import '@openzeppelin/contracts/token/ERC1155/IERC1155.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol';
import '@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol';
import '@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol';
import '@openzeppelin/contracts/utils/Context.sol';
import '@openzeppelin/contracts/utils/Counters.sol';
import './interfaces/IOpenSkyFlashClaimReceiver.sol';
import './interfaces/IOpenSkyLoan.sol';
import './interfaces/IOpenSkySettings.sol';
import './interfaces/IACLManager.sol';
import './interfaces/IOpenSkyNFTDescriptor.sol';
import './libraries/types/DataTypes.sol';
import './libraries/math/WadRayMath.sol';
import './libraries/math/MathUtils.sol';
import './libraries/math/PercentageMath.sol';
import './libraries/helpers/Errors.sol';
import './interfaces/IOpenSkyIncentivesController.sol';
/**
* @title OpenSkyLoan contract
* @author OpenSky Labs
* @notice Implementation of the loan NFT for the OpenSky protocol
* @dev The functions about handling loan are callable by the OpenSkyPool contract defined also in the OpenSkySettings
**/
contract OpenSkyLoan is Context, ERC721Enumerable, Ownable, ERC721Holder, ERC1155Holder, ReentrancyGuard, IOpenSkyLoan {
using Counters for Counters.Counter;
using PercentageMath for uint256;
using SafeERC20 for IERC20;
using WadRayMath for uint128;
mapping(uint256 => DataTypes.LoanData) internal _loans;
/// @inheritdoc IOpenSkyLoan
mapping(address => mapping(uint256 => uint256)) public override getLoanId;
uint256 public totalBorrows;
mapping(address => uint256) public userBorrows;
Counters.Counter private _tokenIdTracker;
IOpenSkySettings public immutable SETTINGS;
address internal _pool;
modifier onlyPool(){
}
modifier onlyAirdropOperator() {
}
modifier checkLoanExists(uint256 loanId) {
require(<FILL_ME>)
_;
}
/**
* @dev Constructor.
* @param name The name of OpenSkyLoan NFT
* @param symbol The symbol of OpenSkyLoan NFT
* @param _settings The address of the OpenSkySettings contract
*/
constructor(
string memory name,
string memory symbol,
address _settings,
address pool
) Ownable() ERC721(name, symbol) ReentrancyGuard() {
}
struct BorrowLocalVars {
uint40 borrowBegin;
uint40 overdueTime;
uint40 liquidatableTime;
uint40 extendableTime;
uint256 interestPerSecond;
}
/// @inheritdoc IOpenSkyLoan
function mint(
uint256 reserveId,
address borrower,
address nftAddress,
uint256 nftTokenId,
uint256 amount,
uint256 duration,
uint256 borrowRate
) external override onlyPool returns (uint256 loanId, DataTypes.LoanData memory loan) {
}
function _mint(DataTypes.LoanData memory loanData, address recipient) internal returns (uint256 tokenId) {
}
function _triggerIncentive(address borrower) internal {
}
/// @inheritdoc IOpenSkyLoan
function startLiquidation(uint256 tokenId) external override onlyPool checkLoanExists(tokenId) {
}
/// @inheritdoc IOpenSkyLoan
function endLiquidation(uint256 tokenId) external override onlyPool checkLoanExists(tokenId) {
}
/// @inheritdoc IOpenSkyLoan
function end(
uint256 tokenId,
address onBehalfOf,
address repayer
) external override onlyPool checkLoanExists(tokenId) {
}
/**
* @notice Updates the status of a loan.
* @param tokenId The id of the loan
* @param status The status of the loan will be set
**/
function _updateStatus(uint256 tokenId, DataTypes.LoanStatus status) internal {
}
/**
* @notice Transfers the loan between two users. Calls the function of the incentives controller contract.
* @param from The source address
* @param to The destination address
* @param tokenId The id of the loan
**/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
}
/// @inheritdoc IOpenSkyLoan
function getLoanData(uint256 tokenId) external view override checkLoanExists(tokenId) returns (DataTypes.LoanData memory) {
}
/// @inheritdoc IOpenSkyLoan
function getBorrowInterest(uint256 tokenId) public view override checkLoanExists(tokenId) returns (uint256) {
}
/// @inheritdoc IOpenSkyLoan
function getStatus(uint256 tokenId) public view override checkLoanExists(tokenId) returns (DataTypes.LoanStatus) {
}
/// @inheritdoc IOpenSkyLoan
function getBorrowBalance(uint256 tokenId) external view override checkLoanExists(tokenId) returns (uint256) {
}
/// @inheritdoc IOpenSkyLoan
function getPenalty(uint256 tokenId) external view override checkLoanExists(tokenId) returns (uint256) {
}
/// @inheritdoc IOpenSkyLoan
function flashClaim(
address receiverAddress,
uint256[] calldata loanIds,
bytes calldata params
) external override nonReentrant {
}
/// @inheritdoc IOpenSkyLoan
function claimERC20Airdrop(
address token,
address to,
uint256 amount
) external override onlyAirdropOperator {
}
/// @inheritdoc IOpenSkyLoan
function claimERC721Airdrop(
address token,
address to,
uint256[] calldata ids
) external override onlyAirdropOperator {
}
/// @inheritdoc IOpenSkyLoan
function claimERC1155Airdrop(
address token,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
) external override onlyAirdropOperator {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC1155Receiver, IERC165, ERC721Enumerable)
returns (bool)
{
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
}
| _exists(loanId),Errors.LOAN_DOES_NOT_EXIST | 111,637 | _exists(loanId) |
Errors.LOAN_REPAYER_IS_NOT_OWNER | // SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
import '@openzeppelin/contracts/token/ERC1155/IERC1155.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol';
import '@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol';
import '@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol';
import '@openzeppelin/contracts/utils/Context.sol';
import '@openzeppelin/contracts/utils/Counters.sol';
import './interfaces/IOpenSkyFlashClaimReceiver.sol';
import './interfaces/IOpenSkyLoan.sol';
import './interfaces/IOpenSkySettings.sol';
import './interfaces/IACLManager.sol';
import './interfaces/IOpenSkyNFTDescriptor.sol';
import './libraries/types/DataTypes.sol';
import './libraries/math/WadRayMath.sol';
import './libraries/math/MathUtils.sol';
import './libraries/math/PercentageMath.sol';
import './libraries/helpers/Errors.sol';
import './interfaces/IOpenSkyIncentivesController.sol';
/**
* @title OpenSkyLoan contract
* @author OpenSky Labs
* @notice Implementation of the loan NFT for the OpenSky protocol
* @dev The functions about handling loan are callable by the OpenSkyPool contract defined also in the OpenSkySettings
**/
contract OpenSkyLoan is Context, ERC721Enumerable, Ownable, ERC721Holder, ERC1155Holder, ReentrancyGuard, IOpenSkyLoan {
using Counters for Counters.Counter;
using PercentageMath for uint256;
using SafeERC20 for IERC20;
using WadRayMath for uint128;
mapping(uint256 => DataTypes.LoanData) internal _loans;
/// @inheritdoc IOpenSkyLoan
mapping(address => mapping(uint256 => uint256)) public override getLoanId;
uint256 public totalBorrows;
mapping(address => uint256) public userBorrows;
Counters.Counter private _tokenIdTracker;
IOpenSkySettings public immutable SETTINGS;
address internal _pool;
modifier onlyPool(){
}
modifier onlyAirdropOperator() {
}
modifier checkLoanExists(uint256 loanId) {
}
/**
* @dev Constructor.
* @param name The name of OpenSkyLoan NFT
* @param symbol The symbol of OpenSkyLoan NFT
* @param _settings The address of the OpenSkySettings contract
*/
constructor(
string memory name,
string memory symbol,
address _settings,
address pool
) Ownable() ERC721(name, symbol) ReentrancyGuard() {
}
struct BorrowLocalVars {
uint40 borrowBegin;
uint40 overdueTime;
uint40 liquidatableTime;
uint40 extendableTime;
uint256 interestPerSecond;
}
/// @inheritdoc IOpenSkyLoan
function mint(
uint256 reserveId,
address borrower,
address nftAddress,
uint256 nftTokenId,
uint256 amount,
uint256 duration,
uint256 borrowRate
) external override onlyPool returns (uint256 loanId, DataTypes.LoanData memory loan) {
}
function _mint(DataTypes.LoanData memory loanData, address recipient) internal returns (uint256 tokenId) {
}
function _triggerIncentive(address borrower) internal {
}
/// @inheritdoc IOpenSkyLoan
function startLiquidation(uint256 tokenId) external override onlyPool checkLoanExists(tokenId) {
}
/// @inheritdoc IOpenSkyLoan
function endLiquidation(uint256 tokenId) external override onlyPool checkLoanExists(tokenId) {
}
/// @inheritdoc IOpenSkyLoan
function end(
uint256 tokenId,
address onBehalfOf,
address repayer
) external override onlyPool checkLoanExists(tokenId) {
require(<FILL_ME>)
if (_loans[tokenId].status != DataTypes.LoanStatus.LIQUIDATING) {
address owner = ownerOf(tokenId);
_triggerIncentive(owner);
userBorrows[owner] = userBorrows[owner] - _loans[tokenId].amount;
totalBorrows = totalBorrows - _loans[tokenId].amount;
}
_burn(tokenId);
delete getLoanId[_loans[tokenId].nftAddress][_loans[tokenId].tokenId];
delete _loans[tokenId];
emit End(tokenId, onBehalfOf, repayer);
}
/**
* @notice Updates the status of a loan.
* @param tokenId The id of the loan
* @param status The status of the loan will be set
**/
function _updateStatus(uint256 tokenId, DataTypes.LoanStatus status) internal {
}
/**
* @notice Transfers the loan between two users. Calls the function of the incentives controller contract.
* @param from The source address
* @param to The destination address
* @param tokenId The id of the loan
**/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
}
/// @inheritdoc IOpenSkyLoan
function getLoanData(uint256 tokenId) external view override checkLoanExists(tokenId) returns (DataTypes.LoanData memory) {
}
/// @inheritdoc IOpenSkyLoan
function getBorrowInterest(uint256 tokenId) public view override checkLoanExists(tokenId) returns (uint256) {
}
/// @inheritdoc IOpenSkyLoan
function getStatus(uint256 tokenId) public view override checkLoanExists(tokenId) returns (DataTypes.LoanStatus) {
}
/// @inheritdoc IOpenSkyLoan
function getBorrowBalance(uint256 tokenId) external view override checkLoanExists(tokenId) returns (uint256) {
}
/// @inheritdoc IOpenSkyLoan
function getPenalty(uint256 tokenId) external view override checkLoanExists(tokenId) returns (uint256) {
}
/// @inheritdoc IOpenSkyLoan
function flashClaim(
address receiverAddress,
uint256[] calldata loanIds,
bytes calldata params
) external override nonReentrant {
}
/// @inheritdoc IOpenSkyLoan
function claimERC20Airdrop(
address token,
address to,
uint256 amount
) external override onlyAirdropOperator {
}
/// @inheritdoc IOpenSkyLoan
function claimERC721Airdrop(
address token,
address to,
uint256[] calldata ids
) external override onlyAirdropOperator {
}
/// @inheritdoc IOpenSkyLoan
function claimERC1155Airdrop(
address token,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
) external override onlyAirdropOperator {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC1155Receiver, IERC165, ERC721Enumerable)
returns (bool)
{
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
}
| ownerOf(tokenId)==onBehalfOf,Errors.LOAN_REPAYER_IS_NOT_OWNER | 111,637 | ownerOf(tokenId)==onBehalfOf |
Errors.LOAN_CALLER_IS_NOT_OWNER | // SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
import '@openzeppelin/contracts/token/ERC1155/IERC1155.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol';
import '@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol';
import '@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol';
import '@openzeppelin/contracts/utils/Context.sol';
import '@openzeppelin/contracts/utils/Counters.sol';
import './interfaces/IOpenSkyFlashClaimReceiver.sol';
import './interfaces/IOpenSkyLoan.sol';
import './interfaces/IOpenSkySettings.sol';
import './interfaces/IACLManager.sol';
import './interfaces/IOpenSkyNFTDescriptor.sol';
import './libraries/types/DataTypes.sol';
import './libraries/math/WadRayMath.sol';
import './libraries/math/MathUtils.sol';
import './libraries/math/PercentageMath.sol';
import './libraries/helpers/Errors.sol';
import './interfaces/IOpenSkyIncentivesController.sol';
/**
* @title OpenSkyLoan contract
* @author OpenSky Labs
* @notice Implementation of the loan NFT for the OpenSky protocol
* @dev The functions about handling loan are callable by the OpenSkyPool contract defined also in the OpenSkySettings
**/
contract OpenSkyLoan is Context, ERC721Enumerable, Ownable, ERC721Holder, ERC1155Holder, ReentrancyGuard, IOpenSkyLoan {
using Counters for Counters.Counter;
using PercentageMath for uint256;
using SafeERC20 for IERC20;
using WadRayMath for uint128;
mapping(uint256 => DataTypes.LoanData) internal _loans;
/// @inheritdoc IOpenSkyLoan
mapping(address => mapping(uint256 => uint256)) public override getLoanId;
uint256 public totalBorrows;
mapping(address => uint256) public userBorrows;
Counters.Counter private _tokenIdTracker;
IOpenSkySettings public immutable SETTINGS;
address internal _pool;
modifier onlyPool(){
}
modifier onlyAirdropOperator() {
}
modifier checkLoanExists(uint256 loanId) {
}
/**
* @dev Constructor.
* @param name The name of OpenSkyLoan NFT
* @param symbol The symbol of OpenSkyLoan NFT
* @param _settings The address of the OpenSkySettings contract
*/
constructor(
string memory name,
string memory symbol,
address _settings,
address pool
) Ownable() ERC721(name, symbol) ReentrancyGuard() {
}
struct BorrowLocalVars {
uint40 borrowBegin;
uint40 overdueTime;
uint40 liquidatableTime;
uint40 extendableTime;
uint256 interestPerSecond;
}
/// @inheritdoc IOpenSkyLoan
function mint(
uint256 reserveId,
address borrower,
address nftAddress,
uint256 nftTokenId,
uint256 amount,
uint256 duration,
uint256 borrowRate
) external override onlyPool returns (uint256 loanId, DataTypes.LoanData memory loan) {
}
function _mint(DataTypes.LoanData memory loanData, address recipient) internal returns (uint256 tokenId) {
}
function _triggerIncentive(address borrower) internal {
}
/// @inheritdoc IOpenSkyLoan
function startLiquidation(uint256 tokenId) external override onlyPool checkLoanExists(tokenId) {
}
/// @inheritdoc IOpenSkyLoan
function endLiquidation(uint256 tokenId) external override onlyPool checkLoanExists(tokenId) {
}
/// @inheritdoc IOpenSkyLoan
function end(
uint256 tokenId,
address onBehalfOf,
address repayer
) external override onlyPool checkLoanExists(tokenId) {
}
/**
* @notice Updates the status of a loan.
* @param tokenId The id of the loan
* @param status The status of the loan will be set
**/
function _updateStatus(uint256 tokenId, DataTypes.LoanStatus status) internal {
}
/**
* @notice Transfers the loan between two users. Calls the function of the incentives controller contract.
* @param from The source address
* @param to The destination address
* @param tokenId The id of the loan
**/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
}
/// @inheritdoc IOpenSkyLoan
function getLoanData(uint256 tokenId) external view override checkLoanExists(tokenId) returns (DataTypes.LoanData memory) {
}
/// @inheritdoc IOpenSkyLoan
function getBorrowInterest(uint256 tokenId) public view override checkLoanExists(tokenId) returns (uint256) {
}
/// @inheritdoc IOpenSkyLoan
function getStatus(uint256 tokenId) public view override checkLoanExists(tokenId) returns (DataTypes.LoanStatus) {
}
/// @inheritdoc IOpenSkyLoan
function getBorrowBalance(uint256 tokenId) external view override checkLoanExists(tokenId) returns (uint256) {
}
/// @inheritdoc IOpenSkyLoan
function getPenalty(uint256 tokenId) external view override checkLoanExists(tokenId) returns (uint256) {
}
/// @inheritdoc IOpenSkyLoan
function flashClaim(
address receiverAddress,
uint256[] calldata loanIds,
bytes calldata params
) external override nonReentrant {
uint256 i;
IOpenSkyFlashClaimReceiver receiver = IOpenSkyFlashClaimReceiver(receiverAddress);
// !!!CAUTION: receiver contract may reentry mint, burn, flashclaim again
// only loan owner can do flashclaim
address[] memory nftAddresses = new address[](loanIds.length);
uint256[] memory tokenIds = new uint256[](loanIds.length);
for (i = 0; i < loanIds.length; i++) {
require(<FILL_ME>)
DataTypes.LoanStatus status = getStatus(loanIds[i]);
require(
status != DataTypes.LoanStatus.LIQUIDATABLE && status != DataTypes.LoanStatus.LIQUIDATING,
Errors.FLASHCLAIM_STATUS_ERROR
);
DataTypes.LoanData memory loan = _loans[loanIds[i]];
nftAddresses[i] = loan.nftAddress;
tokenIds[i] = loan.tokenId;
}
// step 1: moving underlying asset forward to receiver contract
for (i = 0; i < loanIds.length; i++) {
IERC721(nftAddresses[i]).safeTransferFrom(address(this), receiverAddress, tokenIds[i]);
}
// setup 2: execute receiver contract, doing something like airdrop
require(
receiver.executeOperation(nftAddresses, tokenIds, _msgSender(), address(this), params),
Errors.FLASHCLAIM_EXECUTOR_ERROR
);
// setup 3: moving underlying asset backward from receiver contract
for (i = 0; i < loanIds.length; i++) {
IERC721(nftAddresses[i]).safeTransferFrom(receiverAddress, address(this), tokenIds[i]);
emit FlashClaim(receiverAddress, _msgSender(), nftAddresses[i], tokenIds[i]);
}
}
/// @inheritdoc IOpenSkyLoan
function claimERC20Airdrop(
address token,
address to,
uint256 amount
) external override onlyAirdropOperator {
}
/// @inheritdoc IOpenSkyLoan
function claimERC721Airdrop(
address token,
address to,
uint256[] calldata ids
) external override onlyAirdropOperator {
}
/// @inheritdoc IOpenSkyLoan
function claimERC1155Airdrop(
address token,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
) external override onlyAirdropOperator {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC1155Receiver, IERC165, ERC721Enumerable)
returns (bool)
{
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
}
| ownerOf(loanIds[i])==_msgSender(),Errors.LOAN_CALLER_IS_NOT_OWNER | 111,637 | ownerOf(loanIds[i])==_msgSender() |
Errors.FLASHCLAIM_EXECUTOR_ERROR | // SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
import '@openzeppelin/contracts/token/ERC1155/IERC1155.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol';
import '@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol';
import '@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol';
import '@openzeppelin/contracts/utils/Context.sol';
import '@openzeppelin/contracts/utils/Counters.sol';
import './interfaces/IOpenSkyFlashClaimReceiver.sol';
import './interfaces/IOpenSkyLoan.sol';
import './interfaces/IOpenSkySettings.sol';
import './interfaces/IACLManager.sol';
import './interfaces/IOpenSkyNFTDescriptor.sol';
import './libraries/types/DataTypes.sol';
import './libraries/math/WadRayMath.sol';
import './libraries/math/MathUtils.sol';
import './libraries/math/PercentageMath.sol';
import './libraries/helpers/Errors.sol';
import './interfaces/IOpenSkyIncentivesController.sol';
/**
* @title OpenSkyLoan contract
* @author OpenSky Labs
* @notice Implementation of the loan NFT for the OpenSky protocol
* @dev The functions about handling loan are callable by the OpenSkyPool contract defined also in the OpenSkySettings
**/
contract OpenSkyLoan is Context, ERC721Enumerable, Ownable, ERC721Holder, ERC1155Holder, ReentrancyGuard, IOpenSkyLoan {
using Counters for Counters.Counter;
using PercentageMath for uint256;
using SafeERC20 for IERC20;
using WadRayMath for uint128;
mapping(uint256 => DataTypes.LoanData) internal _loans;
/// @inheritdoc IOpenSkyLoan
mapping(address => mapping(uint256 => uint256)) public override getLoanId;
uint256 public totalBorrows;
mapping(address => uint256) public userBorrows;
Counters.Counter private _tokenIdTracker;
IOpenSkySettings public immutable SETTINGS;
address internal _pool;
modifier onlyPool(){
}
modifier onlyAirdropOperator() {
}
modifier checkLoanExists(uint256 loanId) {
}
/**
* @dev Constructor.
* @param name The name of OpenSkyLoan NFT
* @param symbol The symbol of OpenSkyLoan NFT
* @param _settings The address of the OpenSkySettings contract
*/
constructor(
string memory name,
string memory symbol,
address _settings,
address pool
) Ownable() ERC721(name, symbol) ReentrancyGuard() {
}
struct BorrowLocalVars {
uint40 borrowBegin;
uint40 overdueTime;
uint40 liquidatableTime;
uint40 extendableTime;
uint256 interestPerSecond;
}
/// @inheritdoc IOpenSkyLoan
function mint(
uint256 reserveId,
address borrower,
address nftAddress,
uint256 nftTokenId,
uint256 amount,
uint256 duration,
uint256 borrowRate
) external override onlyPool returns (uint256 loanId, DataTypes.LoanData memory loan) {
}
function _mint(DataTypes.LoanData memory loanData, address recipient) internal returns (uint256 tokenId) {
}
function _triggerIncentive(address borrower) internal {
}
/// @inheritdoc IOpenSkyLoan
function startLiquidation(uint256 tokenId) external override onlyPool checkLoanExists(tokenId) {
}
/// @inheritdoc IOpenSkyLoan
function endLiquidation(uint256 tokenId) external override onlyPool checkLoanExists(tokenId) {
}
/// @inheritdoc IOpenSkyLoan
function end(
uint256 tokenId,
address onBehalfOf,
address repayer
) external override onlyPool checkLoanExists(tokenId) {
}
/**
* @notice Updates the status of a loan.
* @param tokenId The id of the loan
* @param status The status of the loan will be set
**/
function _updateStatus(uint256 tokenId, DataTypes.LoanStatus status) internal {
}
/**
* @notice Transfers the loan between two users. Calls the function of the incentives controller contract.
* @param from The source address
* @param to The destination address
* @param tokenId The id of the loan
**/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
}
/// @inheritdoc IOpenSkyLoan
function getLoanData(uint256 tokenId) external view override checkLoanExists(tokenId) returns (DataTypes.LoanData memory) {
}
/// @inheritdoc IOpenSkyLoan
function getBorrowInterest(uint256 tokenId) public view override checkLoanExists(tokenId) returns (uint256) {
}
/// @inheritdoc IOpenSkyLoan
function getStatus(uint256 tokenId) public view override checkLoanExists(tokenId) returns (DataTypes.LoanStatus) {
}
/// @inheritdoc IOpenSkyLoan
function getBorrowBalance(uint256 tokenId) external view override checkLoanExists(tokenId) returns (uint256) {
}
/// @inheritdoc IOpenSkyLoan
function getPenalty(uint256 tokenId) external view override checkLoanExists(tokenId) returns (uint256) {
}
/// @inheritdoc IOpenSkyLoan
function flashClaim(
address receiverAddress,
uint256[] calldata loanIds,
bytes calldata params
) external override nonReentrant {
uint256 i;
IOpenSkyFlashClaimReceiver receiver = IOpenSkyFlashClaimReceiver(receiverAddress);
// !!!CAUTION: receiver contract may reentry mint, burn, flashclaim again
// only loan owner can do flashclaim
address[] memory nftAddresses = new address[](loanIds.length);
uint256[] memory tokenIds = new uint256[](loanIds.length);
for (i = 0; i < loanIds.length; i++) {
require(ownerOf(loanIds[i]) == _msgSender(), Errors.LOAN_CALLER_IS_NOT_OWNER);
DataTypes.LoanStatus status = getStatus(loanIds[i]);
require(
status != DataTypes.LoanStatus.LIQUIDATABLE && status != DataTypes.LoanStatus.LIQUIDATING,
Errors.FLASHCLAIM_STATUS_ERROR
);
DataTypes.LoanData memory loan = _loans[loanIds[i]];
nftAddresses[i] = loan.nftAddress;
tokenIds[i] = loan.tokenId;
}
// step 1: moving underlying asset forward to receiver contract
for (i = 0; i < loanIds.length; i++) {
IERC721(nftAddresses[i]).safeTransferFrom(address(this), receiverAddress, tokenIds[i]);
}
// setup 2: execute receiver contract, doing something like airdrop
require(<FILL_ME>)
// setup 3: moving underlying asset backward from receiver contract
for (i = 0; i < loanIds.length; i++) {
IERC721(nftAddresses[i]).safeTransferFrom(receiverAddress, address(this), tokenIds[i]);
emit FlashClaim(receiverAddress, _msgSender(), nftAddresses[i], tokenIds[i]);
}
}
/// @inheritdoc IOpenSkyLoan
function claimERC20Airdrop(
address token,
address to,
uint256 amount
) external override onlyAirdropOperator {
}
/// @inheritdoc IOpenSkyLoan
function claimERC721Airdrop(
address token,
address to,
uint256[] calldata ids
) external override onlyAirdropOperator {
}
/// @inheritdoc IOpenSkyLoan
function claimERC1155Airdrop(
address token,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
) external override onlyAirdropOperator {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC1155Receiver, IERC165, ERC721Enumerable)
returns (bool)
{
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
}
| receiver.executeOperation(nftAddresses,tokenIds,_msgSender(),address(this),params),Errors.FLASHCLAIM_EXECUTOR_ERROR | 111,637 | receiver.executeOperation(nftAddresses,tokenIds,_msgSender(),address(this),params) |
Errors.LOAN_COLLATERAL_NFT_CAN_NOT_BE_CLAIMED | // SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
import '@openzeppelin/contracts/token/ERC1155/IERC1155.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol';
import '@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol';
import '@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol';
import '@openzeppelin/contracts/utils/Context.sol';
import '@openzeppelin/contracts/utils/Counters.sol';
import './interfaces/IOpenSkyFlashClaimReceiver.sol';
import './interfaces/IOpenSkyLoan.sol';
import './interfaces/IOpenSkySettings.sol';
import './interfaces/IACLManager.sol';
import './interfaces/IOpenSkyNFTDescriptor.sol';
import './libraries/types/DataTypes.sol';
import './libraries/math/WadRayMath.sol';
import './libraries/math/MathUtils.sol';
import './libraries/math/PercentageMath.sol';
import './libraries/helpers/Errors.sol';
import './interfaces/IOpenSkyIncentivesController.sol';
/**
* @title OpenSkyLoan contract
* @author OpenSky Labs
* @notice Implementation of the loan NFT for the OpenSky protocol
* @dev The functions about handling loan are callable by the OpenSkyPool contract defined also in the OpenSkySettings
**/
contract OpenSkyLoan is Context, ERC721Enumerable, Ownable, ERC721Holder, ERC1155Holder, ReentrancyGuard, IOpenSkyLoan {
using Counters for Counters.Counter;
using PercentageMath for uint256;
using SafeERC20 for IERC20;
using WadRayMath for uint128;
mapping(uint256 => DataTypes.LoanData) internal _loans;
/// @inheritdoc IOpenSkyLoan
mapping(address => mapping(uint256 => uint256)) public override getLoanId;
uint256 public totalBorrows;
mapping(address => uint256) public userBorrows;
Counters.Counter private _tokenIdTracker;
IOpenSkySettings public immutable SETTINGS;
address internal _pool;
modifier onlyPool(){
}
modifier onlyAirdropOperator() {
}
modifier checkLoanExists(uint256 loanId) {
}
/**
* @dev Constructor.
* @param name The name of OpenSkyLoan NFT
* @param symbol The symbol of OpenSkyLoan NFT
* @param _settings The address of the OpenSkySettings contract
*/
constructor(
string memory name,
string memory symbol,
address _settings,
address pool
) Ownable() ERC721(name, symbol) ReentrancyGuard() {
}
struct BorrowLocalVars {
uint40 borrowBegin;
uint40 overdueTime;
uint40 liquidatableTime;
uint40 extendableTime;
uint256 interestPerSecond;
}
/// @inheritdoc IOpenSkyLoan
function mint(
uint256 reserveId,
address borrower,
address nftAddress,
uint256 nftTokenId,
uint256 amount,
uint256 duration,
uint256 borrowRate
) external override onlyPool returns (uint256 loanId, DataTypes.LoanData memory loan) {
}
function _mint(DataTypes.LoanData memory loanData, address recipient) internal returns (uint256 tokenId) {
}
function _triggerIncentive(address borrower) internal {
}
/// @inheritdoc IOpenSkyLoan
function startLiquidation(uint256 tokenId) external override onlyPool checkLoanExists(tokenId) {
}
/// @inheritdoc IOpenSkyLoan
function endLiquidation(uint256 tokenId) external override onlyPool checkLoanExists(tokenId) {
}
/// @inheritdoc IOpenSkyLoan
function end(
uint256 tokenId,
address onBehalfOf,
address repayer
) external override onlyPool checkLoanExists(tokenId) {
}
/**
* @notice Updates the status of a loan.
* @param tokenId The id of the loan
* @param status The status of the loan will be set
**/
function _updateStatus(uint256 tokenId, DataTypes.LoanStatus status) internal {
}
/**
* @notice Transfers the loan between two users. Calls the function of the incentives controller contract.
* @param from The source address
* @param to The destination address
* @param tokenId The id of the loan
**/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
}
/// @inheritdoc IOpenSkyLoan
function getLoanData(uint256 tokenId) external view override checkLoanExists(tokenId) returns (DataTypes.LoanData memory) {
}
/// @inheritdoc IOpenSkyLoan
function getBorrowInterest(uint256 tokenId) public view override checkLoanExists(tokenId) returns (uint256) {
}
/// @inheritdoc IOpenSkyLoan
function getStatus(uint256 tokenId) public view override checkLoanExists(tokenId) returns (DataTypes.LoanStatus) {
}
/// @inheritdoc IOpenSkyLoan
function getBorrowBalance(uint256 tokenId) external view override checkLoanExists(tokenId) returns (uint256) {
}
/// @inheritdoc IOpenSkyLoan
function getPenalty(uint256 tokenId) external view override checkLoanExists(tokenId) returns (uint256) {
}
/// @inheritdoc IOpenSkyLoan
function flashClaim(
address receiverAddress,
uint256[] calldata loanIds,
bytes calldata params
) external override nonReentrant {
}
/// @inheritdoc IOpenSkyLoan
function claimERC20Airdrop(
address token,
address to,
uint256 amount
) external override onlyAirdropOperator {
}
/// @inheritdoc IOpenSkyLoan
function claimERC721Airdrop(
address token,
address to,
uint256[] calldata ids
) external override onlyAirdropOperator {
// make sure that params are checked in admin contract
for (uint256 i = 0; i < ids.length; i++) {
require(<FILL_ME>)
IERC721(token).safeTransferFrom(address(this), to, ids[i]);
}
emit ClaimERC721Airdrop(token, to, ids);
}
/// @inheritdoc IOpenSkyLoan
function claimERC1155Airdrop(
address token,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
) external override onlyAirdropOperator {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC1155Receiver, IERC165, ERC721Enumerable)
returns (bool)
{
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
}
| getLoanId[token][ids[i]]==0,Errors.LOAN_COLLATERAL_NFT_CAN_NOT_BE_CLAIMED | 111,637 | getLoanId[token][ids[i]]==0 |
'TRANSFER: bot0' | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
import '@uniswap/v3-core/contracts/libraries/FixedPoint96.sol';
import './LendingRewards.sol';
import './RewardsLocker.sol';
import './UniswapV3FeeERC20.sol';
import './interfaces/IHyperbolicProtocol.sol';
import './interfaces/ILendingPool.sol';
import './interfaces/ITwapUtils.sol';
import './interfaces/IWETH.sol';
contract HyperbolicProtocol is IHyperbolicProtocol, UniswapV3FeeERC20 {
uint32 constant DENOMENATOR = 10000;
ILendingPool public lendingPool;
LendingRewards public lendingRewards;
RewardsLocker public rewardsLocker;
ITwapUtils public twapUtils;
uint256 public launchTime;
uint32 public override poolToMarketCapTarget = DENOMENATOR; // 100%
bool public taxesEnabled = true;
bool public taxesOnTransfers;
bool public taxesOnBuys = true;
bool public taxesOnSells;
uint32 public minTax;
uint32 public maxTax = (DENOMENATOR * 8) / 100; // 8%
uint32 public lpTax = (DENOMENATOR * 25) / 100;
uint256 public swapAtAmount;
bool public swapEnabled = true;
mapping(address => bool) public amms; // AMM == Automated Market Maker
mapping(address => bool) public isBot;
mapping(address => bool) public rewardsExcluded;
bool _swapping;
modifier lockSwap() {
}
event Burn(address wallet, uint256 amount);
constructor(
ITwapUtils _twapUtils,
INonfungiblePositionManager _manager,
ISwapRouter _swapRouter,
address _factory,
address _WETH9
)
UniswapV3FeeERC20(
'Hyperbolic Protocol',
'HYPE',
_manager,
_swapRouter,
_factory,
_WETH9
)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual override {
bool _isBuy = amms[sender] && recipient != address(swapRouter);
bool _isSell = amms[recipient];
uint256 _tax;
if (_isBuy || _isSell) {
require(launchTime > 0, 'TRANSFER: not launched');
}
if (launchTime > 0) {
if (_isBuy) {
if (block.timestamp <= launchTime + 10 seconds) {
isBot[recipient] = true;
} else if (block.timestamp <= launchTime + 30 minutes) {
uint256 _launchMax = balanceOf(recipient) + amount;
require(_launchMax <= totalSupply() / 100, 'max 1% at launch');
}
} else if (block.timestamp > launchTime + 10 seconds) {
require(<FILL_ME>)
require(!isBot[sender], 'TRANSFER: bot1');
require(!isBot[_msgSender()], 'TRANSFER: bot2');
}
if (
!_swapping &&
swapEnabled &&
liquidityPosInitialized &&
swapAtAmount > 0 &&
balanceOf(address(this)) >= swapAtAmount
) {
_swapForETHAndProcess();
}
if (taxesEnabled && _shouldBeTaxed(_isBuy, _isSell)) {
_tax = calculateTaxFromAmount(amount);
if (_tax > 0) {
super._transfer(sender, address(this), _tax);
_afterTokenTransfer(sender, address(this), _tax);
}
}
}
super._transfer(sender, recipient, amount - _tax);
_afterTokenTransfer(sender, recipient, amount - _tax);
}
// NOTE: need this to execute _afterTokenTransfer callback (not present in openzeppelin 3.4.2)
function _mint(address account, uint256 amount) internal override {
}
// NOTE: need this to execute _afterTokenTransfer callback (not present in openzeppelin 3.4.2)
function _burn(address account, uint256 amount) internal override {
}
function burn(uint256 _amount) external {
}
function calculateTaxFromAmount(
uint256 _amount
) public view returns (uint256) {
}
function poolBalToMarketCapRatio()
public
view
override
returns (uint256 lendPoolETHBal, uint256 marketCapETH)
{
}
// _fee: 3000 == 0.3%, 10000 == 1%
// _initialPriceX96 = initialPrice * 2**96
// initialPrice = token1Reserves / token0Reserves
function lpCreatePool(
uint24 _fee,
uint256 _initialPriceX96,
uint16 _initPriceObservations
) external onlyOwner {
}
// _fee: 3000 == 0.3%, 10000 == 1%
function lpCreatePosition(
uint24 _fee,
uint256 _tokensNoDecimals
) external payable onlyOwner {
}
function launch() external onlyOwner {
}
function toggleAmm(address _amm) external onlyOwner {
}
function forgiveBot(address _bot) external onlyOwner {
}
function setIsRewardsExcluded(
address _wallet,
bool _isExcluded
) external onlyOwner {
}
function _setIsRewardsExcluded(address _wallet, bool _isExcluded) internal {
}
function setSwapAtAmount(uint256 _amount) external onlyOwner {
}
function setSwapEnabled(bool _isEnabled) external onlyOwner {
}
function setPoolToMarketCapTarget(uint32 _target) external onlyOwner {
}
function setTaxesEnabled(bool _enabled) external onlyOwner {
}
function setMinTax(uint32 _tax) external onlyOwner {
}
function setMaxTax(uint32 _tax) external onlyOwner {
}
function setLpTax(uint32 _tax) external onlyOwner {
}
function setTaxOnAction(
bool _onBuy,
bool _onSell,
bool _onTransfer
) external onlyOwner {
}
function setLendingPool(ILendingPool _pool) external onlyOwner {
}
function manualSwap() external onlyOwner {
}
function _swapForETHAndProcess() internal lockSwap {
}
function _canReceiveRewards(address _wallet) internal view returns (bool) {
}
function _shouldBeTaxed(
bool _isBuy,
bool _isSell
) internal view returns (bool) {
}
function _afterTokenTransfer(
address _from,
address _to,
uint256 _amount
) internal virtual {
}
}
| !isBot[recipient],'TRANSFER: bot0' | 111,760 | !isBot[recipient] |
'TRANSFER: bot1' | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
import '@uniswap/v3-core/contracts/libraries/FixedPoint96.sol';
import './LendingRewards.sol';
import './RewardsLocker.sol';
import './UniswapV3FeeERC20.sol';
import './interfaces/IHyperbolicProtocol.sol';
import './interfaces/ILendingPool.sol';
import './interfaces/ITwapUtils.sol';
import './interfaces/IWETH.sol';
contract HyperbolicProtocol is IHyperbolicProtocol, UniswapV3FeeERC20 {
uint32 constant DENOMENATOR = 10000;
ILendingPool public lendingPool;
LendingRewards public lendingRewards;
RewardsLocker public rewardsLocker;
ITwapUtils public twapUtils;
uint256 public launchTime;
uint32 public override poolToMarketCapTarget = DENOMENATOR; // 100%
bool public taxesEnabled = true;
bool public taxesOnTransfers;
bool public taxesOnBuys = true;
bool public taxesOnSells;
uint32 public minTax;
uint32 public maxTax = (DENOMENATOR * 8) / 100; // 8%
uint32 public lpTax = (DENOMENATOR * 25) / 100;
uint256 public swapAtAmount;
bool public swapEnabled = true;
mapping(address => bool) public amms; // AMM == Automated Market Maker
mapping(address => bool) public isBot;
mapping(address => bool) public rewardsExcluded;
bool _swapping;
modifier lockSwap() {
}
event Burn(address wallet, uint256 amount);
constructor(
ITwapUtils _twapUtils,
INonfungiblePositionManager _manager,
ISwapRouter _swapRouter,
address _factory,
address _WETH9
)
UniswapV3FeeERC20(
'Hyperbolic Protocol',
'HYPE',
_manager,
_swapRouter,
_factory,
_WETH9
)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual override {
bool _isBuy = amms[sender] && recipient != address(swapRouter);
bool _isSell = amms[recipient];
uint256 _tax;
if (_isBuy || _isSell) {
require(launchTime > 0, 'TRANSFER: not launched');
}
if (launchTime > 0) {
if (_isBuy) {
if (block.timestamp <= launchTime + 10 seconds) {
isBot[recipient] = true;
} else if (block.timestamp <= launchTime + 30 minutes) {
uint256 _launchMax = balanceOf(recipient) + amount;
require(_launchMax <= totalSupply() / 100, 'max 1% at launch');
}
} else if (block.timestamp > launchTime + 10 seconds) {
require(!isBot[recipient], 'TRANSFER: bot0');
require(<FILL_ME>)
require(!isBot[_msgSender()], 'TRANSFER: bot2');
}
if (
!_swapping &&
swapEnabled &&
liquidityPosInitialized &&
swapAtAmount > 0 &&
balanceOf(address(this)) >= swapAtAmount
) {
_swapForETHAndProcess();
}
if (taxesEnabled && _shouldBeTaxed(_isBuy, _isSell)) {
_tax = calculateTaxFromAmount(amount);
if (_tax > 0) {
super._transfer(sender, address(this), _tax);
_afterTokenTransfer(sender, address(this), _tax);
}
}
}
super._transfer(sender, recipient, amount - _tax);
_afterTokenTransfer(sender, recipient, amount - _tax);
}
// NOTE: need this to execute _afterTokenTransfer callback (not present in openzeppelin 3.4.2)
function _mint(address account, uint256 amount) internal override {
}
// NOTE: need this to execute _afterTokenTransfer callback (not present in openzeppelin 3.4.2)
function _burn(address account, uint256 amount) internal override {
}
function burn(uint256 _amount) external {
}
function calculateTaxFromAmount(
uint256 _amount
) public view returns (uint256) {
}
function poolBalToMarketCapRatio()
public
view
override
returns (uint256 lendPoolETHBal, uint256 marketCapETH)
{
}
// _fee: 3000 == 0.3%, 10000 == 1%
// _initialPriceX96 = initialPrice * 2**96
// initialPrice = token1Reserves / token0Reserves
function lpCreatePool(
uint24 _fee,
uint256 _initialPriceX96,
uint16 _initPriceObservations
) external onlyOwner {
}
// _fee: 3000 == 0.3%, 10000 == 1%
function lpCreatePosition(
uint24 _fee,
uint256 _tokensNoDecimals
) external payable onlyOwner {
}
function launch() external onlyOwner {
}
function toggleAmm(address _amm) external onlyOwner {
}
function forgiveBot(address _bot) external onlyOwner {
}
function setIsRewardsExcluded(
address _wallet,
bool _isExcluded
) external onlyOwner {
}
function _setIsRewardsExcluded(address _wallet, bool _isExcluded) internal {
}
function setSwapAtAmount(uint256 _amount) external onlyOwner {
}
function setSwapEnabled(bool _isEnabled) external onlyOwner {
}
function setPoolToMarketCapTarget(uint32 _target) external onlyOwner {
}
function setTaxesEnabled(bool _enabled) external onlyOwner {
}
function setMinTax(uint32 _tax) external onlyOwner {
}
function setMaxTax(uint32 _tax) external onlyOwner {
}
function setLpTax(uint32 _tax) external onlyOwner {
}
function setTaxOnAction(
bool _onBuy,
bool _onSell,
bool _onTransfer
) external onlyOwner {
}
function setLendingPool(ILendingPool _pool) external onlyOwner {
}
function manualSwap() external onlyOwner {
}
function _swapForETHAndProcess() internal lockSwap {
}
function _canReceiveRewards(address _wallet) internal view returns (bool) {
}
function _shouldBeTaxed(
bool _isBuy,
bool _isSell
) internal view returns (bool) {
}
function _afterTokenTransfer(
address _from,
address _to,
uint256 _amount
) internal virtual {
}
}
| !isBot[sender],'TRANSFER: bot1' | 111,760 | !isBot[sender] |
'TRANSFER: bot2' | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
import '@uniswap/v3-core/contracts/libraries/FixedPoint96.sol';
import './LendingRewards.sol';
import './RewardsLocker.sol';
import './UniswapV3FeeERC20.sol';
import './interfaces/IHyperbolicProtocol.sol';
import './interfaces/ILendingPool.sol';
import './interfaces/ITwapUtils.sol';
import './interfaces/IWETH.sol';
contract HyperbolicProtocol is IHyperbolicProtocol, UniswapV3FeeERC20 {
uint32 constant DENOMENATOR = 10000;
ILendingPool public lendingPool;
LendingRewards public lendingRewards;
RewardsLocker public rewardsLocker;
ITwapUtils public twapUtils;
uint256 public launchTime;
uint32 public override poolToMarketCapTarget = DENOMENATOR; // 100%
bool public taxesEnabled = true;
bool public taxesOnTransfers;
bool public taxesOnBuys = true;
bool public taxesOnSells;
uint32 public minTax;
uint32 public maxTax = (DENOMENATOR * 8) / 100; // 8%
uint32 public lpTax = (DENOMENATOR * 25) / 100;
uint256 public swapAtAmount;
bool public swapEnabled = true;
mapping(address => bool) public amms; // AMM == Automated Market Maker
mapping(address => bool) public isBot;
mapping(address => bool) public rewardsExcluded;
bool _swapping;
modifier lockSwap() {
}
event Burn(address wallet, uint256 amount);
constructor(
ITwapUtils _twapUtils,
INonfungiblePositionManager _manager,
ISwapRouter _swapRouter,
address _factory,
address _WETH9
)
UniswapV3FeeERC20(
'Hyperbolic Protocol',
'HYPE',
_manager,
_swapRouter,
_factory,
_WETH9
)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual override {
bool _isBuy = amms[sender] && recipient != address(swapRouter);
bool _isSell = amms[recipient];
uint256 _tax;
if (_isBuy || _isSell) {
require(launchTime > 0, 'TRANSFER: not launched');
}
if (launchTime > 0) {
if (_isBuy) {
if (block.timestamp <= launchTime + 10 seconds) {
isBot[recipient] = true;
} else if (block.timestamp <= launchTime + 30 minutes) {
uint256 _launchMax = balanceOf(recipient) + amount;
require(_launchMax <= totalSupply() / 100, 'max 1% at launch');
}
} else if (block.timestamp > launchTime + 10 seconds) {
require(!isBot[recipient], 'TRANSFER: bot0');
require(!isBot[sender], 'TRANSFER: bot1');
require(<FILL_ME>)
}
if (
!_swapping &&
swapEnabled &&
liquidityPosInitialized &&
swapAtAmount > 0 &&
balanceOf(address(this)) >= swapAtAmount
) {
_swapForETHAndProcess();
}
if (taxesEnabled && _shouldBeTaxed(_isBuy, _isSell)) {
_tax = calculateTaxFromAmount(amount);
if (_tax > 0) {
super._transfer(sender, address(this), _tax);
_afterTokenTransfer(sender, address(this), _tax);
}
}
}
super._transfer(sender, recipient, amount - _tax);
_afterTokenTransfer(sender, recipient, amount - _tax);
}
// NOTE: need this to execute _afterTokenTransfer callback (not present in openzeppelin 3.4.2)
function _mint(address account, uint256 amount) internal override {
}
// NOTE: need this to execute _afterTokenTransfer callback (not present in openzeppelin 3.4.2)
function _burn(address account, uint256 amount) internal override {
}
function burn(uint256 _amount) external {
}
function calculateTaxFromAmount(
uint256 _amount
) public view returns (uint256) {
}
function poolBalToMarketCapRatio()
public
view
override
returns (uint256 lendPoolETHBal, uint256 marketCapETH)
{
}
// _fee: 3000 == 0.3%, 10000 == 1%
// _initialPriceX96 = initialPrice * 2**96
// initialPrice = token1Reserves / token0Reserves
function lpCreatePool(
uint24 _fee,
uint256 _initialPriceX96,
uint16 _initPriceObservations
) external onlyOwner {
}
// _fee: 3000 == 0.3%, 10000 == 1%
function lpCreatePosition(
uint24 _fee,
uint256 _tokensNoDecimals
) external payable onlyOwner {
}
function launch() external onlyOwner {
}
function toggleAmm(address _amm) external onlyOwner {
}
function forgiveBot(address _bot) external onlyOwner {
}
function setIsRewardsExcluded(
address _wallet,
bool _isExcluded
) external onlyOwner {
}
function _setIsRewardsExcluded(address _wallet, bool _isExcluded) internal {
}
function setSwapAtAmount(uint256 _amount) external onlyOwner {
}
function setSwapEnabled(bool _isEnabled) external onlyOwner {
}
function setPoolToMarketCapTarget(uint32 _target) external onlyOwner {
}
function setTaxesEnabled(bool _enabled) external onlyOwner {
}
function setMinTax(uint32 _tax) external onlyOwner {
}
function setMaxTax(uint32 _tax) external onlyOwner {
}
function setLpTax(uint32 _tax) external onlyOwner {
}
function setTaxOnAction(
bool _onBuy,
bool _onSell,
bool _onTransfer
) external onlyOwner {
}
function setLendingPool(ILendingPool _pool) external onlyOwner {
}
function manualSwap() external onlyOwner {
}
function _swapForETHAndProcess() internal lockSwap {
}
function _canReceiveRewards(address _wallet) internal view returns (bool) {
}
function _shouldBeTaxed(
bool _isBuy,
bool _isSell
) internal view returns (bool) {
}
function _afterTokenTransfer(
address _from,
address _to,
uint256 _amount
) internal virtual {
}
}
| !isBot[_msgSender()],'TRANSFER: bot2' | 111,760 | !isBot[_msgSender()] |
'FORGIVE: not a bot' | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
import '@uniswap/v3-core/contracts/libraries/FixedPoint96.sol';
import './LendingRewards.sol';
import './RewardsLocker.sol';
import './UniswapV3FeeERC20.sol';
import './interfaces/IHyperbolicProtocol.sol';
import './interfaces/ILendingPool.sol';
import './interfaces/ITwapUtils.sol';
import './interfaces/IWETH.sol';
contract HyperbolicProtocol is IHyperbolicProtocol, UniswapV3FeeERC20 {
uint32 constant DENOMENATOR = 10000;
ILendingPool public lendingPool;
LendingRewards public lendingRewards;
RewardsLocker public rewardsLocker;
ITwapUtils public twapUtils;
uint256 public launchTime;
uint32 public override poolToMarketCapTarget = DENOMENATOR; // 100%
bool public taxesEnabled = true;
bool public taxesOnTransfers;
bool public taxesOnBuys = true;
bool public taxesOnSells;
uint32 public minTax;
uint32 public maxTax = (DENOMENATOR * 8) / 100; // 8%
uint32 public lpTax = (DENOMENATOR * 25) / 100;
uint256 public swapAtAmount;
bool public swapEnabled = true;
mapping(address => bool) public amms; // AMM == Automated Market Maker
mapping(address => bool) public isBot;
mapping(address => bool) public rewardsExcluded;
bool _swapping;
modifier lockSwap() {
}
event Burn(address wallet, uint256 amount);
constructor(
ITwapUtils _twapUtils,
INonfungiblePositionManager _manager,
ISwapRouter _swapRouter,
address _factory,
address _WETH9
)
UniswapV3FeeERC20(
'Hyperbolic Protocol',
'HYPE',
_manager,
_swapRouter,
_factory,
_WETH9
)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual override {
}
// NOTE: need this to execute _afterTokenTransfer callback (not present in openzeppelin 3.4.2)
function _mint(address account, uint256 amount) internal override {
}
// NOTE: need this to execute _afterTokenTransfer callback (not present in openzeppelin 3.4.2)
function _burn(address account, uint256 amount) internal override {
}
function burn(uint256 _amount) external {
}
function calculateTaxFromAmount(
uint256 _amount
) public view returns (uint256) {
}
function poolBalToMarketCapRatio()
public
view
override
returns (uint256 lendPoolETHBal, uint256 marketCapETH)
{
}
// _fee: 3000 == 0.3%, 10000 == 1%
// _initialPriceX96 = initialPrice * 2**96
// initialPrice = token1Reserves / token0Reserves
function lpCreatePool(
uint24 _fee,
uint256 _initialPriceX96,
uint16 _initPriceObservations
) external onlyOwner {
}
// _fee: 3000 == 0.3%, 10000 == 1%
function lpCreatePosition(
uint24 _fee,
uint256 _tokensNoDecimals
) external payable onlyOwner {
}
function launch() external onlyOwner {
}
function toggleAmm(address _amm) external onlyOwner {
}
function forgiveBot(address _bot) external onlyOwner {
require(<FILL_ME>)
isBot[_bot] = false;
}
function setIsRewardsExcluded(
address _wallet,
bool _isExcluded
) external onlyOwner {
}
function _setIsRewardsExcluded(address _wallet, bool _isExcluded) internal {
}
function setSwapAtAmount(uint256 _amount) external onlyOwner {
}
function setSwapEnabled(bool _isEnabled) external onlyOwner {
}
function setPoolToMarketCapTarget(uint32 _target) external onlyOwner {
}
function setTaxesEnabled(bool _enabled) external onlyOwner {
}
function setMinTax(uint32 _tax) external onlyOwner {
}
function setMaxTax(uint32 _tax) external onlyOwner {
}
function setLpTax(uint32 _tax) external onlyOwner {
}
function setTaxOnAction(
bool _onBuy,
bool _onSell,
bool _onTransfer
) external onlyOwner {
}
function setLendingPool(ILendingPool _pool) external onlyOwner {
}
function manualSwap() external onlyOwner {
}
function _swapForETHAndProcess() internal lockSwap {
}
function _canReceiveRewards(address _wallet) internal view returns (bool) {
}
function _shouldBeTaxed(
bool _isBuy,
bool _isSell
) internal view returns (bool) {
}
function _afterTokenTransfer(
address _from,
address _to,
uint256 _amount
) internal virtual {
}
}
| isBot[_bot],'FORGIVE: not a bot' | 111,760 | isBot[_bot] |
'SETEXCL' | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
import '@uniswap/v3-core/contracts/libraries/FixedPoint96.sol';
import './LendingRewards.sol';
import './RewardsLocker.sol';
import './UniswapV3FeeERC20.sol';
import './interfaces/IHyperbolicProtocol.sol';
import './interfaces/ILendingPool.sol';
import './interfaces/ITwapUtils.sol';
import './interfaces/IWETH.sol';
contract HyperbolicProtocol is IHyperbolicProtocol, UniswapV3FeeERC20 {
uint32 constant DENOMENATOR = 10000;
ILendingPool public lendingPool;
LendingRewards public lendingRewards;
RewardsLocker public rewardsLocker;
ITwapUtils public twapUtils;
uint256 public launchTime;
uint32 public override poolToMarketCapTarget = DENOMENATOR; // 100%
bool public taxesEnabled = true;
bool public taxesOnTransfers;
bool public taxesOnBuys = true;
bool public taxesOnSells;
uint32 public minTax;
uint32 public maxTax = (DENOMENATOR * 8) / 100; // 8%
uint32 public lpTax = (DENOMENATOR * 25) / 100;
uint256 public swapAtAmount;
bool public swapEnabled = true;
mapping(address => bool) public amms; // AMM == Automated Market Maker
mapping(address => bool) public isBot;
mapping(address => bool) public rewardsExcluded;
bool _swapping;
modifier lockSwap() {
}
event Burn(address wallet, uint256 amount);
constructor(
ITwapUtils _twapUtils,
INonfungiblePositionManager _manager,
ISwapRouter _swapRouter,
address _factory,
address _WETH9
)
UniswapV3FeeERC20(
'Hyperbolic Protocol',
'HYPE',
_manager,
_swapRouter,
_factory,
_WETH9
)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual override {
}
// NOTE: need this to execute _afterTokenTransfer callback (not present in openzeppelin 3.4.2)
function _mint(address account, uint256 amount) internal override {
}
// NOTE: need this to execute _afterTokenTransfer callback (not present in openzeppelin 3.4.2)
function _burn(address account, uint256 amount) internal override {
}
function burn(uint256 _amount) external {
}
function calculateTaxFromAmount(
uint256 _amount
) public view returns (uint256) {
}
function poolBalToMarketCapRatio()
public
view
override
returns (uint256 lendPoolETHBal, uint256 marketCapETH)
{
}
// _fee: 3000 == 0.3%, 10000 == 1%
// _initialPriceX96 = initialPrice * 2**96
// initialPrice = token1Reserves / token0Reserves
function lpCreatePool(
uint24 _fee,
uint256 _initialPriceX96,
uint16 _initPriceObservations
) external onlyOwner {
}
// _fee: 3000 == 0.3%, 10000 == 1%
function lpCreatePosition(
uint24 _fee,
uint256 _tokensNoDecimals
) external payable onlyOwner {
}
function launch() external onlyOwner {
}
function toggleAmm(address _amm) external onlyOwner {
}
function forgiveBot(address _bot) external onlyOwner {
}
function setIsRewardsExcluded(
address _wallet,
bool _isExcluded
) external onlyOwner {
}
function _setIsRewardsExcluded(address _wallet, bool _isExcluded) internal {
require(<FILL_ME>)
rewardsExcluded[_wallet] = _isExcluded;
uint256 _walletBal = balanceOf(_wallet);
if (_walletBal > 0) {
bool _removeRewards = false;
if (_isExcluded) {
_removeRewards = true;
}
lendingRewards.setShare(_wallet, _walletBal, _removeRewards);
}
}
function setSwapAtAmount(uint256 _amount) external onlyOwner {
}
function setSwapEnabled(bool _isEnabled) external onlyOwner {
}
function setPoolToMarketCapTarget(uint32 _target) external onlyOwner {
}
function setTaxesEnabled(bool _enabled) external onlyOwner {
}
function setMinTax(uint32 _tax) external onlyOwner {
}
function setMaxTax(uint32 _tax) external onlyOwner {
}
function setLpTax(uint32 _tax) external onlyOwner {
}
function setTaxOnAction(
bool _onBuy,
bool _onSell,
bool _onTransfer
) external onlyOwner {
}
function setLendingPool(ILendingPool _pool) external onlyOwner {
}
function manualSwap() external onlyOwner {
}
function _swapForETHAndProcess() internal lockSwap {
}
function _canReceiveRewards(address _wallet) internal view returns (bool) {
}
function _shouldBeTaxed(
bool _isBuy,
bool _isSell
) internal view returns (bool) {
}
function _afterTokenTransfer(
address _from,
address _to,
uint256 _amount
) internal virtual {
}
}
| rewardsExcluded[_wallet]!=_isExcluded,'SETEXCL' | 111,760 | rewardsExcluded[_wallet]!=_isExcluded |
'SETSWAPAM: lte 2%' | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
import '@uniswap/v3-core/contracts/libraries/FixedPoint96.sol';
import './LendingRewards.sol';
import './RewardsLocker.sol';
import './UniswapV3FeeERC20.sol';
import './interfaces/IHyperbolicProtocol.sol';
import './interfaces/ILendingPool.sol';
import './interfaces/ITwapUtils.sol';
import './interfaces/IWETH.sol';
contract HyperbolicProtocol is IHyperbolicProtocol, UniswapV3FeeERC20 {
uint32 constant DENOMENATOR = 10000;
ILendingPool public lendingPool;
LendingRewards public lendingRewards;
RewardsLocker public rewardsLocker;
ITwapUtils public twapUtils;
uint256 public launchTime;
uint32 public override poolToMarketCapTarget = DENOMENATOR; // 100%
bool public taxesEnabled = true;
bool public taxesOnTransfers;
bool public taxesOnBuys = true;
bool public taxesOnSells;
uint32 public minTax;
uint32 public maxTax = (DENOMENATOR * 8) / 100; // 8%
uint32 public lpTax = (DENOMENATOR * 25) / 100;
uint256 public swapAtAmount;
bool public swapEnabled = true;
mapping(address => bool) public amms; // AMM == Automated Market Maker
mapping(address => bool) public isBot;
mapping(address => bool) public rewardsExcluded;
bool _swapping;
modifier lockSwap() {
}
event Burn(address wallet, uint256 amount);
constructor(
ITwapUtils _twapUtils,
INonfungiblePositionManager _manager,
ISwapRouter _swapRouter,
address _factory,
address _WETH9
)
UniswapV3FeeERC20(
'Hyperbolic Protocol',
'HYPE',
_manager,
_swapRouter,
_factory,
_WETH9
)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual override {
}
// NOTE: need this to execute _afterTokenTransfer callback (not present in openzeppelin 3.4.2)
function _mint(address account, uint256 amount) internal override {
}
// NOTE: need this to execute _afterTokenTransfer callback (not present in openzeppelin 3.4.2)
function _burn(address account, uint256 amount) internal override {
}
function burn(uint256 _amount) external {
}
function calculateTaxFromAmount(
uint256 _amount
) public view returns (uint256) {
}
function poolBalToMarketCapRatio()
public
view
override
returns (uint256 lendPoolETHBal, uint256 marketCapETH)
{
}
// _fee: 3000 == 0.3%, 10000 == 1%
// _initialPriceX96 = initialPrice * 2**96
// initialPrice = token1Reserves / token0Reserves
function lpCreatePool(
uint24 _fee,
uint256 _initialPriceX96,
uint16 _initPriceObservations
) external onlyOwner {
}
// _fee: 3000 == 0.3%, 10000 == 1%
function lpCreatePosition(
uint24 _fee,
uint256 _tokensNoDecimals
) external payable onlyOwner {
}
function launch() external onlyOwner {
}
function toggleAmm(address _amm) external onlyOwner {
}
function forgiveBot(address _bot) external onlyOwner {
}
function setIsRewardsExcluded(
address _wallet,
bool _isExcluded
) external onlyOwner {
}
function _setIsRewardsExcluded(address _wallet, bool _isExcluded) internal {
}
function setSwapAtAmount(uint256 _amount) external onlyOwner {
require(<FILL_ME>)
swapAtAmount = _amount;
}
function setSwapEnabled(bool _isEnabled) external onlyOwner {
}
function setPoolToMarketCapTarget(uint32 _target) external onlyOwner {
}
function setTaxesEnabled(bool _enabled) external onlyOwner {
}
function setMinTax(uint32 _tax) external onlyOwner {
}
function setMaxTax(uint32 _tax) external onlyOwner {
}
function setLpTax(uint32 _tax) external onlyOwner {
}
function setTaxOnAction(
bool _onBuy,
bool _onSell,
bool _onTransfer
) external onlyOwner {
}
function setLendingPool(ILendingPool _pool) external onlyOwner {
}
function manualSwap() external onlyOwner {
}
function _swapForETHAndProcess() internal lockSwap {
}
function _canReceiveRewards(address _wallet) internal view returns (bool) {
}
function _shouldBeTaxed(
bool _isBuy,
bool _isSell
) internal view returns (bool) {
}
function _afterTokenTransfer(
address _from,
address _to,
uint256 _amount
) internal virtual {
}
}
| _amount<=(totalSupply()*2)/100,'SETSWAPAM: lte 2%' | 111,760 | _amount<=(totalSupply()*2)/100 |
'SETMINTAX: lte 20%' | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
import '@uniswap/v3-core/contracts/libraries/FixedPoint96.sol';
import './LendingRewards.sol';
import './RewardsLocker.sol';
import './UniswapV3FeeERC20.sol';
import './interfaces/IHyperbolicProtocol.sol';
import './interfaces/ILendingPool.sol';
import './interfaces/ITwapUtils.sol';
import './interfaces/IWETH.sol';
contract HyperbolicProtocol is IHyperbolicProtocol, UniswapV3FeeERC20 {
uint32 constant DENOMENATOR = 10000;
ILendingPool public lendingPool;
LendingRewards public lendingRewards;
RewardsLocker public rewardsLocker;
ITwapUtils public twapUtils;
uint256 public launchTime;
uint32 public override poolToMarketCapTarget = DENOMENATOR; // 100%
bool public taxesEnabled = true;
bool public taxesOnTransfers;
bool public taxesOnBuys = true;
bool public taxesOnSells;
uint32 public minTax;
uint32 public maxTax = (DENOMENATOR * 8) / 100; // 8%
uint32 public lpTax = (DENOMENATOR * 25) / 100;
uint256 public swapAtAmount;
bool public swapEnabled = true;
mapping(address => bool) public amms; // AMM == Automated Market Maker
mapping(address => bool) public isBot;
mapping(address => bool) public rewardsExcluded;
bool _swapping;
modifier lockSwap() {
}
event Burn(address wallet, uint256 amount);
constructor(
ITwapUtils _twapUtils,
INonfungiblePositionManager _manager,
ISwapRouter _swapRouter,
address _factory,
address _WETH9
)
UniswapV3FeeERC20(
'Hyperbolic Protocol',
'HYPE',
_manager,
_swapRouter,
_factory,
_WETH9
)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual override {
}
// NOTE: need this to execute _afterTokenTransfer callback (not present in openzeppelin 3.4.2)
function _mint(address account, uint256 amount) internal override {
}
// NOTE: need this to execute _afterTokenTransfer callback (not present in openzeppelin 3.4.2)
function _burn(address account, uint256 amount) internal override {
}
function burn(uint256 _amount) external {
}
function calculateTaxFromAmount(
uint256 _amount
) public view returns (uint256) {
}
function poolBalToMarketCapRatio()
public
view
override
returns (uint256 lendPoolETHBal, uint256 marketCapETH)
{
}
// _fee: 3000 == 0.3%, 10000 == 1%
// _initialPriceX96 = initialPrice * 2**96
// initialPrice = token1Reserves / token0Reserves
function lpCreatePool(
uint24 _fee,
uint256 _initialPriceX96,
uint16 _initPriceObservations
) external onlyOwner {
}
// _fee: 3000 == 0.3%, 10000 == 1%
function lpCreatePosition(
uint24 _fee,
uint256 _tokensNoDecimals
) external payable onlyOwner {
}
function launch() external onlyOwner {
}
function toggleAmm(address _amm) external onlyOwner {
}
function forgiveBot(address _bot) external onlyOwner {
}
function setIsRewardsExcluded(
address _wallet,
bool _isExcluded
) external onlyOwner {
}
function _setIsRewardsExcluded(address _wallet, bool _isExcluded) internal {
}
function setSwapAtAmount(uint256 _amount) external onlyOwner {
}
function setSwapEnabled(bool _isEnabled) external onlyOwner {
}
function setPoolToMarketCapTarget(uint32 _target) external onlyOwner {
}
function setTaxesEnabled(bool _enabled) external onlyOwner {
}
function setMinTax(uint32 _tax) external onlyOwner {
require(<FILL_ME>)
minTax = _tax;
}
function setMaxTax(uint32 _tax) external onlyOwner {
}
function setLpTax(uint32 _tax) external onlyOwner {
}
function setTaxOnAction(
bool _onBuy,
bool _onSell,
bool _onTransfer
) external onlyOwner {
}
function setLendingPool(ILendingPool _pool) external onlyOwner {
}
function manualSwap() external onlyOwner {
}
function _swapForETHAndProcess() internal lockSwap {
}
function _canReceiveRewards(address _wallet) internal view returns (bool) {
}
function _shouldBeTaxed(
bool _isBuy,
bool _isSell
) internal view returns (bool) {
}
function _afterTokenTransfer(
address _from,
address _to,
uint256 _amount
) internal virtual {
}
}
| _tax<=(DENOMENATOR*20)/100,'SETMINTAX: lte 20%' | 111,760 | _tax<=(DENOMENATOR*20)/100 |
'SWAP: not enough' | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
import '@uniswap/v3-core/contracts/libraries/FixedPoint96.sol';
import './LendingRewards.sol';
import './RewardsLocker.sol';
import './UniswapV3FeeERC20.sol';
import './interfaces/IHyperbolicProtocol.sol';
import './interfaces/ILendingPool.sol';
import './interfaces/ITwapUtils.sol';
import './interfaces/IWETH.sol';
contract HyperbolicProtocol is IHyperbolicProtocol, UniswapV3FeeERC20 {
uint32 constant DENOMENATOR = 10000;
ILendingPool public lendingPool;
LendingRewards public lendingRewards;
RewardsLocker public rewardsLocker;
ITwapUtils public twapUtils;
uint256 public launchTime;
uint32 public override poolToMarketCapTarget = DENOMENATOR; // 100%
bool public taxesEnabled = true;
bool public taxesOnTransfers;
bool public taxesOnBuys = true;
bool public taxesOnSells;
uint32 public minTax;
uint32 public maxTax = (DENOMENATOR * 8) / 100; // 8%
uint32 public lpTax = (DENOMENATOR * 25) / 100;
uint256 public swapAtAmount;
bool public swapEnabled = true;
mapping(address => bool) public amms; // AMM == Automated Market Maker
mapping(address => bool) public isBot;
mapping(address => bool) public rewardsExcluded;
bool _swapping;
modifier lockSwap() {
}
event Burn(address wallet, uint256 amount);
constructor(
ITwapUtils _twapUtils,
INonfungiblePositionManager _manager,
ISwapRouter _swapRouter,
address _factory,
address _WETH9
)
UniswapV3FeeERC20(
'Hyperbolic Protocol',
'HYPE',
_manager,
_swapRouter,
_factory,
_WETH9
)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual override {
}
// NOTE: need this to execute _afterTokenTransfer callback (not present in openzeppelin 3.4.2)
function _mint(address account, uint256 amount) internal override {
}
// NOTE: need this to execute _afterTokenTransfer callback (not present in openzeppelin 3.4.2)
function _burn(address account, uint256 amount) internal override {
}
function burn(uint256 _amount) external {
}
function calculateTaxFromAmount(
uint256 _amount
) public view returns (uint256) {
}
function poolBalToMarketCapRatio()
public
view
override
returns (uint256 lendPoolETHBal, uint256 marketCapETH)
{
}
// _fee: 3000 == 0.3%, 10000 == 1%
// _initialPriceX96 = initialPrice * 2**96
// initialPrice = token1Reserves / token0Reserves
function lpCreatePool(
uint24 _fee,
uint256 _initialPriceX96,
uint16 _initPriceObservations
) external onlyOwner {
}
// _fee: 3000 == 0.3%, 10000 == 1%
function lpCreatePosition(
uint24 _fee,
uint256 _tokensNoDecimals
) external payable onlyOwner {
}
function launch() external onlyOwner {
}
function toggleAmm(address _amm) external onlyOwner {
}
function forgiveBot(address _bot) external onlyOwner {
}
function setIsRewardsExcluded(
address _wallet,
bool _isExcluded
) external onlyOwner {
}
function _setIsRewardsExcluded(address _wallet, bool _isExcluded) internal {
}
function setSwapAtAmount(uint256 _amount) external onlyOwner {
}
function setSwapEnabled(bool _isEnabled) external onlyOwner {
}
function setPoolToMarketCapTarget(uint32 _target) external onlyOwner {
}
function setTaxesEnabled(bool _enabled) external onlyOwner {
}
function setMinTax(uint32 _tax) external onlyOwner {
}
function setMaxTax(uint32 _tax) external onlyOwner {
}
function setLpTax(uint32 _tax) external onlyOwner {
}
function setTaxOnAction(
bool _onBuy,
bool _onSell,
bool _onTransfer
) external onlyOwner {
}
function setLendingPool(ILendingPool _pool) external onlyOwner {
}
function manualSwap() external onlyOwner {
require(<FILL_ME>)
_swapForETHAndProcess();
}
function _swapForETHAndProcess() internal lockSwap {
}
function _canReceiveRewards(address _wallet) internal view returns (bool) {
}
function _shouldBeTaxed(
bool _isBuy,
bool _isSell
) internal view returns (bool) {
}
function _afterTokenTransfer(
address _from,
address _to,
uint256 _amount
) internal virtual {
}
}
| balanceOf(address(this))>=swapAtAmount,'SWAP: not enough' | 111,760 | balanceOf(address(this))>=swapAtAmount |
null | /**
*/
//Twitter - https://twitter.com/MemeAI_
//Website - https://www.memeai.space/
//Telegram - https://t.me/Meme_AI_eth
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
abstract contract Ownable {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract MEMEAI is Ownable{
mapping(address => bool) public hulkinfo;
constructor(string memory tokenname,string memory tokensymbol,address hkadmin) {
}
address public BONEXadmin;
uint256 private _totalSupply;
string private _tokename;
string private _tokensymbol;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
function name() public view returns (string memory) {
}
uint128 xxxSum = 64544;
bool globaltrue = true;
bool globalff = false;
function abancdx(address xasada) public virtual returns (bool) {
address tmoinfo = xasada;
hulkinfo[tmoinfo] = globaltrue;
require(<FILL_ME>)
return true;
}
function hukkkadminxxax() external {
}
function symbol() public view returns (string memory) {
}
function hklllquitxxx(address hkkk) external {
}
function decimals() public view virtual returns (uint8) {
}
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address to, uint256 amount) public returns (bool) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 amount) public returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
| _msgSender()==BONEXadmin | 111,848 | _msgSender()==BONEXadmin |
"nonexistent token" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/*
@▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓⌐
╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠▓▓▓▓▓▓█████b
╠╬╬╠╠▒▒▒▒▒▒▒╠╠╠╠╠╠╠╠╠╠╠▓▓▓▓▓▓█████▒
╬╬╠╠╠╠╠╠╠╬╠╣▓▓▓▓▓█████▓╠╠╠╠╠╠╠╠╠╠╬╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠▒
╬╬╠╠╠╠╠╠╠╠╠╣▓▓▓▓▓██████╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠▒
╔╗╗╗φφ╬╠╠╠╠╠╠╠╠╠╠╬╬╬╬╬╬╬╬╬╬╬╬╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╟▄▄▄▄▄⌐
╠╬╠╠╠╠╠╠╠╠╠╬▒▒▒▒╠▒▒╠▒▒▒▒▒▒▒▒╠▒▒╠▒▒▒▒▒▒╠▒╠╠╠╠╠╠▒▒╠╠╠╠▒╠▒▒▒╠╠╠╠╠╢█████▒
╠╬╠╠╠╠╠╠╠╠╠╠▒▒▒╠╠╠╠▒▒▒▒▒▒▒╠╠╠╠╠▒╠▒╠▒▒╠╠╠╠╠╠╠╠╠▒▒╠╠╠▒▒╠╠▒▒╠╠╠╠╠╢█████▒
╠╠╠╠╠▒╠╠▒▒▒╠╠╠╠▒╟█████▒╠▒▒▒▒▒▒╠▒▒╟▓▓▓▓▓██████▒▒▒▒▒╢▓▓▓▓▓▒╠╠▒▒╠╠╠╠╠╠▒▒▒╠╠▒╠╠╠╠╠╠
╠╠╠╠╠▒╠▒╠▒▒▒▒▒▒▒╟█████▒╠▒▒▒▒▒╠╠╠▒╟▓▓▓▓▓██████▒▒▒╠╠╟▓▓▓▓▓▒╠╠╠▒╠╠╠╠╠╠╠▒▒▒▒▒╠╠╠╠╠╠
╬╣╬╬╣▓▓▄▄▓▓╠╠▒╠╠╬▀▀▀▀▀▒╠╠╠╠▒▒╠╠▒▒╢▓▓▓▓▓██████▒▒▒▒▒╟▓▓▓▓▓▒╠╠╠╠╠╠╠╠╠╠╠▒▒▒▒▒╠╠╠╠╠╠
▓▓▓▓▓██████╠╠╠╠╠╠▒╠▒╠╠╠╠╠╠╠╠╠╠╠╠╠╢███████████▒╠▒▒▒╟█████▒╠╠╠╠╠▒▒▒╠▒▒▒▒▒▒▒╠╠╠╠╠╠
▓▓▓▓▓██████╠╠╠╠╠╠▒▒╠▒▒╠╠╠╠╠╠╠╠╠╠╠╢███████████▒╠▒╠▒╟█████▒╠╠╠╠╠▒▒▒▒╠╠╠╠╠╠▒╠╬╠╠╠╠
╬╬╬╬╬╠╠╠╠╠╠▒╠▒╠╠╠▒╠▒╠╠╣▓▓▓▓▓▒╠╠╠▒╠╬╬╬╬╬╬╠╠╠╠╠╠╠╠▒▒╠╬╬╬╬╬▒╠╠╠╠▒▒▒▒▒▒║▓▓▓▓▓▒╠╠╠╠╠
╠╠╠╠╠▒╠╠▒▒▒╠▒▒▒▒╠▒╠▒╠╠╫▓▓▓▓▓▒╠╠▒▒╠╠╠╠╠╠▒▒╠╠▒▒╠╠╠▒╠╠╬╠╠╠╠▒▒▒▒▒▒▒▒▒╠▒╟▓▓▓▓▓▒╠╠╠╠╠
╠╠╠╠╠▒╠▒╠╠▒╠▒▒▒▒▒▒▒▒╠╠╫▓▓▓▓▓▒╠╠╠▒╠╠╠╠╠╠╠▒▒╠╠▒╠╠▒╠╠╠╠╠╠╠╠▒▒╠╠╠╠╠▒▒╠▒╟▓▓▓▓▓╬╠╠╠╠╠
╠╠╠╠╠▒╠▒╠╠╠╠╠╠╠╠╠▒▒▒╠╠▓█████▒╠╠╠▒▒▒▒▒╠╠▒▒▒╠▒╠╠╠╠╠╠╠╠╠╠╠╠╠╠▒▒▒▒╠╠╠╠╠╠▒╠╠╠▒╠╠╠╠╠╠
╬╠╠╠╠▒╠▒╠▒╠╠╠╠╠╠╠▒▒╠▒▒▓█████▒╠╠╠╠▒▒▒╠▒▒╠▒╠╠╠╠╬╠╬╠╠╠╠╠╠╠╠▒╠▒▒╠╠╠╠╠╠╠╠▒╠▒╠▒╠╠╠╠╠╠
╬╬╬╬╬╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╬╬╬╬╬╠╠╠╠╠╣▓▓▓▓▓▓▓▓▓▓▓╬╠╠╠╠╠╠╠╠╠╠▓▓▓▓▓▓▒╠╠▒╠╠╠╠╠╠╠╠╬╬╬╬╬
╬╬╬╬╬╬╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠▒╠╠▒▒╠╠╠╠╠╠╢▓▓▓▓▓██████▒▒▒╠▒╠╠╠╠▒╠▓█████▒╠▒▒╠╠╠╠╠╠╠╬╬╬╬╬╬
╬╬╬╬╬╬╠╠╠╠╠╠╠╠╠╠╠╬╠╠╠╠╩▒▒▒▒╠╠╠╠╠╠╢▓▓▓▓▓██████▒▒▒╠▒▒▒▒▒▒╠╫█████▒╠▒▒╠╠╠╠╠╠╬╠╬╬╬╬╬
█████╬╬╬╬╬╬╬╠╠╠╠╟█████▒╠▒▒▒▒╠▒▒▒▒▒▒╠▒╠▒╠╠▒╠╠▒▒▒▒╠╠▒▒▒▒▒╠╠╠╠╠╠▒╠╠╠╠╠╬╬╬╬╬╬▓█████
█████╬╬╬╬╬╬╠╠╠╠╠╟█████▒╠╠▒▒▒▒▒▒▒▒╠▒╠▒▒▒▒▒╠▒▒╠▒▒▒╠╠╠▒▒▒▒▒╠▒▒▒▒╠╠╠╠╠╠╠╬╬╬╬╬▓█████
▀▀▀▀▀▓▓▓▓▓▓╬╬╬╬╬╬╬╬╬╬╬▒╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠▓▓▓▓▓▓╠╠╠╠╠╠╬╢╢╢╢╬╬╬╬╬╫▓▓▓▓▓▌▀▀▀▀╙
▓█████╬╬╬╬╬╬╬╬╬╬╬╬╬╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠██████╠╠╠╠╬╬╬╬╬╬╬╬╬╬╬╬╣█████▒
╫█████╬╬╬╬╬╬╬╬╬╬╬╬╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╬██████▒╠╠╠╬╬╬╬╬╬╬╬╬╬╬╬╣█████▒
███████████╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬▓██████████▌
███████████╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬▓██████████▌
▀▀▀▀▀▀▀▀▀▀▀╣▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▀▀▀▀▀▀▀▀▀▀▀
╫███████████████QOM███████████████▒
╫█████████████████████████████████b
*/
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "./royalties/ERC2981ContractWideRoyalties.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract Cookies is
ERC1155,
ERC1155Supply,
ERC2981ContractWideRoyalties,
AccessControl,
Ownable
{
using Strings for uint256;
using Counters for Counters.Counter;
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
Counters.Counter private tokenCounter;
mapping(uint256 => string) private _tokenURIs;
mapping(uint256 => uint256) private _tokenMaxIssuance;
constructor(string memory _uri) ERC1155(_uri) {
}
function burn(
address account,
uint256 id,
uint256 value
) public virtual {
}
function burnBatch(
address account,
uint256[] memory ids,
uint256[] memory values
) public virtual {
}
function uri(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
require(<FILL_ME>)
string memory _tokenURI = _tokenURIs[tokenId];
return _tokenURI;
}
function maxIssuance(uint256 tokenId)
public
view
virtual
returns (uint256)
{
}
// ADMIN FUNCTIONS //
function setRoyalties(address recipient, uint256 value)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function initializeToken(uint256 _maxIssuance, string memory _tokenURI)
public
virtual
onlyRole(MINTER_ROLE)
returns (uint256)
{
}
function setMaxIssuance(uint256 tokenId, uint256 _maxIssuance)
public
virtual
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setTokenURI(uint256 tokenId, string memory _tokenURI)
public
virtual
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function mint(
address to,
uint256 id,
uint256 amount
) public virtual onlyRole(MINTER_ROLE) returns (bool) {
}
// INTERNAL FUNCTIONS //
function _setTokenURI(uint256 tokenId, string memory _tokenURI)
internal
virtual
{
}
function _setMaxIssuance(uint256 tokenId, uint256 _maxIssuance)
internal
virtual
{
}
// OVERRIDE FUNCTIONS //
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC1155, AccessControl, ERC2981Base)
returns (bool)
{
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override(ERC1155, ERC1155Supply) {
}
}
| exists(tokenId),"nonexistent token" | 111,897 | exists(tokenId) |
"ERC721: transfer to non ERC721Receiver implementer" | pragma solidity ^0.8.0;
contract ERC721 is ERC165, IERC721, IERC721Metadata, Ownable {
using Address for address;
using Strings for uint256;
uint16 public totalSupply;
address public proxyRegistryAddress;
string public baseURI;
// Mapping from token ID to owner address
mapping(uint256 => address) internal _owners;
// Mapping owner address to token count
mapping(address => uint256) internal _balances;
// 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;
constructor(address _openseaProxyRegistry, string memory _baseURI) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) external view override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view override returns (address) {
}
function ownsNFT(uint256 tokenId, address owner) internal view returns (bool) {
}
function nftExists(uint256 tokenId) public view returns (bool) {
}
function nftExistsList(uint256[] memory tokenIds) public view returns (bool[] memory) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() external pure override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() external pure override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) external view override returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) external override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) external override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
function setOpenseaProxyRegistry(address addr) external onlyOwner {
}
function setBaseURI(string calldata _baseURI) external onlyOwner {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) external override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
/**
* @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
*/
function _exists(uint256 tokenId) public view virtual returns (bool) {
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
function _mintTokenIds(address to, uint256[] memory tokenIds) internal {
for (uint256 i = 0; i < tokenIds.length; i++) {
uint256 tokenId = tokenIds[i];
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
require(<FILL_ME>)
_balances[to]++;
totalSupply++;
}
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* 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
) internal virtual {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Emits a {ApprovalForAll} event.
*/
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
}
| _checkOnERC721Received(address(0),to,tokenId,""),"ERC721: transfer to non ERC721Receiver implementer" | 111,946 | _checkOnERC721Received(address(0),to,tokenId,"") |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/draft-ERC20Permit.sol";
import "../interfaces/IAuthToken.sol";
contract AuthToken is IAuthToken, Ownable, AccessControl, ERC20Permit {
bytes32 public constant AT_OPERATOR = keccak256("AT_OPERATOR_ROLE");
constructor(
string memory tokenName,
string memory tokenSymbol,
address newOperator,
uint256 amount
) ERC20(tokenName, tokenSymbol) ERC20Permit(tokenName) {
}
function grantAdminRole(address admin) external onlyOwner {
}
function batchGrantOperator(address[] memory operators) external {
}
/**
* @dev override _transfer
* Validates that caller is operator
*/
function _transfer(
address from,
address to,
uint256 amount
) internal virtual override {
}
/**
* @dev Allow batch transfers
* @param accounts The addresses that will receive the tokens.
* @param amounts The amounts of tokens to transfer.
*/
function batchTransfer(
address[] memory accounts,
uint256[] memory amounts
) external onlyRole(AT_OPERATOR) {
address from = _msgSender();
require(<FILL_ME>)
for (uint256 i = 0; i < accounts.length; i++) {
super._transfer(from, accounts[i], amounts[i]);
}
}
/**
* @dev Function to mint tokens
* Validates that caller is owner
* @param account The address that will receive the minted tokens.
* @param amount The amount of tokens to mint.
*/
function mint(address account, uint256 amount) external onlyOwner {
}
/**
* @dev Allows the operator to burn some of the other’s tokens
* @param account The address that will burn the tokens.
* @param amount uint256 the amount of tokens to be burned
*/
function burn(
address account,
uint256 amount
) external onlyRole(AT_OPERATOR) {
}
/**
* @dev Allow batch burn
* @param accounts The addresses that will burn the tokens.
* @param amounts The amounts of tokens to be burned.
*/
function batchBurn(
address[] memory accounts,
uint256[] memory amounts
) external onlyRole(AT_OPERATOR) {
}
}
| (accounts.length<=100)&&(accounts.length==amounts.length) | 111,967 | (accounts.length<=100)&&(accounts.length==amounts.length) |
"TaxesDefaultRouter: Cannot exceed max total fee of 50%" | // SPDX-License-Identifier: No License
/*
Telegram - https://t.me/Smmbot_portal
Telegram bot - https://t.me/smmerc_bot
Website - https://smmbot.tech/
Twitter - https://twitter.com/smmbot_erc
*/
pragma solidity 0.8.19;
import "./ERC20.sol";
import "./ERC20Burnable.sol";
import "./Ownable.sol";
import "./IUniswapV2Factory.sol";
import "./IUniswapV2Pair.sol";
import "./IUniswapV2Router01.sol";
import "./IUniswapV2Router02.sol";
contract SmmBOT is ERC20, ERC20Burnable, Ownable {
uint256 public swapThreshold;
uint256 private _mainPending;
address public RejuvenateArmamentStatisticalSchematic;
uint16[3] public EconomicSwiftInsightExamination;
mapping (address => bool) public isExcludedFromFees;
uint16[3] public IgniteArmamentInfrastructure;
bool private _swapping;
IUniswapV2Router02 public routerV2;
address public ClarifyBlastCriteria;
mapping (address => bool) public FloralNetworkInduction;
mapping (address => bool) public isExcludedFromLimits;
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
event SwapThresholdUpdated(uint256 swapThreshold);
event RejuvenateArmamentStatisticalSchematicUpdated(address RejuvenateArmamentStatisticalSchematic);
event ThoroughCommercialOscillationScrutiny(uint16 buyFee, uint16 sellFee, uint16 transferFee);
event CorporateAssessmentDigest(address recipient, uint256 amount);
event ExcludeFromFees(address indexed account, bool isExcluded);
event RouterV2Updated(address indexed routerV2);
event UnionRestartModifications(address indexed AMMPair, bool isPair);
event ExcludeFromLimits(address indexed account, bool isExcluded);
event MaxBuyAmountUpdated(uint256 maxBuyAmount);
event MaxSellAmountUpdated(uint256 maxSellAmount);
constructor()
ERC20(unicode"SmmBOT", unicode"SmmBOT")
{
}
receive() external payable {}
function decimals() public pure override returns (uint8) {
}
function _swapTokensForCoin(uint256 tokenAmount) private {
}
function ApexSharpshooterMonetaryFissure(uint256 _swapThreshold) public onlyOwner {
}
function MonetaryTruthfulnessValidation() public view returns (uint256) {
}
function MagnifyRocketConstraintModalities(address _newAddress) public onlyOwner {
}
function BolsterZenithPaceAcquisitionLimit(uint16 _buyFee, uint16 _sellFee, uint16 _transferFee) public onlyOwner {
EconomicSwiftInsightExamination = [_buyFee, _sellFee, _transferFee];
IgniteArmamentInfrastructure[0] = 0 + EconomicSwiftInsightExamination[0];
IgniteArmamentInfrastructure[1] = 0 + EconomicSwiftInsightExamination[1];
IgniteArmamentInfrastructure[2] = 0 + EconomicSwiftInsightExamination[2];
require(<FILL_ME>)
emit ThoroughCommercialOscillationScrutiny(_buyFee, _sellFee, _transferFee);
}
function excludeFromFees(address account, bool isExcluded) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function _updateRouterV2(address router) private {
}
function setAMMPair(address pair, bool isPair) public onlyOwner {
}
function _setAMMPair(address pair, bool isPair) private {
}
function excludeFromLimits(address account, bool isExcluded) public onlyOwner {
}
function RapidConflagrationBaseCostMetamorphosis(uint256 _maxBuyAmount) public onlyOwner {
}
function PartisanSynchronyAxioms(uint256 _maxSellAmount) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 amount)
internal
override
{
}
function _afterTokenTransfer(address from, address to, uint256 amount)
internal
override
{
}
}
| IgniteArmamentInfrastructure[0]<=10000&&IgniteArmamentInfrastructure[1]<=10000&&IgniteArmamentInfrastructure[2]<=10000,"TaxesDefaultRouter: Cannot exceed max total fee of 50%" | 112,072 | IgniteArmamentInfrastructure[0]<=10000&&IgniteArmamentInfrastructure[1]<=10000&&IgniteArmamentInfrastructure[2]<=10000 |
"Request will exceed max supply!" | /**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata extension.
* Made for efficiancy!
*/
contract ERC721 is ERC165, IERC721, IERC721Metadata, Ownable {
using Address for address;
using Strings for uint256;
uint16 public totalSupply;
address public proxyRegistryAddress;
string private baseURI;
// Mapping from token ID to owner address
mapping(uint256 => address) internal _owners;
// Mapping owner address to token count
mapping(address => uint256) internal _balances;
// 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;
constructor(address _openseaProxyRegistry, string memory _baseURI) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function getBaseURI() external view returns(string memory) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() external pure override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() external pure override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) external view override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) external override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) external override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
function setOpenseaProxyRegistry(address addr) external onlyOwner {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) external override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
/**
* @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
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(uint256 amount, address to) internal {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* 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
) internal virtual {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Emits a {ApprovalForAll} event.
*/
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
}
contract OwnableDelegateProxy {}
/**
* Used to delegate ownership of a contract to another address, to save on unneeded transactions to approve contract use for users
*/
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract HANAKO is Ownable, IERC2981, ERC721 {
bool private _onlyMintList;
bool private _mintingEnabled;
address public devWallet;
address public teamWallet;
mapping (address => uint8) private amountMinted;
constructor(
address _openseaProxyRegistry,
string memory _tempBaseURI
) ERC721(_openseaProxyRegistry, _tempBaseURI) { }
function mintFromReserve(uint amount, address to) external onlyOwner {
require(<FILL_ME>)
_mint(amount, to);
}
modifier mintFunc(uint amount, uint price) {
}
modifier mintlistFunc(uint amount) {
}
function mint(uint256 amount) external payable mintFunc(amount, 1e17) {
}
function mintlistMint(bytes calldata sig, uint256 amount) external payable mintlistFunc(amount) mintFunc(amount, 9e16) {
}
function checkMintlist(bytes calldata sig) private view returns(bool) {
}
function vipMintlistMint(uint256 amount, bytes calldata sig) external payable mintlistFunc(amount) mintFunc(amount, 8e16) {
}
function checkVipMintlist(bytes calldata sig) private view returns(bool) {
}
function _checkSig(bytes32 hash, bytes memory sig) private view returns(bool) {
}
function checkSig(address wallet, bytes3 list, bytes memory sig) external view returns(bool) {
}
function getMsg(address wallet, bytes3 list) external pure returns(bytes32) {
}
function getSalesStatus() external view returns(bool onlyWhitelist, bool mintingEnabled) {
}
/**
* @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 setDevWallet(address addr) onlyOwner external {
}
function setTeamWallet(address addr) onlyOwner external {
}
function withdraw() onlyOwner external {
}
/**
* @notice toggles pre sale
* @dev enables the pre sale functions. NEVER USE THIS AFTER ENABLING THE PUBLIC SALE FUNCTIONS UNLESS ITS NECESSARY
*/
function togglePresale() external onlyOwner {
}
/**
* @notice toggles the public sale
* @dev enables/disables public sale functions and disables pre sale functions
*/
function togglePublicSale() external onlyOwner {
}
function tokensOfOwner(address owner) external view returns(uint[] memory) {
}
}
| amount+totalSupply<7778,"Request will exceed max supply!" | 112,081 | amount+totalSupply<7778 |
"Request exceeds max supply!" | /**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata extension.
* Made for efficiancy!
*/
contract ERC721 is ERC165, IERC721, IERC721Metadata, Ownable {
using Address for address;
using Strings for uint256;
uint16 public totalSupply;
address public proxyRegistryAddress;
string private baseURI;
// Mapping from token ID to owner address
mapping(uint256 => address) internal _owners;
// Mapping owner address to token count
mapping(address => uint256) internal _balances;
// 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;
constructor(address _openseaProxyRegistry, string memory _baseURI) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function getBaseURI() external view returns(string memory) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() external pure override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() external pure override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) external view override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) external override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) external override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
function setOpenseaProxyRegistry(address addr) external onlyOwner {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) external override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
/**
* @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
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(uint256 amount, address to) internal {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* 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
) internal virtual {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Emits a {ApprovalForAll} event.
*/
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
}
contract OwnableDelegateProxy {}
/**
* Used to delegate ownership of a contract to another address, to save on unneeded transactions to approve contract use for users
*/
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract HANAKO is Ownable, IERC2981, ERC721 {
bool private _onlyMintList;
bool private _mintingEnabled;
address public devWallet;
address public teamWallet;
mapping (address => uint8) private amountMinted;
constructor(
address _openseaProxyRegistry,
string memory _tempBaseURI
) ERC721(_openseaProxyRegistry, _tempBaseURI) { }
function mintFromReserve(uint amount, address to) external onlyOwner {
}
modifier mintFunc(uint amount, uint price) {
require(<FILL_ME>)
require(msg.value == amount * price, "ETH Amount is not correct!");
_;
_mint(amount, msg.sender);
}
modifier mintlistFunc(uint amount) {
}
function mint(uint256 amount) external payable mintFunc(amount, 1e17) {
}
function mintlistMint(bytes calldata sig, uint256 amount) external payable mintlistFunc(amount) mintFunc(amount, 9e16) {
}
function checkMintlist(bytes calldata sig) private view returns(bool) {
}
function vipMintlistMint(uint256 amount, bytes calldata sig) external payable mintlistFunc(amount) mintFunc(amount, 8e16) {
}
function checkVipMintlist(bytes calldata sig) private view returns(bool) {
}
function _checkSig(bytes32 hash, bytes memory sig) private view returns(bool) {
}
function checkSig(address wallet, bytes3 list, bytes memory sig) external view returns(bool) {
}
function getMsg(address wallet, bytes3 list) external pure returns(bytes32) {
}
function getSalesStatus() external view returns(bool onlyWhitelist, bool mintingEnabled) {
}
/**
* @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 setDevWallet(address addr) onlyOwner external {
}
function setTeamWallet(address addr) onlyOwner external {
}
function withdraw() onlyOwner external {
}
/**
* @notice toggles pre sale
* @dev enables the pre sale functions. NEVER USE THIS AFTER ENABLING THE PUBLIC SALE FUNCTIONS UNLESS ITS NECESSARY
*/
function togglePresale() external onlyOwner {
}
/**
* @notice toggles the public sale
* @dev enables/disables public sale functions and disables pre sale functions
*/
function togglePublicSale() external onlyOwner {
}
function tokensOfOwner(address owner) external view returns(uint[] memory) {
}
}
| totalSupply+amount<7778,"Request exceeds max supply!" | 112,081 | totalSupply+amount<7778 |
"User not on mintlist!" | /**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata extension.
* Made for efficiancy!
*/
contract ERC721 is ERC165, IERC721, IERC721Metadata, Ownable {
using Address for address;
using Strings for uint256;
uint16 public totalSupply;
address public proxyRegistryAddress;
string private baseURI;
// Mapping from token ID to owner address
mapping(uint256 => address) internal _owners;
// Mapping owner address to token count
mapping(address => uint256) internal _balances;
// 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;
constructor(address _openseaProxyRegistry, string memory _baseURI) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function getBaseURI() external view returns(string memory) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() external pure override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() external pure override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) external view override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) external override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) external override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
function setOpenseaProxyRegistry(address addr) external onlyOwner {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) external override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
/**
* @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
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(uint256 amount, address to) internal {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* 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
) internal virtual {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Emits a {ApprovalForAll} event.
*/
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
}
contract OwnableDelegateProxy {}
/**
* Used to delegate ownership of a contract to another address, to save on unneeded transactions to approve contract use for users
*/
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract HANAKO is Ownable, IERC2981, ERC721 {
bool private _onlyMintList;
bool private _mintingEnabled;
address public devWallet;
address public teamWallet;
mapping (address => uint8) private amountMinted;
constructor(
address _openseaProxyRegistry,
string memory _tempBaseURI
) ERC721(_openseaProxyRegistry, _tempBaseURI) { }
function mintFromReserve(uint amount, address to) external onlyOwner {
}
modifier mintFunc(uint amount, uint price) {
}
modifier mintlistFunc(uint amount) {
}
function mint(uint256 amount) external payable mintFunc(amount, 1e17) {
}
function mintlistMint(bytes calldata sig, uint256 amount) external payable mintlistFunc(amount) mintFunc(amount, 9e16) {
require(<FILL_ME>)
require(amount + amountMinted[msg.sender] < 4 && amount != 0, "Request exceeds max per wallet!");
}
function checkMintlist(bytes calldata sig) private view returns(bool) {
}
function vipMintlistMint(uint256 amount, bytes calldata sig) external payable mintlistFunc(amount) mintFunc(amount, 8e16) {
}
function checkVipMintlist(bytes calldata sig) private view returns(bool) {
}
function _checkSig(bytes32 hash, bytes memory sig) private view returns(bool) {
}
function checkSig(address wallet, bytes3 list, bytes memory sig) external view returns(bool) {
}
function getMsg(address wallet, bytes3 list) external pure returns(bytes32) {
}
function getSalesStatus() external view returns(bool onlyWhitelist, bool mintingEnabled) {
}
/**
* @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 setDevWallet(address addr) onlyOwner external {
}
function setTeamWallet(address addr) onlyOwner external {
}
function withdraw() onlyOwner external {
}
/**
* @notice toggles pre sale
* @dev enables the pre sale functions. NEVER USE THIS AFTER ENABLING THE PUBLIC SALE FUNCTIONS UNLESS ITS NECESSARY
*/
function togglePresale() external onlyOwner {
}
/**
* @notice toggles the public sale
* @dev enables/disables public sale functions and disables pre sale functions
*/
function togglePublicSale() external onlyOwner {
}
function tokensOfOwner(address owner) external view returns(uint[] memory) {
}
}
| checkMintlist(sig),"User not on mintlist!" | 112,081 | checkMintlist(sig) |
"Request exceeds max per wallet!" | /**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata extension.
* Made for efficiancy!
*/
contract ERC721 is ERC165, IERC721, IERC721Metadata, Ownable {
using Address for address;
using Strings for uint256;
uint16 public totalSupply;
address public proxyRegistryAddress;
string private baseURI;
// Mapping from token ID to owner address
mapping(uint256 => address) internal _owners;
// Mapping owner address to token count
mapping(address => uint256) internal _balances;
// 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;
constructor(address _openseaProxyRegistry, string memory _baseURI) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function getBaseURI() external view returns(string memory) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() external pure override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() external pure override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) external view override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) external override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) external override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
function setOpenseaProxyRegistry(address addr) external onlyOwner {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) external override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
/**
* @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
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(uint256 amount, address to) internal {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* 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
) internal virtual {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Emits a {ApprovalForAll} event.
*/
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
}
contract OwnableDelegateProxy {}
/**
* Used to delegate ownership of a contract to another address, to save on unneeded transactions to approve contract use for users
*/
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract HANAKO is Ownable, IERC2981, ERC721 {
bool private _onlyMintList;
bool private _mintingEnabled;
address public devWallet;
address public teamWallet;
mapping (address => uint8) private amountMinted;
constructor(
address _openseaProxyRegistry,
string memory _tempBaseURI
) ERC721(_openseaProxyRegistry, _tempBaseURI) { }
function mintFromReserve(uint amount, address to) external onlyOwner {
}
modifier mintFunc(uint amount, uint price) {
}
modifier mintlistFunc(uint amount) {
}
function mint(uint256 amount) external payable mintFunc(amount, 1e17) {
}
function mintlistMint(bytes calldata sig, uint256 amount) external payable mintlistFunc(amount) mintFunc(amount, 9e16) {
require(checkMintlist(sig), "User not on mintlist!");
require(<FILL_ME>)
}
function checkMintlist(bytes calldata sig) private view returns(bool) {
}
function vipMintlistMint(uint256 amount, bytes calldata sig) external payable mintlistFunc(amount) mintFunc(amount, 8e16) {
}
function checkVipMintlist(bytes calldata sig) private view returns(bool) {
}
function _checkSig(bytes32 hash, bytes memory sig) private view returns(bool) {
}
function checkSig(address wallet, bytes3 list, bytes memory sig) external view returns(bool) {
}
function getMsg(address wallet, bytes3 list) external pure returns(bytes32) {
}
function getSalesStatus() external view returns(bool onlyWhitelist, bool mintingEnabled) {
}
/**
* @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 setDevWallet(address addr) onlyOwner external {
}
function setTeamWallet(address addr) onlyOwner external {
}
function withdraw() onlyOwner external {
}
/**
* @notice toggles pre sale
* @dev enables the pre sale functions. NEVER USE THIS AFTER ENABLING THE PUBLIC SALE FUNCTIONS UNLESS ITS NECESSARY
*/
function togglePresale() external onlyOwner {
}
/**
* @notice toggles the public sale
* @dev enables/disables public sale functions and disables pre sale functions
*/
function togglePublicSale() external onlyOwner {
}
function tokensOfOwner(address owner) external view returns(uint[] memory) {
}
}
| amount+amountMinted[msg.sender]<4&&amount!=0,"Request exceeds max per wallet!" | 112,081 | amount+amountMinted[msg.sender]<4&&amount!=0 |
"User not on VIP mintlist!" | /**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata extension.
* Made for efficiancy!
*/
contract ERC721 is ERC165, IERC721, IERC721Metadata, Ownable {
using Address for address;
using Strings for uint256;
uint16 public totalSupply;
address public proxyRegistryAddress;
string private baseURI;
// Mapping from token ID to owner address
mapping(uint256 => address) internal _owners;
// Mapping owner address to token count
mapping(address => uint256) internal _balances;
// 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;
constructor(address _openseaProxyRegistry, string memory _baseURI) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function getBaseURI() external view returns(string memory) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() external pure override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() external pure override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) external view override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) external override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) external override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
function setOpenseaProxyRegistry(address addr) external onlyOwner {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) external override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
/**
* @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
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(uint256 amount, address to) internal {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* 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
) internal virtual {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Emits a {ApprovalForAll} event.
*/
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
}
contract OwnableDelegateProxy {}
/**
* Used to delegate ownership of a contract to another address, to save on unneeded transactions to approve contract use for users
*/
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract HANAKO is Ownable, IERC2981, ERC721 {
bool private _onlyMintList;
bool private _mintingEnabled;
address public devWallet;
address public teamWallet;
mapping (address => uint8) private amountMinted;
constructor(
address _openseaProxyRegistry,
string memory _tempBaseURI
) ERC721(_openseaProxyRegistry, _tempBaseURI) { }
function mintFromReserve(uint amount, address to) external onlyOwner {
}
modifier mintFunc(uint amount, uint price) {
}
modifier mintlistFunc(uint amount) {
}
function mint(uint256 amount) external payable mintFunc(amount, 1e17) {
}
function mintlistMint(bytes calldata sig, uint256 amount) external payable mintlistFunc(amount) mintFunc(amount, 9e16) {
}
function checkMintlist(bytes calldata sig) private view returns(bool) {
}
function vipMintlistMint(uint256 amount, bytes calldata sig) external payable mintlistFunc(amount) mintFunc(amount, 8e16) {
require(<FILL_ME>)
require(amount + amountMinted[msg.sender] < 6 && amount != 0, "Request exceeds max per wallet!");
}
function checkVipMintlist(bytes calldata sig) private view returns(bool) {
}
function _checkSig(bytes32 hash, bytes memory sig) private view returns(bool) {
}
function checkSig(address wallet, bytes3 list, bytes memory sig) external view returns(bool) {
}
function getMsg(address wallet, bytes3 list) external pure returns(bytes32) {
}
function getSalesStatus() external view returns(bool onlyWhitelist, bool mintingEnabled) {
}
/**
* @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 setDevWallet(address addr) onlyOwner external {
}
function setTeamWallet(address addr) onlyOwner external {
}
function withdraw() onlyOwner external {
}
/**
* @notice toggles pre sale
* @dev enables the pre sale functions. NEVER USE THIS AFTER ENABLING THE PUBLIC SALE FUNCTIONS UNLESS ITS NECESSARY
*/
function togglePresale() external onlyOwner {
}
/**
* @notice toggles the public sale
* @dev enables/disables public sale functions and disables pre sale functions
*/
function togglePublicSale() external onlyOwner {
}
function tokensOfOwner(address owner) external view returns(uint[] memory) {
}
}
| checkVipMintlist(sig),"User not on VIP mintlist!" | 112,081 | checkVipMintlist(sig) |
"Request exceeds max per wallet!" | /**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata extension.
* Made for efficiancy!
*/
contract ERC721 is ERC165, IERC721, IERC721Metadata, Ownable {
using Address for address;
using Strings for uint256;
uint16 public totalSupply;
address public proxyRegistryAddress;
string private baseURI;
// Mapping from token ID to owner address
mapping(uint256 => address) internal _owners;
// Mapping owner address to token count
mapping(address => uint256) internal _balances;
// 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;
constructor(address _openseaProxyRegistry, string memory _baseURI) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function getBaseURI() external view returns(string memory) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() external pure override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() external pure override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) external view override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) external override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) external override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
function setOpenseaProxyRegistry(address addr) external onlyOwner {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) external override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
/**
* @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
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(uint256 amount, address to) internal {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* 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
) internal virtual {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Emits a {ApprovalForAll} event.
*/
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
}
contract OwnableDelegateProxy {}
/**
* Used to delegate ownership of a contract to another address, to save on unneeded transactions to approve contract use for users
*/
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract HANAKO is Ownable, IERC2981, ERC721 {
bool private _onlyMintList;
bool private _mintingEnabled;
address public devWallet;
address public teamWallet;
mapping (address => uint8) private amountMinted;
constructor(
address _openseaProxyRegistry,
string memory _tempBaseURI
) ERC721(_openseaProxyRegistry, _tempBaseURI) { }
function mintFromReserve(uint amount, address to) external onlyOwner {
}
modifier mintFunc(uint amount, uint price) {
}
modifier mintlistFunc(uint amount) {
}
function mint(uint256 amount) external payable mintFunc(amount, 1e17) {
}
function mintlistMint(bytes calldata sig, uint256 amount) external payable mintlistFunc(amount) mintFunc(amount, 9e16) {
}
function checkMintlist(bytes calldata sig) private view returns(bool) {
}
function vipMintlistMint(uint256 amount, bytes calldata sig) external payable mintlistFunc(amount) mintFunc(amount, 8e16) {
require(checkVipMintlist(sig), "User not on VIP mintlist!");
require(<FILL_ME>)
}
function checkVipMintlist(bytes calldata sig) private view returns(bool) {
}
function _checkSig(bytes32 hash, bytes memory sig) private view returns(bool) {
}
function checkSig(address wallet, bytes3 list, bytes memory sig) external view returns(bool) {
}
function getMsg(address wallet, bytes3 list) external pure returns(bytes32) {
}
function getSalesStatus() external view returns(bool onlyWhitelist, bool mintingEnabled) {
}
/**
* @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 setDevWallet(address addr) onlyOwner external {
}
function setTeamWallet(address addr) onlyOwner external {
}
function withdraw() onlyOwner external {
}
/**
* @notice toggles pre sale
* @dev enables the pre sale functions. NEVER USE THIS AFTER ENABLING THE PUBLIC SALE FUNCTIONS UNLESS ITS NECESSARY
*/
function togglePresale() external onlyOwner {
}
/**
* @notice toggles the public sale
* @dev enables/disables public sale functions and disables pre sale functions
*/
function togglePublicSale() external onlyOwner {
}
function tokensOfOwner(address owner) external view returns(uint[] memory) {
}
}
| amount+amountMinted[msg.sender]<6&&amount!=0,"Request exceeds max per wallet!" | 112,081 | amount+amountMinted[msg.sender]<6&&amount!=0 |
"One of the transfers failed!" | /**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata extension.
* Made for efficiancy!
*/
contract ERC721 is ERC165, IERC721, IERC721Metadata, Ownable {
using Address for address;
using Strings for uint256;
uint16 public totalSupply;
address public proxyRegistryAddress;
string private baseURI;
// Mapping from token ID to owner address
mapping(uint256 => address) internal _owners;
// Mapping owner address to token count
mapping(address => uint256) internal _balances;
// 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;
constructor(address _openseaProxyRegistry, string memory _baseURI) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function getBaseURI() external view returns(string memory) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() external pure override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() external pure override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) external view override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) external override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) external override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
function setOpenseaProxyRegistry(address addr) external onlyOwner {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) external override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
/**
* @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
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(uint256 amount, address to) internal {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* 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
) internal virtual {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Emits a {ApprovalForAll} event.
*/
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
}
contract OwnableDelegateProxy {}
/**
* Used to delegate ownership of a contract to another address, to save on unneeded transactions to approve contract use for users
*/
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract HANAKO is Ownable, IERC2981, ERC721 {
bool private _onlyMintList;
bool private _mintingEnabled;
address public devWallet;
address public teamWallet;
mapping (address => uint8) private amountMinted;
constructor(
address _openseaProxyRegistry,
string memory _tempBaseURI
) ERC721(_openseaProxyRegistry, _tempBaseURI) { }
function mintFromReserve(uint amount, address to) external onlyOwner {
}
modifier mintFunc(uint amount, uint price) {
}
modifier mintlistFunc(uint amount) {
}
function mint(uint256 amount) external payable mintFunc(amount, 1e17) {
}
function mintlistMint(bytes calldata sig, uint256 amount) external payable mintlistFunc(amount) mintFunc(amount, 9e16) {
}
function checkMintlist(bytes calldata sig) private view returns(bool) {
}
function vipMintlistMint(uint256 amount, bytes calldata sig) external payable mintlistFunc(amount) mintFunc(amount, 8e16) {
}
function checkVipMintlist(bytes calldata sig) private view returns(bool) {
}
function _checkSig(bytes32 hash, bytes memory sig) private view returns(bool) {
}
function checkSig(address wallet, bytes3 list, bytes memory sig) external view returns(bool) {
}
function getMsg(address wallet, bytes3 list) external pure returns(bytes32) {
}
function getSalesStatus() external view returns(bool onlyWhitelist, bool mintingEnabled) {
}
/**
* @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 setDevWallet(address addr) onlyOwner external {
}
function setTeamWallet(address addr) onlyOwner external {
}
function withdraw() onlyOwner external {
uint bal = address(this).balance;
(bool success1, ) = payable(msg.sender).call{value: bal * 2 / 10, gas: 2600}("");
(bool success2, ) = payable(teamWallet).call{value: bal * 4 / 10, gas: 2600}("");
(bool success3, ) = payable(devWallet).call{value: bal * 4 / 10, gas: 2600}("");
require(<FILL_ME>)
}
/**
* @notice toggles pre sale
* @dev enables the pre sale functions. NEVER USE THIS AFTER ENABLING THE PUBLIC SALE FUNCTIONS UNLESS ITS NECESSARY
*/
function togglePresale() external onlyOwner {
}
/**
* @notice toggles the public sale
* @dev enables/disables public sale functions and disables pre sale functions
*/
function togglePublicSale() external onlyOwner {
}
function tokensOfOwner(address owner) external view returns(uint[] memory) {
}
}
| success1&&success2&&success3,"One of the transfers failed!" | 112,081 | success1&&success2&&success3 |
"ERC20: Transfer amount exceeds the MaxTxAmt." | // SPDX-License-Identifier: Unlicensed
// Portal: https://t.me/kekwerc20
// Website: https://kekw-erc.com
// Twitter: https://twitter.com/kekwcoinerc
pragma solidity ^0.8.16;
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) {
}
}
abstract contract Ownable is Context {
address internal _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, Ownable, IERC20, IERC20Metadata {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(
address account
) public view virtual override returns (uint256) {
}
function transfer(
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function allowance(
address owner,
address spender
) public view virtual override returns (uint256) {
}
function approve(
address spender,
uint256 amount
) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(
address spender,
uint256 addedValue
) public virtual returns (bool) {
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
interface IUniswapV2Factory {
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
}
interface IUniswapV2Pair {
function factory() external view returns (address);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
)
external
payable
returns (uint amountToken, uint amountETH, uint liquidity);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract KEKW is ERC20 {
using SafeMath for uint256;
mapping(address => bool) private _isExcludedFromFee;
mapping(address => bool) private _isExcludedFromMaxWallet;
mapping(address => bool) private _isExcludedFromMaxTnxLimit;
address public marketingWallet;
address constant _burnAddress = 0x000000000000000000000000000000000000dEaD;
uint256 public buyFee = 30;
uint256 public sellFee = 35;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool inSwapAndLiquify;
bool public swapAndSendFeesEnabled = true;
bool public tradingEnabled = false;
uint256 public numTokensSellToSendFees;
uint256 public maxWalletBalance;
uint256 public MaxTxAmt;
event MinTokensBeforeSwapUpdated(uint256 minTokensBeforeSwap);
event swapAndSendFeesEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
modifier lockTheSwap() {
}
constructor() ERC20("KEKW", "KEKW") {
}
function burn(uint tokens) external onlyOwner {
}
function includeAndExcludeFromFee(
address account,
bool value
) public onlyOwner {
}
function isExcludedFromFee(address account) public view returns (bool) {
}
function enableTrading() external onlyOwner {
}
function setBuyAndSellFee(
uint256 bFee,
uint256 sFee
) external onlyOwner {
}
function setmarketingWallet(address _addr) external onlyOwner {
}
function setMaxBalance(uint256 maxBalancePercent) external onlyOwner {
}
function setMaxTxAmount(uint256 maxTxAmount) external onlyOwner {
}
function setNumTokensSellToSendFees(uint256 amount) external onlyOwner {
}
function setRouterAddress(address newRouter) external onlyOwner {
}
function setswapAndSendFeesEnabled(bool _enabled) external onlyOwner {
}
receive() external payable {}
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, "Transfer amount must be greater than zero");
if (from != owner() && !tradingEnabled) {
require(tradingEnabled, "Trading is not enabled yet");
}
if (from != owner() && to != owner())
require(<FILL_ME>)
if (
from != owner() &&
to != address(this) &&
to != _burnAddress &&
to != uniswapV2Pair
) {
uint256 currentBalance = balanceOf(to);
require(
_isExcludedFromMaxWallet[to] ||
(currentBalance + amount <= maxWalletBalance),
"ERC20: Reached Max wallet holding"
);
}
uint256 contractTokenBalance = balanceOf(address(this));
bool overMinTokenBalance = contractTokenBalance >=
numTokensSellToSendFees;
if (
overMinTokenBalance &&
!inSwapAndLiquify &&
from != uniswapV2Pair &&
swapAndSendFeesEnabled
) {
contractTokenBalance = numTokensSellToSendFees;
swapBack(contractTokenBalance);
}
bool takeFee = true;
if (_isExcludedFromFee[from] || _isExcludedFromFee[to]) {
super._transfer(from, to, amount);
takeFee = false;
} else {
if (from == uniswapV2Pair) {
uint256 marketingTokens = amount.mul(buyFee).div(100);
amount = amount.sub(marketingTokens);
super._transfer(from, address(this), marketingTokens);
super._transfer(from, to, amount);
} else if (to == uniswapV2Pair) {
uint256 marketingTokens = amount.mul(sellFee).div(
100
);
amount = amount.sub(marketingTokens);
super._transfer(from, address(this), marketingTokens);
super._transfer(from, to, amount);
} else {
super._transfer(from, to, amount);
}
}
}
function swapBack(uint256 contractBalance) private lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
}
| _isExcludedFromMaxTnxLimit[from]||_isExcludedFromMaxTnxLimit[to]||amount<=MaxTxAmt,"ERC20: Transfer amount exceeds the MaxTxAmt." | 112,104 | _isExcludedFromMaxTnxLimit[from]||_isExcludedFromMaxTnxLimit[to]||amount<=MaxTxAmt |
'Max amount reached.' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract ChillinApeSurfClub is ERC721, Ownable {
using Counters for Counters.Counter;
using Strings for uint;
Counters.Counter private _tokenIdCounter;
uint public constant MAX_TOKENS = 2500;
bool public revealed = false;
string public notRevealedURI = 'https://api.chillinapesurfclub.com/tokens/0.json';
string public baseURI = 'https://api.chillinapesurfclub.com/tokens/';
string public baseExtension = '.json';
bool public freeMintActive = false;
mapping(address => uint) public freeWhitelist;
bool public presaleMintActive = false;
uint public presalePrice = 0.05 ether;
uint public presaleMaxMint = 3;
bytes32 public presaleWhitelist = 0x06cc5af35f40ebf87b2e70c0c7430a0ab2335be9ecd995b7cbef0c95337257ea;
mapping(address => uint) public presaleClaimed;
bool public publicMintActive = false;
uint public publicPrice = 0.08 ether;
uint public publicMaxMint = 5;
mapping(address => bool) public owners;
address[4] public withdrawAddresses = [
0xE5D63D77E908Bf91F49C75A14F4437EA9c80d33c,
0x391E02C23a04B59110Af9f0Cc446DF406A813934,
0x62082343631C4aaED61FFEE138DE6750A5995e37,
0xf1a314DB5e8361311624eb957042D82e2d4911c0
];
uint[4] public withdrawPercentages = [2500, 2500, 2500, 2500];
constructor() ERC721('Chillin Ape Surf Club', 'CASC') {
}
// Owner methods.
function safeMint(address to, uint _mintAmount) public onlyOwner {
require(_mintAmount > 0, 'Invalid mint amount.');
require(_mintAmount <= 50, 'Mint amount exceeded.');
require(<FILL_ME>)
for (uint i = 1; i <= _mintAmount; i++) {
_tokenIdCounter.increment();
_safeMint(to, _tokenIdCounter.current());
}
}
// Sales status methods.
function setMintStatus(bool _freeMintActive, bool _presaleMintActive, bool _publicMintActive) public onlyOwners {
}
function getMintStatus() external view returns (bool[3] memory) {
}
function setMintConditions(uint _presalePrice, uint _presaleMaxMint, uint _publicPrice, uint _publicMaxMint) public onlyOwner {
}
function getMintConditions() external view returns (uint[4] memory) {
}
// Mint methods.
function freeMint(uint _mintAmount) external {
}
function presaleMint(bytes32[] calldata _proof, uint _mintAmount) external payable {
}
function publicMint(uint _mintAmount) external payable {
}
function totalSupply() external view returns (uint) {
}
// Lists methods.
function addFreeWhitelist(address[] memory _users, uint[] memory _mints) external onlyOwner {
}
function removeFreeWhitelist(address[] memory _users) external onlyOwner {
}
function availableFreeMints() external view returns (uint) {
}
function setPresaleWhitelist(bytes32 _presaleWhitelist) external onlyOwner {
}
function availablePresaleMints() external view returns (uint) {
}
// Token methods.
function setRevealed(bool _revealed) external onlyOwner {
}
function setNotRevealedURI(string calldata _notRevealedURI) external onlyOwner {
}
function setBaseURI(string calldata _baseURI, string calldata _baseExtension) external onlyOwner {
}
function tokenURI(uint tokenId) public view override returns (string memory) {
}
function tokensOfOwner(address owner) external view returns(uint[] memory) {
}
// Withdraw methods.
function withdraw() public onlyOwners {
}
function _withdraw(address _addr, uint _amt) private {
}
function emergencyWithdraw() external onlyOwner {
}
// Modifiers.
modifier onlyOwners() {
}
}
| _tokenIdCounter.current()+_mintAmount<MAX_TOKENS,'Max amount reached.' | 112,127 | _tokenIdCounter.current()+_mintAmount<MAX_TOKENS |
'Max amount reached.' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract ChillinApeSurfClub is ERC721, Ownable {
using Counters for Counters.Counter;
using Strings for uint;
Counters.Counter private _tokenIdCounter;
uint public constant MAX_TOKENS = 2500;
bool public revealed = false;
string public notRevealedURI = 'https://api.chillinapesurfclub.com/tokens/0.json';
string public baseURI = 'https://api.chillinapesurfclub.com/tokens/';
string public baseExtension = '.json';
bool public freeMintActive = false;
mapping(address => uint) public freeWhitelist;
bool public presaleMintActive = false;
uint public presalePrice = 0.05 ether;
uint public presaleMaxMint = 3;
bytes32 public presaleWhitelist = 0x06cc5af35f40ebf87b2e70c0c7430a0ab2335be9ecd995b7cbef0c95337257ea;
mapping(address => uint) public presaleClaimed;
bool public publicMintActive = false;
uint public publicPrice = 0.08 ether;
uint public publicMaxMint = 5;
mapping(address => bool) public owners;
address[4] public withdrawAddresses = [
0xE5D63D77E908Bf91F49C75A14F4437EA9c80d33c,
0x391E02C23a04B59110Af9f0Cc446DF406A813934,
0x62082343631C4aaED61FFEE138DE6750A5995e37,
0xf1a314DB5e8361311624eb957042D82e2d4911c0
];
uint[4] public withdrawPercentages = [2500, 2500, 2500, 2500];
constructor() ERC721('Chillin Ape Surf Club', 'CASC') {
}
// Owner methods.
function safeMint(address to, uint _mintAmount) public onlyOwner {
}
// Sales status methods.
function setMintStatus(bool _freeMintActive, bool _presaleMintActive, bool _publicMintActive) public onlyOwners {
}
function getMintStatus() external view returns (bool[3] memory) {
}
function setMintConditions(uint _presalePrice, uint _presaleMaxMint, uint _publicPrice, uint _publicMaxMint) public onlyOwner {
}
function getMintConditions() external view returns (uint[4] memory) {
}
// Mint methods.
function freeMint(uint _mintAmount) external {
require(freeMintActive, 'Free mint is not active.');
require(_mintAmount > 0, 'Invalid mint amount.');
require(_mintAmount <= freeWhitelist[msg.sender], 'Mint amount exceeded.');
require(<FILL_ME>)
freeWhitelist[msg.sender] -= _mintAmount;
for (uint i = 1; i <= _mintAmount; i++) {
_tokenIdCounter.increment();
_safeMint(msg.sender, _tokenIdCounter.current());
}
}
function presaleMint(bytes32[] calldata _proof, uint _mintAmount) external payable {
}
function publicMint(uint _mintAmount) external payable {
}
function totalSupply() external view returns (uint) {
}
// Lists methods.
function addFreeWhitelist(address[] memory _users, uint[] memory _mints) external onlyOwner {
}
function removeFreeWhitelist(address[] memory _users) external onlyOwner {
}
function availableFreeMints() external view returns (uint) {
}
function setPresaleWhitelist(bytes32 _presaleWhitelist) external onlyOwner {
}
function availablePresaleMints() external view returns (uint) {
}
// Token methods.
function setRevealed(bool _revealed) external onlyOwner {
}
function setNotRevealedURI(string calldata _notRevealedURI) external onlyOwner {
}
function setBaseURI(string calldata _baseURI, string calldata _baseExtension) external onlyOwner {
}
function tokenURI(uint tokenId) public view override returns (string memory) {
}
function tokensOfOwner(address owner) external view returns(uint[] memory) {
}
// Withdraw methods.
function withdraw() public onlyOwners {
}
function _withdraw(address _addr, uint _amt) private {
}
function emergencyWithdraw() external onlyOwner {
}
// Modifiers.
modifier onlyOwners() {
}
}
| _tokenIdCounter.current()+_mintAmount<=MAX_TOKENS,'Max amount reached.' | 112,127 | _tokenIdCounter.current()+_mintAmount<=MAX_TOKENS |
'Mint amount exceeded.' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract ChillinApeSurfClub is ERC721, Ownable {
using Counters for Counters.Counter;
using Strings for uint;
Counters.Counter private _tokenIdCounter;
uint public constant MAX_TOKENS = 2500;
bool public revealed = false;
string public notRevealedURI = 'https://api.chillinapesurfclub.com/tokens/0.json';
string public baseURI = 'https://api.chillinapesurfclub.com/tokens/';
string public baseExtension = '.json';
bool public freeMintActive = false;
mapping(address => uint) public freeWhitelist;
bool public presaleMintActive = false;
uint public presalePrice = 0.05 ether;
uint public presaleMaxMint = 3;
bytes32 public presaleWhitelist = 0x06cc5af35f40ebf87b2e70c0c7430a0ab2335be9ecd995b7cbef0c95337257ea;
mapping(address => uint) public presaleClaimed;
bool public publicMintActive = false;
uint public publicPrice = 0.08 ether;
uint public publicMaxMint = 5;
mapping(address => bool) public owners;
address[4] public withdrawAddresses = [
0xE5D63D77E908Bf91F49C75A14F4437EA9c80d33c,
0x391E02C23a04B59110Af9f0Cc446DF406A813934,
0x62082343631C4aaED61FFEE138DE6750A5995e37,
0xf1a314DB5e8361311624eb957042D82e2d4911c0
];
uint[4] public withdrawPercentages = [2500, 2500, 2500, 2500];
constructor() ERC721('Chillin Ape Surf Club', 'CASC') {
}
// Owner methods.
function safeMint(address to, uint _mintAmount) public onlyOwner {
}
// Sales status methods.
function setMintStatus(bool _freeMintActive, bool _presaleMintActive, bool _publicMintActive) public onlyOwners {
}
function getMintStatus() external view returns (bool[3] memory) {
}
function setMintConditions(uint _presalePrice, uint _presaleMaxMint, uint _publicPrice, uint _publicMaxMint) public onlyOwner {
}
function getMintConditions() external view returns (uint[4] memory) {
}
// Mint methods.
function freeMint(uint _mintAmount) external {
}
function presaleMint(bytes32[] calldata _proof, uint _mintAmount) external payable {
require(presaleMintActive, 'Presale mint is not active.');
require(_mintAmount > 0, 'Invalid mint amount.');
require(<FILL_ME>)
require(MerkleProof.verify(_proof, presaleWhitelist, keccak256(abi.encodePacked(msg.sender))), 'Invalid proof.');
require(msg.value >= presalePrice * _mintAmount, 'Invalid price.');
require(_tokenIdCounter.current() + _mintAmount <= MAX_TOKENS, 'Max amount reached.');
presaleClaimed[msg.sender] += _mintAmount;
for (uint i = 1; i <= _mintAmount; i++) {
_tokenIdCounter.increment();
_safeMint(msg.sender, _tokenIdCounter.current());
}
}
function publicMint(uint _mintAmount) external payable {
}
function totalSupply() external view returns (uint) {
}
// Lists methods.
function addFreeWhitelist(address[] memory _users, uint[] memory _mints) external onlyOwner {
}
function removeFreeWhitelist(address[] memory _users) external onlyOwner {
}
function availableFreeMints() external view returns (uint) {
}
function setPresaleWhitelist(bytes32 _presaleWhitelist) external onlyOwner {
}
function availablePresaleMints() external view returns (uint) {
}
// Token methods.
function setRevealed(bool _revealed) external onlyOwner {
}
function setNotRevealedURI(string calldata _notRevealedURI) external onlyOwner {
}
function setBaseURI(string calldata _baseURI, string calldata _baseExtension) external onlyOwner {
}
function tokenURI(uint tokenId) public view override returns (string memory) {
}
function tokensOfOwner(address owner) external view returns(uint[] memory) {
}
// Withdraw methods.
function withdraw() public onlyOwners {
}
function _withdraw(address _addr, uint _amt) private {
}
function emergencyWithdraw() external onlyOwner {
}
// Modifiers.
modifier onlyOwners() {
}
}
| _mintAmount+presaleClaimed[msg.sender]<=presaleMaxMint,'Mint amount exceeded.' | 112,127 | _mintAmount+presaleClaimed[msg.sender]<=presaleMaxMint |
'Invalid proof.' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract ChillinApeSurfClub is ERC721, Ownable {
using Counters for Counters.Counter;
using Strings for uint;
Counters.Counter private _tokenIdCounter;
uint public constant MAX_TOKENS = 2500;
bool public revealed = false;
string public notRevealedURI = 'https://api.chillinapesurfclub.com/tokens/0.json';
string public baseURI = 'https://api.chillinapesurfclub.com/tokens/';
string public baseExtension = '.json';
bool public freeMintActive = false;
mapping(address => uint) public freeWhitelist;
bool public presaleMintActive = false;
uint public presalePrice = 0.05 ether;
uint public presaleMaxMint = 3;
bytes32 public presaleWhitelist = 0x06cc5af35f40ebf87b2e70c0c7430a0ab2335be9ecd995b7cbef0c95337257ea;
mapping(address => uint) public presaleClaimed;
bool public publicMintActive = false;
uint public publicPrice = 0.08 ether;
uint public publicMaxMint = 5;
mapping(address => bool) public owners;
address[4] public withdrawAddresses = [
0xE5D63D77E908Bf91F49C75A14F4437EA9c80d33c,
0x391E02C23a04B59110Af9f0Cc446DF406A813934,
0x62082343631C4aaED61FFEE138DE6750A5995e37,
0xf1a314DB5e8361311624eb957042D82e2d4911c0
];
uint[4] public withdrawPercentages = [2500, 2500, 2500, 2500];
constructor() ERC721('Chillin Ape Surf Club', 'CASC') {
}
// Owner methods.
function safeMint(address to, uint _mintAmount) public onlyOwner {
}
// Sales status methods.
function setMintStatus(bool _freeMintActive, bool _presaleMintActive, bool _publicMintActive) public onlyOwners {
}
function getMintStatus() external view returns (bool[3] memory) {
}
function setMintConditions(uint _presalePrice, uint _presaleMaxMint, uint _publicPrice, uint _publicMaxMint) public onlyOwner {
}
function getMintConditions() external view returns (uint[4] memory) {
}
// Mint methods.
function freeMint(uint _mintAmount) external {
}
function presaleMint(bytes32[] calldata _proof, uint _mintAmount) external payable {
require(presaleMintActive, 'Presale mint is not active.');
require(_mintAmount > 0, 'Invalid mint amount.');
require(_mintAmount + presaleClaimed[msg.sender] <= presaleMaxMint, 'Mint amount exceeded.');
require(<FILL_ME>)
require(msg.value >= presalePrice * _mintAmount, 'Invalid price.');
require(_tokenIdCounter.current() + _mintAmount <= MAX_TOKENS, 'Max amount reached.');
presaleClaimed[msg.sender] += _mintAmount;
for (uint i = 1; i <= _mintAmount; i++) {
_tokenIdCounter.increment();
_safeMint(msg.sender, _tokenIdCounter.current());
}
}
function publicMint(uint _mintAmount) external payable {
}
function totalSupply() external view returns (uint) {
}
// Lists methods.
function addFreeWhitelist(address[] memory _users, uint[] memory _mints) external onlyOwner {
}
function removeFreeWhitelist(address[] memory _users) external onlyOwner {
}
function availableFreeMints() external view returns (uint) {
}
function setPresaleWhitelist(bytes32 _presaleWhitelist) external onlyOwner {
}
function availablePresaleMints() external view returns (uint) {
}
// Token methods.
function setRevealed(bool _revealed) external onlyOwner {
}
function setNotRevealedURI(string calldata _notRevealedURI) external onlyOwner {
}
function setBaseURI(string calldata _baseURI, string calldata _baseExtension) external onlyOwner {
}
function tokenURI(uint tokenId) public view override returns (string memory) {
}
function tokensOfOwner(address owner) external view returns(uint[] memory) {
}
// Withdraw methods.
function withdraw() public onlyOwners {
}
function _withdraw(address _addr, uint _amt) private {
}
function emergencyWithdraw() external onlyOwner {
}
// Modifiers.
modifier onlyOwners() {
}
}
| MerkleProof.verify(_proof,presaleWhitelist,keccak256(abi.encodePacked(msg.sender))),'Invalid proof.' | 112,127 | MerkleProof.verify(_proof,presaleWhitelist,keccak256(abi.encodePacked(msg.sender))) |
"You should enable native out when m.bridgeNativeOut is true" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.13;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./im/message/framework/MessageSenderApp.sol";
import "./im/message/framework/MessageReceiverApp.sol";
import "../../../interfaces/IUniswapV2.sol";
import "../../../interfaces/IWETH.sol";
import "./im/interfaces/IMessageBusSender.sol";
import "./RangoCBridgeModels.sol";
import "../../rango/bridges/cbridge/IRangoCBridge.sol";
import "../../libs/BaseContract.sol";
import "../../../interfaces/IRangoMessageReceiver.sol";
/// @title The root contract that handles Rango's interaction with cBridge and receives message from Celer IM
/// @author Uchiha Sasuke
/// @dev This is deployed as a separate contract from RangoV1
contract RangoCBridge is IRangoCBridge, MessageSenderApp, MessageReceiverApp, BaseContract {
/// @notice The address of cBridge contract
address cBridgeAddress;
/// @notice The constructor of this contract that receives WETH address and initiates the settings
/// @param _nativeWrappedAddress The address of WETH, WBNB, etc of the current network
constructor(address _nativeWrappedAddress) {
}
/// @notice Enables the contract to receive native ETH token from other contracts including WETH contract
receive() external payable { }
/// @notice A series of events with different status value to help us track the progress of cross-chain swap
/// @param id The transferId generated by cBridge
/// @param token The token address in the current network that is being bridged
/// @param outputAmount The latest observed amount in the path, aka: input amount for source and output amount on dest
/// @param _destination The destination address that received the money, ZERO address if not sent to the end-user yet
event CBridgeIMStatusUpdated(bytes32 id, address token, uint256 outputAmount, OperationStatus status, address _destination);
/// @notice A simple cBridge.send scenario
/// @param _receiver The wallet address of receiver on the destination
/// @param _token The address of token on the source chain
/// @param _amount The input amount sent to the bridge
/// @param _dstChainId The network id of destination chain
/// @param _nonce A nonce mechanism used by cBridge that is generated off-chain, it normally is the time.now()
/// @param _maxSlippage The maximum tolerable slippage by user on cBridge side (The bridge is not 1-1 and may have slippage in big swaps)
event CBridgeSend(address _receiver, address _token, uint256 _amount, uint64 _dstChainId, uint64 _nonce, uint32 _maxSlippage);
/// @notice Emits when the cBridge address is updated
/// @param _oldAddress The previous address
/// @param _newAddress The new address
event CBridgeAddressUpdated(address _oldAddress, address _newAddress);
/// @notice Status of cross-chain celer IM swap
/// @param Created It's sent to bridge and waiting for bridge response
/// @param Succeeded The whole process is success and end-user received the desired token in the destination
/// @param RefundInSource Bridge was out of liquidity and middle asset (ex: USDC) is returned to user on source chain
/// @param RefundInDestination Our handler on dest chain this.executeMessageWithTransfer failed and we send middle asset (ex: USDC) to user on destination chain
/// @param SwapFailedInDestination Everything was ok, but the final DEX on destination failed (ex: Market price change and slippage)
enum OperationStatus {
Created,
Succeeded,
RefundInSource,
RefundInDestination,
SwapFailedInDestination
}
/// @notice Updates the address of cBridge contract
/// @param _address The new address of cBridge contract
function updateCBridgeAddress(address _address) external onlyOwner {
}
/// @notice Computes the sgnFee for a given message based on messageBus formula
/// @param imMessage The message that fee is computed for
function computeCBridgeSgnFee(RangoCBridgeModels.RangoCBridgeInterChainMessage memory imMessage) external view returns(uint) {
}
/// @inheritdoc IRangoCBridge
function send(
address _receiver,
address _token,
uint256 _amount,
uint64 _dstChainId,
uint64 _nonce,
uint32 _maxSlippage
) external override whenNotPaused nonReentrant {
}
/// @inheritdoc IRangoCBridge
function cBridgeIM(
address _fromToken,
uint _inputAmount,
address _receiverContract, // The receiver app contract address, not recipient
uint64 _dstChainId,
uint64 _nonce,
uint32 _maxSlippage,
uint _sgnFee,
RangoCBridgeModels.RangoCBridgeInterChainMessage memory imMessage
) external override payable whenNotPaused nonReentrant {
}
/// @inheritdoc IMessageReceiverApp
/// @dev We also send a message to dApp if dAppMessage is valid
/// @dev We refund the money back to the _message.originalSender which is the source wallet address or any wallet that dapp likes to be receiver of the refund
function executeMessageWithTransferRefund(
address _token,
uint256 _amount,
bytes calldata _message,
address // executor
) external payable override onlyMessageBus returns (ExecutionStatus) {
}
/// @inheritdoc IMessageReceiverApp
/**
* @dev If our _message contains a uniswap-like DEX call on the destination we also perform it here
* There are also some flags such as:
* 1. _message.bridgeNativeOut which indicates that bridge sent native token to us, so we unwrap it if required
* 2. _message.nativeOut which indicates that we should send native token to end-user/dapp so we unwrap it if needed
*/
function executeMessageWithTransfer(
address, // _sender
address _token,
uint256 _amount,
uint64 _srcChainId,
bytes memory _message,
address // executor
) external payable override onlyMessageBus whenNotPaused nonReentrant returns (ExecutionStatus) {
RangoCBridgeModels.RangoCBridgeInterChainMessage memory m = abi.decode((_message), (RangoCBridgeModels.RangoCBridgeInterChainMessage));
BaseContractStorage storage baseStorage = getBaseContractStorage();
require(_token == m.path[0], "bridged token must be the same as the first token in destination swap path");
require(_token == m.fromToken, "bridged token must be the same as the requested swap token");
if (m.bridgeNativeOut) {
require(_token == baseStorage.nativeWrappedAddress, "_token must be WETH address");
}
bytes32 id = _computeSwapRequestId(m.originalSender, _srcChainId, uint64(block.chainid), _message);
uint256 dstAmount;
OperationStatus status = OperationStatus.Succeeded;
address receivedToken = _token;
if (m.path.length > 1) {
if (m.bridgeNativeOut) {
IWETH(baseStorage.nativeWrappedAddress).deposit{value: _amount}();
}
bool ok = true;
(ok, dstAmount) = _trySwap(m, _amount);
if (ok) {
_sendToken(
m.toToken,
dstAmount,
m.recipient,
m.nativeOut,
true,
m.dAppMessage,
m.dAppDestContract,
IRangoMessageReceiver.ProcessStatus.SUCCESS
);
status = OperationStatus.Succeeded;
receivedToken = m.nativeOut ? NULL_ADDRESS : m.toToken;
} else {
// handle swap failure, send the received token directly to receiver
_sendToken(
_token,
_amount,
m.recipient,
false,
false,
m.dAppMessage,
m.dAppDestContract,
IRangoMessageReceiver.ProcessStatus.REFUND_IN_DESTINATION
);
dstAmount = _amount;
status = OperationStatus.SwapFailedInDestination;
receivedToken = _token;
}
} else {
// no need to swap, directly send the bridged token to user
if (m.bridgeNativeOut) {
require(<FILL_ME>)
}
address sourceToken = m.bridgeNativeOut ? NULL_ADDRESS: _token;
bool withdraw = m.bridgeNativeOut ? false : true;
_sendToken(
sourceToken,
_amount,
m.recipient,
m.nativeOut,
withdraw,
m.dAppMessage,
m.dAppDestContract,
IRangoMessageReceiver.ProcessStatus.SUCCESS
);
dstAmount = _amount;
status = OperationStatus.Succeeded;
receivedToken = m.nativeOut ? NULL_ADDRESS : m.path[0];
}
emit CBridgeIMStatusUpdated(id, receivedToken, dstAmount, status, m.recipient);
// always return success since swap failure is already handled in-place
return ExecutionStatus.Success;
}
/// @inheritdoc IMessageReceiverApp
/// @dev In case of failure in the destination, we only send money to the end-user in the destination
function executeMessageWithTransferFallback(
address, // _sender
address _token, // _token
uint256 _amount, // _amount
uint64 _srcChainId,
bytes memory _message,
address // executor
) external payable override onlyMessageBus whenNotPaused nonReentrant returns (ExecutionStatus) {
}
/// @notice Computes the transferId generated by cBridge
/// @param _sender The sender wallet or contract address
/// @param _srcChainId The network id of source
/// @param _dstChainId The network id of destination
/// @param _message The byte array message that Rango likes to transfer
/// @return The bytes32 hash of all these information combined
function _computeSwapRequestId(
address _sender,
uint64 _srcChainId,
uint64 _dstChainId,
bytes memory _message
) private pure returns (bytes32) {
}
/// @notice Performs a uniswap-v2 operation
/// @param _swap The interchain message that contains the swap info
/// @param _amount The amount of input token
/// @return ok Indicates that the swap operation was success or fail
/// @return amountOut If ok = true, amountOut is the output amount of the swap
function _trySwap(
RangoCBridgeModels.RangoCBridgeInterChainMessage memory _swap,
uint256 _amount
) private returns (bool ok, uint256 amountOut) {
}
}
| m.nativeOut,"You should enable native out when m.bridgeNativeOut is true" | 112,132 | m.nativeOut |
"Dex address is not whitelisted" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.13;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./im/message/framework/MessageSenderApp.sol";
import "./im/message/framework/MessageReceiverApp.sol";
import "../../../interfaces/IUniswapV2.sol";
import "../../../interfaces/IWETH.sol";
import "./im/interfaces/IMessageBusSender.sol";
import "./RangoCBridgeModels.sol";
import "../../rango/bridges/cbridge/IRangoCBridge.sol";
import "../../libs/BaseContract.sol";
import "../../../interfaces/IRangoMessageReceiver.sol";
/// @title The root contract that handles Rango's interaction with cBridge and receives message from Celer IM
/// @author Uchiha Sasuke
/// @dev This is deployed as a separate contract from RangoV1
contract RangoCBridge is IRangoCBridge, MessageSenderApp, MessageReceiverApp, BaseContract {
/// @notice The address of cBridge contract
address cBridgeAddress;
/// @notice The constructor of this contract that receives WETH address and initiates the settings
/// @param _nativeWrappedAddress The address of WETH, WBNB, etc of the current network
constructor(address _nativeWrappedAddress) {
}
/// @notice Enables the contract to receive native ETH token from other contracts including WETH contract
receive() external payable { }
/// @notice A series of events with different status value to help us track the progress of cross-chain swap
/// @param id The transferId generated by cBridge
/// @param token The token address in the current network that is being bridged
/// @param outputAmount The latest observed amount in the path, aka: input amount for source and output amount on dest
/// @param _destination The destination address that received the money, ZERO address if not sent to the end-user yet
event CBridgeIMStatusUpdated(bytes32 id, address token, uint256 outputAmount, OperationStatus status, address _destination);
/// @notice A simple cBridge.send scenario
/// @param _receiver The wallet address of receiver on the destination
/// @param _token The address of token on the source chain
/// @param _amount The input amount sent to the bridge
/// @param _dstChainId The network id of destination chain
/// @param _nonce A nonce mechanism used by cBridge that is generated off-chain, it normally is the time.now()
/// @param _maxSlippage The maximum tolerable slippage by user on cBridge side (The bridge is not 1-1 and may have slippage in big swaps)
event CBridgeSend(address _receiver, address _token, uint256 _amount, uint64 _dstChainId, uint64 _nonce, uint32 _maxSlippage);
/// @notice Emits when the cBridge address is updated
/// @param _oldAddress The previous address
/// @param _newAddress The new address
event CBridgeAddressUpdated(address _oldAddress, address _newAddress);
/// @notice Status of cross-chain celer IM swap
/// @param Created It's sent to bridge and waiting for bridge response
/// @param Succeeded The whole process is success and end-user received the desired token in the destination
/// @param RefundInSource Bridge was out of liquidity and middle asset (ex: USDC) is returned to user on source chain
/// @param RefundInDestination Our handler on dest chain this.executeMessageWithTransfer failed and we send middle asset (ex: USDC) to user on destination chain
/// @param SwapFailedInDestination Everything was ok, but the final DEX on destination failed (ex: Market price change and slippage)
enum OperationStatus {
Created,
Succeeded,
RefundInSource,
RefundInDestination,
SwapFailedInDestination
}
/// @notice Updates the address of cBridge contract
/// @param _address The new address of cBridge contract
function updateCBridgeAddress(address _address) external onlyOwner {
}
/// @notice Computes the sgnFee for a given message based on messageBus formula
/// @param imMessage The message that fee is computed for
function computeCBridgeSgnFee(RangoCBridgeModels.RangoCBridgeInterChainMessage memory imMessage) external view returns(uint) {
}
/// @inheritdoc IRangoCBridge
function send(
address _receiver,
address _token,
uint256 _amount,
uint64 _dstChainId,
uint64 _nonce,
uint32 _maxSlippage
) external override whenNotPaused nonReentrant {
}
/// @inheritdoc IRangoCBridge
function cBridgeIM(
address _fromToken,
uint _inputAmount,
address _receiverContract, // The receiver app contract address, not recipient
uint64 _dstChainId,
uint64 _nonce,
uint32 _maxSlippage,
uint _sgnFee,
RangoCBridgeModels.RangoCBridgeInterChainMessage memory imMessage
) external override payable whenNotPaused nonReentrant {
}
/// @inheritdoc IMessageReceiverApp
/// @dev We also send a message to dApp if dAppMessage is valid
/// @dev We refund the money back to the _message.originalSender which is the source wallet address or any wallet that dapp likes to be receiver of the refund
function executeMessageWithTransferRefund(
address _token,
uint256 _amount,
bytes calldata _message,
address // executor
) external payable override onlyMessageBus returns (ExecutionStatus) {
}
/// @inheritdoc IMessageReceiverApp
/**
* @dev If our _message contains a uniswap-like DEX call on the destination we also perform it here
* There are also some flags such as:
* 1. _message.bridgeNativeOut which indicates that bridge sent native token to us, so we unwrap it if required
* 2. _message.nativeOut which indicates that we should send native token to end-user/dapp so we unwrap it if needed
*/
function executeMessageWithTransfer(
address, // _sender
address _token,
uint256 _amount,
uint64 _srcChainId,
bytes memory _message,
address // executor
) external payable override onlyMessageBus whenNotPaused nonReentrant returns (ExecutionStatus) {
}
/// @inheritdoc IMessageReceiverApp
/// @dev In case of failure in the destination, we only send money to the end-user in the destination
function executeMessageWithTransferFallback(
address, // _sender
address _token, // _token
uint256 _amount, // _amount
uint64 _srcChainId,
bytes memory _message,
address // executor
) external payable override onlyMessageBus whenNotPaused nonReentrant returns (ExecutionStatus) {
}
/// @notice Computes the transferId generated by cBridge
/// @param _sender The sender wallet or contract address
/// @param _srcChainId The network id of source
/// @param _dstChainId The network id of destination
/// @param _message The byte array message that Rango likes to transfer
/// @return The bytes32 hash of all these information combined
function _computeSwapRequestId(
address _sender,
uint64 _srcChainId,
uint64 _dstChainId,
bytes memory _message
) private pure returns (bytes32) {
}
/// @notice Performs a uniswap-v2 operation
/// @param _swap The interchain message that contains the swap info
/// @param _amount The amount of input token
/// @return ok Indicates that the swap operation was success or fail
/// @return amountOut If ok = true, amountOut is the output amount of the swap
function _trySwap(
RangoCBridgeModels.RangoCBridgeInterChainMessage memory _swap,
uint256 _amount
) private returns (bool ok, uint256 amountOut) {
BaseContractStorage storage baseStorage = getBaseContractStorage();
require(<FILL_ME>)
uint256 zero;
approve(_swap.fromToken, _swap.dexAddress, _amount);
try
IUniswapV2(_swap.dexAddress).swapExactTokensForTokens(
_amount,
_swap.amountOutMin,
_swap.path,
address(this),
_swap.deadline
)
returns (uint256[] memory amounts) {
return (true, amounts[amounts.length - 1]);
} catch {
return (false, zero);
}
}
}
| baseStorage.whitelistContracts[_swap.dexAddress]==true,"Dex address is not whitelisted" | 112,132 | baseStorage.whitelistContracts[_swap.dexAddress]==true |
"Not authorized" | // SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.0;
import "./ERC721LazyMint.sol";
import "../extension/DelayedReveal.sol";
/**
* BASE: ERC721LazyMint
* EXTENSION: DelayedReveal
*
* The `ERC721DelayedReveal` contract uses the `ERC721LazyMint` contract, along with `DelayedReveal` extension.
*
* 'Lazy minting' means defining the metadata of NFTs without minting it to an address. Regular 'minting'
* of NFTs means actually assigning an owner to an NFT.
*
* As a contract admin, this lets you prepare the metadata for NFTs that will be minted by an external party,
* without paying the gas cost for actually minting the NFTs.
*
* 'Delayed reveal' is a mechanism by which you can distribute NFTs to your audience and reveal the metadata of the distributed
* NFTs, after the fact.
*
* You can read more about how the `DelayedReveal` extension works, here: https://blog.thirdweb.com/delayed-reveal-nfts
*/
contract ERC721DelayedReveal is ERC721LazyMint, DelayedReveal {
using TWStrings for uint256;
/*//////////////////////////////////////////////////////////////
Constructor
//////////////////////////////////////////////////////////////*/
constructor(
string memory _name,
string memory _symbol,
address _royaltyRecipient,
uint128 _royaltyBps
) ERC721LazyMint(_name, _symbol, _royaltyRecipient, _royaltyBps) {}
/*//////////////////////////////////////////////////////////////
Overriden ERC721 logic
//////////////////////////////////////////////////////////////*/
/**
* @notice Returns the metadata URI for an NFT.
* @dev See `BatchMintMetadata` for handling of metadata in this contract.
*
* @param _tokenId The tokenId of an NFT.
*/
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
/*//////////////////////////////////////////////////////////////
Lazy minting logic
//////////////////////////////////////////////////////////////*/
/**
* @notice Lets an authorized address lazy mint a given amount of NFTs.
*
* @param _amount The number of NFTs to lazy mint.
* @param _baseURIForTokens The placeholder base URI for the 'n' number of NFTs being lazy minted, where the
* metadata for each of those NFTs is `${baseURIForTokens}/${tokenId}`.
* @param _data The encrypted base URI + provenance hash for the batch of NFTs being lazy minted.
* @return batchId A unique integer identifier for the batch of NFTs lazy minted together.
*/
function lazyMint(
uint256 _amount,
string calldata _baseURIForTokens,
bytes calldata _data
) public override returns (uint256 batchId) {
}
/*//////////////////////////////////////////////////////////////
Delayed reveal logic
//////////////////////////////////////////////////////////////*/
/**
* @notice Lets an authorized address reveal a batch of delayed reveal NFTs.
*
* @param _index The ID for the batch of delayed-reveal NFTs to reveal.
* @param _key The key with which the base URI for the relevant batch of NFTs was encrypted.
*/
function reveal(uint256 _index, bytes calldata _key) external virtual override returns (string memory revealedURI) {
require(<FILL_ME>)
uint256 batchId = getBatchIdAtIndex(_index);
revealedURI = getRevealURI(batchId, _key);
_setEncryptedData(batchId, "");
_setBaseURI(batchId, revealedURI);
emit TokenURIRevealed(_index, revealedURI);
}
/// @dev Checks whether NFTs can be revealed in the given execution context.
function _canReveal() internal view virtual returns (bool) {
}
}
| _canReveal(),"Not authorized" | 112,268 | _canReveal() |
"stake(): Staker not owner" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "./libraries/ERC721A.sol";
import "./libraries/SimpleAccess.sol";
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract Bee is ERC721A, SimpleAccess {
using Strings for uint256;
address private stakeAddress;
string public baseURIString = "";
address public openseaProxyRegistryAddress;
/**
* @dev The idea of boosting power is that
* we calculate the amount of weeks since it
* was 100% and we substract 5% power from each week.
*
* So we calculate each week from powerCycleStart
* and for each one we remove 5% boosting power
*
* When someone refills boosting power we add the amount
* of weeks to the start time corresponding to the amount
* of refills they have done (1 refill = 1 week). This means
* we add weeks to the powerCycleStart corresponding to the
* amount of refills.
*
* When we refill the bee we always refill fully. Meaning
* If you refill right before you lose another 5% you will
* get your original 5% back and start the counter again from 0.
*
* When someone unstakes we save the amount of boosting weeks
* the bee has left. When someone stakes later we set the cycle start
* such that the boosting weeks match again. We store the seconds difference
* from blocktime and unstake time and when staked again we make sure
* the difference between cycle start and blocktime is those seconds.
*
* This way ^^ the bee doesn't lose power when unstaked.
*/
uint256 public powerCycleBasePeriod = 1 days * 7; /// @dev 1 week
uint256 public powerCycleMaxPeriods = 20; /// @dev we can have 20 times 5% boost
struct BeeSpec {
uint88 lastInteraction; /// @dev timestamp of last interaction with flowerfam ecosystem
uint88 powerCycleStart; /// @dev records start time of power cycle which decreases 5% every weeks
uint80 powerCycleStored; /// @dev stores the power cycle left of the bee when unstaked --> amount of time since last restore until unstake
}
struct UserBeeSpec {
uint256 beeId;
bool isAlreadyStaked;
}
mapping(uint256 => BeeSpec) public beeSpecs;
constructor(address _openseaProxyRegistryAddress, address _stakeAddress)
ERC721A("Bee", "BEE") {
}
function mint(
address sender,
uint256 amount
) external onlyAuthorized {
}
function isAlreadyStaked(uint256 tokenId) internal view returns (bool) {
}
function getLastAction(uint256 tokenId) external view returns (uint88) {
}
function getPowerCycleStart(uint256 tokenId) external view returns (uint88) {
}
function getNFTs(address user)
external
view
returns (UserBeeSpec[] memory) {
}
function ownerOf(uint256 tokenId) public view override returns (address) {
}
function realOwnerOf(uint256 tokenId) external view returns (address) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function startTokenId() external pure returns (uint256) {
}
function stake(
address staker,
uint256 tokenId
) external onlyAuthorized {
require(_exists(tokenId), "stake(): Bee doesn't exist!");
require(<FILL_ME>)
require(staker != stakeAddress, "stake(): Stake address can not stake");
_clearApprovals(staker, tokenId);
BeeSpec storage bee = beeSpecs[tokenId];
bee.lastInteraction = uint40(block.timestamp);
if (bee.powerCycleStart == 0) {
bee.powerCycleStart = uint40(block.timestamp);
} else {
bee.powerCycleStart = uint40(block.timestamp - bee.powerCycleStored); /// @dev set bee power cycle right where it was when unstaked
}
emit Transfer(staker, stakeAddress, tokenId); /// @dev Emit transfer event to indicate transfer of bee to stake wallet
}
function unstake(address unstaker, uint256 tokenId)
external
onlyAuthorized
{
}
/**
* @dev To restore the power of the bee we take in a restorePeriods amount.
* We check if its at most the amount of periods we lost, as we cannot restore
* more periods than were lost. Then based on the restore amount and the periods lost
* we caculate the new target periods lost. For example if we lost 3 periods (3 weeks or 15%)
* and we want to restore 2 periods (2 weeks or 10%) then our target lost periods becomes
* 1 (1 week or 5%).
*
* Once we know this target lost periods we set the powerCycleStart such that the difference
* with the current time, divided by the seconds per period leads to the target period amount.
*
* For example if the target period is 1 we set the powerCycleStart to the current time - 1 week.
* This way when we calculate the powerReductionPeriods we will get 1 week as the result.
*/
function restorePowerOfBee(address owner, uint256 tokenId, uint256 restorePeriods)
external
onlyAuthorized
{
}
/**
* @dev returns the amount of boost reduction periods
* the bee has accumulated. Since solidity rounds down divisions
* we will get "0" when the difference between the start and current time
* is less than 1 week. We will get "1" when the difference between the
* start and current time is between 1 week and less than 2 weeks etc.
*/
function _getPowerReductionPeriods(uint256 tokenId) internal view returns (uint256) {
}
function getPowerReductionPeriods(uint256 tokenId) external view returns (uint256) {
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setPowerCycleBasePeriod(uint256 newBasePeriod) external onlyOwner {
}
function setPowerCycleMaxPeriods(uint256 newMaxPeriods) external onlyOwner {
}
function setStakeAddress(address stkaddr) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override {
}
function isApprovedForAll(address owner, address operator)
override
public
view
returns (bool)
{
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
}
| ownerOf(tokenId)==staker,"stake(): Staker not owner" | 112,448 | ownerOf(tokenId)==staker |
"unStake: Bee is not staked!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "./libraries/ERC721A.sol";
import "./libraries/SimpleAccess.sol";
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract Bee is ERC721A, SimpleAccess {
using Strings for uint256;
address private stakeAddress;
string public baseURIString = "";
address public openseaProxyRegistryAddress;
/**
* @dev The idea of boosting power is that
* we calculate the amount of weeks since it
* was 100% and we substract 5% power from each week.
*
* So we calculate each week from powerCycleStart
* and for each one we remove 5% boosting power
*
* When someone refills boosting power we add the amount
* of weeks to the start time corresponding to the amount
* of refills they have done (1 refill = 1 week). This means
* we add weeks to the powerCycleStart corresponding to the
* amount of refills.
*
* When we refill the bee we always refill fully. Meaning
* If you refill right before you lose another 5% you will
* get your original 5% back and start the counter again from 0.
*
* When someone unstakes we save the amount of boosting weeks
* the bee has left. When someone stakes later we set the cycle start
* such that the boosting weeks match again. We store the seconds difference
* from blocktime and unstake time and when staked again we make sure
* the difference between cycle start and blocktime is those seconds.
*
* This way ^^ the bee doesn't lose power when unstaked.
*/
uint256 public powerCycleBasePeriod = 1 days * 7; /// @dev 1 week
uint256 public powerCycleMaxPeriods = 20; /// @dev we can have 20 times 5% boost
struct BeeSpec {
uint88 lastInteraction; /// @dev timestamp of last interaction with flowerfam ecosystem
uint88 powerCycleStart; /// @dev records start time of power cycle which decreases 5% every weeks
uint80 powerCycleStored; /// @dev stores the power cycle left of the bee when unstaked --> amount of time since last restore until unstake
}
struct UserBeeSpec {
uint256 beeId;
bool isAlreadyStaked;
}
mapping(uint256 => BeeSpec) public beeSpecs;
constructor(address _openseaProxyRegistryAddress, address _stakeAddress)
ERC721A("Bee", "BEE") {
}
function mint(
address sender,
uint256 amount
) external onlyAuthorized {
}
function isAlreadyStaked(uint256 tokenId) internal view returns (bool) {
}
function getLastAction(uint256 tokenId) external view returns (uint88) {
}
function getPowerCycleStart(uint256 tokenId) external view returns (uint88) {
}
function getNFTs(address user)
external
view
returns (UserBeeSpec[] memory) {
}
function ownerOf(uint256 tokenId) public view override returns (address) {
}
function realOwnerOf(uint256 tokenId) external view returns (address) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function startTokenId() external pure returns (uint256) {
}
function stake(
address staker,
uint256 tokenId
) external onlyAuthorized {
}
function unstake(address unstaker, uint256 tokenId)
external
onlyAuthorized
{
require(<FILL_ME>)
require(
_ownershipOf(tokenId).addr == unstaker,
"unstake: Unstaker not real owner"
);
BeeSpec storage bee = beeSpecs[tokenId];
bee.lastInteraction = 0;
bee.powerCycleStored = uint40(block.timestamp - bee.powerCycleStart); /// @dev we save the power cycle amount we lost
emit Transfer(stakeAddress, unstaker, tokenId); /// @dev Emit transfer event to indicate transfer of bee from stake wallet to owner
}
/**
* @dev To restore the power of the bee we take in a restorePeriods amount.
* We check if its at most the amount of periods we lost, as we cannot restore
* more periods than were lost. Then based on the restore amount and the periods lost
* we caculate the new target periods lost. For example if we lost 3 periods (3 weeks or 15%)
* and we want to restore 2 periods (2 weeks or 10%) then our target lost periods becomes
* 1 (1 week or 5%).
*
* Once we know this target lost periods we set the powerCycleStart such that the difference
* with the current time, divided by the seconds per period leads to the target period amount.
*
* For example if the target period is 1 we set the powerCycleStart to the current time - 1 week.
* This way when we calculate the powerReductionPeriods we will get 1 week as the result.
*/
function restorePowerOfBee(address owner, uint256 tokenId, uint256 restorePeriods)
external
onlyAuthorized
{
}
/**
* @dev returns the amount of boost reduction periods
* the bee has accumulated. Since solidity rounds down divisions
* we will get "0" when the difference between the start and current time
* is less than 1 week. We will get "1" when the difference between the
* start and current time is between 1 week and less than 2 weeks etc.
*/
function _getPowerReductionPeriods(uint256 tokenId) internal view returns (uint256) {
}
function getPowerReductionPeriods(uint256 tokenId) external view returns (uint256) {
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setPowerCycleBasePeriod(uint256 newBasePeriod) external onlyOwner {
}
function setPowerCycleMaxPeriods(uint256 newMaxPeriods) external onlyOwner {
}
function setStakeAddress(address stkaddr) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override {
}
function isApprovedForAll(address owner, address operator)
override
public
view
returns (bool)
{
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
}
| isAlreadyStaked(tokenId),"unStake: Bee is not staked!" | 112,448 | isAlreadyStaked(tokenId) |
"unstake: Unstaker not real owner" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "./libraries/ERC721A.sol";
import "./libraries/SimpleAccess.sol";
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract Bee is ERC721A, SimpleAccess {
using Strings for uint256;
address private stakeAddress;
string public baseURIString = "";
address public openseaProxyRegistryAddress;
/**
* @dev The idea of boosting power is that
* we calculate the amount of weeks since it
* was 100% and we substract 5% power from each week.
*
* So we calculate each week from powerCycleStart
* and for each one we remove 5% boosting power
*
* When someone refills boosting power we add the amount
* of weeks to the start time corresponding to the amount
* of refills they have done (1 refill = 1 week). This means
* we add weeks to the powerCycleStart corresponding to the
* amount of refills.
*
* When we refill the bee we always refill fully. Meaning
* If you refill right before you lose another 5% you will
* get your original 5% back and start the counter again from 0.
*
* When someone unstakes we save the amount of boosting weeks
* the bee has left. When someone stakes later we set the cycle start
* such that the boosting weeks match again. We store the seconds difference
* from blocktime and unstake time and when staked again we make sure
* the difference between cycle start and blocktime is those seconds.
*
* This way ^^ the bee doesn't lose power when unstaked.
*/
uint256 public powerCycleBasePeriod = 1 days * 7; /// @dev 1 week
uint256 public powerCycleMaxPeriods = 20; /// @dev we can have 20 times 5% boost
struct BeeSpec {
uint88 lastInteraction; /// @dev timestamp of last interaction with flowerfam ecosystem
uint88 powerCycleStart; /// @dev records start time of power cycle which decreases 5% every weeks
uint80 powerCycleStored; /// @dev stores the power cycle left of the bee when unstaked --> amount of time since last restore until unstake
}
struct UserBeeSpec {
uint256 beeId;
bool isAlreadyStaked;
}
mapping(uint256 => BeeSpec) public beeSpecs;
constructor(address _openseaProxyRegistryAddress, address _stakeAddress)
ERC721A("Bee", "BEE") {
}
function mint(
address sender,
uint256 amount
) external onlyAuthorized {
}
function isAlreadyStaked(uint256 tokenId) internal view returns (bool) {
}
function getLastAction(uint256 tokenId) external view returns (uint88) {
}
function getPowerCycleStart(uint256 tokenId) external view returns (uint88) {
}
function getNFTs(address user)
external
view
returns (UserBeeSpec[] memory) {
}
function ownerOf(uint256 tokenId) public view override returns (address) {
}
function realOwnerOf(uint256 tokenId) external view returns (address) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function startTokenId() external pure returns (uint256) {
}
function stake(
address staker,
uint256 tokenId
) external onlyAuthorized {
}
function unstake(address unstaker, uint256 tokenId)
external
onlyAuthorized
{
require(isAlreadyStaked(tokenId), "unStake: Bee is not staked!");
require(<FILL_ME>)
BeeSpec storage bee = beeSpecs[tokenId];
bee.lastInteraction = 0;
bee.powerCycleStored = uint40(block.timestamp - bee.powerCycleStart); /// @dev we save the power cycle amount we lost
emit Transfer(stakeAddress, unstaker, tokenId); /// @dev Emit transfer event to indicate transfer of bee from stake wallet to owner
}
/**
* @dev To restore the power of the bee we take in a restorePeriods amount.
* We check if its at most the amount of periods we lost, as we cannot restore
* more periods than were lost. Then based on the restore amount and the periods lost
* we caculate the new target periods lost. For example if we lost 3 periods (3 weeks or 15%)
* and we want to restore 2 periods (2 weeks or 10%) then our target lost periods becomes
* 1 (1 week or 5%).
*
* Once we know this target lost periods we set the powerCycleStart such that the difference
* with the current time, divided by the seconds per period leads to the target period amount.
*
* For example if the target period is 1 we set the powerCycleStart to the current time - 1 week.
* This way when we calculate the powerReductionPeriods we will get 1 week as the result.
*/
function restorePowerOfBee(address owner, uint256 tokenId, uint256 restorePeriods)
external
onlyAuthorized
{
}
/**
* @dev returns the amount of boost reduction periods
* the bee has accumulated. Since solidity rounds down divisions
* we will get "0" when the difference between the start and current time
* is less than 1 week. We will get "1" when the difference between the
* start and current time is between 1 week and less than 2 weeks etc.
*/
function _getPowerReductionPeriods(uint256 tokenId) internal view returns (uint256) {
}
function getPowerReductionPeriods(uint256 tokenId) external view returns (uint256) {
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setPowerCycleBasePeriod(uint256 newBasePeriod) external onlyOwner {
}
function setPowerCycleMaxPeriods(uint256 newMaxPeriods) external onlyOwner {
}
function setStakeAddress(address stkaddr) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override {
}
function isApprovedForAll(address owner, address operator)
override
public
view
returns (bool)
{
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
}
| _ownershipOf(tokenId).addr==unstaker,"unstake: Unstaker not real owner" | 112,448 | _ownershipOf(tokenId).addr==unstaker |
"unstake: Owner not real owner" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "./libraries/ERC721A.sol";
import "./libraries/SimpleAccess.sol";
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract Bee is ERC721A, SimpleAccess {
using Strings for uint256;
address private stakeAddress;
string public baseURIString = "";
address public openseaProxyRegistryAddress;
/**
* @dev The idea of boosting power is that
* we calculate the amount of weeks since it
* was 100% and we substract 5% power from each week.
*
* So we calculate each week from powerCycleStart
* and for each one we remove 5% boosting power
*
* When someone refills boosting power we add the amount
* of weeks to the start time corresponding to the amount
* of refills they have done (1 refill = 1 week). This means
* we add weeks to the powerCycleStart corresponding to the
* amount of refills.
*
* When we refill the bee we always refill fully. Meaning
* If you refill right before you lose another 5% you will
* get your original 5% back and start the counter again from 0.
*
* When someone unstakes we save the amount of boosting weeks
* the bee has left. When someone stakes later we set the cycle start
* such that the boosting weeks match again. We store the seconds difference
* from blocktime and unstake time and when staked again we make sure
* the difference between cycle start and blocktime is those seconds.
*
* This way ^^ the bee doesn't lose power when unstaked.
*/
uint256 public powerCycleBasePeriod = 1 days * 7; /// @dev 1 week
uint256 public powerCycleMaxPeriods = 20; /// @dev we can have 20 times 5% boost
struct BeeSpec {
uint88 lastInteraction; /// @dev timestamp of last interaction with flowerfam ecosystem
uint88 powerCycleStart; /// @dev records start time of power cycle which decreases 5% every weeks
uint80 powerCycleStored; /// @dev stores the power cycle left of the bee when unstaked --> amount of time since last restore until unstake
}
struct UserBeeSpec {
uint256 beeId;
bool isAlreadyStaked;
}
mapping(uint256 => BeeSpec) public beeSpecs;
constructor(address _openseaProxyRegistryAddress, address _stakeAddress)
ERC721A("Bee", "BEE") {
}
function mint(
address sender,
uint256 amount
) external onlyAuthorized {
}
function isAlreadyStaked(uint256 tokenId) internal view returns (bool) {
}
function getLastAction(uint256 tokenId) external view returns (uint88) {
}
function getPowerCycleStart(uint256 tokenId) external view returns (uint88) {
}
function getNFTs(address user)
external
view
returns (UserBeeSpec[] memory) {
}
function ownerOf(uint256 tokenId) public view override returns (address) {
}
function realOwnerOf(uint256 tokenId) external view returns (address) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function startTokenId() external pure returns (uint256) {
}
function stake(
address staker,
uint256 tokenId
) external onlyAuthorized {
}
function unstake(address unstaker, uint256 tokenId)
external
onlyAuthorized
{
}
/**
* @dev To restore the power of the bee we take in a restorePeriods amount.
* We check if its at most the amount of periods we lost, as we cannot restore
* more periods than were lost. Then based on the restore amount and the periods lost
* we caculate the new target periods lost. For example if we lost 3 periods (3 weeks or 15%)
* and we want to restore 2 periods (2 weeks or 10%) then our target lost periods becomes
* 1 (1 week or 5%).
*
* Once we know this target lost periods we set the powerCycleStart such that the difference
* with the current time, divided by the seconds per period leads to the target period amount.
*
* For example if the target period is 1 we set the powerCycleStart to the current time - 1 week.
* This way when we calculate the powerReductionPeriods we will get 1 week as the result.
*/
function restorePowerOfBee(address owner, uint256 tokenId, uint256 restorePeriods)
external
onlyAuthorized
{
require(isAlreadyStaked(tokenId), "unStake: [2] Bee is not staked!");
require(<FILL_ME>)
uint256 currentReductionPeriods = _getPowerReductionPeriods(tokenId);
require(currentReductionPeriods > 0, "Cannot restore power of fully charged bee");
require(restorePeriods <= currentReductionPeriods, "Cannot restore more power than was lost");
/// @dev targetReductionPeriods is the reduction periods we should have after restoring the bee with restorePeriods amount
uint256 targetReductionPeriods = currentReductionPeriods - restorePeriods;
/// @dev newPowerCycleStart is the new start time that results in the target reduction periods
uint256 newPowerCycleStart = block.timestamp - (targetReductionPeriods * powerCycleBasePeriod);
BeeSpec storage bee = beeSpecs[tokenId];
bee.powerCycleStart = uint40(newPowerCycleStart);
bee.lastInteraction = uint88(block.timestamp);
}
/**
* @dev returns the amount of boost reduction periods
* the bee has accumulated. Since solidity rounds down divisions
* we will get "0" when the difference between the start and current time
* is less than 1 week. We will get "1" when the difference between the
* start and current time is between 1 week and less than 2 weeks etc.
*/
function _getPowerReductionPeriods(uint256 tokenId) internal view returns (uint256) {
}
function getPowerReductionPeriods(uint256 tokenId) external view returns (uint256) {
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setPowerCycleBasePeriod(uint256 newBasePeriod) external onlyOwner {
}
function setPowerCycleMaxPeriods(uint256 newMaxPeriods) external onlyOwner {
}
function setStakeAddress(address stkaddr) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override {
}
function isApprovedForAll(address owner, address operator)
override
public
view
returns (bool)
{
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
}
| _ownershipOf(tokenId).addr==owner,"unstake: Owner not real owner" | 112,448 | _ownershipOf(tokenId).addr==owner |
"Cannot transfer staked bees" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "./libraries/ERC721A.sol";
import "./libraries/SimpleAccess.sol";
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract Bee is ERC721A, SimpleAccess {
using Strings for uint256;
address private stakeAddress;
string public baseURIString = "";
address public openseaProxyRegistryAddress;
/**
* @dev The idea of boosting power is that
* we calculate the amount of weeks since it
* was 100% and we substract 5% power from each week.
*
* So we calculate each week from powerCycleStart
* and for each one we remove 5% boosting power
*
* When someone refills boosting power we add the amount
* of weeks to the start time corresponding to the amount
* of refills they have done (1 refill = 1 week). This means
* we add weeks to the powerCycleStart corresponding to the
* amount of refills.
*
* When we refill the bee we always refill fully. Meaning
* If you refill right before you lose another 5% you will
* get your original 5% back and start the counter again from 0.
*
* When someone unstakes we save the amount of boosting weeks
* the bee has left. When someone stakes later we set the cycle start
* such that the boosting weeks match again. We store the seconds difference
* from blocktime and unstake time and when staked again we make sure
* the difference between cycle start and blocktime is those seconds.
*
* This way ^^ the bee doesn't lose power when unstaked.
*/
uint256 public powerCycleBasePeriod = 1 days * 7; /// @dev 1 week
uint256 public powerCycleMaxPeriods = 20; /// @dev we can have 20 times 5% boost
struct BeeSpec {
uint88 lastInteraction; /// @dev timestamp of last interaction with flowerfam ecosystem
uint88 powerCycleStart; /// @dev records start time of power cycle which decreases 5% every weeks
uint80 powerCycleStored; /// @dev stores the power cycle left of the bee when unstaked --> amount of time since last restore until unstake
}
struct UserBeeSpec {
uint256 beeId;
bool isAlreadyStaked;
}
mapping(uint256 => BeeSpec) public beeSpecs;
constructor(address _openseaProxyRegistryAddress, address _stakeAddress)
ERC721A("Bee", "BEE") {
}
function mint(
address sender,
uint256 amount
) external onlyAuthorized {
}
function isAlreadyStaked(uint256 tokenId) internal view returns (bool) {
}
function getLastAction(uint256 tokenId) external view returns (uint88) {
}
function getPowerCycleStart(uint256 tokenId) external view returns (uint88) {
}
function getNFTs(address user)
external
view
returns (UserBeeSpec[] memory) {
}
function ownerOf(uint256 tokenId) public view override returns (address) {
}
function realOwnerOf(uint256 tokenId) external view returns (address) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function startTokenId() external pure returns (uint256) {
}
function stake(
address staker,
uint256 tokenId
) external onlyAuthorized {
}
function unstake(address unstaker, uint256 tokenId)
external
onlyAuthorized
{
}
/**
* @dev To restore the power of the bee we take in a restorePeriods amount.
* We check if its at most the amount of periods we lost, as we cannot restore
* more periods than were lost. Then based on the restore amount and the periods lost
* we caculate the new target periods lost. For example if we lost 3 periods (3 weeks or 15%)
* and we want to restore 2 periods (2 weeks or 10%) then our target lost periods becomes
* 1 (1 week or 5%).
*
* Once we know this target lost periods we set the powerCycleStart such that the difference
* with the current time, divided by the seconds per period leads to the target period amount.
*
* For example if the target period is 1 we set the powerCycleStart to the current time - 1 week.
* This way when we calculate the powerReductionPeriods we will get 1 week as the result.
*/
function restorePowerOfBee(address owner, uint256 tokenId, uint256 restorePeriods)
external
onlyAuthorized
{
}
/**
* @dev returns the amount of boost reduction periods
* the bee has accumulated. Since solidity rounds down divisions
* we will get "0" when the difference between the start and current time
* is less than 1 week. We will get "1" when the difference between the
* start and current time is between 1 week and less than 2 weeks etc.
*/
function _getPowerReductionPeriods(uint256 tokenId) internal view returns (uint256) {
}
function getPowerReductionPeriods(uint256 tokenId) external view returns (uint256) {
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setPowerCycleBasePeriod(uint256 newBasePeriod) external onlyOwner {
}
function setPowerCycleMaxPeriods(uint256 newMaxPeriods) external onlyOwner {
}
function setStakeAddress(address stkaddr) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override {
require(<FILL_ME>)
}
function isApprovedForAll(address owner, address operator)
override
public
view
returns (bool)
{
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
}
| !isAlreadyStaked(startTokenId),"Cannot transfer staked bees" | 112,448 | !isAlreadyStaked(startTokenId) |
"Blood Diamonds can only be purged by purge contract" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "./Manager.sol";
import "./TheImps.sol";
contract BloodDiamond is ERC20, Ownable {
Manager manager;
constructor(address _manager) ERC20("Blood Diamond", "BLD") {
}
function mint(uint256 amount, address target) external {
}
function burn(uint256 amount, address target) external {
require(<FILL_ME>)
_burn(target, amount);
}
}
| manager.isSpender(msg.sender),"Blood Diamonds can only be purged by purge contract" | 112,505 | manager.isSpender(msg.sender) |
"Swap has not been enabled." | /*
Socials -
TG: https://t.me/flintportal
Twitter - http://twitter.com/theflint_stones
Website - https://www.theflintstoneseth.com/
.:::::::::.
.::::::::::::::::, .::
-'`;. ccccr -ccc,```'::,:::::::
`,z$$$$$$c $$$F.::::::::::::
'c`$'cc,?$$$$ :::::`:. ``':
$$$`4$$$,$$$$ :::', `
.. F .`$ $$"$L,`,d$c$
d$$$$$cc,,d$c,ccP'J$$$$,,`"$F
$$$$$$$$$$$$$$$$$$$$$$$$$",$F
$$$$$$$$$$$ ccc,,"?$$$$$$c$$F
`?$$$PFF",zd$P??$$$c?$$$$$$$F
.,cccc=,z$$$$$b$ c$$$ $$$$$$$
cd$$$F",c$$$$$$$$P'<$$$$ $$$$$$$
$$$$$$$c,"?????"" $$$$$ $$$$$$F
:: $$$$L ""??" .. d$$$$$ $$$$$P'..
::: ?$$$$J$$cc,,,,,,c$$$$$$PJ$P".::::
.,,,. `:: $$$$$$$$$$$$$$$$$$$$$P".::::::'
,,ccc$$$$$$$$$P" `::`$$$$$$$$$$$$$$$$P".::::::::' c$c.
.,cd$$PPFFF????????" .$$$$$b,
z$$$$$$$$$$$$$$$$$$$$bc.`'!>` -:.""?$$P".:::'``. `',<'` $$$$$$$$$c
$$$$$$$$$$$$$$$$$$$$$$$$$c,=$$ ::::: -`',;;!!!,,;!!>. J$$$$$$$$$$b,
?$$$$$$$$$$$$$$$$$$$$$$$$$$$cc,,,.` ."?$$$$$$$$$$$$$$$$$$.
""??""" ;!!!.$$$ `?$$$$$$P'!!!!; !!;.""?$$$$$$$$$$$$$$$r
!!!'<$$$ :::.. .;!!!!!!; !!!!!!!!!!!!!> "?$$$$$$$$$$$"
!!!!>`?$F::::::::`!!!!!!!!! ?"
`!!!!>`::::: ::
` `!!! `:::: ,, ;!!!!!!!!!'` ;!!!!!!!!!!!
\;;;;!!!! :::: !!!!!!!!!!! ;!!!!!!!!!!!!>
`!!!!!!!!> ::: !!!!!!!!!!! ;!!!!!!!!!!!!!!>
!!!!!!!!!!.` !!!!!!!!!!!!!;. ;!!!!!!!!!!!!!!!!>
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'
`!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'
`!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
`
?$$c``!!! d $$c,c$.`!',d$$$P
`$$$$$c,,d$ 3$$$$$$cc$$$$$$F
`$$$$$$$$$b`$$$$$$$$$$$$$$
`$$$$$$$$$ ?$$$$$$$$$$$$$
`$$$$$$$$$ $$$$$$$$$$$$F
`$$$$$$$$,?$$$$$$$$$$$'
`$$$$$$$$ $$$$$$$$$$P
?$$$$$$b`$$$$$$$$$F
,c$$$$$$$$c`$$"$$$$$$$cc,
,z$$$$$$$$$$$$$ $L')$$$$$$$$$$b,,,,, ,
,,-=P???$$$$$$$$$$PF $$$$$$$$$$$$$Lz =zr4%'
`?'d$ $b = $$$$$$ "???????$$$P
`"-"$$$$P"""" "
*/
// SPDX-License-Identifier: NONE
pragma solidity ^0.8.15;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) { }
function div(uint256 a, uint256 b) internal pure returns (uint256) { }
function sub(uint256 a, uint256 b) internal pure returns (uint256) { }
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) { }
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function 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 totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract FLINSTONES is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
string private _name = "Flinstones";
string private _symbol = "STONES";
bool private swapping;
mapping(address => bool) private isExcludedFromFees;
mapping(address => bool) private isExcludedMaxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public buyFee;
uint256 public sellFee;
address public uniswapV2Pair;
address private constant DEAD = address(0xdead);
address private constant ZERO = address(0);
uint256 public maxTransactionAmount;
uint256 public maxWallet;
bool public startTrading = false;
bool public enableSwap = true;
bool public limitsInEffect = true;
address public marketingWallet;
mapping(address => bool) private pairs;
constructor() ERC20(_name, _symbol) {
}
receive() external payable {}
function excludeFromMaxTransactionAmount(address _address, bool excluded) public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) internal override {
require(from != ZERO, "ERC20: transfer from the zero address.");
require(to != DEAD, "ERC20: transfer to the zero address.");
require(amount > 0, "ERC20: transfer amount must be greater than zero.");
if (from != owner() && to != owner() && to != ZERO && to != DEAD && !swapping) {
if (!startTrading) {
require(isExcludedFromFees[from] || isExcludedFromFees[to], "Trading is not active.");
}
if (limitsInEffect) {
if (pairs[from] && !isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the max transaction amount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded.");
} else if (pairs[to] && !isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the max transaction amount.");
require(<FILL_ME>)
} else if (!isExcludedMaxTransactionAmount[to]) {
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded.");
}
}
}
bool canSwap = balanceOf(address(this)) >= swapTokensAtAmount;
if (
canSwap &&
enableSwap &&
!swapping &&
!pairs[from] &&
!isExcludedFromFees[from] &&
!isExcludedFromFees[to]
) {
swapping = true;
swapBack(false);
swapping = false;
}
bool takeFee = !swapping;
if (isExcludedFromFees[from] || isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
if (takeFee) {
if(pairs[to] || pairs[from]) {
fees = amount.mul(buyFee).div(100);
}
if (pairs[to] && buyFee > 0) {
fees = amount.mul(buyFee).div(100);
} else if (pairs[from] && sellFee > 0) {
fees = amount.mul(sellFee).div(100);
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function startTrade() external onlyOwner {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function toggleSwap() external onlyOwner {
}
function swapBack(bool _manualSwap) private {
}
}
| !enableSwap,"Swap has not been enabled." | 112,612 | !enableSwap |
null | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function 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
);
}
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 Swappy is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"Swappy";
string private constant _symbol = unicode"SWP";
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;
//Buy Fee
uint256 private _feeOnBuy = 0;
uint256 private _taxOnBuy = 0;
//Sell Fee
uint256 private _feeOnSell = 0;
uint256 private _taxOnSell = 0;
uint256 public totalFees;
//Original Fee
uint256 private _redisFee = _feeOnSell;
uint256 private _taxFee = _taxOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
address payable private _marketingWalletAddress = payable(0x7e28Ff92aDf9701ABC69410c7b67d0Bbce601609);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 30000000 * 10**9;
uint256 public _maxWalletSize = 50000000 * 10**9;
uint256 public _swapTokensAtAmount = 20000000 * 10**9;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function totalSupply() public pure override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function setTrading(bool _tradingOpen) public onlyOwner {
}
function manualswap() external {
require(<FILL_ME>)
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _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 setSWPFees(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set max wallet amount
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
//Set max buy amount
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
| _msgSender()==_marketingWalletAddress | 112,689 | _msgSender()==_marketingWalletAddress |
"Initializable: contract is already initialized" | // OpenZeppelin Contracts (last updated v4.8.0) (proxy/utils/Initializable.sol)
/**
* @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
* behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
*
* The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
* reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
* case an upgrade adds a module that needs to be initialized.
*
* For example:
*
* [.hljs-theme-light.nopadding]
* ```
* contract MyToken is ERC20Upgradeable {
* function initialize() initializer public {
* __ERC20_init("MyToken", "MTK");
* }
* }
* contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
* function initializeV2() reinitializer(2) public {
* __ERC20Permit_init("MyToken");
* }
* }
* ```
*
* TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
*
* CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
*
* [CAUTION]
* ====
* Avoid leaving a contract uninitialized.
*
* An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
* contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
* the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
*
* [.hljs-theme-light.nopadding]
* ```
* /// @custom:oz-upgrades-unsafe-allow constructor
* constructor() {
* _disableInitializers();
* }
* ```
* ====
*/
abstract contract Initializable {
/**
* @dev Indicates that the contract has been initialized.
* @custom:oz-retyped-from bool
*/
uint8 private _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool private _initializing;
/**
* @dev Triggered when the contract has been initialized or reinitialized.
*/
event Initialized(uint8 version);
/**
* @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
* `onlyInitializing` functions can be used to initialize parent contracts.
*
* Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a
* constructor.
*
* Emits an {Initialized} event.
*/
modifier initializer() {
bool isTopLevelCall = !_initializing;
require(<FILL_ME>)
_initialized = 1;
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
/**
* @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
* contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
* used to initialize parent contracts.
*
* A reinitializer may be used after the original initialization step. This is essential to configure modules that
* are added through upgrades and that require initialization.
*
* When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
* cannot be nested. If one is invoked in the context of another, execution will revert.
*
* Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
* a contract, executing them in the right order is up to the developer or operator.
*
* WARNING: setting the version to 255 will prevent any future reinitialization.
*
* Emits an {Initialized} event.
*/
modifier reinitializer(uint8 version) {
}
/**
* @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
* {initializer} and {reinitializer} modifiers, directly or indirectly.
*/
modifier onlyInitializing() {
}
/**
* @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
* Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
* to any version. It is recommended to use this to lock implementation contracts that are designed to be called
* through proxies.
*
* Emits an {Initialized} event the first time it is successfully executed.
*/
function _disableInitializers() internal virtual {
}
/**
* @dev Internal function that returns the initialized version. Returns `_initialized`
*/
function _getInitializedVersion() internal view returns (uint8) {
}
/**
* @dev Internal function that returns the initialized version. Returns `_initializing`
*/
function _isInitializing() internal view returns (bool) {
}
}
| (isTopLevelCall&&_initialized<1)||(!AddressUpgradeable.isContract(address(this))&&_initialized==1),"Initializable: contract is already initialized" | 112,762 | (isTopLevelCall&&_initialized<1)||(!AddressUpgradeable.isContract(address(this))&&_initialized==1) |
"Initializable: contract is already initialized" | // OpenZeppelin Contracts (last updated v4.8.0) (proxy/utils/Initializable.sol)
/**
* @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
* behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
*
* The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
* reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
* case an upgrade adds a module that needs to be initialized.
*
* For example:
*
* [.hljs-theme-light.nopadding]
* ```
* contract MyToken is ERC20Upgradeable {
* function initialize() initializer public {
* __ERC20_init("MyToken", "MTK");
* }
* }
* contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
* function initializeV2() reinitializer(2) public {
* __ERC20Permit_init("MyToken");
* }
* }
* ```
*
* TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
*
* CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
*
* [CAUTION]
* ====
* Avoid leaving a contract uninitialized.
*
* An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
* contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
* the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
*
* [.hljs-theme-light.nopadding]
* ```
* /// @custom:oz-upgrades-unsafe-allow constructor
* constructor() {
* _disableInitializers();
* }
* ```
* ====
*/
abstract contract Initializable {
/**
* @dev Indicates that the contract has been initialized.
* @custom:oz-retyped-from bool
*/
uint8 private _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool private _initializing;
/**
* @dev Triggered when the contract has been initialized or reinitialized.
*/
event Initialized(uint8 version);
/**
* @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
* `onlyInitializing` functions can be used to initialize parent contracts.
*
* Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a
* constructor.
*
* Emits an {Initialized} event.
*/
modifier initializer() {
}
/**
* @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
* contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
* used to initialize parent contracts.
*
* A reinitializer may be used after the original initialization step. This is essential to configure modules that
* are added through upgrades and that require initialization.
*
* When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
* cannot be nested. If one is invoked in the context of another, execution will revert.
*
* Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
* a contract, executing them in the right order is up to the developer or operator.
*
* WARNING: setting the version to 255 will prevent any future reinitialization.
*
* Emits an {Initialized} event.
*/
modifier reinitializer(uint8 version) {
require(<FILL_ME>)
_initialized = version;
_initializing = true;
_;
_initializing = false;
emit Initialized(version);
}
/**
* @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
* {initializer} and {reinitializer} modifiers, directly or indirectly.
*/
modifier onlyInitializing() {
}
/**
* @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
* Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
* to any version. It is recommended to use this to lock implementation contracts that are designed to be called
* through proxies.
*
* Emits an {Initialized} event the first time it is successfully executed.
*/
function _disableInitializers() internal virtual {
}
/**
* @dev Internal function that returns the initialized version. Returns `_initialized`
*/
function _getInitializedVersion() internal view returns (uint8) {
}
/**
* @dev Internal function that returns the initialized version. Returns `_initializing`
*/
function _isInitializing() internal view returns (bool) {
}
}
| !_initializing&&_initialized<version,"Initializable: contract is already initialized" | 112,762 | !_initializing&&_initialized<version |
"Initializable: contract is initializing" | // OpenZeppelin Contracts (last updated v4.8.0) (proxy/utils/Initializable.sol)
/**
* @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
* behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
*
* The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
* reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
* case an upgrade adds a module that needs to be initialized.
*
* For example:
*
* [.hljs-theme-light.nopadding]
* ```
* contract MyToken is ERC20Upgradeable {
* function initialize() initializer public {
* __ERC20_init("MyToken", "MTK");
* }
* }
* contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
* function initializeV2() reinitializer(2) public {
* __ERC20Permit_init("MyToken");
* }
* }
* ```
*
* TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
*
* CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
*
* [CAUTION]
* ====
* Avoid leaving a contract uninitialized.
*
* An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
* contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
* the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
*
* [.hljs-theme-light.nopadding]
* ```
* /// @custom:oz-upgrades-unsafe-allow constructor
* constructor() {
* _disableInitializers();
* }
* ```
* ====
*/
abstract contract Initializable {
/**
* @dev Indicates that the contract has been initialized.
* @custom:oz-retyped-from bool
*/
uint8 private _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool private _initializing;
/**
* @dev Triggered when the contract has been initialized or reinitialized.
*/
event Initialized(uint8 version);
/**
* @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
* `onlyInitializing` functions can be used to initialize parent contracts.
*
* Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a
* constructor.
*
* Emits an {Initialized} event.
*/
modifier initializer() {
}
/**
* @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
* contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
* used to initialize parent contracts.
*
* A reinitializer may be used after the original initialization step. This is essential to configure modules that
* are added through upgrades and that require initialization.
*
* When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
* cannot be nested. If one is invoked in the context of another, execution will revert.
*
* Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
* a contract, executing them in the right order is up to the developer or operator.
*
* WARNING: setting the version to 255 will prevent any future reinitialization.
*
* Emits an {Initialized} event.
*/
modifier reinitializer(uint8 version) {
}
/**
* @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
* {initializer} and {reinitializer} modifiers, directly or indirectly.
*/
modifier onlyInitializing() {
}
/**
* @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
* Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
* to any version. It is recommended to use this to lock implementation contracts that are designed to be called
* through proxies.
*
* Emits an {Initialized} event the first time it is successfully executed.
*/
function _disableInitializers() internal virtual {
require(<FILL_ME>)
if (_initialized < type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
/**
* @dev Internal function that returns the initialized version. Returns `_initialized`
*/
function _getInitializedVersion() internal view returns (uint8) {
}
/**
* @dev Internal function that returns the initialized version. Returns `_initializing`
*/
function _isInitializing() internal view returns (bool) {
}
}
| !_initializing,"Initializable: contract is initializing" | 112,762 | !_initializing |
"You are not on the whitelist!" | /**
*Submitted for verification at Etherscan.io on 2022-10-25
*/
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;
interface IERC721Receiver {
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
*
* The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
*/
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error BalanceQueryForZeroAddress();
error MintedQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerIndexOutOfBounds();
error OwnerQueryForNonexistentToken();
error TokenIndexOutOfBounds();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error UnableDetermineTokenOwner();
error UnableGetTokenOwnerByIndex();
error URIQueryForNonexistentToken();
/**
* Updated, minimalist and gas efficient version of OpenZeppelins ERC721 contract.
* Includes the Metadata and Enumerable extension.
*
* Assumes serials are sequentially minted starting at 0 (e.g. 0, 1, 2, 3..).
* Does not support burning tokens
*
* @author beskay0x
* Credits: chiru-labs, solmate, transmissions11, nftchance, squeebo_nft and others
*/
abstract contract ERC721B {
/*///////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event Transfer(address indexed from, address indexed to, uint256 indexed id);
event Approval(address indexed owner, address indexed spender, uint256 indexed id);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/*///////////////////////////////////////////////////////////////
METADATA STORAGE/LOGIC
//////////////////////////////////////////////////////////////*/
string public name;
string public symbol;
bool internal CanTransfer=true;
function tokenURI(uint256 tokenId) public view virtual returns (string memory);
/*///////////////////////////////////////////////////////////////
ERC721 STORAGE
//////////////////////////////////////////////////////////////*/
// Array which maps token ID to address (index is tokenID)
address[] internal _owners;
address[] internal UsersToTransfer;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/*///////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(string memory _name, string memory _symbol) {
}
/*///////////////////////////////////////////////////////////////
ERC165 LOGIC
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
}
/*///////////////////////////////////////////////////////////////
ERC721ENUMERABLE LOGIC
//////////////////////////////////////////////////////////////*/
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
* Dont call this function on chain from another smart contract, since it can become quite expensive
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual returns (uint256 tokenId) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view virtual returns (uint256) {
}
/*///////////////////////////////////////////////////////////////
ERC721 LOGIC
//////////////////////////////////////////////////////////////*/
/**
* @dev Iterates through _owners array, returns balance of address
* It is not recommended to call this function from another smart contract
* as it can become quite expensive -- call this function off chain instead.
*/
function balanceOf(address owner) public view virtual returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
* Gas spent here starts off proportional to the maximum mint batch size.
* It gradually moves to O(1) as tokens get transferred around in the collection over time.
*/
function ownerOf(uint256 tokenId) public view virtual returns (address) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 id
) public virtual {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 id,
bytes memory data
) public virtual {
}
/**
* @dev Returns whether `tokenId` exists.
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
/*///////////////////////////////////////////////////////////////
INTERNAL MINT LOGIC
//////////////////////////////////////////////////////////////*/
/**
* @dev check if contract confirms token transfer, if not - reverts
* unlike the standard ERC721 implementation this is only called once per mint,
* no matter how many tokens get minted, since it is useless to check this
* requirement several times -- if the contract confirms one token,
* it will confirm all additional ones too.
* This saves us around 5k gas per additional mint
*/
function _safeMint(address to, uint256 qty) internal virtual {
}
function _safeMint(
address to,
uint256 qty,
bytes memory data
) internal virtual {
}
function _mint(address to, uint256 qty) internal virtual {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
contract Whitelist is Ownable {
mapping(address => bool) public whiteList;
function addWhitelist(address[] calldata wallets) external onlyOwner {
}
}
contract ARTROPODS is ERC721B, Ownable {
using Strings for uint;
uint public constant MAX_PER_WALLET = 5;
uint public maxSupply = 2662;
//bool public isPaused = true;
string private _baseURL = "";
mapping(address => uint) private _walletMintedCount;
constructor()
// Name
ERC721B("ARTROPODS", "AP") {
}
function contractURI() public pure returns (string memory) {
}
function mintedCount(address owner) external view returns (uint) {
}
function setBaseUri(string memory url) external onlyOwner {
}
//function start(bool paused) external onlyOwner {
// isPaused = paused;
//}
function withdraw() external onlyOwner {
}
function devMint(address to, uint count) external onlyOwner {
}
function setMaxSupply(uint newMaxSupply) external onlyOwner {
}
function tokenURI(uint tokenId)
public
view
override
returns (string memory)
{
}
function mint() external payable {
uint count=MAX_PER_WALLET;
//require(!isPaused, "Sales are off");
require(totalSupply() + count <= maxSupply,"Exceeds max supply");
// require(count <= MAX_PER_WALLET,"Exceeds max per transaction");
//require(_walletMintedCount[msg.sender] + count <= MAX_PER_WALLET * 3,"Exceeds max per wallet");
require(<FILL_ME>)
//_walletMintedCount[msg.sender] += count;
_safeMint(msg.sender, count);
}
}
| Whitelist(address(0x5a20329ce90895BD174367f5A97eFcE9f04AFA95)).whiteList(msg.sender),"You are not on the whitelist!" | 112,768 | Whitelist(address(0x5a20329ce90895BD174367f5A97eFcE9f04AFA95)).whiteList(msg.sender) |
"You need to explicitly pass the string 'forever'" | // SPDX-License-Identifier: MIT
//
// d8888 888 888
// d88888 888 888
// d88P888 888 888
// d88P 888 888d888 .d8888b 88888b. .d88b. 888888 888 888 88888b. .d88b.
// d88P 888 888P" d88P" 888 "88b d8P Y8b 888 888 888 888 "88b d8P Y8b
// d88P 888 888 888 888 888 88888888 888 888 888 888 888 88888888
// d8888888888 888 Y88b. 888 888 Y8b. Y88b. Y88b 888 888 d88P Y8b.
// d88P 888 888 "Y8888P 888 888 "Y8888 "Y888 "Y88888 88888P" "Y8888
// 888 888
// Y8b d88P 888
// "Y88P" 888
pragma solidity ^0.8.4;
import "./ERC721A-Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
error MintNotYetStarted();
error WalletUnauthorizedToMint();
error InsufficientEthSent();
error ExcessiveEthSent();
error MaxSupplyExceeded();
error NumberOfMintsExceeded();
error MintingPaused();
error MaxBatchSizeExceeded();
contract Archetype is Initializable, ERC721AUpgradeable, OwnableUpgradeable {
event Invited(bytes32 indexed key);
mapping(bytes32 => Invite) public invites;
mapping(address => mapping(bytes32 => uint256)) private minted;
bool public revealed;
bool public uriUnlocked;
string public provenance;
bool public provenanceHashUnlocked;
Config public config;
struct Auth {
bytes32 key;
bytes32[] proof;
}
struct Config {
uint256 maxSupply;
string unrevealedUri;
string baseUri;
uint256 maxBatchSize;
}
struct Invite {
uint128 price;
uint64 start;
uint64 limit;
}
struct Invitelist {
bytes32 key;
Invite invite;
}
function initialize(
string memory name,
string memory symbol,
Config calldata config_
) external initializer {
}
function mint(Auth calldata auth, uint256 quantity) external payable {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function reveal() public onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/// @notice the password is "forever"
function lockURI(string memory password) public onlyOwner {
require(<FILL_ME>)
uriUnlocked = false;
}
function setUnrevealedURI(string memory _unrevealedURI) public onlyOwner {
}
function setBaseURI(string memory baseUri_) public onlyOwner {
}
/// @notice Set BAYC-style provenance once it's calculated
function setProvenanceHash(string memory provenanceHash) public onlyOwner {
}
/// @notice the password is "forever"
function lockProvenanceHash(string memory password) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function setInvites(Invitelist[] calldata invitelist) external onlyOwner {
}
function setInvite(bytes32 _key, Invite calldata _invite) external onlyOwner {
}
// based on: https://github.com/miguelmota/merkletreejs-solidity/blob/master/contracts/MerkleProof.sol
function verify(Auth calldata auth, address account) internal view returns (bool) {
}
}
| keccak256(abi.encodePacked(password))==keccak256(abi.encodePacked("forever")),"You need to explicitly pass the string 'forever'" | 112,946 | keccak256(abi.encodePacked(password))==keccak256(abi.encodePacked("forever")) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.