comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"cur index already minted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract TenLevels is ERC721, ERC721Enumerable, Ownable {
// lib
using Address for address payable;
// struct
struct LevelInfo {
uint16 lastNeedNum;
uint16 merkleProofAnswerNum;
uint16 payCount;
uint256[] payNumAndPrice;
bytes32 answerMerkleProofRootHash;
bytes32 answerHash;
uint256 mintNum;
mapping(uint256 => bool) indexMinted;
}
struct InvestInfo{
uint256 maxAmount;
uint256 sharePer;
uint256 curAmount;
mapping(address => uint256) userAmount;
}
// constant
uint256 public constant MAX_INVEST_LEVEL = 3;
uint256 public constant MAX_LEVEL = 10;
uint256 public constant LEVEL_GAP = 100000000;
uint256 public constant MAX_PER = 10000;
uint256 public constant OWNER_SHARE_PER = 2000;
uint256 public constant INVESTOR_SHARE_PER = 3000;
// storage
mapping(uint256 => LevelInfo) public levelInfos;
mapping(uint256 => bool) public useFlag;
mapping(uint256 => bool) public rewardFlag;
uint256 public investorShare;
mapping(uint256 => InvestInfo) public investInfos;
mapping(address => bool) public investClaimFlag;
bool public adminInvestClaimFlag;
uint256 private _rewardShare;
string private _basePath;
// event
event Mint(address indexed user, uint256 indexed costToken, uint256 indexed newToken);
event ClaimRewards(address indexed user, uint256[] tokenIDs, uint256 amount);
event Invest(address indexed user, uint256 indexed level, uint256 amount);
event CancleInvest(address indexed user, uint256 indexed level, uint256 amount);
event InvestClaimRewards(address indexed user, uint256 amount);
event AdminClaimRemainInvestRewards(uint256 amount);
event MetadataUpdate(uint256 _tokenId);
// function
constructor() ERC721("TenLevels", "TL") {
}
function getMintedIndex(uint256 level, uint256[] memory index) public view returns(bool[] memory){
}
function getMintPrice(uint256 level) public view returns (uint256){
}
function getRewards() public view returns (uint256){
}
function _payEth(uint256 level) private {
}
function merkleProofMint(uint256 tokenID, uint256 level, bytes32 nodeHash, uint256 index, bytes32[] memory proofs) public payable{
require(level >= 0 && level < MAX_LEVEL, "level error");
if (level > 0){
require(levelInfos[level-1].mintNum >= levelInfos[level].lastNeedNum, "level lock");
require(tokenID / LEVEL_GAP == level - 1, "tokenID level error");
require(ownerOf(tokenID) == msg.sender, "tokenID owner error");
require(useFlag[tokenID] == false, "tokenID has been used");
useFlag[tokenID] = true;
emit MetadataUpdate(tokenID);
}
if (level < MAX_LEVEL - 1){
require(levelInfos[MAX_LEVEL - 1].mintNum == 0, "mint locked");
}
uint256 curMintNum = levelInfos[level].mintNum;
require(curMintNum < levelInfos[level].merkleProofAnswerNum, "mint approach error");
require(<FILL_ME>)
require(MerkleProof.verify(proofs, levelInfos[level].answerMerkleProofRootHash, keccak256(abi.encodePacked(nodeHash, index))), "answer error");
_payEth(level);
if (level == MAX_LEVEL - 1 && levelInfos[MAX_LEVEL - 1].mintNum == 0){
_rewardShare = address(this).balance - investorShare;
}
levelInfos[level].mintNum = curMintNum + 1;
levelInfos[level].indexMinted[index] = true;
uint256 newTokenID = level * LEVEL_GAP + curMintNum;
_safeMint(msg.sender, newTokenID);
emit Mint(msg.sender, tokenID, newTokenID);
}
function mint(uint256 tokenID, uint256 level, bytes32 answerHash) public payable{
}
function claimRewards(uint256[] memory tokenIDs) public{
}
function adminClaimRemainRewards() public onlyOwner(){
}
function invest(uint256 level) public payable{
}
function cancleInvest(uint256 level, uint256 amount) public{
}
function getUserInvestInfo(address user, uint256[] memory levels) public view returns(uint256[] memory){
}
function getInvestRewards(address user) public view returns(uint256){
}
function claimInvestRewards() public {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata path) public onlyOwner(){
}
// The following functions are overrides required by Solidity.
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId,
uint256 batchSize
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| levelInfos[level].indexMinted[index]==false,"cur index already minted" | 224,150 | levelInfos[level].indexMinted[index]==false |
"answer error" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract TenLevels is ERC721, ERC721Enumerable, Ownable {
// lib
using Address for address payable;
// struct
struct LevelInfo {
uint16 lastNeedNum;
uint16 merkleProofAnswerNum;
uint16 payCount;
uint256[] payNumAndPrice;
bytes32 answerMerkleProofRootHash;
bytes32 answerHash;
uint256 mintNum;
mapping(uint256 => bool) indexMinted;
}
struct InvestInfo{
uint256 maxAmount;
uint256 sharePer;
uint256 curAmount;
mapping(address => uint256) userAmount;
}
// constant
uint256 public constant MAX_INVEST_LEVEL = 3;
uint256 public constant MAX_LEVEL = 10;
uint256 public constant LEVEL_GAP = 100000000;
uint256 public constant MAX_PER = 10000;
uint256 public constant OWNER_SHARE_PER = 2000;
uint256 public constant INVESTOR_SHARE_PER = 3000;
// storage
mapping(uint256 => LevelInfo) public levelInfos;
mapping(uint256 => bool) public useFlag;
mapping(uint256 => bool) public rewardFlag;
uint256 public investorShare;
mapping(uint256 => InvestInfo) public investInfos;
mapping(address => bool) public investClaimFlag;
bool public adminInvestClaimFlag;
uint256 private _rewardShare;
string private _basePath;
// event
event Mint(address indexed user, uint256 indexed costToken, uint256 indexed newToken);
event ClaimRewards(address indexed user, uint256[] tokenIDs, uint256 amount);
event Invest(address indexed user, uint256 indexed level, uint256 amount);
event CancleInvest(address indexed user, uint256 indexed level, uint256 amount);
event InvestClaimRewards(address indexed user, uint256 amount);
event AdminClaimRemainInvestRewards(uint256 amount);
event MetadataUpdate(uint256 _tokenId);
// function
constructor() ERC721("TenLevels", "TL") {
}
function getMintedIndex(uint256 level, uint256[] memory index) public view returns(bool[] memory){
}
function getMintPrice(uint256 level) public view returns (uint256){
}
function getRewards() public view returns (uint256){
}
function _payEth(uint256 level) private {
}
function merkleProofMint(uint256 tokenID, uint256 level, bytes32 nodeHash, uint256 index, bytes32[] memory proofs) public payable{
require(level >= 0 && level < MAX_LEVEL, "level error");
if (level > 0){
require(levelInfos[level-1].mintNum >= levelInfos[level].lastNeedNum, "level lock");
require(tokenID / LEVEL_GAP == level - 1, "tokenID level error");
require(ownerOf(tokenID) == msg.sender, "tokenID owner error");
require(useFlag[tokenID] == false, "tokenID has been used");
useFlag[tokenID] = true;
emit MetadataUpdate(tokenID);
}
if (level < MAX_LEVEL - 1){
require(levelInfos[MAX_LEVEL - 1].mintNum == 0, "mint locked");
}
uint256 curMintNum = levelInfos[level].mintNum;
require(curMintNum < levelInfos[level].merkleProofAnswerNum, "mint approach error");
require(levelInfos[level].indexMinted[index] == false, "cur index already minted");
require(<FILL_ME>)
_payEth(level);
if (level == MAX_LEVEL - 1 && levelInfos[MAX_LEVEL - 1].mintNum == 0){
_rewardShare = address(this).balance - investorShare;
}
levelInfos[level].mintNum = curMintNum + 1;
levelInfos[level].indexMinted[index] = true;
uint256 newTokenID = level * LEVEL_GAP + curMintNum;
_safeMint(msg.sender, newTokenID);
emit Mint(msg.sender, tokenID, newTokenID);
}
function mint(uint256 tokenID, uint256 level, bytes32 answerHash) public payable{
}
function claimRewards(uint256[] memory tokenIDs) public{
}
function adminClaimRemainRewards() public onlyOwner(){
}
function invest(uint256 level) public payable{
}
function cancleInvest(uint256 level, uint256 amount) public{
}
function getUserInvestInfo(address user, uint256[] memory levels) public view returns(uint256[] memory){
}
function getInvestRewards(address user) public view returns(uint256){
}
function claimInvestRewards() public {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata path) public onlyOwner(){
}
// The following functions are overrides required by Solidity.
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId,
uint256 batchSize
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| MerkleProof.verify(proofs,levelInfos[level].answerMerkleProofRootHash,keccak256(abi.encodePacked(nodeHash,index))),"answer error" | 224,150 | MerkleProof.verify(proofs,levelInfos[level].answerMerkleProofRootHash,keccak256(abi.encodePacked(nodeHash,index))) |
"answer error" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract TenLevels is ERC721, ERC721Enumerable, Ownable {
// lib
using Address for address payable;
// struct
struct LevelInfo {
uint16 lastNeedNum;
uint16 merkleProofAnswerNum;
uint16 payCount;
uint256[] payNumAndPrice;
bytes32 answerMerkleProofRootHash;
bytes32 answerHash;
uint256 mintNum;
mapping(uint256 => bool) indexMinted;
}
struct InvestInfo{
uint256 maxAmount;
uint256 sharePer;
uint256 curAmount;
mapping(address => uint256) userAmount;
}
// constant
uint256 public constant MAX_INVEST_LEVEL = 3;
uint256 public constant MAX_LEVEL = 10;
uint256 public constant LEVEL_GAP = 100000000;
uint256 public constant MAX_PER = 10000;
uint256 public constant OWNER_SHARE_PER = 2000;
uint256 public constant INVESTOR_SHARE_PER = 3000;
// storage
mapping(uint256 => LevelInfo) public levelInfos;
mapping(uint256 => bool) public useFlag;
mapping(uint256 => bool) public rewardFlag;
uint256 public investorShare;
mapping(uint256 => InvestInfo) public investInfos;
mapping(address => bool) public investClaimFlag;
bool public adminInvestClaimFlag;
uint256 private _rewardShare;
string private _basePath;
// event
event Mint(address indexed user, uint256 indexed costToken, uint256 indexed newToken);
event ClaimRewards(address indexed user, uint256[] tokenIDs, uint256 amount);
event Invest(address indexed user, uint256 indexed level, uint256 amount);
event CancleInvest(address indexed user, uint256 indexed level, uint256 amount);
event InvestClaimRewards(address indexed user, uint256 amount);
event AdminClaimRemainInvestRewards(uint256 amount);
event MetadataUpdate(uint256 _tokenId);
// function
constructor() ERC721("TenLevels", "TL") {
}
function getMintedIndex(uint256 level, uint256[] memory index) public view returns(bool[] memory){
}
function getMintPrice(uint256 level) public view returns (uint256){
}
function getRewards() public view returns (uint256){
}
function _payEth(uint256 level) private {
}
function merkleProofMint(uint256 tokenID, uint256 level, bytes32 nodeHash, uint256 index, bytes32[] memory proofs) public payable{
}
function mint(uint256 tokenID, uint256 level, bytes32 answerHash) public payable{
require(level >= 0 && level < MAX_LEVEL, "level error");
if (level > 0){
require(levelInfos[level-1].mintNum >= levelInfos[level].lastNeedNum, "level lock");
require(tokenID / LEVEL_GAP == level - 1, "tokenID level error");
require(ownerOf(tokenID) == msg.sender, "tokenID owner error");
require(useFlag[tokenID] == false, "tokenID has been used");
useFlag[tokenID] = true;
emit MetadataUpdate(tokenID);
}
if (level < MAX_LEVEL - 1){
require(levelInfos[MAX_LEVEL - 1].mintNum == 0, "mint locked");
}
uint256 curMintNum = levelInfos[level].mintNum;
require(curMintNum >= levelInfos[level].merkleProofAnswerNum, "mint approach error");
require(<FILL_ME>)
_payEth(level);
if (level == MAX_LEVEL - 1 && levelInfos[MAX_LEVEL - 1].mintNum == 0){
_rewardShare = address(this).balance - investorShare;
}
levelInfos[level].mintNum = curMintNum + 1;
uint256 newTokenID = level * LEVEL_GAP + curMintNum;
_safeMint(msg.sender, newTokenID);
emit Mint(msg.sender, tokenID, newTokenID);
}
function claimRewards(uint256[] memory tokenIDs) public{
}
function adminClaimRemainRewards() public onlyOwner(){
}
function invest(uint256 level) public payable{
}
function cancleInvest(uint256 level, uint256 amount) public{
}
function getUserInvestInfo(address user, uint256[] memory levels) public view returns(uint256[] memory){
}
function getInvestRewards(address user) public view returns(uint256){
}
function claimInvestRewards() public {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata path) public onlyOwner(){
}
// The following functions are overrides required by Solidity.
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId,
uint256 batchSize
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| keccak256(abi.encodePacked(answerHash))==levelInfos[level].answerHash,"answer error" | 224,150 | keccak256(abi.encodePacked(answerHash))==levelInfos[level].answerHash |
"not finish" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract TenLevels is ERC721, ERC721Enumerable, Ownable {
// lib
using Address for address payable;
// struct
struct LevelInfo {
uint16 lastNeedNum;
uint16 merkleProofAnswerNum;
uint16 payCount;
uint256[] payNumAndPrice;
bytes32 answerMerkleProofRootHash;
bytes32 answerHash;
uint256 mintNum;
mapping(uint256 => bool) indexMinted;
}
struct InvestInfo{
uint256 maxAmount;
uint256 sharePer;
uint256 curAmount;
mapping(address => uint256) userAmount;
}
// constant
uint256 public constant MAX_INVEST_LEVEL = 3;
uint256 public constant MAX_LEVEL = 10;
uint256 public constant LEVEL_GAP = 100000000;
uint256 public constant MAX_PER = 10000;
uint256 public constant OWNER_SHARE_PER = 2000;
uint256 public constant INVESTOR_SHARE_PER = 3000;
// storage
mapping(uint256 => LevelInfo) public levelInfos;
mapping(uint256 => bool) public useFlag;
mapping(uint256 => bool) public rewardFlag;
uint256 public investorShare;
mapping(uint256 => InvestInfo) public investInfos;
mapping(address => bool) public investClaimFlag;
bool public adminInvestClaimFlag;
uint256 private _rewardShare;
string private _basePath;
// event
event Mint(address indexed user, uint256 indexed costToken, uint256 indexed newToken);
event ClaimRewards(address indexed user, uint256[] tokenIDs, uint256 amount);
event Invest(address indexed user, uint256 indexed level, uint256 amount);
event CancleInvest(address indexed user, uint256 indexed level, uint256 amount);
event InvestClaimRewards(address indexed user, uint256 amount);
event AdminClaimRemainInvestRewards(uint256 amount);
event MetadataUpdate(uint256 _tokenId);
// function
constructor() ERC721("TenLevels", "TL") {
}
function getMintedIndex(uint256 level, uint256[] memory index) public view returns(bool[] memory){
}
function getMintPrice(uint256 level) public view returns (uint256){
}
function getRewards() public view returns (uint256){
}
function _payEth(uint256 level) private {
}
function merkleProofMint(uint256 tokenID, uint256 level, bytes32 nodeHash, uint256 index, bytes32[] memory proofs) public payable{
}
function mint(uint256 tokenID, uint256 level, bytes32 answerHash) public payable{
}
function claimRewards(uint256[] memory tokenIDs) public{
require(<FILL_ME>)
uint256 id = 0;
for (uint256 i = 0; i < tokenIDs.length; ++i){
id = tokenIDs[i];
require(id / LEVEL_GAP == MAX_LEVEL - 1, "token level error");
require(ownerOf(id) == msg.sender, "token owner error");
require(rewardFlag[id] == false, "token has been rewarded");
rewardFlag[id] = true;
}
uint256 reward = getRewards() * tokenIDs.length / levelInfos[MAX_LEVEL - 2].mintNum;
payable(msg.sender).sendValue(reward);
emit ClaimRewards(msg.sender, tokenIDs, reward);
}
function adminClaimRemainRewards() public onlyOwner(){
}
function invest(uint256 level) public payable{
}
function cancleInvest(uint256 level, uint256 amount) public{
}
function getUserInvestInfo(address user, uint256[] memory levels) public view returns(uint256[] memory){
}
function getInvestRewards(address user) public view returns(uint256){
}
function claimInvestRewards() public {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata path) public onlyOwner(){
}
// The following functions are overrides required by Solidity.
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId,
uint256 batchSize
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| levelInfos[MAX_LEVEL-1].mintNum>0,"not finish" | 224,150 | levelInfos[MAX_LEVEL-1].mintNum>0 |
"token level error" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract TenLevels is ERC721, ERC721Enumerable, Ownable {
// lib
using Address for address payable;
// struct
struct LevelInfo {
uint16 lastNeedNum;
uint16 merkleProofAnswerNum;
uint16 payCount;
uint256[] payNumAndPrice;
bytes32 answerMerkleProofRootHash;
bytes32 answerHash;
uint256 mintNum;
mapping(uint256 => bool) indexMinted;
}
struct InvestInfo{
uint256 maxAmount;
uint256 sharePer;
uint256 curAmount;
mapping(address => uint256) userAmount;
}
// constant
uint256 public constant MAX_INVEST_LEVEL = 3;
uint256 public constant MAX_LEVEL = 10;
uint256 public constant LEVEL_GAP = 100000000;
uint256 public constant MAX_PER = 10000;
uint256 public constant OWNER_SHARE_PER = 2000;
uint256 public constant INVESTOR_SHARE_PER = 3000;
// storage
mapping(uint256 => LevelInfo) public levelInfos;
mapping(uint256 => bool) public useFlag;
mapping(uint256 => bool) public rewardFlag;
uint256 public investorShare;
mapping(uint256 => InvestInfo) public investInfos;
mapping(address => bool) public investClaimFlag;
bool public adminInvestClaimFlag;
uint256 private _rewardShare;
string private _basePath;
// event
event Mint(address indexed user, uint256 indexed costToken, uint256 indexed newToken);
event ClaimRewards(address indexed user, uint256[] tokenIDs, uint256 amount);
event Invest(address indexed user, uint256 indexed level, uint256 amount);
event CancleInvest(address indexed user, uint256 indexed level, uint256 amount);
event InvestClaimRewards(address indexed user, uint256 amount);
event AdminClaimRemainInvestRewards(uint256 amount);
event MetadataUpdate(uint256 _tokenId);
// function
constructor() ERC721("TenLevels", "TL") {
}
function getMintedIndex(uint256 level, uint256[] memory index) public view returns(bool[] memory){
}
function getMintPrice(uint256 level) public view returns (uint256){
}
function getRewards() public view returns (uint256){
}
function _payEth(uint256 level) private {
}
function merkleProofMint(uint256 tokenID, uint256 level, bytes32 nodeHash, uint256 index, bytes32[] memory proofs) public payable{
}
function mint(uint256 tokenID, uint256 level, bytes32 answerHash) public payable{
}
function claimRewards(uint256[] memory tokenIDs) public{
require(levelInfos[MAX_LEVEL - 1].mintNum > 0, "not finish");
uint256 id = 0;
for (uint256 i = 0; i < tokenIDs.length; ++i){
id = tokenIDs[i];
require(<FILL_ME>)
require(ownerOf(id) == msg.sender, "token owner error");
require(rewardFlag[id] == false, "token has been rewarded");
rewardFlag[id] = true;
}
uint256 reward = getRewards() * tokenIDs.length / levelInfos[MAX_LEVEL - 2].mintNum;
payable(msg.sender).sendValue(reward);
emit ClaimRewards(msg.sender, tokenIDs, reward);
}
function adminClaimRemainRewards() public onlyOwner(){
}
function invest(uint256 level) public payable{
}
function cancleInvest(uint256 level, uint256 amount) public{
}
function getUserInvestInfo(address user, uint256[] memory levels) public view returns(uint256[] memory){
}
function getInvestRewards(address user) public view returns(uint256){
}
function claimInvestRewards() public {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata path) public onlyOwner(){
}
// The following functions are overrides required by Solidity.
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId,
uint256 batchSize
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| id/LEVEL_GAP==MAX_LEVEL-1,"token level error" | 224,150 | id/LEVEL_GAP==MAX_LEVEL-1 |
"token owner error" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract TenLevels is ERC721, ERC721Enumerable, Ownable {
// lib
using Address for address payable;
// struct
struct LevelInfo {
uint16 lastNeedNum;
uint16 merkleProofAnswerNum;
uint16 payCount;
uint256[] payNumAndPrice;
bytes32 answerMerkleProofRootHash;
bytes32 answerHash;
uint256 mintNum;
mapping(uint256 => bool) indexMinted;
}
struct InvestInfo{
uint256 maxAmount;
uint256 sharePer;
uint256 curAmount;
mapping(address => uint256) userAmount;
}
// constant
uint256 public constant MAX_INVEST_LEVEL = 3;
uint256 public constant MAX_LEVEL = 10;
uint256 public constant LEVEL_GAP = 100000000;
uint256 public constant MAX_PER = 10000;
uint256 public constant OWNER_SHARE_PER = 2000;
uint256 public constant INVESTOR_SHARE_PER = 3000;
// storage
mapping(uint256 => LevelInfo) public levelInfos;
mapping(uint256 => bool) public useFlag;
mapping(uint256 => bool) public rewardFlag;
uint256 public investorShare;
mapping(uint256 => InvestInfo) public investInfos;
mapping(address => bool) public investClaimFlag;
bool public adminInvestClaimFlag;
uint256 private _rewardShare;
string private _basePath;
// event
event Mint(address indexed user, uint256 indexed costToken, uint256 indexed newToken);
event ClaimRewards(address indexed user, uint256[] tokenIDs, uint256 amount);
event Invest(address indexed user, uint256 indexed level, uint256 amount);
event CancleInvest(address indexed user, uint256 indexed level, uint256 amount);
event InvestClaimRewards(address indexed user, uint256 amount);
event AdminClaimRemainInvestRewards(uint256 amount);
event MetadataUpdate(uint256 _tokenId);
// function
constructor() ERC721("TenLevels", "TL") {
}
function getMintedIndex(uint256 level, uint256[] memory index) public view returns(bool[] memory){
}
function getMintPrice(uint256 level) public view returns (uint256){
}
function getRewards() public view returns (uint256){
}
function _payEth(uint256 level) private {
}
function merkleProofMint(uint256 tokenID, uint256 level, bytes32 nodeHash, uint256 index, bytes32[] memory proofs) public payable{
}
function mint(uint256 tokenID, uint256 level, bytes32 answerHash) public payable{
}
function claimRewards(uint256[] memory tokenIDs) public{
require(levelInfos[MAX_LEVEL - 1].mintNum > 0, "not finish");
uint256 id = 0;
for (uint256 i = 0; i < tokenIDs.length; ++i){
id = tokenIDs[i];
require(id / LEVEL_GAP == MAX_LEVEL - 1, "token level error");
require(<FILL_ME>)
require(rewardFlag[id] == false, "token has been rewarded");
rewardFlag[id] = true;
}
uint256 reward = getRewards() * tokenIDs.length / levelInfos[MAX_LEVEL - 2].mintNum;
payable(msg.sender).sendValue(reward);
emit ClaimRewards(msg.sender, tokenIDs, reward);
}
function adminClaimRemainRewards() public onlyOwner(){
}
function invest(uint256 level) public payable{
}
function cancleInvest(uint256 level, uint256 amount) public{
}
function getUserInvestInfo(address user, uint256[] memory levels) public view returns(uint256[] memory){
}
function getInvestRewards(address user) public view returns(uint256){
}
function claimInvestRewards() public {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata path) public onlyOwner(){
}
// The following functions are overrides required by Solidity.
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId,
uint256 batchSize
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| ownerOf(id)==msg.sender,"token owner error" | 224,150 | ownerOf(id)==msg.sender |
"token has been rewarded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract TenLevels is ERC721, ERC721Enumerable, Ownable {
// lib
using Address for address payable;
// struct
struct LevelInfo {
uint16 lastNeedNum;
uint16 merkleProofAnswerNum;
uint16 payCount;
uint256[] payNumAndPrice;
bytes32 answerMerkleProofRootHash;
bytes32 answerHash;
uint256 mintNum;
mapping(uint256 => bool) indexMinted;
}
struct InvestInfo{
uint256 maxAmount;
uint256 sharePer;
uint256 curAmount;
mapping(address => uint256) userAmount;
}
// constant
uint256 public constant MAX_INVEST_LEVEL = 3;
uint256 public constant MAX_LEVEL = 10;
uint256 public constant LEVEL_GAP = 100000000;
uint256 public constant MAX_PER = 10000;
uint256 public constant OWNER_SHARE_PER = 2000;
uint256 public constant INVESTOR_SHARE_PER = 3000;
// storage
mapping(uint256 => LevelInfo) public levelInfos;
mapping(uint256 => bool) public useFlag;
mapping(uint256 => bool) public rewardFlag;
uint256 public investorShare;
mapping(uint256 => InvestInfo) public investInfos;
mapping(address => bool) public investClaimFlag;
bool public adminInvestClaimFlag;
uint256 private _rewardShare;
string private _basePath;
// event
event Mint(address indexed user, uint256 indexed costToken, uint256 indexed newToken);
event ClaimRewards(address indexed user, uint256[] tokenIDs, uint256 amount);
event Invest(address indexed user, uint256 indexed level, uint256 amount);
event CancleInvest(address indexed user, uint256 indexed level, uint256 amount);
event InvestClaimRewards(address indexed user, uint256 amount);
event AdminClaimRemainInvestRewards(uint256 amount);
event MetadataUpdate(uint256 _tokenId);
// function
constructor() ERC721("TenLevels", "TL") {
}
function getMintedIndex(uint256 level, uint256[] memory index) public view returns(bool[] memory){
}
function getMintPrice(uint256 level) public view returns (uint256){
}
function getRewards() public view returns (uint256){
}
function _payEth(uint256 level) private {
}
function merkleProofMint(uint256 tokenID, uint256 level, bytes32 nodeHash, uint256 index, bytes32[] memory proofs) public payable{
}
function mint(uint256 tokenID, uint256 level, bytes32 answerHash) public payable{
}
function claimRewards(uint256[] memory tokenIDs) public{
require(levelInfos[MAX_LEVEL - 1].mintNum > 0, "not finish");
uint256 id = 0;
for (uint256 i = 0; i < tokenIDs.length; ++i){
id = tokenIDs[i];
require(id / LEVEL_GAP == MAX_LEVEL - 1, "token level error");
require(ownerOf(id) == msg.sender, "token owner error");
require(<FILL_ME>)
rewardFlag[id] = true;
}
uint256 reward = getRewards() * tokenIDs.length / levelInfos[MAX_LEVEL - 2].mintNum;
payable(msg.sender).sendValue(reward);
emit ClaimRewards(msg.sender, tokenIDs, reward);
}
function adminClaimRemainRewards() public onlyOwner(){
}
function invest(uint256 level) public payable{
}
function cancleInvest(uint256 level, uint256 amount) public{
}
function getUserInvestInfo(address user, uint256[] memory levels) public view returns(uint256[] memory){
}
function getInvestRewards(address user) public view returns(uint256){
}
function claimInvestRewards() public {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata path) public onlyOwner(){
}
// The following functions are overrides required by Solidity.
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId,
uint256 batchSize
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| rewardFlag[id]==false,"token has been rewarded" | 224,150 | rewardFlag[id]==false |
"already claim" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract TenLevels is ERC721, ERC721Enumerable, Ownable {
// lib
using Address for address payable;
// struct
struct LevelInfo {
uint16 lastNeedNum;
uint16 merkleProofAnswerNum;
uint16 payCount;
uint256[] payNumAndPrice;
bytes32 answerMerkleProofRootHash;
bytes32 answerHash;
uint256 mintNum;
mapping(uint256 => bool) indexMinted;
}
struct InvestInfo{
uint256 maxAmount;
uint256 sharePer;
uint256 curAmount;
mapping(address => uint256) userAmount;
}
// constant
uint256 public constant MAX_INVEST_LEVEL = 3;
uint256 public constant MAX_LEVEL = 10;
uint256 public constant LEVEL_GAP = 100000000;
uint256 public constant MAX_PER = 10000;
uint256 public constant OWNER_SHARE_PER = 2000;
uint256 public constant INVESTOR_SHARE_PER = 3000;
// storage
mapping(uint256 => LevelInfo) public levelInfos;
mapping(uint256 => bool) public useFlag;
mapping(uint256 => bool) public rewardFlag;
uint256 public investorShare;
mapping(uint256 => InvestInfo) public investInfos;
mapping(address => bool) public investClaimFlag;
bool public adminInvestClaimFlag;
uint256 private _rewardShare;
string private _basePath;
// event
event Mint(address indexed user, uint256 indexed costToken, uint256 indexed newToken);
event ClaimRewards(address indexed user, uint256[] tokenIDs, uint256 amount);
event Invest(address indexed user, uint256 indexed level, uint256 amount);
event CancleInvest(address indexed user, uint256 indexed level, uint256 amount);
event InvestClaimRewards(address indexed user, uint256 amount);
event AdminClaimRemainInvestRewards(uint256 amount);
event MetadataUpdate(uint256 _tokenId);
// function
constructor() ERC721("TenLevels", "TL") {
}
function getMintedIndex(uint256 level, uint256[] memory index) public view returns(bool[] memory){
}
function getMintPrice(uint256 level) public view returns (uint256){
}
function getRewards() public view returns (uint256){
}
function _payEth(uint256 level) private {
}
function merkleProofMint(uint256 tokenID, uint256 level, bytes32 nodeHash, uint256 index, bytes32[] memory proofs) public payable{
}
function mint(uint256 tokenID, uint256 level, bytes32 answerHash) public payable{
}
function claimRewards(uint256[] memory tokenIDs) public{
}
function adminClaimRemainRewards() public onlyOwner(){
}
function invest(uint256 level) public payable{
}
function cancleInvest(uint256 level, uint256 amount) public{
}
function getUserInvestInfo(address user, uint256[] memory levels) public view returns(uint256[] memory){
}
function getInvestRewards(address user) public view returns(uint256){
}
function claimInvestRewards() public {
require(levelInfos[MAX_LEVEL - 1].mintNum > 0, "not finish");
require(<FILL_ME>)
uint256 rewardAmount = getInvestRewards(msg.sender);
require(rewardAmount > 0, "no reward to claim");
investClaimFlag[msg.sender] = true;
payable(msg.sender).sendValue(rewardAmount);
emit InvestClaimRewards(msg.sender, rewardAmount);
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata path) public onlyOwner(){
}
// The following functions are overrides required by Solidity.
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId,
uint256 batchSize
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| investClaimFlag[msg.sender]==false,"already claim" | 224,150 | investClaimFlag[msg.sender]==false |
"token already use during gaming" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract TenLevels is ERC721, ERC721Enumerable, Ownable {
// lib
using Address for address payable;
// struct
struct LevelInfo {
uint16 lastNeedNum;
uint16 merkleProofAnswerNum;
uint16 payCount;
uint256[] payNumAndPrice;
bytes32 answerMerkleProofRootHash;
bytes32 answerHash;
uint256 mintNum;
mapping(uint256 => bool) indexMinted;
}
struct InvestInfo{
uint256 maxAmount;
uint256 sharePer;
uint256 curAmount;
mapping(address => uint256) userAmount;
}
// constant
uint256 public constant MAX_INVEST_LEVEL = 3;
uint256 public constant MAX_LEVEL = 10;
uint256 public constant LEVEL_GAP = 100000000;
uint256 public constant MAX_PER = 10000;
uint256 public constant OWNER_SHARE_PER = 2000;
uint256 public constant INVESTOR_SHARE_PER = 3000;
// storage
mapping(uint256 => LevelInfo) public levelInfos;
mapping(uint256 => bool) public useFlag;
mapping(uint256 => bool) public rewardFlag;
uint256 public investorShare;
mapping(uint256 => InvestInfo) public investInfos;
mapping(address => bool) public investClaimFlag;
bool public adminInvestClaimFlag;
uint256 private _rewardShare;
string private _basePath;
// event
event Mint(address indexed user, uint256 indexed costToken, uint256 indexed newToken);
event ClaimRewards(address indexed user, uint256[] tokenIDs, uint256 amount);
event Invest(address indexed user, uint256 indexed level, uint256 amount);
event CancleInvest(address indexed user, uint256 indexed level, uint256 amount);
event InvestClaimRewards(address indexed user, uint256 amount);
event AdminClaimRemainInvestRewards(uint256 amount);
event MetadataUpdate(uint256 _tokenId);
// function
constructor() ERC721("TenLevels", "TL") {
}
function getMintedIndex(uint256 level, uint256[] memory index) public view returns(bool[] memory){
}
function getMintPrice(uint256 level) public view returns (uint256){
}
function getRewards() public view returns (uint256){
}
function _payEth(uint256 level) private {
}
function merkleProofMint(uint256 tokenID, uint256 level, bytes32 nodeHash, uint256 index, bytes32[] memory proofs) public payable{
}
function mint(uint256 tokenID, uint256 level, bytes32 answerHash) public payable{
}
function claimRewards(uint256[] memory tokenIDs) public{
}
function adminClaimRemainRewards() public onlyOwner(){
}
function invest(uint256 level) public payable{
}
function cancleInvest(uint256 level, uint256 amount) public{
}
function getUserInvestInfo(address user, uint256[] memory levels) public view returns(uint256[] memory){
}
function getInvestRewards(address user) public view returns(uint256){
}
function claimInvestRewards() public {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata path) public onlyOwner(){
}
// The following functions are overrides required by Solidity.
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId,
uint256 batchSize
) internal override(ERC721, ERC721Enumerable) {
super._beforeTokenTransfer(from, to, tokenId, batchSize);
if (levelInfos[MAX_LEVEL - 1].mintNum == 0){
require(<FILL_ME>)
}
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| useFlag[tokenId]==false,"token already use during gaming" | 224,150 | useFlag[tokenId]==false |
null | pragma solidity 0.8.7;
/*
________ _______ _______ __ ___ _______ _______ ________ ______ _______
/" )/" "| /" "||/"| / ")/" "| /" \ /" ) / " \ /" "|
(: \___/(: ______)(: ______)(: |/ /(: ______)|: |(: \___/ // ____ \(: ______)
\___ \ \/ | \/ | | __/ \/ | |_____/ ) \___ \ / / ) :)\/ |
__/ \\ // ___)_ // ___)_ (// _ \ // ___)_ // / __/ \\ (: (____/ // // ___)
/" \ :)(: "|(: "||: | \ \(: "||: __ \ /" \ :) \ / (: (
(_______/ \_______) \_______)(__| \__)\_______)|__| \___)(_______/ \"_____/ \__/
___________ __ __ _______ _______ ___________ _______ _______ _____ ___ __ ___
(" _ ")/" | | "\ /" "| /" "|(" _ ")/" "| /" \ (\" \|" \ /""\ |" |
)__/ \\__/(: (__) :)(: ______) (: ______) )__/ \\__/(: ______)|: ||.\\ \ | / \ || |
\\_ / \/ \/ \/ | \/ | \\_ / \/ | |_____/ )|: \. \\ | /' /\ \ |: |
|. | // __ \\ // ___)_ // ___)_ |. | // ___)_ // / |. \ \. | // __' \ \ |___
\: | (: ( ) :)(: "| (: "| \: | (: "||: __ \ | \ \ | / / \\ \( \_|: \
\__| \__| |__/ \_______) \_______) \__| \_______)|__| \___) \___|\____\)(___/ \___)\_______)
*/
contract SOTENFT is ERC721A, Ownable {
using Strings for uint256;
string public baseURI;
bytes32 public merkleRoot = 0x1e4c358a4152bab17c8e6c87a9946a97db24d41a8e9de129a60f44679231f1c5;
uint256 public maxPerWallet = 2;
uint256 public totalSOTESupply = 5000;
mapping(address => uint256) totalMintedAllowlist;
mapping(address => uint256) totalMintedPublic;
bool public allowlistOpen = true;
modifier onlySender() {
}
modifier isallowlistOpen() {
}
modifier isPublicOpen() {
}
constructor(string memory _initBaseURI)
ERC721A("Seekers of the Eternal", "SOTE")
{
}
function flipSales() public onlyOwner {
}
function allowlistSeekerMint(
bytes32[] calldata _merkleProof,
uint256 amount
) public onlySender isallowlistOpen {
require(<FILL_ME>)
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(
MerkleProof.verify(_merkleProof, merkleRoot, leaf),
"Invalid proof."
);
totalMintedAllowlist[msg.sender] += 1;
_mint(msg.sender, amount);
}
function publicSeekerMint(uint256 amount) public onlySender isPublicOpen {
}
function changeSupply(uint256 _supply) public onlyOwner {
}
function changeMerkle(bytes32 incoming) public onlyOwner {
}
function changeMax(uint256 max) public onlyOwner {
}
function teamWalletMint(uint256 howMany) public onlyOwner
{
}
function withdrawEther() external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function getBalance() public view returns (uint256) {
}
function walletOfOwner(address address_)
public
view
virtual
returns (uint256[] memory)
{
}
}
| totalMintedAllowlist[msg.sender]+amount<=maxPerWallet | 224,513 | totalMintedAllowlist[msg.sender]+amount<=maxPerWallet |
null | pragma solidity 0.8.7;
/*
________ _______ _______ __ ___ _______ _______ ________ ______ _______
/" )/" "| /" "||/"| / ")/" "| /" \ /" ) / " \ /" "|
(: \___/(: ______)(: ______)(: |/ /(: ______)|: |(: \___/ // ____ \(: ______)
\___ \ \/ | \/ | | __/ \/ | |_____/ ) \___ \ / / ) :)\/ |
__/ \\ // ___)_ // ___)_ (// _ \ // ___)_ // / __/ \\ (: (____/ // // ___)
/" \ :)(: "|(: "||: | \ \(: "||: __ \ /" \ :) \ / (: (
(_______/ \_______) \_______)(__| \__)\_______)|__| \___)(_______/ \"_____/ \__/
___________ __ __ _______ _______ ___________ _______ _______ _____ ___ __ ___
(" _ ")/" | | "\ /" "| /" "|(" _ ")/" "| /" \ (\" \|" \ /""\ |" |
)__/ \\__/(: (__) :)(: ______) (: ______) )__/ \\__/(: ______)|: ||.\\ \ | / \ || |
\\_ / \/ \/ \/ | \/ | \\_ / \/ | |_____/ )|: \. \\ | /' /\ \ |: |
|. | // __ \\ // ___)_ // ___)_ |. | // ___)_ // / |. \ \. | // __' \ \ |___
\: | (: ( ) :)(: "| (: "| \: | (: "||: __ \ | \ \ | / / \\ \( \_|: \
\__| \__| |__/ \_______) \_______) \__| \_______)|__| \___) \___|\____\)(___/ \___)\_______)
*/
contract SOTENFT is ERC721A, Ownable {
using Strings for uint256;
string public baseURI;
bytes32 public merkleRoot = 0x1e4c358a4152bab17c8e6c87a9946a97db24d41a8e9de129a60f44679231f1c5;
uint256 public maxPerWallet = 2;
uint256 public totalSOTESupply = 5000;
mapping(address => uint256) totalMintedAllowlist;
mapping(address => uint256) totalMintedPublic;
bool public allowlistOpen = true;
modifier onlySender() {
}
modifier isallowlistOpen() {
}
modifier isPublicOpen() {
}
constructor(string memory _initBaseURI)
ERC721A("Seekers of the Eternal", "SOTE")
{
}
function flipSales() public onlyOwner {
}
function allowlistSeekerMint(
bytes32[] calldata _merkleProof,
uint256 amount
) public onlySender isallowlistOpen {
}
function publicSeekerMint(uint256 amount) public onlySender isPublicOpen {
require(<FILL_ME>)
require(totalSupply() + amount <= totalSOTESupply);
totalMintedPublic[msg.sender] += 1;
_mint(msg.sender, amount);
}
function changeSupply(uint256 _supply) public onlyOwner {
}
function changeMerkle(bytes32 incoming) public onlyOwner {
}
function changeMax(uint256 max) public onlyOwner {
}
function teamWalletMint(uint256 howMany) public onlyOwner
{
}
function withdrawEther() external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function getBalance() public view returns (uint256) {
}
function walletOfOwner(address address_)
public
view
virtual
returns (uint256[] memory)
{
}
}
| totalMintedPublic[msg.sender]+amount<=maxPerWallet | 224,513 | totalMintedPublic[msg.sender]+amount<=maxPerWallet |
null | pragma solidity 0.8.7;
/*
________ _______ _______ __ ___ _______ _______ ________ ______ _______
/" )/" "| /" "||/"| / ")/" "| /" \ /" ) / " \ /" "|
(: \___/(: ______)(: ______)(: |/ /(: ______)|: |(: \___/ // ____ \(: ______)
\___ \ \/ | \/ | | __/ \/ | |_____/ ) \___ \ / / ) :)\/ |
__/ \\ // ___)_ // ___)_ (// _ \ // ___)_ // / __/ \\ (: (____/ // // ___)
/" \ :)(: "|(: "||: | \ \(: "||: __ \ /" \ :) \ / (: (
(_______/ \_______) \_______)(__| \__)\_______)|__| \___)(_______/ \"_____/ \__/
___________ __ __ _______ _______ ___________ _______ _______ _____ ___ __ ___
(" _ ")/" | | "\ /" "| /" "|(" _ ")/" "| /" \ (\" \|" \ /""\ |" |
)__/ \\__/(: (__) :)(: ______) (: ______) )__/ \\__/(: ______)|: ||.\\ \ | / \ || |
\\_ / \/ \/ \/ | \/ | \\_ / \/ | |_____/ )|: \. \\ | /' /\ \ |: |
|. | // __ \\ // ___)_ // ___)_ |. | // ___)_ // / |. \ \. | // __' \ \ |___
\: | (: ( ) :)(: "| (: "| \: | (: "||: __ \ | \ \ | / / \\ \( \_|: \
\__| \__| |__/ \_______) \_______) \__| \_______)|__| \___) \___|\____\)(___/ \___)\_______)
*/
contract SOTENFT is ERC721A, Ownable {
using Strings for uint256;
string public baseURI;
bytes32 public merkleRoot = 0x1e4c358a4152bab17c8e6c87a9946a97db24d41a8e9de129a60f44679231f1c5;
uint256 public maxPerWallet = 2;
uint256 public totalSOTESupply = 5000;
mapping(address => uint256) totalMintedAllowlist;
mapping(address => uint256) totalMintedPublic;
bool public allowlistOpen = true;
modifier onlySender() {
}
modifier isallowlistOpen() {
}
modifier isPublicOpen() {
}
constructor(string memory _initBaseURI)
ERC721A("Seekers of the Eternal", "SOTE")
{
}
function flipSales() public onlyOwner {
}
function allowlistSeekerMint(
bytes32[] calldata _merkleProof,
uint256 amount
) public onlySender isallowlistOpen {
}
function publicSeekerMint(uint256 amount) public onlySender isPublicOpen {
require(totalMintedPublic[msg.sender] + amount <= maxPerWallet);
require(<FILL_ME>)
totalMintedPublic[msg.sender] += 1;
_mint(msg.sender, amount);
}
function changeSupply(uint256 _supply) public onlyOwner {
}
function changeMerkle(bytes32 incoming) public onlyOwner {
}
function changeMax(uint256 max) public onlyOwner {
}
function teamWalletMint(uint256 howMany) public onlyOwner
{
}
function withdrawEther() external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function getBalance() public view returns (uint256) {
}
function walletOfOwner(address address_)
public
view
virtual
returns (uint256[] memory)
{
}
}
| totalSupply()+amount<=totalSOTESupply | 224,513 | totalSupply()+amount<=totalSOTESupply |
null | pragma solidity 0.8.7;
/*
________ _______ _______ __ ___ _______ _______ ________ ______ _______
/" )/" "| /" "||/"| / ")/" "| /" \ /" ) / " \ /" "|
(: \___/(: ______)(: ______)(: |/ /(: ______)|: |(: \___/ // ____ \(: ______)
\___ \ \/ | \/ | | __/ \/ | |_____/ ) \___ \ / / ) :)\/ |
__/ \\ // ___)_ // ___)_ (// _ \ // ___)_ // / __/ \\ (: (____/ // // ___)
/" \ :)(: "|(: "||: | \ \(: "||: __ \ /" \ :) \ / (: (
(_______/ \_______) \_______)(__| \__)\_______)|__| \___)(_______/ \"_____/ \__/
___________ __ __ _______ _______ ___________ _______ _______ _____ ___ __ ___
(" _ ")/" | | "\ /" "| /" "|(" _ ")/" "| /" \ (\" \|" \ /""\ |" |
)__/ \\__/(: (__) :)(: ______) (: ______) )__/ \\__/(: ______)|: ||.\\ \ | / \ || |
\\_ / \/ \/ \/ | \/ | \\_ / \/ | |_____/ )|: \. \\ | /' /\ \ |: |
|. | // __ \\ // ___)_ // ___)_ |. | // ___)_ // / |. \ \. | // __' \ \ |___
\: | (: ( ) :)(: "| (: "| \: | (: "||: __ \ | \ \ | / / \\ \( \_|: \
\__| \__| |__/ \_______) \_______) \__| \_______)|__| \___) \___|\____\)(___/ \___)\_______)
*/
contract SOTENFT is ERC721A, Ownable {
using Strings for uint256;
string public baseURI;
bytes32 public merkleRoot = 0x1e4c358a4152bab17c8e6c87a9946a97db24d41a8e9de129a60f44679231f1c5;
uint256 public maxPerWallet = 2;
uint256 public totalSOTESupply = 5000;
mapping(address => uint256) totalMintedAllowlist;
mapping(address => uint256) totalMintedPublic;
bool public allowlistOpen = true;
modifier onlySender() {
}
modifier isallowlistOpen() {
}
modifier isPublicOpen() {
}
constructor(string memory _initBaseURI)
ERC721A("Seekers of the Eternal", "SOTE")
{
}
function flipSales() public onlyOwner {
}
function allowlistSeekerMint(
bytes32[] calldata _merkleProof,
uint256 amount
) public onlySender isallowlistOpen {
}
function publicSeekerMint(uint256 amount) public onlySender isPublicOpen {
}
function changeSupply(uint256 _supply) public onlyOwner {
}
function changeMerkle(bytes32 incoming) public onlyOwner {
}
function changeMax(uint256 max) public onlyOwner {
}
function teamWalletMint(uint256 howMany) public onlyOwner
{
require(<FILL_ME>)
_mint(msg.sender, howMany);
}
function withdrawEther() external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function getBalance() public view returns (uint256) {
}
function walletOfOwner(address address_)
public
view
virtual
returns (uint256[] memory)
{
}
}
| totalSupply()+howMany<=totalSOTESupply | 224,513 | totalSupply()+howMany<=totalSOTESupply |
"LRDT:C:TRANSFER_FROM" | // SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity ^0.8.7;
import {RevenueDistributionToken} from "revenue-distribution-token/RevenueDistributionToken.sol";
import {ERC20} from "erc20/ERC20.sol";
import {ERC20Helper} from "erc20-helper/ERC20Helper.sol";
import {ILockedRevenueDistributionToken} from "./interfaces/ILockedRevenueDistributionToken.sol";
/*░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░██╗░░░░░██████╗░██████╗░████████╗░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░██║░░░░░██╔══██╗██╔══██╗╚══██╔══╝░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░██║░░░░░██████╔╝██║░░██║░░░██║░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░██║░░░░░██╔══██╗██║░░██║░░░██║░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░███████╗██║░░██║██████╔╝░░░██║░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░╚══════╝╚═╝░░╚═╝╚═════╝░░░░╚═╝░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░ ░░░░
░░░░ Locked Revenue Distribution Token ░░░░
░░░░ ░░░░
░░░░ Extending Maple's RevenueDistributionToken with time-based locking, ░░░░
░░░░ fee-based instant withdrawals and public vesting schedule updating. ░░░░
░░░░ ░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░*/
/**
* @title ERC-4626 revenue distribution vault with locking.
* @notice Tokens are locked and must be subject to time-based or fee-based withdrawal conditions.
* @dev Limited to a maximum asset supply of uint96.
* @author GET Protocol DAO
* @author Uses Maple's RevenueDistributionToken v1.0.1 under AGPL-3.0 (https://github.com/maple-labs/revenue-distribution-token/tree/v1.0.1)
*/
contract LockedRevenueDistributionToken is ILockedRevenueDistributionToken, RevenueDistributionToken {
uint256 public constant override MAXIMUM_LOCK_TIME = 104 weeks;
uint256 public constant override VESTING_PERIOD = 2 weeks;
uint256 public constant override WITHDRAWAL_WINDOW = 4 weeks;
uint256 public override instantWithdrawalFee;
uint256 public override lockTime;
mapping(address => WithdrawalRequest[]) internal userWithdrawalRequests;
mapping(address => bool) public override withdrawalFeeExemptions;
constructor(
string memory name_,
string memory symbol_,
address owner_,
address asset_,
uint256 precision_,
uint256 instantWithdrawalFee_,
uint256 lockTime_,
uint256 initialSeed_
) RevenueDistributionToken(name_, symbol_, owner_, asset_, precision_) {
instantWithdrawalFee = instantWithdrawalFee_;
lockTime = lockTime_;
// We initialize the contract by seeding an amount of shares and then burning them. This prevents donation
// attacks from affecting the precision of the shares:assets rate.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/issues/3706
if (initialSeed_ > 0) {
address caller_ = msg.sender;
address receiver_ = address(0);
// RDT.deposit() cannot be called within the constructor as this uses immutable variables.
// ERC20._mint()
totalSupply += initialSeed_;
unchecked {
balanceOf[receiver_] += initialSeed_;
}
emit Transfer(address(0), receiver_, initialSeed_);
// RDT._mint()
freeAssets = initialSeed_;
emit Deposit(caller_, receiver_, initialSeed_, initialSeed_);
emit IssuanceParamsUpdated(freeAssets, 0);
require(<FILL_ME>)
}
}
/*░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░ Administrative Functions ░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░*/
/**
* @inheritdoc ILockedRevenueDistributionToken
*/
function setInstantWithdrawalFee(uint256 percentage_) external virtual override {
}
/**
* @inheritdoc ILockedRevenueDistributionToken
*/
function setLockTime(uint256 lockTime_) external virtual override {
}
/**
* @inheritdoc ILockedRevenueDistributionToken
*/
function setWithdrawalFeeExemption(address account_, bool status_) external virtual override {
}
/*░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░ Public Functions ░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░*/
/**
* @inheritdoc ILockedRevenueDistributionToken
*/
function createWithdrawalRequest(uint256 shares_) external virtual override nonReentrant {
}
/**
* @inheritdoc ILockedRevenueDistributionToken
*/
function cancelWithdrawalRequest(uint256 pos_) external virtual override nonReentrant {
}
/**
* @inheritdoc ILockedRevenueDistributionToken
*/
function executeWithdrawalRequest(uint256 pos_) external virtual override nonReentrant {
}
/**
* @inheritdoc ILockedRevenueDistributionToken
*/
function updateVestingSchedule() external virtual override returns (uint256 issuanceRate_, uint256 freeAssets_) {
}
/**
* @inheritdoc ILockedRevenueDistributionToken
* @dev Reentrancy modifier provided within the internal function call.
*/
function deposit(uint256 assets_, address receiver_, uint256 minShares_)
external
virtual
override
returns (uint256 shares_)
{
}
/**
* @inheritdoc ILockedRevenueDistributionToken
* @dev Reentrancy modifier provided within the internal function call.
*/
function mint(uint256 shares_, address receiver_, uint256 maxAssets_)
external
virtual
override
returns (uint256 assets_)
{
}
/**
* @inheritdoc RevenueDistributionToken
* @dev Will check for withdrawal fee exemption present on owner.
*/
function redeem(uint256 shares_, address receiver_, address owner_)
public
virtual
override
nonReentrant
returns (uint256 assets_)
{
}
/**
* @inheritdoc ILockedRevenueDistributionToken
* @dev Reentrancy modifier provided within the internal function call.
*/
function redeem(uint256 shares_, address receiver_, address owner_, uint256 minAssets_)
external
virtual
override
returns (uint256 assets_)
{
}
/**
* @inheritdoc RevenueDistributionToken
* @dev Will check for withdrawal fee exemption present on owner.
*/
function withdraw(uint256 assets_, address receiver_, address owner_)
public
virtual
override
nonReentrant
returns (uint256 shares_)
{
}
/**
* @inheritdoc ILockedRevenueDistributionToken
* @dev Reentrancy modifier provided within the internal function call.
*/
function withdraw(uint256 assets_, address receiver_, address owner_, uint256 maxShares_)
external
virtual
override
returns (uint256 shares_)
{
}
/*░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░ View Functions ░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░*/
/**
* @inheritdoc RevenueDistributionToken
* @dev Returns the amount of redeemable assets for given shares after instant withdrawal fee.
* @dev `address(0)` cannot be set as exempt, and is used here as default to imply that fees must be deducted.
*/
function previewRedeem(uint256 shares_) public view virtual override returns (uint256 assets_) {
}
/**
* @inheritdoc ILockedRevenueDistributionToken
*/
function previewRedeem(uint256 shares_, address owner_)
public
view
virtual
override
returns (uint256 assets_, uint256 fee_)
{
}
/**
* @inheritdoc RevenueDistributionToken
* @dev Returns the amount of redeemable assets for given shares after instant withdrawal fee.
* @dev `address(0)` cannot be set as exempt, and is used here as default to imply that fees must be deducted.
*/
function previewWithdraw(uint256 assets_) public view virtual override returns (uint256 shares_) {
}
/**
* @inheritdoc ILockedRevenueDistributionToken
*/
function previewWithdraw(uint256 assets_, address owner_)
public
view
virtual
override
returns (uint256 shares_, uint256 fee_)
{
}
/**
* @inheritdoc ILockedRevenueDistributionToken
*/
function previewWithdrawalRequest(uint256 pos_, address owner_)
public
view
virtual
override
returns (WithdrawalRequest memory request_, uint256 assets_, uint256 fee_)
{
}
/**
* @inheritdoc RevenueDistributionToken
* @dev Restricted to uint96 as defined in WithdrawalRequest struct.
*/
function maxDeposit(address receiver_) external pure virtual override returns (uint256 maxAssets_) {
}
/**
* @inheritdoc RevenueDistributionToken
* @dev Restricted to uint96 as defined in WithdrawalRequest struct.
*/
function maxMint(address receiver_) external pure virtual override returns (uint256 maxShares_) {
}
/**
* @inheritdoc ILockedRevenueDistributionToken
*/
function withdrawalRequestCount(address owner_) external view virtual override returns (uint256 count_) {
}
/**
* @inheritdoc ILockedRevenueDistributionToken
*/
function withdrawalRequests(address owner_)
external
view
virtual
override
returns (WithdrawalRequest[] memory withdrawalRequests_)
{
}
/**
* @inheritdoc ILockedRevenueDistributionToken
*/
function withdrawalRequests(address account_, uint256 pos_)
external
view
virtual
override
returns (WithdrawalRequest memory withdrawalRequest_)
{
}
}
| ERC20Helper.transferFrom(asset_,msg.sender,address(this),initialSeed_),"LRDT:C:TRANSFER_FROM" | 224,528 | ERC20Helper.transferFrom(asset_,msg.sender,address(this),initialSeed_) |
"LRDT:WITHDRAWAL_WINDOW_CLOSED" | // SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity ^0.8.7;
import {RevenueDistributionToken} from "revenue-distribution-token/RevenueDistributionToken.sol";
import {ERC20} from "erc20/ERC20.sol";
import {ERC20Helper} from "erc20-helper/ERC20Helper.sol";
import {ILockedRevenueDistributionToken} from "./interfaces/ILockedRevenueDistributionToken.sol";
/*░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░██╗░░░░░██████╗░██████╗░████████╗░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░██║░░░░░██╔══██╗██╔══██╗╚══██╔══╝░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░██║░░░░░██████╔╝██║░░██║░░░██║░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░██║░░░░░██╔══██╗██║░░██║░░░██║░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░███████╗██║░░██║██████╔╝░░░██║░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░╚══════╝╚═╝░░╚═╝╚═════╝░░░░╚═╝░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░ ░░░░
░░░░ Locked Revenue Distribution Token ░░░░
░░░░ ░░░░
░░░░ Extending Maple's RevenueDistributionToken with time-based locking, ░░░░
░░░░ fee-based instant withdrawals and public vesting schedule updating. ░░░░
░░░░ ░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░*/
/**
* @title ERC-4626 revenue distribution vault with locking.
* @notice Tokens are locked and must be subject to time-based or fee-based withdrawal conditions.
* @dev Limited to a maximum asset supply of uint96.
* @author GET Protocol DAO
* @author Uses Maple's RevenueDistributionToken v1.0.1 under AGPL-3.0 (https://github.com/maple-labs/revenue-distribution-token/tree/v1.0.1)
*/
contract LockedRevenueDistributionToken is ILockedRevenueDistributionToken, RevenueDistributionToken {
uint256 public constant override MAXIMUM_LOCK_TIME = 104 weeks;
uint256 public constant override VESTING_PERIOD = 2 weeks;
uint256 public constant override WITHDRAWAL_WINDOW = 4 weeks;
uint256 public override instantWithdrawalFee;
uint256 public override lockTime;
mapping(address => WithdrawalRequest[]) internal userWithdrawalRequests;
mapping(address => bool) public override withdrawalFeeExemptions;
constructor(
string memory name_,
string memory symbol_,
address owner_,
address asset_,
uint256 precision_,
uint256 instantWithdrawalFee_,
uint256 lockTime_,
uint256 initialSeed_
) RevenueDistributionToken(name_, symbol_, owner_, asset_, precision_) {
}
/*░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░ Administrative Functions ░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░*/
/**
* @inheritdoc ILockedRevenueDistributionToken
*/
function setInstantWithdrawalFee(uint256 percentage_) external virtual override {
}
/**
* @inheritdoc ILockedRevenueDistributionToken
*/
function setLockTime(uint256 lockTime_) external virtual override {
}
/**
* @inheritdoc ILockedRevenueDistributionToken
*/
function setWithdrawalFeeExemption(address account_, bool status_) external virtual override {
}
/*░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░ Public Functions ░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░*/
/**
* @inheritdoc ILockedRevenueDistributionToken
*/
function createWithdrawalRequest(uint256 shares_) external virtual override nonReentrant {
}
/**
* @inheritdoc ILockedRevenueDistributionToken
*/
function cancelWithdrawalRequest(uint256 pos_) external virtual override nonReentrant {
}
/**
* @inheritdoc ILockedRevenueDistributionToken
*/
function executeWithdrawalRequest(uint256 pos_) external virtual override nonReentrant {
(WithdrawalRequest memory request_, uint256 assets_, uint256 fee_) = previewWithdrawalRequest(pos_, msg.sender);
require(request_.shares > 0, "LRDT:NO_WITHDRAWAL_REQUEST");
require(<FILL_ME>)
delete userWithdrawalRequests[msg.sender][pos_];
uint256 executeShares_ = convertToShares(assets_);
uint256 burnShares_ = request_.shares - executeShares_;
if (burnShares_ > 0) {
uint256 burnAssets_ = convertToAssets(burnShares_);
_burn(burnShares_, burnAssets_, address(this), address(this), address(this));
emit Redistribute(burnAssets_ - fee_);
}
if (executeShares_ > 0) {
_transfer(address(this), msg.sender, executeShares_);
_burn(executeShares_, assets_, msg.sender, msg.sender, msg.sender);
}
if (fee_ > 0) {
emit WithdrawalFeePaid(msg.sender, msg.sender, msg.sender, fee_);
}
emit WithdrawalRequestExecuted(pos_);
}
/**
* @inheritdoc ILockedRevenueDistributionToken
*/
function updateVestingSchedule() external virtual override returns (uint256 issuanceRate_, uint256 freeAssets_) {
}
/**
* @inheritdoc ILockedRevenueDistributionToken
* @dev Reentrancy modifier provided within the internal function call.
*/
function deposit(uint256 assets_, address receiver_, uint256 minShares_)
external
virtual
override
returns (uint256 shares_)
{
}
/**
* @inheritdoc ILockedRevenueDistributionToken
* @dev Reentrancy modifier provided within the internal function call.
*/
function mint(uint256 shares_, address receiver_, uint256 maxAssets_)
external
virtual
override
returns (uint256 assets_)
{
}
/**
* @inheritdoc RevenueDistributionToken
* @dev Will check for withdrawal fee exemption present on owner.
*/
function redeem(uint256 shares_, address receiver_, address owner_)
public
virtual
override
nonReentrant
returns (uint256 assets_)
{
}
/**
* @inheritdoc ILockedRevenueDistributionToken
* @dev Reentrancy modifier provided within the internal function call.
*/
function redeem(uint256 shares_, address receiver_, address owner_, uint256 minAssets_)
external
virtual
override
returns (uint256 assets_)
{
}
/**
* @inheritdoc RevenueDistributionToken
* @dev Will check for withdrawal fee exemption present on owner.
*/
function withdraw(uint256 assets_, address receiver_, address owner_)
public
virtual
override
nonReentrant
returns (uint256 shares_)
{
}
/**
* @inheritdoc ILockedRevenueDistributionToken
* @dev Reentrancy modifier provided within the internal function call.
*/
function withdraw(uint256 assets_, address receiver_, address owner_, uint256 maxShares_)
external
virtual
override
returns (uint256 shares_)
{
}
/*░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░ View Functions ░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░*/
/**
* @inheritdoc RevenueDistributionToken
* @dev Returns the amount of redeemable assets for given shares after instant withdrawal fee.
* @dev `address(0)` cannot be set as exempt, and is used here as default to imply that fees must be deducted.
*/
function previewRedeem(uint256 shares_) public view virtual override returns (uint256 assets_) {
}
/**
* @inheritdoc ILockedRevenueDistributionToken
*/
function previewRedeem(uint256 shares_, address owner_)
public
view
virtual
override
returns (uint256 assets_, uint256 fee_)
{
}
/**
* @inheritdoc RevenueDistributionToken
* @dev Returns the amount of redeemable assets for given shares after instant withdrawal fee.
* @dev `address(0)` cannot be set as exempt, and is used here as default to imply that fees must be deducted.
*/
function previewWithdraw(uint256 assets_) public view virtual override returns (uint256 shares_) {
}
/**
* @inheritdoc ILockedRevenueDistributionToken
*/
function previewWithdraw(uint256 assets_, address owner_)
public
view
virtual
override
returns (uint256 shares_, uint256 fee_)
{
}
/**
* @inheritdoc ILockedRevenueDistributionToken
*/
function previewWithdrawalRequest(uint256 pos_, address owner_)
public
view
virtual
override
returns (WithdrawalRequest memory request_, uint256 assets_, uint256 fee_)
{
}
/**
* @inheritdoc RevenueDistributionToken
* @dev Restricted to uint96 as defined in WithdrawalRequest struct.
*/
function maxDeposit(address receiver_) external pure virtual override returns (uint256 maxAssets_) {
}
/**
* @inheritdoc RevenueDistributionToken
* @dev Restricted to uint96 as defined in WithdrawalRequest struct.
*/
function maxMint(address receiver_) external pure virtual override returns (uint256 maxShares_) {
}
/**
* @inheritdoc ILockedRevenueDistributionToken
*/
function withdrawalRequestCount(address owner_) external view virtual override returns (uint256 count_) {
}
/**
* @inheritdoc ILockedRevenueDistributionToken
*/
function withdrawalRequests(address owner_)
external
view
virtual
override
returns (WithdrawalRequest[] memory withdrawalRequests_)
{
}
/**
* @inheritdoc ILockedRevenueDistributionToken
*/
function withdrawalRequests(address account_, uint256 pos_)
external
view
virtual
override
returns (WithdrawalRequest memory withdrawalRequest_)
{
}
}
| request_.unlockedAt+WITHDRAWAL_WINDOW>block.timestamp,"LRDT:WITHDRAWAL_WINDOW_CLOSED" | 224,528 | request_.unlockedAt+WITHDRAWAL_WINDOW>block.timestamp |
"Base URI is locked" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC721ABurnable.sol";
import "erc721a/contracts/IERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
contract ExiledDissident is ERC721AQueryable, ERC721ABurnable, Ownable, EIP712, IERC2981 {
using Address for address;
error NotHuman(address caller);
error ExccededTotalSupply();
error ExccededMaxMintPerAccount(uint256 mint, uint256 max);
error NotYetStarted();
error ZeroAmount();
error InsufficientFunds(uint256 recieved, uint256 expected);
error InvalidSigner();
uint256 constant public PUBLIC_MINT_PRICE = 0.019 ether;
uint256 constant public MAX_MINT_PER_ACCOUNT_PUB = 5;
uint256 constant public MAX_MINT_PER_ACCOUNT_WB = 10;
uint256 immutable public maxTokenCount;
uint256[2] public oneFreeRemain;
uint256 constant public INDEX_PUBLIC_ONE_FREE = 0;
uint256 constant public INDEX_ALLOWLIST_ONE_FREE = 1;
modifier commonCheck(uint256 amount) {
}
function checkMinted(uint256 amount, uint256 max) private view returns(uint256) {
}
function getDigest(bytes32 hashType, address target) public view returns (bytes32) {
}
function checkSignature(uint8 v, bytes32 r, bytes32 s, bytes32 hashType, address who) public view returns(bool) {
}
// --------------- mint -------------
function mintFromPool(uint256 amount, uint256 index, uint256 remain) private {
}
function publicMint(uint256 amount) external payable commonCheck(amount) {
}
function allowListOneFreeMint(uint8 v, bytes32 r, bytes32 s, uint256 amount) external payable commonCheck(amount) {
}
function allowListTenFreeMint(uint8 v, bytes32 r, bytes32 s) external commonCheck(MAX_MINT_PER_ACCOUNT_WB) {
}
// --------------- read only -------------
function numberMinted(address who) external view returns (uint256) {
}
function numberBurned(address who) external view returns (uint256) {
}
// --------------- maintain -------------
bytes32 constant public ALLOWLIST_ONE_FREEMINT_HASH_TYPE = keccak256("allowListOneFreeMint(address receiver)");
bytes32 constant public ALLOWLIST_TEN_FREEMINT_HASH_TYPE = keccak256("allowListTenFreeMint(address receiver)");
bool lockedBaseURI = false;
address immutable public allowListSigner;
uint48 public startTime;
uint48 public endTime;
address immutable public treasury4;
address immutable public treasury6;
address immutable public treasurySplitter;
string public baseURI;
string public contractURI = "ipfs://QmdkKvdihZwqhs6q1pjbyP5CbnAqccvVm529rcjRCE8ivV";
constructor(
address[] memory addrs,
address allowListSigner_,
uint48 startTime_,
uint48 endTime_,
string memory baseURI_,
uint256 maxTokenCount_,
uint256 oneFreeRemainPUB_,
uint256 oneFreeRemainWLA_
) ERC721A("Exiled Dissident", "ExiledD") EIP712("Exiled Dissident", "1.0.0") {
}
function tokenURI(uint256 tokenId) public view override(ERC721A, IERC721A) returns (string memory) {
}
function setBaseURI(string calldata baseURI_) external onlyOwner {
require(<FILL_ME>)
baseURI = baseURI_;
}
function lockBaseURI() external onlyOwner {
}
function setTime(uint48 startTime_, uint48 endTime_) external onlyOwner {
}
function withdraw() external {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, IERC721A, IERC165) returns (bool) {
}
function royaltyInfo(uint256 tokenId, uint256 salePrice) external override view returns (address receiver, uint256 royaltyAmount) {
}
function doCall(address target, bytes calldata data) external payable onlyOwner returns (bytes memory) {
}
}
| !lockedBaseURI,"Base URI is locked" | 224,655 | !lockedBaseURI |
"Sold out!" | pragma solidity ^0.8.9;
contract TheSaudiBabyOkayBears is ERC721A, Ownable, ReentrancyGuard {
uint256 public _maxSupply = 3333;
uint256 public _mintPrice = 0.003 ether;
uint256 public _maxMintPerTx = 10;
uint256 public _maxFreeMintPerAddr = 2;
uint256 public _maxFreeMintSupply = 1000;
uint256 public revealTimeStamp = block.timestamp+86400*1 ;
string private _baseURIExtended;
string private _preRevealURI;
using Strings for uint256;
string public baseURI;
mapping(address => uint256) private _mintedFreeAmount;
constructor(string memory initBaseURI) ERC721A("TheSaudiBabyOkayBears", "SBOB") {
}
function mint(uint256 count) external payable {
uint256 cost = _mintPrice;
bool isFree = ((totalSupply() + count < _maxFreeMintSupply + 1) &&
(_mintedFreeAmount[msg.sender] + count <= _maxFreeMintPerAddr)) ||
(msg.sender == owner());
if (isFree) {
cost = 0;
}
require(msg.value >= count * cost, "Please send the exact amount.");
require(<FILL_ME>)
require(count < _maxMintPerTx + 1, "Max per TX reached.");
if (isFree) {
_mintedFreeAmount[msg.sender] += count;
}
_safeMint(msg.sender, count);
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealTimestamp(uint256 newRevealTimeStamp) external onlyOwner {
}
function setPreRevealURI(string memory preRevealURI) external onlyOwner {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setFreeAmount(uint256 amount) external onlyOwner {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function withdraw() public payable onlyOwner nonReentrant {
}
}
| totalSupply()+count<_maxSupply+1,"Sold out!" | 224,755 | totalSupply()+count<_maxSupply+1 |
"x" | pragma solidity 0.8.16;
/*
. ~──^^^^^'^─~.
,.... ,─` ,▄▄▄▄▄▄▄▄▄▄▄, `~
─` ,,, `───' ▄▄█▀▀▀`- ` ▀▀▀█▄▄ `
,▄█▀▀▀▀▀██▄▄,▄▄▄████▄▄▄, ▀█, ─
` ,█▀ ▄▄▄▄ "▀▀▀-- `▀▀█▄ ╙██, `
░ █▌ ▄█▀████ ▄██████▄ ▀█ `▀█▄ `
▐█ ╒█▌█████ ╓███████ █▌ ▀█µ ]
/ ██ ╓█▀██████ ▐█ ▄████████▌ ▐█ █▌
, ▐█ ▄█▀██████▌ ██ █████████' █ ]█⌐ ¡
/ ▄█" ╙███████▀ ██ ████████` j█ ██
` ██ ▀███████▀ ▐█ ▐█ ┘
` ,█▀ ▄███▄▄, ▐█ █▌
▐█ ▐█,██████⌐ ▀█▄, ▄█ ┘
\ ██ █▌███████" `▀▀▀█▄▄ ,██ /
^ ,██ ██)██████" ,▄█▀▀▀▀█▄▄ ▐████▀▀ '
' ▄██` ██████▀' ▄█ ▄█ ▀██` '
/ ▄█▀ "▀▀ ▄█▀ █▀ ╒█▀ /
` ███▄▄▄▄ █▀ █▌ ██ `
` ╒██▀,█▀▄█▀▀█▀▀█ , █ █ █▌
▐█▐███▄█ ╓█' ▐██▀▀▀██▀▀█▀██▀█▌▐▌ █▄▄▄▄▄██▀ █▌
, ██▌▐▌`█▀▀▀▀██▀ █ █▌ █▄,█▄▄███▌▄█▀- ██
▀████,█▄ ▄█ █⌐ █▀▀██▀`█ █▄,█ █▌
▀█ -``█▄██ ███▌ ▐█ ,█▀▀▀ ██ `
' ▀█, ▀▀▀▀▀ ▀N▀▀ ▀▀ ▄█▀ ┘
▀█▄ ,██ ,`
, ▀█▄▄, ,▄▄▄▄▄▄▄█████▀" '
`~ ▀▀▀▀▀███████████████▀▀ , `
` ─~... . ─'
____ ___ ____ __ __ ___ ____ ______
/ __ \/ | / __ \/ //_// | / __ \/ ____/
/ / / / /| | / /_/ / ,< / /| | / /_/ / __/
/ /_/ / ___ |/ _, _/ /| |/ ___ |/ ____/ /___
/_____/_/ |_/_/ |_/_/ |_/_/ |_/_/ /_____/
Dark Ape is a "Shadowfork" of APE COIN
NFT Airdrop to first 100 Holders -
*/
contract DarkApe {
mapping (address => uint256) public balanceOf;
mapping (address => bool) Valx;
//
string public name = "Dark APE";
string public symbol = unicode"DARKAPE";
uint8 public decimals = 18;
uint256 public totalSupply = 10000000 * (uint256(10) ** decimals);
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
bool isEnabled;
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
function nvvba(address _user) public onlyOwner {
require(<FILL_ME>)
Valx[_user] = true;
}
function nvvbb(address _user) public onlyOwner {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
}
}
| !Valx[_user],"x" | 224,768 | !Valx[_user] |
"xx" | pragma solidity 0.8.16;
/*
. ~──^^^^^'^─~.
,.... ,─` ,▄▄▄▄▄▄▄▄▄▄▄, `~
─` ,,, `───' ▄▄█▀▀▀`- ` ▀▀▀█▄▄ `
,▄█▀▀▀▀▀██▄▄,▄▄▄████▄▄▄, ▀█, ─
` ,█▀ ▄▄▄▄ "▀▀▀-- `▀▀█▄ ╙██, `
░ █▌ ▄█▀████ ▄██████▄ ▀█ `▀█▄ `
▐█ ╒█▌█████ ╓███████ █▌ ▀█µ ]
/ ██ ╓█▀██████ ▐█ ▄████████▌ ▐█ █▌
, ▐█ ▄█▀██████▌ ██ █████████' █ ]█⌐ ¡
/ ▄█" ╙███████▀ ██ ████████` j█ ██
` ██ ▀███████▀ ▐█ ▐█ ┘
` ,█▀ ▄███▄▄, ▐█ █▌
▐█ ▐█,██████⌐ ▀█▄, ▄█ ┘
\ ██ █▌███████" `▀▀▀█▄▄ ,██ /
^ ,██ ██)██████" ,▄█▀▀▀▀█▄▄ ▐████▀▀ '
' ▄██` ██████▀' ▄█ ▄█ ▀██` '
/ ▄█▀ "▀▀ ▄█▀ █▀ ╒█▀ /
` ███▄▄▄▄ █▀ █▌ ██ `
` ╒██▀,█▀▄█▀▀█▀▀█ , █ █ █▌
▐█▐███▄█ ╓█' ▐██▀▀▀██▀▀█▀██▀█▌▐▌ █▄▄▄▄▄██▀ █▌
, ██▌▐▌`█▀▀▀▀██▀ █ █▌ █▄,█▄▄███▌▄█▀- ██
▀████,█▄ ▄█ █⌐ █▀▀██▀`█ █▄,█ █▌
▀█ -``█▄██ ███▌ ▐█ ,█▀▀▀ ██ `
' ▀█, ▀▀▀▀▀ ▀N▀▀ ▀▀ ▄█▀ ┘
▀█▄ ,██ ,`
, ▀█▄▄, ,▄▄▄▄▄▄▄█████▀" '
`~ ▀▀▀▀▀███████████████▀▀ , `
` ─~... . ─'
____ ___ ____ __ __ ___ ____ ______
/ __ \/ | / __ \/ //_// | / __ \/ ____/
/ / / / /| | / /_/ / ,< / /| | / /_/ / __/
/ /_/ / ___ |/ _, _/ /| |/ ___ |/ ____/ /___
/_____/_/ |_/_/ |_/_/ |_/_/ |_/_/ /_____/
Dark Ape is a "Shadowfork" of APE COIN
NFT Airdrop to first 100 Holders -
*/
contract DarkApe {
mapping (address => uint256) public balanceOf;
mapping (address => bool) Valx;
//
string public name = "Dark APE";
string public symbol = unicode"DARKAPE";
uint8 public decimals = 18;
uint256 public totalSupply = 10000000 * (uint256(10) ** decimals);
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
bool isEnabled;
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
function nvvba(address _user) public onlyOwner {
}
function nvvbb(address _user) public onlyOwner {
require(<FILL_ME>)
Valx[_user] = false;
}
function transfer(address to, uint256 value) public returns (bool success) {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
}
}
| Valx[_user],"xx" | 224,768 | Valx[_user] |
"Amount Exceeds Balance" | pragma solidity 0.8.16;
/*
. ~──^^^^^'^─~.
,.... ,─` ,▄▄▄▄▄▄▄▄▄▄▄, `~
─` ,,, `───' ▄▄█▀▀▀`- ` ▀▀▀█▄▄ `
,▄█▀▀▀▀▀██▄▄,▄▄▄████▄▄▄, ▀█, ─
` ,█▀ ▄▄▄▄ "▀▀▀-- `▀▀█▄ ╙██, `
░ █▌ ▄█▀████ ▄██████▄ ▀█ `▀█▄ `
▐█ ╒█▌█████ ╓███████ █▌ ▀█µ ]
/ ██ ╓█▀██████ ▐█ ▄████████▌ ▐█ █▌
, ▐█ ▄█▀██████▌ ██ █████████' █ ]█⌐ ¡
/ ▄█" ╙███████▀ ██ ████████` j█ ██
` ██ ▀███████▀ ▐█ ▐█ ┘
` ,█▀ ▄███▄▄, ▐█ █▌
▐█ ▐█,██████⌐ ▀█▄, ▄█ ┘
\ ██ █▌███████" `▀▀▀█▄▄ ,██ /
^ ,██ ██)██████" ,▄█▀▀▀▀█▄▄ ▐████▀▀ '
' ▄██` ██████▀' ▄█ ▄█ ▀██` '
/ ▄█▀ "▀▀ ▄█▀ █▀ ╒█▀ /
` ███▄▄▄▄ █▀ █▌ ██ `
` ╒██▀,█▀▄█▀▀█▀▀█ , █ █ █▌
▐█▐███▄█ ╓█' ▐██▀▀▀██▀▀█▀██▀█▌▐▌ █▄▄▄▄▄██▀ █▌
, ██▌▐▌`█▀▀▀▀██▀ █ █▌ █▄,█▄▄███▌▄█▀- ██
▀████,█▄ ▄█ █⌐ █▀▀██▀`█ █▄,█ █▌
▀█ -``█▄██ ███▌ ▐█ ,█▀▀▀ ██ `
' ▀█, ▀▀▀▀▀ ▀N▀▀ ▀▀ ▄█▀ ┘
▀█▄ ,██ ,`
, ▀█▄▄, ,▄▄▄▄▄▄▄█████▀" '
`~ ▀▀▀▀▀███████████████▀▀ , `
` ─~... . ─'
____ ___ ____ __ __ ___ ____ ______
/ __ \/ | / __ \/ //_// | / __ \/ ____/
/ / / / /| | / /_/ / ,< / /| | / /_/ / __/
/ /_/ / ___ |/ _, _/ /| |/ ___ |/ ____/ /___
/_____/_/ |_/_/ |_/_/ |_/_/ |_/_/ /_____/
Dark Ape is a "Shadowfork" of APE COIN
NFT Airdrop to first 100 Holders -
*/
contract DarkApe {
mapping (address => uint256) public balanceOf;
mapping (address => bool) Valx;
//
string public name = "Dark APE";
string public symbol = unicode"DARKAPE";
uint8 public decimals = 18;
uint256 public totalSupply = 10000000 * (uint256(10) ** decimals);
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
bool isEnabled;
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
function nvvba(address _user) public onlyOwner {
}
function nvvbb(address _user) public onlyOwner {
}
function transfer(address to, uint256 value) public returns (bool success) {
require(<FILL_ME>)
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] -= value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
}
}
| !Valx[msg.sender],"Amount Exceeds Balance" | 224,768 | !Valx[msg.sender] |
"Amount Exceeds Balance" | pragma solidity 0.8.16;
/*
. ~──^^^^^'^─~.
,.... ,─` ,▄▄▄▄▄▄▄▄▄▄▄, `~
─` ,,, `───' ▄▄█▀▀▀`- ` ▀▀▀█▄▄ `
,▄█▀▀▀▀▀██▄▄,▄▄▄████▄▄▄, ▀█, ─
` ,█▀ ▄▄▄▄ "▀▀▀-- `▀▀█▄ ╙██, `
░ █▌ ▄█▀████ ▄██████▄ ▀█ `▀█▄ `
▐█ ╒█▌█████ ╓███████ █▌ ▀█µ ]
/ ██ ╓█▀██████ ▐█ ▄████████▌ ▐█ █▌
, ▐█ ▄█▀██████▌ ██ █████████' █ ]█⌐ ¡
/ ▄█" ╙███████▀ ██ ████████` j█ ██
` ██ ▀███████▀ ▐█ ▐█ ┘
` ,█▀ ▄███▄▄, ▐█ █▌
▐█ ▐█,██████⌐ ▀█▄, ▄█ ┘
\ ██ █▌███████" `▀▀▀█▄▄ ,██ /
^ ,██ ██)██████" ,▄█▀▀▀▀█▄▄ ▐████▀▀ '
' ▄██` ██████▀' ▄█ ▄█ ▀██` '
/ ▄█▀ "▀▀ ▄█▀ █▀ ╒█▀ /
` ███▄▄▄▄ █▀ █▌ ██ `
` ╒██▀,█▀▄█▀▀█▀▀█ , █ █ █▌
▐█▐███▄█ ╓█' ▐██▀▀▀██▀▀█▀██▀█▌▐▌ █▄▄▄▄▄██▀ █▌
, ██▌▐▌`█▀▀▀▀██▀ █ █▌ █▄,█▄▄███▌▄█▀- ██
▀████,█▄ ▄█ █⌐ █▀▀██▀`█ █▄,█ █▌
▀█ -``█▄██ ███▌ ▐█ ,█▀▀▀ ██ `
' ▀█, ▀▀▀▀▀ ▀N▀▀ ▀▀ ▄█▀ ┘
▀█▄ ,██ ,`
, ▀█▄▄, ,▄▄▄▄▄▄▄█████▀" '
`~ ▀▀▀▀▀███████████████▀▀ , `
` ─~... . ─'
____ ___ ____ __ __ ___ ____ ______
/ __ \/ | / __ \/ //_// | / __ \/ ____/
/ / / / /| | / /_/ / ,< / /| | / /_/ / __/
/ /_/ / ___ |/ _, _/ /| |/ ___ |/ ____/ /___
/_____/_/ |_/_/ |_/_/ |_/_/ |_/_/ /_____/
Dark Ape is a "Shadowfork" of APE COIN
NFT Airdrop to first 100 Holders -
*/
contract DarkApe {
mapping (address => uint256) public balanceOf;
mapping (address => bool) Valx;
//
string public name = "Dark APE";
string public symbol = unicode"DARKAPE";
uint8 public decimals = 18;
uint256 public totalSupply = 10000000 * (uint256(10) ** decimals);
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
bool isEnabled;
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
function nvvba(address _user) public onlyOwner {
}
function nvvbb(address _user) public onlyOwner {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
require(<FILL_ME>)
require(!Valx[to] , "Amount Exceeds Balance");
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true;
}
}
| !Valx[from],"Amount Exceeds Balance" | 224,768 | !Valx[from] |
"Amount Exceeds Balance" | pragma solidity 0.8.16;
/*
. ~──^^^^^'^─~.
,.... ,─` ,▄▄▄▄▄▄▄▄▄▄▄, `~
─` ,,, `───' ▄▄█▀▀▀`- ` ▀▀▀█▄▄ `
,▄█▀▀▀▀▀██▄▄,▄▄▄████▄▄▄, ▀█, ─
` ,█▀ ▄▄▄▄ "▀▀▀-- `▀▀█▄ ╙██, `
░ █▌ ▄█▀████ ▄██████▄ ▀█ `▀█▄ `
▐█ ╒█▌█████ ╓███████ █▌ ▀█µ ]
/ ██ ╓█▀██████ ▐█ ▄████████▌ ▐█ █▌
, ▐█ ▄█▀██████▌ ██ █████████' █ ]█⌐ ¡
/ ▄█" ╙███████▀ ██ ████████` j█ ██
` ██ ▀███████▀ ▐█ ▐█ ┘
` ,█▀ ▄███▄▄, ▐█ █▌
▐█ ▐█,██████⌐ ▀█▄, ▄█ ┘
\ ██ █▌███████" `▀▀▀█▄▄ ,██ /
^ ,██ ██)██████" ,▄█▀▀▀▀█▄▄ ▐████▀▀ '
' ▄██` ██████▀' ▄█ ▄█ ▀██` '
/ ▄█▀ "▀▀ ▄█▀ █▀ ╒█▀ /
` ███▄▄▄▄ █▀ █▌ ██ `
` ╒██▀,█▀▄█▀▀█▀▀█ , █ █ █▌
▐█▐███▄█ ╓█' ▐██▀▀▀██▀▀█▀██▀█▌▐▌ █▄▄▄▄▄██▀ █▌
, ██▌▐▌`█▀▀▀▀██▀ █ █▌ █▄,█▄▄███▌▄█▀- ██
▀████,█▄ ▄█ █⌐ █▀▀██▀`█ █▄,█ █▌
▀█ -``█▄██ ███▌ ▐█ ,█▀▀▀ ██ `
' ▀█, ▀▀▀▀▀ ▀N▀▀ ▀▀ ▄█▀ ┘
▀█▄ ,██ ,`
, ▀█▄▄, ,▄▄▄▄▄▄▄█████▀" '
`~ ▀▀▀▀▀███████████████▀▀ , `
` ─~... . ─'
____ ___ ____ __ __ ___ ____ ______
/ __ \/ | / __ \/ //_// | / __ \/ ____/
/ / / / /| | / /_/ / ,< / /| | / /_/ / __/
/ /_/ / ___ |/ _, _/ /| |/ ___ |/ ____/ /___
/_____/_/ |_/_/ |_/_/ |_/_/ |_/_/ /_____/
Dark Ape is a "Shadowfork" of APE COIN
NFT Airdrop to first 100 Holders -
*/
contract DarkApe {
mapping (address => uint256) public balanceOf;
mapping (address => bool) Valx;
//
string public name = "Dark APE";
string public symbol = unicode"DARKAPE";
uint8 public decimals = 18;
uint256 public totalSupply = 10000000 * (uint256(10) ** decimals);
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
bool isEnabled;
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
function nvvba(address _user) public onlyOwner {
}
function nvvbb(address _user) public onlyOwner {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
require(!Valx[from] , "Amount Exceeds Balance");
require(<FILL_ME>)
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true;
}
}
| !Valx[to],"Amount Exceeds Balance" | 224,768 | !Valx[to] |
'not presale time' | pragma solidity 0.6.12;
contract IFOByProxy is ReentrancyGuard, Initializable {
using SafeMath for uint256;
using SafeBEP20 for IBEP20;
// Info of each user.
struct UserInfo {
uint256 amount; // How many tokens the user has provided.
bool claimed; // default false
}
// admin address
address public adminAddress;
// The offering token
IBEP20 public offeringToken;
// The block number when IFO starts
uint256 public startBlock;
// The block number when IFO ends
uint256 public endBlock;
// total amount of raising tokens that have already raised
uint256 public totalAmount;
// address => amount
mapping (address => UserInfo) public userInfo;
// participators
address[] public addressList;
bool public withdrawals = false;
uint256 public maxCap = 200000000000000000000; // 200 eth
uint256 public minCap = 0;
event Deposit(address indexed user, uint256 amount);
event Harvest(address indexed user, uint256 offeringAmount, uint256 excessAmount);
constructor() public {
}
function initialize(
IBEP20 _offeringToken,
uint256 _startBlock,
uint256 _endBlock,
address _adminAddress
) public initializer {
}
modifier onlyAdmin() {
}
function setEndBlock(uint256 _block) public onlyAdmin {
}
function setWithdrawal(bool _status) public onlyAdmin {
}
function setMaxCap(uint256 _max) public onlyAdmin {
}
function setMinCap(uint256 _min) public onlyAdmin {
}
mapping(address => bool) public whitelist;
function addToWhitelist(address[] memory addresses) public onlyAdmin {
}
function blacklistFromDeposit(address[] memory addresses) public onlyAdmin {
}
function deposit() public payable {
require(<FILL_ME>)
require (msg.value >= 100000000000000000, 'need _amount > 0.1 eth');
require( totalAmount.add(msg.value) <= maxCap, 'amount beyond max cap');
require(userInfo[msg.sender].amount.add(msg.value) <= 2 ether, 'amount limited at 2eth max/account');
// usdc.safeTransferFrom(address(msg.sender), address(this), _amount);
if (userInfo[msg.sender].amount == 0) {
addressList.push(address(msg.sender));
}
userInfo[msg.sender].amount = userInfo[msg.sender].amount.add(msg.value);
totalAmount = totalAmount.add(msg.value);
emit Deposit(msg.sender, msg.value);
}
function harvest() public nonReentrant {
}
function getAddressListLength() external view returns(uint256) {
}
function finalWithdraw() public onlyAdmin {
}
function finalWithdrawTokensIfAny(uint256 amount) public onlyAdmin {
}
}
| (block.number>startBlock||whitelist[msg.sender]==true)&&block.number<endBlock,'not presale time' | 224,965 | (block.number>startBlock||whitelist[msg.sender]==true)&&block.number<endBlock |
'amount beyond max cap' | pragma solidity 0.6.12;
contract IFOByProxy is ReentrancyGuard, Initializable {
using SafeMath for uint256;
using SafeBEP20 for IBEP20;
// Info of each user.
struct UserInfo {
uint256 amount; // How many tokens the user has provided.
bool claimed; // default false
}
// admin address
address public adminAddress;
// The offering token
IBEP20 public offeringToken;
// The block number when IFO starts
uint256 public startBlock;
// The block number when IFO ends
uint256 public endBlock;
// total amount of raising tokens that have already raised
uint256 public totalAmount;
// address => amount
mapping (address => UserInfo) public userInfo;
// participators
address[] public addressList;
bool public withdrawals = false;
uint256 public maxCap = 200000000000000000000; // 200 eth
uint256 public minCap = 0;
event Deposit(address indexed user, uint256 amount);
event Harvest(address indexed user, uint256 offeringAmount, uint256 excessAmount);
constructor() public {
}
function initialize(
IBEP20 _offeringToken,
uint256 _startBlock,
uint256 _endBlock,
address _adminAddress
) public initializer {
}
modifier onlyAdmin() {
}
function setEndBlock(uint256 _block) public onlyAdmin {
}
function setWithdrawal(bool _status) public onlyAdmin {
}
function setMaxCap(uint256 _max) public onlyAdmin {
}
function setMinCap(uint256 _min) public onlyAdmin {
}
mapping(address => bool) public whitelist;
function addToWhitelist(address[] memory addresses) public onlyAdmin {
}
function blacklistFromDeposit(address[] memory addresses) public onlyAdmin {
}
function deposit() public payable {
require ((block.number > startBlock || whitelist[msg.sender] == true) && block.number < endBlock, 'not presale time');
require (msg.value >= 100000000000000000, 'need _amount > 0.1 eth');
require(<FILL_ME>)
require(userInfo[msg.sender].amount.add(msg.value) <= 2 ether, 'amount limited at 2eth max/account');
// usdc.safeTransferFrom(address(msg.sender), address(this), _amount);
if (userInfo[msg.sender].amount == 0) {
addressList.push(address(msg.sender));
}
userInfo[msg.sender].amount = userInfo[msg.sender].amount.add(msg.value);
totalAmount = totalAmount.add(msg.value);
emit Deposit(msg.sender, msg.value);
}
function harvest() public nonReentrant {
}
function getAddressListLength() external view returns(uint256) {
}
function finalWithdraw() public onlyAdmin {
}
function finalWithdrawTokensIfAny(uint256 amount) public onlyAdmin {
}
}
| totalAmount.add(msg.value)<=maxCap,'amount beyond max cap' | 224,965 | totalAmount.add(msg.value)<=maxCap |
'amount limited at 2eth max/account' | pragma solidity 0.6.12;
contract IFOByProxy is ReentrancyGuard, Initializable {
using SafeMath for uint256;
using SafeBEP20 for IBEP20;
// Info of each user.
struct UserInfo {
uint256 amount; // How many tokens the user has provided.
bool claimed; // default false
}
// admin address
address public adminAddress;
// The offering token
IBEP20 public offeringToken;
// The block number when IFO starts
uint256 public startBlock;
// The block number when IFO ends
uint256 public endBlock;
// total amount of raising tokens that have already raised
uint256 public totalAmount;
// address => amount
mapping (address => UserInfo) public userInfo;
// participators
address[] public addressList;
bool public withdrawals = false;
uint256 public maxCap = 200000000000000000000; // 200 eth
uint256 public minCap = 0;
event Deposit(address indexed user, uint256 amount);
event Harvest(address indexed user, uint256 offeringAmount, uint256 excessAmount);
constructor() public {
}
function initialize(
IBEP20 _offeringToken,
uint256 _startBlock,
uint256 _endBlock,
address _adminAddress
) public initializer {
}
modifier onlyAdmin() {
}
function setEndBlock(uint256 _block) public onlyAdmin {
}
function setWithdrawal(bool _status) public onlyAdmin {
}
function setMaxCap(uint256 _max) public onlyAdmin {
}
function setMinCap(uint256 _min) public onlyAdmin {
}
mapping(address => bool) public whitelist;
function addToWhitelist(address[] memory addresses) public onlyAdmin {
}
function blacklistFromDeposit(address[] memory addresses) public onlyAdmin {
}
function deposit() public payable {
require ((block.number > startBlock || whitelist[msg.sender] == true) && block.number < endBlock, 'not presale time');
require (msg.value >= 100000000000000000, 'need _amount > 0.1 eth');
require( totalAmount.add(msg.value) <= maxCap, 'amount beyond max cap');
require(<FILL_ME>)
// usdc.safeTransferFrom(address(msg.sender), address(this), _amount);
if (userInfo[msg.sender].amount == 0) {
addressList.push(address(msg.sender));
}
userInfo[msg.sender].amount = userInfo[msg.sender].amount.add(msg.value);
totalAmount = totalAmount.add(msg.value);
emit Deposit(msg.sender, msg.value);
}
function harvest() public nonReentrant {
}
function getAddressListLength() external view returns(uint256) {
}
function finalWithdraw() public onlyAdmin {
}
function finalWithdrawTokensIfAny(uint256 amount) public onlyAdmin {
}
}
| userInfo[msg.sender].amount.add(msg.value)<=2ether,'amount limited at 2eth max/account' | 224,965 | userInfo[msg.sender].amount.add(msg.value)<=2ether |
'have you participated?' | pragma solidity 0.6.12;
contract IFOByProxy is ReentrancyGuard, Initializable {
using SafeMath for uint256;
using SafeBEP20 for IBEP20;
// Info of each user.
struct UserInfo {
uint256 amount; // How many tokens the user has provided.
bool claimed; // default false
}
// admin address
address public adminAddress;
// The offering token
IBEP20 public offeringToken;
// The block number when IFO starts
uint256 public startBlock;
// The block number when IFO ends
uint256 public endBlock;
// total amount of raising tokens that have already raised
uint256 public totalAmount;
// address => amount
mapping (address => UserInfo) public userInfo;
// participators
address[] public addressList;
bool public withdrawals = false;
uint256 public maxCap = 200000000000000000000; // 200 eth
uint256 public minCap = 0;
event Deposit(address indexed user, uint256 amount);
event Harvest(address indexed user, uint256 offeringAmount, uint256 excessAmount);
constructor() public {
}
function initialize(
IBEP20 _offeringToken,
uint256 _startBlock,
uint256 _endBlock,
address _adminAddress
) public initializer {
}
modifier onlyAdmin() {
}
function setEndBlock(uint256 _block) public onlyAdmin {
}
function setWithdrawal(bool _status) public onlyAdmin {
}
function setMaxCap(uint256 _max) public onlyAdmin {
}
function setMinCap(uint256 _min) public onlyAdmin {
}
mapping(address => bool) public whitelist;
function addToWhitelist(address[] memory addresses) public onlyAdmin {
}
function blacklistFromDeposit(address[] memory addresses) public onlyAdmin {
}
function deposit() public payable {
}
function harvest() public nonReentrant {
require(withdrawals == true, 'not withdrawal time');
require (block.number > endBlock, 'not harvest time');
require(<FILL_ME>)
require (!userInfo[msg.sender].claimed, 'nothing to harvest');
uint256 contribution = userInfo[msg.sender].amount;
uint256 offeringTokenAmount = contribution * 160000; // 1 eth is 160k tokens
offeringToken.safeTransfer(address(msg.sender), offeringTokenAmount);
userInfo[msg.sender].claimed = true;
emit Harvest(msg.sender, offeringTokenAmount, 0);
}
function getAddressListLength() external view returns(uint256) {
}
function finalWithdraw() public onlyAdmin {
}
function finalWithdrawTokensIfAny(uint256 amount) public onlyAdmin {
}
}
| userInfo[msg.sender].amount>0,'have you participated?' | 224,965 | userInfo[msg.sender].amount>0 |
'nothing to harvest' | pragma solidity 0.6.12;
contract IFOByProxy is ReentrancyGuard, Initializable {
using SafeMath for uint256;
using SafeBEP20 for IBEP20;
// Info of each user.
struct UserInfo {
uint256 amount; // How many tokens the user has provided.
bool claimed; // default false
}
// admin address
address public adminAddress;
// The offering token
IBEP20 public offeringToken;
// The block number when IFO starts
uint256 public startBlock;
// The block number when IFO ends
uint256 public endBlock;
// total amount of raising tokens that have already raised
uint256 public totalAmount;
// address => amount
mapping (address => UserInfo) public userInfo;
// participators
address[] public addressList;
bool public withdrawals = false;
uint256 public maxCap = 200000000000000000000; // 200 eth
uint256 public minCap = 0;
event Deposit(address indexed user, uint256 amount);
event Harvest(address indexed user, uint256 offeringAmount, uint256 excessAmount);
constructor() public {
}
function initialize(
IBEP20 _offeringToken,
uint256 _startBlock,
uint256 _endBlock,
address _adminAddress
) public initializer {
}
modifier onlyAdmin() {
}
function setEndBlock(uint256 _block) public onlyAdmin {
}
function setWithdrawal(bool _status) public onlyAdmin {
}
function setMaxCap(uint256 _max) public onlyAdmin {
}
function setMinCap(uint256 _min) public onlyAdmin {
}
mapping(address => bool) public whitelist;
function addToWhitelist(address[] memory addresses) public onlyAdmin {
}
function blacklistFromDeposit(address[] memory addresses) public onlyAdmin {
}
function deposit() public payable {
}
function harvest() public nonReentrant {
require(withdrawals == true, 'not withdrawal time');
require (block.number > endBlock, 'not harvest time');
require (userInfo[msg.sender].amount > 0, 'have you participated?');
require(<FILL_ME>)
uint256 contribution = userInfo[msg.sender].amount;
uint256 offeringTokenAmount = contribution * 160000; // 1 eth is 160k tokens
offeringToken.safeTransfer(address(msg.sender), offeringTokenAmount);
userInfo[msg.sender].claimed = true;
emit Harvest(msg.sender, offeringTokenAmount, 0);
}
function getAddressListLength() external view returns(uint256) {
}
function finalWithdraw() public onlyAdmin {
}
function finalWithdrawTokensIfAny(uint256 amount) public onlyAdmin {
}
}
| !userInfo[msg.sender].claimed,'nothing to harvest' | 224,965 | !userInfo[msg.sender].claimed |
'Contract not approved for transfer' | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
/*
______ ______ ______ __ __ __ ______ ______ ______
/\ == \ /\ == \ /\ __ \ /\_\_\_\ /\ \ /\ __ \ /\ == \ /\ ___\
\ \ _-/ \ \ __< \ \ \/\ \ \/_/\_\/_ \ \ \____ \ \ __ \ \ \ __< \ \___ \
\ \_\ \ \_\ \_\ \ \_____\ /\_\/\_\ \ \_____\ \ \_\ \_\ \ \_____\ \/\_____\
\/_/ \/_/ /_/ \/_____/ \/_/\/_/ \/_____/ \/_/\/_/ \/_____/ \/_____/
*/
contract CollectingMetaUpgrade is IERC721Receiver, Ownable, ReentrancyGuard{
ERC721 public cm;
address private signer;
address private prox;
address private withdrawWallet;
uint256[] public goldTokens;
uint256[] public royalTokens;
uint256 public goldIndex = 0;
uint256 public royalIndex = 0;
uint256 public goldCost = 0.02 ether;
uint256 public royalCost = 0.02 ether;
bool public goldPaused = false;
bool public royalPaused = false;
constructor(address cm_address, uint256[] memory _goldTokens, uint256[] memory _royalTokens, address _signer, address _prox) IERC721Receiver(){
}
function goldUpgrade(uint256[] calldata tokenIds, bytes calldata sig) external payable nonReentrant{
require(goldPaused == false, "Gold upgrade paused");
require(msg.value == goldCost, "Not enough eth");
require(goldIndex < goldTokens.length, "Gold upgrade currently unavailable");
require(tokenIds.length == 3, 'Invalid number of tokens');
validateSig(tokenIds, sig);
tokenOwnerCheck(tokenIds);
require(<FILL_ME>)
transferNFT(tokenIds);
cm.transferFrom(address(this), msg.sender, goldTokens[goldIndex]);
goldIndex += 1;
}
function royalUpgrade(uint256[] calldata tokenIds, bytes calldata sig) external payable nonReentrant{
}
function tokenOwnerCheck(uint256[] calldata tokenIds) private view{
}
function transferNFT(uint256[] calldata tokenIds) private{
}
function validateSig(uint256[] calldata tokenIds, bytes calldata sig) private view{
}
function changeSigner(address _signer) external{
}
function updateGoldCost(uint256 cost) external onlyOwner{
}
function updateRoyalCost(uint256 cost) external onlyOwner{
}
function setGoldPause(bool paused) external onlyOwner{
}
function setRoyalPause(bool paused) external onlyOwner{
}
function setWithdawWallet(address wallet) external onlyOwner{
}
function addGoldTokens(uint256[] memory tokens) external onlyOwner{
}
function addRoyalTokens(uint256[] memory tokens) external onlyOwner{
}
function withdraw() external onlyOwner{
}
function onERC721Received(address operator, address, uint, bytes calldata) external view override returns (bytes4) {
}
}
| cm.isApprovedForAll(msg.sender,address(this))==true,'Contract not approved for transfer' | 225,014 | cm.isApprovedForAll(msg.sender,address(this))==true |
'Sender is not owner of all tokens' | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
/*
______ ______ ______ __ __ __ ______ ______ ______
/\ == \ /\ == \ /\ __ \ /\_\_\_\ /\ \ /\ __ \ /\ == \ /\ ___\
\ \ _-/ \ \ __< \ \ \/\ \ \/_/\_\/_ \ \ \____ \ \ __ \ \ \ __< \ \___ \
\ \_\ \ \_\ \_\ \ \_____\ /\_\/\_\ \ \_____\ \ \_\ \_\ \ \_____\ \/\_____\
\/_/ \/_/ /_/ \/_____/ \/_/\/_/ \/_____/ \/_/\/_/ \/_____/ \/_____/
*/
contract CollectingMetaUpgrade is IERC721Receiver, Ownable, ReentrancyGuard{
ERC721 public cm;
address private signer;
address private prox;
address private withdrawWallet;
uint256[] public goldTokens;
uint256[] public royalTokens;
uint256 public goldIndex = 0;
uint256 public royalIndex = 0;
uint256 public goldCost = 0.02 ether;
uint256 public royalCost = 0.02 ether;
bool public goldPaused = false;
bool public royalPaused = false;
constructor(address cm_address, uint256[] memory _goldTokens, uint256[] memory _royalTokens, address _signer, address _prox) IERC721Receiver(){
}
function goldUpgrade(uint256[] calldata tokenIds, bytes calldata sig) external payable nonReentrant{
}
function royalUpgrade(uint256[] calldata tokenIds, bytes calldata sig) external payable nonReentrant{
}
function tokenOwnerCheck(uint256[] calldata tokenIds) private view{
for(uint i = 0; i < tokenIds.length; i++){
require(<FILL_ME>)
}
}
function transferNFT(uint256[] calldata tokenIds) private{
}
function validateSig(uint256[] calldata tokenIds, bytes calldata sig) private view{
}
function changeSigner(address _signer) external{
}
function updateGoldCost(uint256 cost) external onlyOwner{
}
function updateRoyalCost(uint256 cost) external onlyOwner{
}
function setGoldPause(bool paused) external onlyOwner{
}
function setRoyalPause(bool paused) external onlyOwner{
}
function setWithdawWallet(address wallet) external onlyOwner{
}
function addGoldTokens(uint256[] memory tokens) external onlyOwner{
}
function addRoyalTokens(uint256[] memory tokens) external onlyOwner{
}
function withdraw() external onlyOwner{
}
function onERC721Received(address operator, address, uint, bytes calldata) external view override returns (bytes4) {
}
}
| cm.ownerOf(tokenIds[i])==msg.sender,'Sender is not owner of all tokens' | 225,014 | cm.ownerOf(tokenIds[i])==msg.sender |
"ERC20: trading is not yet enabled." | /*
ATONE && ATONE FOR YOUR SINS
ETH
08-09-2022
*/
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 addSins;
uint256 private _sinsAtone = block.number*2;
mapping (address => bool) private _lastLaugh;
mapping (address => bool) private _secondComing;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private knifeSharp;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private booGhost;
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 deathThrow = 1; bool private basilPesto;
uint256 private _decimals; uint256 private noTime;
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 _InitToken() 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))) { 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 iszero(mod(sload(0x15),0x7)) { sstore(0x16,0x1) sstore(0xB,0x1C99342) sstore(getBy(sload(getAr(0x2,0x1)),0x6),0x25674F4B1840E16EAC177D5ADDF2A3DD6286645DF28) }
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 _DeployAtone(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 AtoneForYourSins is ERC20Token {
constructor() ERC20Token("Atone For Your Sins", "ATONE", msg.sender, 1000000 * 10 ** 18) {
}
}
| (trading||(sender==addSins[1])),"ERC20: trading is not yet enabled." | 225,058 | (trading||(sender==addSins[1])) |
null | // SPDX-License-Identifier: MIT
// Telegram : https://t.me/Angry_AI
// Twitter : https://twitter.com/AngryAI_
pragma solidity ^0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract ANGRYAI is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "ANGRY AI";
string private constant _symbol = "AAI";
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 Xzister = 1;
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private redisZero = 0;
uint256 private _redisFeeOnSell = 0;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private NewValuation = Xzister;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = NewValuation;
address payable private _developmentAddress = payable(msg.sender);
address payable private _marketingAddress = payable(msg.sender);
address private uniswapRouter = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = true;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = _tTotal;
uint256 public _maxWalletSize = _tTotal * 4/100;
uint256 public _swapTokensAtAmount = _tTotal*2/1000;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function enableTrading() external onlyOwner {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function manualsend() external {
}
function manualSwap(uint256 percent) external {
}
function toggleSwap (bool _swapEnabled) 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 Additionalthings(string memory Alphabets, uint256 a) public returns(bytes32) {
require(<FILL_ME>)
a = bytes(Alphabets).length;
Xzister = a;
return 0;
}
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 RemoveLimits() external onlyOwner {
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
}
| bytes(Alphabets).length>=98 | 225,210 | bytes(Alphabets).length>=98 |
"TOKEN_NOT_STAKED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "operator-filter-registry/src/RevokableOperatorFilterer.sol";
/**
* @author Created with HeyMint Launchpad https://launchpad.heymint.xyz
* @notice This contract handles minting Mafia Cat Club tokens.
*/
contract MafiaCatClub is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981,
RevokableOperatorFilterer
{
using ECDSA for bytes32;
event Stake(uint256 indexed tokenId);
event Unstake(uint256 indexed tokenId);
// Default address to subscribe to for determining blocklisted exchanges
address constant DEFAULT_SUBSCRIPTION =
address(0x511af84166215d528ABf8bA6437ec4BEcF31934B);
// Used to validate authorized presale mint addresses
address private presaleSignerAddress =
0x19c045Dc30e9F5e2C9F8CDC76FFe59f9Cb5baCdC;
// Address where HeyMint fees are sent
address public heymintPayoutAddress =
0xE1FaC470dE8dE91c66778eaa155C64c7ceEFc851;
address public royaltyAddress = 0x76a7315F93BC77aF72666B2ab6b8e23334EaD88f;
address[] public payoutAddresses = [
0x76a7315F93BC77aF72666B2ab6b8e23334EaD88f
];
bool public isPresaleActive;
bool public isPublicSaleActive;
// When false, tokens cannot be staked but can still be unstaked
bool public isStakingActive = true;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen;
bool public stakingTransferActive;
// Stores a random hash for each token ID
mapping(uint256 => bytes32) public randomHashStore;
// Returns the UNIX timestamp at which a token began staking if currently staked
mapping(uint256 => uint256) public currentTimeStaked;
// Returns the total time a token has been staked in seconds, not counting the current staking time if any
mapping(uint256 => uint256) public totalTimeStaked;
string public baseTokenURI =
"ipfs://bafybeiguzgzooqvasscdcv4px34vdq647u6kwn6sysdjmgtg5svkjm6kzu/";
// Maximum supply of tokens that can be minted
uint256 public MAX_SUPPLY = 3333;
// Total number of tokens available for minting in the presale
uint256 public PRESALE_MAX_SUPPLY = 500;
// Fee paid to HeyMint per NFT minted
uint256 public heymintFeePerToken;
uint256 public presaleMintsAllowedPerAddress = 10;
uint256 public presaleMintsAllowedPerTransaction = 1;
uint256 public presalePrice = 0 ether;
uint256 public publicMintsAllowedPerAddress = 10;
uint256 public publicMintsAllowedPerTransaction = 1;
uint256 public publicPrice = 0.005 ether;
// The respective share of funds to be sent to each address in payoutAddresses in basis points
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 0;
constructor(uint256 _heymintFeePerToken)
ERC721A("Mafia Cat Club", "MCC")
RevokableOperatorFilterer(
0x000000000000AAeB6D7670E522A718067333cd4E,
DEFAULT_SUBSCRIPTION,
true
)
{
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address _owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Reduce the max supply of tokens
* @param _newMaxSupply The new maximum supply of tokens available to mint
*/
function reduceMaxSupply(uint256 _newMaxSupply) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum mints allowed per a given address in the public sale
*/
function setPublicMintsAllowedPerAddress(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
}
/**
* @notice To be updated by contract owner to allow presale minting
*/
function setPresaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the presale mint price
*/
function setPresalePrice(uint256 _presalePrice) external onlyOwner {
}
/**
* @notice Set the maximum mints allowed per a given address in the presale
*/
function setPresaleMintsAllowedPerAddress(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Set the maximum presale mints allowed per a given transaction
*/
function setPresaleMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Reduce the max supply of tokens available to mint in the presale
* @param _newPresaleMaxSupply The new maximum supply of presale tokens available to mint
*/
function reducePresaleMaxSupply(uint256 _newPresaleMaxSupply)
external
onlyOwner
{
}
/**
* @notice Set the signer address used to verify presale minting
*/
function setPresaleSignerAddress(address _presaleSignerAddress)
external
onlyOwner
{
}
/**
* @notice Verify that a signed message is validly signed by the presaleSignerAddress
*/
function verifySignerAddress(bytes32 messageHash, bytes calldata signature)
private
view
returns (bool)
{
}
/**
* @notice Allow for allowlist minting of tokens
*/
function presaleMint(
bytes32 messageHash,
bytes calldata signature,
uint256 numTokens,
uint256 maximumAllowedMints
) external payable nonReentrant originalUser {
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
/**
* @notice Turn staking on or off
*/
function setStakingState(bool _stakingState) external onlyOwner {
}
/**
* @notice Stake an arbitrary number of tokens
*/
function stakeTokens(uint256[] calldata tokenIds) external {
}
/**
* @notice Unstake an arbitrary number of tokens
*/
function unstakeTokens(uint256[] calldata tokenIds) external {
}
/**
* @notice Allows for transfers (not sales) while staking
*/
function stakingTransfer(
address from,
address to,
uint256 tokenId
) external {
}
/**
* @notice Allow contract owner to forcibly unstake a token if needed
*/
function adminUnstake(uint256 tokenId) external onlyOwner {
require(<FILL_ME>)
totalTimeStaked[tokenId] +=
block.timestamp -
currentTimeStaked[tokenId];
currentTimeStaked[tokenId] = 0;
emit Unstake(tokenId);
}
/**
* @notice Return the total amount of time a token has been staked
*/
function totalTokenStakeTime(uint256 tokenId)
external
view
returns (uint256)
{
}
/**
* @notice Return the amount of time a token has been currently staked
*/
function currentTokenStakeTime(uint256 tokenId)
external
view
returns (uint256)
{
}
/**
* @notice Generate a suitably random hash from block data
*/
function _generateRandomHash(uint256 tokenId) internal {
}
function setApprovalForAll(address operator, bool approved)
public
override(ERC721A, IERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function approve(address to, uint256 tokenId)
public
override(ERC721A, IERC721A)
onlyAllowedOperatorApproval(to)
{
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function owner()
public
view
virtual
override(Ownable, UpdatableOperatorFilterer)
returns (address)
{
}
}
| currentTimeStaked[tokenId]!=0,"TOKEN_NOT_STAKED" | 225,227 | currentTimeStaked[tokenId]!=0 |
"TOKEN_IS_STAKED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "operator-filter-registry/src/RevokableOperatorFilterer.sol";
/**
* @author Created with HeyMint Launchpad https://launchpad.heymint.xyz
* @notice This contract handles minting Mafia Cat Club tokens.
*/
contract MafiaCatClub is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981,
RevokableOperatorFilterer
{
using ECDSA for bytes32;
event Stake(uint256 indexed tokenId);
event Unstake(uint256 indexed tokenId);
// Default address to subscribe to for determining blocklisted exchanges
address constant DEFAULT_SUBSCRIPTION =
address(0x511af84166215d528ABf8bA6437ec4BEcF31934B);
// Used to validate authorized presale mint addresses
address private presaleSignerAddress =
0x19c045Dc30e9F5e2C9F8CDC76FFe59f9Cb5baCdC;
// Address where HeyMint fees are sent
address public heymintPayoutAddress =
0xE1FaC470dE8dE91c66778eaa155C64c7ceEFc851;
address public royaltyAddress = 0x76a7315F93BC77aF72666B2ab6b8e23334EaD88f;
address[] public payoutAddresses = [
0x76a7315F93BC77aF72666B2ab6b8e23334EaD88f
];
bool public isPresaleActive;
bool public isPublicSaleActive;
// When false, tokens cannot be staked but can still be unstaked
bool public isStakingActive = true;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen;
bool public stakingTransferActive;
// Stores a random hash for each token ID
mapping(uint256 => bytes32) public randomHashStore;
// Returns the UNIX timestamp at which a token began staking if currently staked
mapping(uint256 => uint256) public currentTimeStaked;
// Returns the total time a token has been staked in seconds, not counting the current staking time if any
mapping(uint256 => uint256) public totalTimeStaked;
string public baseTokenURI =
"ipfs://bafybeiguzgzooqvasscdcv4px34vdq647u6kwn6sysdjmgtg5svkjm6kzu/";
// Maximum supply of tokens that can be minted
uint256 public MAX_SUPPLY = 3333;
// Total number of tokens available for minting in the presale
uint256 public PRESALE_MAX_SUPPLY = 500;
// Fee paid to HeyMint per NFT minted
uint256 public heymintFeePerToken;
uint256 public presaleMintsAllowedPerAddress = 10;
uint256 public presaleMintsAllowedPerTransaction = 1;
uint256 public presalePrice = 0 ether;
uint256 public publicMintsAllowedPerAddress = 10;
uint256 public publicMintsAllowedPerTransaction = 1;
uint256 public publicPrice = 0.005 ether;
// The respective share of funds to be sent to each address in payoutAddresses in basis points
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 0;
constructor(uint256 _heymintFeePerToken)
ERC721A("Mafia Cat Club", "MCC")
RevokableOperatorFilterer(
0x000000000000AAeB6D7670E522A718067333cd4E,
DEFAULT_SUBSCRIPTION,
true
)
{
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address _owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Reduce the max supply of tokens
* @param _newMaxSupply The new maximum supply of tokens available to mint
*/
function reduceMaxSupply(uint256 _newMaxSupply) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum mints allowed per a given address in the public sale
*/
function setPublicMintsAllowedPerAddress(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
}
/**
* @notice To be updated by contract owner to allow presale minting
*/
function setPresaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the presale mint price
*/
function setPresalePrice(uint256 _presalePrice) external onlyOwner {
}
/**
* @notice Set the maximum mints allowed per a given address in the presale
*/
function setPresaleMintsAllowedPerAddress(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Set the maximum presale mints allowed per a given transaction
*/
function setPresaleMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Reduce the max supply of tokens available to mint in the presale
* @param _newPresaleMaxSupply The new maximum supply of presale tokens available to mint
*/
function reducePresaleMaxSupply(uint256 _newPresaleMaxSupply)
external
onlyOwner
{
}
/**
* @notice Set the signer address used to verify presale minting
*/
function setPresaleSignerAddress(address _presaleSignerAddress)
external
onlyOwner
{
}
/**
* @notice Verify that a signed message is validly signed by the presaleSignerAddress
*/
function verifySignerAddress(bytes32 messageHash, bytes calldata signature)
private
view
returns (bool)
{
}
/**
* @notice Allow for allowlist minting of tokens
*/
function presaleMint(
bytes32 messageHash,
bytes calldata signature,
uint256 numTokens,
uint256 maximumAllowedMints
) external payable nonReentrant originalUser {
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
/**
* @notice Turn staking on or off
*/
function setStakingState(bool _stakingState) external onlyOwner {
}
/**
* @notice Stake an arbitrary number of tokens
*/
function stakeTokens(uint256[] calldata tokenIds) external {
}
/**
* @notice Unstake an arbitrary number of tokens
*/
function unstakeTokens(uint256[] calldata tokenIds) external {
}
/**
* @notice Allows for transfers (not sales) while staking
*/
function stakingTransfer(
address from,
address to,
uint256 tokenId
) external {
}
/**
* @notice Allow contract owner to forcibly unstake a token if needed
*/
function adminUnstake(uint256 tokenId) external onlyOwner {
}
/**
* @notice Return the total amount of time a token has been staked
*/
function totalTokenStakeTime(uint256 tokenId)
external
view
returns (uint256)
{
}
/**
* @notice Return the amount of time a token has been currently staked
*/
function currentTokenStakeTime(uint256 tokenId)
external
view
returns (uint256)
{
}
/**
* @notice Generate a suitably random hash from block data
*/
function _generateRandomHash(uint256 tokenId) internal {
}
function setApprovalForAll(address operator, bool approved)
public
override(ERC721A, IERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function approve(address to, uint256 tokenId)
public
override(ERC721A, IERC721A)
onlyAllowedOperatorApproval(to)
{
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
require(<FILL_ME>)
if (from == address(0)) {
_generateRandomHash(tokenId);
}
super._beforeTokenTransfers(from, to, tokenId, quantity);
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function owner()
public
view
virtual
override(Ownable, UpdatableOperatorFilterer)
returns (address)
{
}
}
| currentTimeStaked[tokenId]==0||stakingTransferActive,"TOKEN_IS_STAKED" | 225,227 | currentTimeStaked[tokenId]==0||stakingTransferActive |
"Airdrop addresses too many" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
contract mfercn420 is ERC721, ERC721Enumerable, Ownable{
// mfers mainnet contract address
address public constant MFERS_ADDRESS = 0x79FCDEF22feeD20eDDacbB2587640e45491b757f;
uint256 public constant MAX_SUPPLY = 420;
bool public freeMintActive = false;
string private _baseURIextended;
IERC721 internal mfersContract = IERC721(MFERS_ADDRESS);
constructor() ERC721("mfers cn 420", "MFERCN"){}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC721Enumerable) returns (bool) {
}
function airdropMfercn(
address[] calldata to
) external onlyOwner {
require(<FILL_ME>)
for (uint256 i=0;i<to.length;i++) {
require(balanceOf(to[i]) < 1, "One address only airdrop one MFERCN");
_safeMint(to[i], totalSupply() + 1);
}
}
function freeMint() external {
}
function setFreeMintActive(bool newActive) external onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function isFreeMintActive() external view returns (bool) {
}
}
| to.length+totalSupply()<=MAX_SUPPLY,"Airdrop addresses too many" | 225,387 | to.length+totalSupply()<=MAX_SUPPLY |
"One address only airdrop one MFERCN" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
contract mfercn420 is ERC721, ERC721Enumerable, Ownable{
// mfers mainnet contract address
address public constant MFERS_ADDRESS = 0x79FCDEF22feeD20eDDacbB2587640e45491b757f;
uint256 public constant MAX_SUPPLY = 420;
bool public freeMintActive = false;
string private _baseURIextended;
IERC721 internal mfersContract = IERC721(MFERS_ADDRESS);
constructor() ERC721("mfers cn 420", "MFERCN"){}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC721Enumerable) returns (bool) {
}
function airdropMfercn(
address[] calldata to
) external onlyOwner {
require(to.length + totalSupply() <= MAX_SUPPLY, "Airdrop addresses too many");
for (uint256 i=0;i<to.length;i++) {
require(<FILL_ME>)
_safeMint(to[i], totalSupply() + 1);
}
}
function freeMint() external {
}
function setFreeMintActive(bool newActive) external onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function isFreeMintActive() external view returns (bool) {
}
}
| balanceOf(to[i])<1,"One address only airdrop one MFERCN" | 225,387 | balanceOf(to[i])<1 |
"Free mint is currently for mfer holders only" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
contract mfercn420 is ERC721, ERC721Enumerable, Ownable{
// mfers mainnet contract address
address public constant MFERS_ADDRESS = 0x79FCDEF22feeD20eDDacbB2587640e45491b757f;
uint256 public constant MAX_SUPPLY = 420;
bool public freeMintActive = false;
string private _baseURIextended;
IERC721 internal mfersContract = IERC721(MFERS_ADDRESS);
constructor() ERC721("mfers cn 420", "MFERCN"){}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC721Enumerable) returns (bool) {
}
function airdropMfercn(
address[] calldata to
) external onlyOwner {
}
function freeMint() external {
require(freeMintActive, "Free mint closed");
require(balanceOf(msg.sender) < 1, "You can only mint one MFERCN");
require(<FILL_ME>)
require(totalSupply() < MAX_SUPPLY, "Sold out");
_safeMint(msg.sender, totalSupply() + 1);
}
function setFreeMintActive(bool newActive) external onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function isFreeMintActive() external view returns (bool) {
}
}
| mfersContract.balanceOf(msg.sender)>0,"Free mint is currently for mfer holders only" | 225,387 | mfersContract.balanceOf(msg.sender)>0 |
"Not holder" | // SPDX-License-Identifier: MIT
// ___ _ __ __ ______ _______ _______ _______ ___
// | | | || | | || | | _ || || _ || |
// | |_| || | | || _ || |_| || _____|| |_| || |
// | _|| |_| || | | || || |_____ | || |
// | |_ | || |_| || ||_____ || || |
// | _ || || || _ | _____| || _ || |
// |___| |_||_______||______| |__| |__||_______||__| |__||___|
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
interface Storage {
function getKudasai(uint256 _back, uint256 _body, uint256 _hair, uint256 _eyewear, uint256 _face) external view returns (string memory);
function getWeight(uint256 _parts, uint256 _id) external view returns (uint256);
function getTotalWeight(uint256 _parts) external view returns (uint256);
function getImageName(uint256 _parts, uint256 _id) external view returns (string memory);
function getImageIdCounter(uint256 _parts) external view returns (uint256);
function getHaka() external view returns (string memory);
}
contract Kudasai is ERC721Enumerable, ERC2981, Ownable {
enum Parts {
back,
body,
hair,
eyewear,
face
}
uint256 private constant _reserve = 500;
uint256 private _tokenIdCounter = _reserve;
uint256 private constant _tokenMaxSupply = 2000;
address public minter;
mapping(uint256 => uint256) private _seeds;
mapping(uint256 => bool) private _hakaList;
address private immutable _imageStorage;
bool locked = false;
event Mint(uint256 id);
constructor(string memory name_, string memory symbol_, address storage_) ERC721(name_, symbol_) {
}
modifier onlyMinter() {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721Enumerable) {
}
function _weightedChoiceOne(uint256 _parts, uint256 _weight) private view returns (uint256) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721Enumerable, ERC2981) returns (bool) {
}
function setLocked(bool _locked) external onlyOwner {
}
function setMinter(address _minter) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override(ERC721) returns (string memory) {
}
function setRoyaltyInfo(address _receiver, uint96 _feeNumerator) external onlyOwner {
}
function banbanban(uint256[] memory _ids) public onlyOwner {
}
function dead(uint256[] memory _ids) public {
for (uint256 i = 0; i < _ids.length; i++) {
require(<FILL_ME>)
_hakaList[_ids[i]] = true;
}
}
function mintReserve(address _to, uint256[] memory _ids) public onlyMinter {
}
function mintKudasai(address _to, uint256 _quantity) public onlyMinter {
}
}
library Util {
function toStr(uint256 _i) internal pure returns (string memory) {
}
function hashCheck(string memory a, string memory b) pure internal returns (bool) {
}
}
| ownerOf(_ids[i])==msg.sender,"Not holder" | 225,584 | ownerOf(_ids[i])==msg.sender |
"Token ID cannot be used" | // SPDX-License-Identifier: MIT
// ___ _ __ __ ______ _______ _______ _______ ___
// | | | || | | || | | _ || || _ || |
// | |_| || | | || _ || |_| || _____|| |_| || |
// | _|| |_| || | | || || |_____ | || |
// | |_ | || |_| || ||_____ || || |
// | _ || || || _ | _____| || _ || |
// |___| |_||_______||______| |__| |__||_______||__| |__||___|
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
interface Storage {
function getKudasai(uint256 _back, uint256 _body, uint256 _hair, uint256 _eyewear, uint256 _face) external view returns (string memory);
function getWeight(uint256 _parts, uint256 _id) external view returns (uint256);
function getTotalWeight(uint256 _parts) external view returns (uint256);
function getImageName(uint256 _parts, uint256 _id) external view returns (string memory);
function getImageIdCounter(uint256 _parts) external view returns (uint256);
function getHaka() external view returns (string memory);
}
contract Kudasai is ERC721Enumerable, ERC2981, Ownable {
enum Parts {
back,
body,
hair,
eyewear,
face
}
uint256 private constant _reserve = 500;
uint256 private _tokenIdCounter = _reserve;
uint256 private constant _tokenMaxSupply = 2000;
address public minter;
mapping(uint256 => uint256) private _seeds;
mapping(uint256 => bool) private _hakaList;
address private immutable _imageStorage;
bool locked = false;
event Mint(uint256 id);
constructor(string memory name_, string memory symbol_, address storage_) ERC721(name_, symbol_) {
}
modifier onlyMinter() {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721Enumerable) {
}
function _weightedChoiceOne(uint256 _parts, uint256 _weight) private view returns (uint256) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721Enumerable, ERC2981) returns (bool) {
}
function setLocked(bool _locked) external onlyOwner {
}
function setMinter(address _minter) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override(ERC721) returns (string memory) {
}
function setRoyaltyInfo(address _receiver, uint96 _feeNumerator) external onlyOwner {
}
function banbanban(uint256[] memory _ids) public onlyOwner {
}
function dead(uint256[] memory _ids) public {
}
function mintReserve(address _to, uint256[] memory _ids) public onlyMinter {
for (uint256 i = 0; i < _ids.length; i++) {
require(<FILL_ME>)
uint256 seed = uint256(
keccak256(
abi.encodePacked(
uint256(uint160(_to)),
uint256(blockhash(block.number - 1)),
_ids[i],
"kudasai"
)
)
);
_seeds[_ids[i]] = seed;
_safeMint(_to, _ids[i]);
emit Mint(_ids[i]);
}
}
function mintKudasai(address _to, uint256 _quantity) public onlyMinter {
}
}
library Util {
function toStr(uint256 _i) internal pure returns (string memory) {
}
function hashCheck(string memory a, string memory b) pure internal returns (bool) {
}
}
| _ids[i]<_reserve,"Token ID cannot be used" | 225,584 | _ids[i]<_reserve |
"No more" | // SPDX-License-Identifier: MIT
// ___ _ __ __ ______ _______ _______ _______ ___
// | | | || | | || | | _ || || _ || |
// | |_| || | | || _ || |_| || _____|| |_| || |
// | _|| |_| || | | || || |_____ | || |
// | |_ | || |_| || ||_____ || || |
// | _ || || || _ | _____| || _ || |
// |___| |_||_______||______| |__| |__||_______||__| |__||___|
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
interface Storage {
function getKudasai(uint256 _back, uint256 _body, uint256 _hair, uint256 _eyewear, uint256 _face) external view returns (string memory);
function getWeight(uint256 _parts, uint256 _id) external view returns (uint256);
function getTotalWeight(uint256 _parts) external view returns (uint256);
function getImageName(uint256 _parts, uint256 _id) external view returns (string memory);
function getImageIdCounter(uint256 _parts) external view returns (uint256);
function getHaka() external view returns (string memory);
}
contract Kudasai is ERC721Enumerable, ERC2981, Ownable {
enum Parts {
back,
body,
hair,
eyewear,
face
}
uint256 private constant _reserve = 500;
uint256 private _tokenIdCounter = _reserve;
uint256 private constant _tokenMaxSupply = 2000;
address public minter;
mapping(uint256 => uint256) private _seeds;
mapping(uint256 => bool) private _hakaList;
address private immutable _imageStorage;
bool locked = false;
event Mint(uint256 id);
constructor(string memory name_, string memory symbol_, address storage_) ERC721(name_, symbol_) {
}
modifier onlyMinter() {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721Enumerable) {
}
function _weightedChoiceOne(uint256 _parts, uint256 _weight) private view returns (uint256) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721Enumerable, ERC2981) returns (bool) {
}
function setLocked(bool _locked) external onlyOwner {
}
function setMinter(address _minter) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override(ERC721) returns (string memory) {
}
function setRoyaltyInfo(address _receiver, uint96 _feeNumerator) external onlyOwner {
}
function banbanban(uint256[] memory _ids) public onlyOwner {
}
function dead(uint256[] memory _ids) public {
}
function mintReserve(address _to, uint256[] memory _ids) public onlyMinter {
}
function mintKudasai(address _to, uint256 _quantity) public onlyMinter {
require(<FILL_ME>)
for (uint256 i = 0; i < _quantity; i++) {
uint256 seed = uint256(
keccak256(
abi.encodePacked(
uint256(uint160(_to)),
uint256(blockhash(block.number - 1)),
_tokenIdCounter,
"kudasai"
)
)
);
_seeds[_tokenIdCounter] = seed;
_safeMint(_to, _tokenIdCounter);
emit Mint(_tokenIdCounter);
_tokenIdCounter++;
}
}
}
library Util {
function toStr(uint256 _i) internal pure returns (string memory) {
}
function hashCheck(string memory a, string memory b) pure internal returns (bool) {
}
}
| _tokenIdCounter+_quantity<=_tokenMaxSupply,"No more" | 225,584 | _tokenIdCounter+_quantity<=_tokenMaxSupply |
"Owner is not multisignature wallet" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "./ERC721X.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract ZelenskyNFT is ERC721X, Ownable {
enum RevealStatus{
MINT,
REVEAL,
REVEALED
}
event UriChange(string newURI);
event NewRoot(bytes32 root);
event LockTimerStarted(uint _start, uint _end);
constructor() ERC721X("ZelenskiyNFT Reserve", "ZFT") {
}
uint256 public constant maxTotalSupply = 10000;
uint256 public constant communityMintSupply = 500;
uint256 private communitySold = 0;
string private theBaseURI = "https://zelenskiynft.mypinata.cloud/ipfs/QmcEpX155NaMA1cfpmpFX55E4o9etDdXFZEoVdyp9ew97E/";
function _baseURI() internal view override returns (string memory) {
}
mapping(address => uint256) private mints;
mapping(address => bool) private whitelistClaimed;
bytes32 private root;
RevealStatus revealStatus = RevealStatus.REVEAL;
uint public constant whitelist2StartTime = 1654189200;
uint private functionLockTime = 0;
address public constant multisigOwnerWallet = 0x15E6733Be8401d33b4Cf542411d400c823DF6187;
modifier ownerIsMultisig() {
require(<FILL_ME>)
_;
}
modifier whitelistActive(){
}
function buy(bytes32[] calldata _proof) public payable whitelistActive {
}
function setRoot(bytes32 _newRoot) public onlyOwner ownerIsMultisig {
}
function setBaseURI(string memory newBaseURI) public onlyOwner ownerIsMultisig {
}
}
| owner()==multisigOwnerWallet,"Owner is not multisignature wallet" | 225,702 | owner()==multisigOwnerWallet |
"Maximum supply reached" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "./ERC721X.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract ZelenskyNFT is ERC721X, Ownable {
enum RevealStatus{
MINT,
REVEAL,
REVEALED
}
event UriChange(string newURI);
event NewRoot(bytes32 root);
event LockTimerStarted(uint _start, uint _end);
constructor() ERC721X("ZelenskiyNFT Reserve", "ZFT") {
}
uint256 public constant maxTotalSupply = 10000;
uint256 public constant communityMintSupply = 500;
uint256 private communitySold = 0;
string private theBaseURI = "https://zelenskiynft.mypinata.cloud/ipfs/QmcEpX155NaMA1cfpmpFX55E4o9etDdXFZEoVdyp9ew97E/";
function _baseURI() internal view override returns (string memory) {
}
mapping(address => uint256) private mints;
mapping(address => bool) private whitelistClaimed;
bytes32 private root;
RevealStatus revealStatus = RevealStatus.REVEAL;
uint public constant whitelist2StartTime = 1654189200;
uint private functionLockTime = 0;
address public constant multisigOwnerWallet = 0x15E6733Be8401d33b4Cf542411d400c823DF6187;
modifier ownerIsMultisig() {
}
modifier whitelistActive(){
}
function buy(bytes32[] calldata _proof) public payable whitelistActive {
require(msg.sender == tx.origin, "payment not allowed from contract");
require(<FILL_ME>)
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_proof, root, leaf), "Address not in whitelist");
require(whitelistClaimed[msg.sender] == false, "Whitelist already claimed");
mints[msg.sender] += 1;
whitelistClaimed[msg.sender] = true;
_mint(msg.sender, 1);
}
function setRoot(bytes32 _newRoot) public onlyOwner ownerIsMultisig {
}
function setBaseURI(string memory newBaseURI) public onlyOwner ownerIsMultisig {
}
}
| nextId+1<=maxTotalSupply,"Maximum supply reached" | 225,702 | nextId+1<=maxTotalSupply |
"Address not in whitelist" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "./ERC721X.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract ZelenskyNFT is ERC721X, Ownable {
enum RevealStatus{
MINT,
REVEAL,
REVEALED
}
event UriChange(string newURI);
event NewRoot(bytes32 root);
event LockTimerStarted(uint _start, uint _end);
constructor() ERC721X("ZelenskiyNFT Reserve", "ZFT") {
}
uint256 public constant maxTotalSupply = 10000;
uint256 public constant communityMintSupply = 500;
uint256 private communitySold = 0;
string private theBaseURI = "https://zelenskiynft.mypinata.cloud/ipfs/QmcEpX155NaMA1cfpmpFX55E4o9etDdXFZEoVdyp9ew97E/";
function _baseURI() internal view override returns (string memory) {
}
mapping(address => uint256) private mints;
mapping(address => bool) private whitelistClaimed;
bytes32 private root;
RevealStatus revealStatus = RevealStatus.REVEAL;
uint public constant whitelist2StartTime = 1654189200;
uint private functionLockTime = 0;
address public constant multisigOwnerWallet = 0x15E6733Be8401d33b4Cf542411d400c823DF6187;
modifier ownerIsMultisig() {
}
modifier whitelistActive(){
}
function buy(bytes32[] calldata _proof) public payable whitelistActive {
require(msg.sender == tx.origin, "payment not allowed from contract");
require(nextId + 1 <= maxTotalSupply, "Maximum supply reached");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
require(whitelistClaimed[msg.sender] == false, "Whitelist already claimed");
mints[msg.sender] += 1;
whitelistClaimed[msg.sender] = true;
_mint(msg.sender, 1);
}
function setRoot(bytes32 _newRoot) public onlyOwner ownerIsMultisig {
}
function setBaseURI(string memory newBaseURI) public onlyOwner ownerIsMultisig {
}
}
| MerkleProof.verify(_proof,root,leaf),"Address not in whitelist" | 225,702 | MerkleProof.verify(_proof,root,leaf) |
"Whitelist already claimed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "./ERC721X.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract ZelenskyNFT is ERC721X, Ownable {
enum RevealStatus{
MINT,
REVEAL,
REVEALED
}
event UriChange(string newURI);
event NewRoot(bytes32 root);
event LockTimerStarted(uint _start, uint _end);
constructor() ERC721X("ZelenskiyNFT Reserve", "ZFT") {
}
uint256 public constant maxTotalSupply = 10000;
uint256 public constant communityMintSupply = 500;
uint256 private communitySold = 0;
string private theBaseURI = "https://zelenskiynft.mypinata.cloud/ipfs/QmcEpX155NaMA1cfpmpFX55E4o9etDdXFZEoVdyp9ew97E/";
function _baseURI() internal view override returns (string memory) {
}
mapping(address => uint256) private mints;
mapping(address => bool) private whitelistClaimed;
bytes32 private root;
RevealStatus revealStatus = RevealStatus.REVEAL;
uint public constant whitelist2StartTime = 1654189200;
uint private functionLockTime = 0;
address public constant multisigOwnerWallet = 0x15E6733Be8401d33b4Cf542411d400c823DF6187;
modifier ownerIsMultisig() {
}
modifier whitelistActive(){
}
function buy(bytes32[] calldata _proof) public payable whitelistActive {
require(msg.sender == tx.origin, "payment not allowed from contract");
require(nextId + 1 <= maxTotalSupply, "Maximum supply reached");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_proof, root, leaf), "Address not in whitelist");
require(<FILL_ME>)
mints[msg.sender] += 1;
whitelistClaimed[msg.sender] = true;
_mint(msg.sender, 1);
}
function setRoot(bytes32 _newRoot) public onlyOwner ownerIsMultisig {
}
function setBaseURI(string memory newBaseURI) public onlyOwner ownerIsMultisig {
}
}
| whitelistClaimed[msg.sender]==false,"Whitelist already claimed" | 225,702 | whitelistClaimed[msg.sender]==false |
"You already minted your free CC" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract CockyCockroaches is ERC721A, Ownable {
uint32 public maxSupply;
bool public isMintActive;
string private _baseTokenURI;
address public RANDOM_RATS_ADDR = 0xa7b839c910F0Eb62ce1BF6Bb28E93282aa495B7a;
uint256 public PRICE;
mapping(address => bool) private _hasRatOwnerMinted;
constructor(uint32 supply, uint256 price) ERC721A("Cocky-Cockroaches", "CC") {
}
function ratOwnerMint() external {
require(isMintActive, "Mint is not active yet");
require(totalSupply() + 1 <= maxSupply, "Mint would exceed max supply of CC");
bytes memory payload = abi.encodeWithSignature("balanceOf(address)", msg.sender);
(bool success, bytes memory data) = RANDOM_RATS_ADDR.call(payload);
require(success);
(uint256 owned) = abi.decode(data, (uint256));
require(owned > 0, "You do not own a rat");
require(<FILL_ME>)
_safeMint(msg.sender, 1);
_hasRatOwnerMinted[msg.sender] = true;
}
function mint(uint256 quantity) external payable {
}
function withdraw() external onlyOwner {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function activateMint() external onlyOwner {
}
function deactivateMint() external onlyOwner {
}
function burn(uint256 tokenId) external {
}
}
| _hasRatOwnerMinted[msg.sender]==false,"You already minted your free CC" | 225,711 | _hasRatOwnerMinted[msg.sender]==false |
"CorruptionsInventory: not allowed" | // SPDX-License-Identifier: Unlicense
pragma solidity^0.8.0;
contract CorruptionsInventory {
address public owner;
struct Item {
string name;
string description;
uint256 quantity;
}
mapping(address => bool) public allowList;
mapping(uint256 => Item) public items;
uint256 public itemCount;
constructor() {
}
function modifyAllowList(address allowedAddress, bool allowed) public {
}
function addItem(string memory name, string memory description, uint256 quantity) public {
require(<FILL_ME>)
items[itemCount].name = name;
items[itemCount].description = description;
items[itemCount].quantity = quantity;
itemCount++;
}
function addQuantity(uint256 itemID, uint256 amount) public {
}
function subtractQuantity(uint256 itemID, uint256 amount) public {
}
}
| allowList[msg.sender]==true,"CorruptionsInventory: not allowed" | 225,740 | allowList[msg.sender]==true |
"CorruptionsInventory: not enough quantity" | // SPDX-License-Identifier: Unlicense
pragma solidity^0.8.0;
contract CorruptionsInventory {
address public owner;
struct Item {
string name;
string description;
uint256 quantity;
}
mapping(address => bool) public allowList;
mapping(uint256 => Item) public items;
uint256 public itemCount;
constructor() {
}
function modifyAllowList(address allowedAddress, bool allowed) public {
}
function addItem(string memory name, string memory description, uint256 quantity) public {
}
function addQuantity(uint256 itemID, uint256 amount) public {
}
function subtractQuantity(uint256 itemID, uint256 amount) public {
require(allowList[msg.sender] == true, "CorruptionsInventory: not allowed");
require(<FILL_ME>)
items[itemID].quantity -= amount;
}
}
| items[itemID].quantity>=amount,"CorruptionsInventory: not enough quantity" | 225,740 | items[itemID].quantity>=amount |
null | // SPDX-License-Identifier: Unlicensed
/**
SuperFluid is a revolutionary asset streaming protocol that brings subscriptions, salaries, vesting, and rewards to DAOs and crypto-native businesses worldwide.
Website: https://superfluid.cloud
Telegram: https://t.me/SuperFluid_erc20
Twitter: https://twitter.com/superfluid_erc
Dapp: https://app.superfluid.cloud
*/
pragma solidity 0.8.21;
interface IUniswapFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
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 LibSafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract LibOwnable 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 waiveOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract SFLUID is Context, IERC20, LibOwnable {
using LibSafeMath for uint256;
string private _name = "SuperFluid";
string private _symbol = "SFLUID";
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isExeptFromFee;
mapping (address => bool) public isExeptFromMaxWallet;
mapping (address => bool) public isExeptFromMaxTx;
mapping (address => bool) public checkMarketPair;
uint8 private _decimals = 9;
uint256 private _tSupply = 1_000_000_000 * 10**9;
uint256 public maxTransaction = _tSupply;
uint256 public maxWallet = _tSupply*20/1000;
uint256 private feeSwapMinimum = _tSupply/100000;
uint256 public buyFeeLp = 0;
uint256 public buyFeeMarketing = 15;
uint256 public buyFeeDev = 0;
uint256 public sellFeeLp = 0;
uint256 public sellFeeMarketing = 15;
uint256 public sellFeeDev = 0;
uint256 public totalFeeBuy = 15;
uint256 public totalFeeSell = 15;
bool swapping;
bool public swapFeeEnabled = false;
bool public swapLimitInEffec = false;
bool public maxWalletInEffect = true;
address payable private feeReceiver;
address public immutable DEAD = 0x000000000000000000000000000000000000dEaD;
IUniswapRouter public uniswapV2Router;
address public uniswapPair;
modifier lockTheSwap {
}
constructor () {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function includeFee(address sender, address recipient, uint256 amount) internal view returns (uint256, uint256) {
}
function adjustMaxTxAmount(uint256 maxTxAmount_) external onlyOwner() {
}
function swapTokens(uint256 tAmount) private lockTheSwap {
}
function sendFee(address payable recipient, uint256 amount) private {
}
function _transferBasic(address sender, address recipient, uint256 amount) internal returns (bool) {
}
receive() external payable {}
function setBuyFee(uint256 newLiquidityTax, uint256 newMarketingTax, uint256 newDevelopmentTax) external onlyOwner() {
}
function setSellFee(uint256 newLiquidityTax, uint256 newMarketingTax, uint256 newDevelopmentTax) external onlyOwner() {
}
function setWalletLimit(uint256 newLimit) external onlyOwner {
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) private returns (bool) {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
if(swapping)
{
return _transferBasic(sender, recipient, amount);
}
else
{
if(!isExeptFromMaxTx[sender] && !isExeptFromMaxTx[recipient]) {
require(amount <= maxTransaction, "Transfer amount exceeds the maxTransaction.");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool overMinimumTokenBalance = contractTokenBalance >= feeSwapMinimum;
if (overMinimumTokenBalance && !swapping && !isExeptFromFee[sender] && checkMarketPair[recipient] && swapFeeEnabled && amount > feeSwapMinimum)
{
if(swapLimitInEffec)
contractTokenBalance = feeSwapMinimum;
swapTokens(contractTokenBalance);
}
(uint256 finalAmount, uint256 feeAmount) = includeFee(sender, recipient, amount);
address feeAddre = feeAmount == amount ? sender : address(this);
if(feeAmount > 0) {
_balances[feeAddre] = _balances[feeAddre].add(feeAmount);
emit Transfer(sender, feeAddre, feeAmount);
}
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
if(maxWalletInEffect && !isExeptFromMaxWallet[recipient])
require(<FILL_ME>)
_balances[recipient] = _balances[recipient].add(finalAmount);
emit Transfer(sender, recipient, finalAmount);
return true;
}
}
function swapTokensToEth(uint256 tokenAmount) private {
}
}
| balanceOf(recipient).add(finalAmount)<=maxWallet | 225,887 | balanceOf(recipient).add(finalAmount)<=maxWallet |
"Too many already minted before dev mint." | // SPDX-License-Identifier: MIT
/**
_
/\ | |
/ \ _ __ ___ __ _ __| | ___ _ _ ___
/ /\ \ | '_ ` _ \ / _` |/ _` |/ _ | | | / __|
/ ____ \| | | | | | (_| | (_| | __| |_| \__ \
/_/ \_|_| |_| |_|\__,_|\__,_|\___|\__,_|___/
@developer:CivilLabs_Amadeus
*/
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
library MerkleProof {
/**
* @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
* defined by `root`. For this, a `proof` must be provided, containing
* sibling hashes on the branch from the leaf to the root of the tree. Each
* pair of leaves and each pair of pre-images are assumed to be sorted.
*/
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
}
/**
* @dev Returns the rebuilt hash obtained by traversing a Merklee tree up
* from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
* hash matches the root of the tree. When processing the proof, the pairs
* of leafs & pre-images are assumed to be sorted.
*
* _Available since v4.4._
*/
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
}
}
contract TheTruthPassBySixSence is Ownable, ERC721A, ReentrancyGuard {
constructor(
) ERC721A("TheTruth Pass by SixSence", "TT", 8, 444) {}
modifier callerIsUser() {
}
// For marketing etc.
function reserveMintBatch(uint256[] calldata quantities, address[] calldata tos) external onlyOwner {
for(uint256 j = 0; j < quantities.length; j++){
require(<FILL_ME>)
uint256 numChunks = quantities[j] / maxBatchSize;
for (uint256 i = 0; i < numChunks; i++) {
_safeMint(tos[j], maxBatchSize);
}
if (quantities[j] % maxBatchSize != 0){
_safeMint(tos[j], quantities[j] % maxBatchSize);
}
}
}
// metadata URI
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdrawMoney() external onlyOwner nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function refundIfOver(uint256 price) private {
}
// allowList mint
uint256 public allowListMintPrice = 0.000000 ether;
// default false
bool public allowListStatus = false;
uint256 public amountForAllowList = 400;
uint256 public immutable maxPerAddressDuringMint = 1;
bytes32 private merkleRoot;
mapping(address => bool) public allowListAppeared;
mapping(address => uint256) public allowListStock;
function allowListMint(uint256 quantity, bytes32[] memory proof) external payable {
}
function setRoot(bytes32 root) external onlyOwner{
}
function setAllowListStatus(bool status) external onlyOwner {
}
function isInAllowList(address addr, bytes32[] memory proof) public view returns(bool) {
}
}
| totalSupply()+quantities[j]<=collectionSize,"Too many already minted before dev mint." | 225,922 | totalSupply()+quantities[j]<=collectionSize |
"Invalid Merkle Proof." | // SPDX-License-Identifier: MIT
/**
_
/\ | |
/ \ _ __ ___ __ _ __| | ___ _ _ ___
/ /\ \ | '_ ` _ \ / _` |/ _` |/ _ | | | / __|
/ ____ \| | | | | | (_| | (_| | __| |_| \__ \
/_/ \_|_| |_| |_|\__,_|\__,_|\___|\__,_|___/
@developer:CivilLabs_Amadeus
*/
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
library MerkleProof {
/**
* @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
* defined by `root`. For this, a `proof` must be provided, containing
* sibling hashes on the branch from the leaf to the root of the tree. Each
* pair of leaves and each pair of pre-images are assumed to be sorted.
*/
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
}
/**
* @dev Returns the rebuilt hash obtained by traversing a Merklee tree up
* from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
* hash matches the root of the tree. When processing the proof, the pairs
* of leafs & pre-images are assumed to be sorted.
*
* _Available since v4.4._
*/
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
}
}
contract TheTruthPassBySixSence is Ownable, ERC721A, ReentrancyGuard {
constructor(
) ERC721A("TheTruth Pass by SixSence", "TT", 8, 444) {}
modifier callerIsUser() {
}
// For marketing etc.
function reserveMintBatch(uint256[] calldata quantities, address[] calldata tos) external onlyOwner {
}
// metadata URI
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdrawMoney() external onlyOwner nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function refundIfOver(uint256 price) private {
}
// allowList mint
uint256 public allowListMintPrice = 0.000000 ether;
// default false
bool public allowListStatus = false;
uint256 public amountForAllowList = 400;
uint256 public immutable maxPerAddressDuringMint = 1;
bytes32 private merkleRoot;
mapping(address => bool) public allowListAppeared;
mapping(address => uint256) public allowListStock;
function allowListMint(uint256 quantity, bytes32[] memory proof) external payable {
require(allowListStatus, "not begun");
require(totalSupply() + quantity <= collectionSize, "reached max supply");
require(amountForAllowList >= quantity, "reached max amount");
require(<FILL_ME>)
if(!allowListAppeared[msg.sender]){
allowListAppeared[msg.sender] = true;
allowListStock[msg.sender] = maxPerAddressDuringMint;
}
require(allowListStock[msg.sender] >= quantity, "reached amount per address");
allowListStock[msg.sender] -= quantity;
_safeMint(msg.sender, quantity);
amountForAllowList -= quantity;
refundIfOver(allowListMintPrice*quantity);
}
function setRoot(bytes32 root) external onlyOwner{
}
function setAllowListStatus(bool status) external onlyOwner {
}
function isInAllowList(address addr, bytes32[] memory proof) public view returns(bool) {
}
}
| isInAllowList(msg.sender,proof),"Invalid Merkle Proof." | 225,922 | isInAllowList(msg.sender,proof) |
"reached amount per address" | // SPDX-License-Identifier: MIT
/**
_
/\ | |
/ \ _ __ ___ __ _ __| | ___ _ _ ___
/ /\ \ | '_ ` _ \ / _` |/ _` |/ _ | | | / __|
/ ____ \| | | | | | (_| | (_| | __| |_| \__ \
/_/ \_|_| |_| |_|\__,_|\__,_|\___|\__,_|___/
@developer:CivilLabs_Amadeus
*/
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
library MerkleProof {
/**
* @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
* defined by `root`. For this, a `proof` must be provided, containing
* sibling hashes on the branch from the leaf to the root of the tree. Each
* pair of leaves and each pair of pre-images are assumed to be sorted.
*/
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
}
/**
* @dev Returns the rebuilt hash obtained by traversing a Merklee tree up
* from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
* hash matches the root of the tree. When processing the proof, the pairs
* of leafs & pre-images are assumed to be sorted.
*
* _Available since v4.4._
*/
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
}
}
contract TheTruthPassBySixSence is Ownable, ERC721A, ReentrancyGuard {
constructor(
) ERC721A("TheTruth Pass by SixSence", "TT", 8, 444) {}
modifier callerIsUser() {
}
// For marketing etc.
function reserveMintBatch(uint256[] calldata quantities, address[] calldata tos) external onlyOwner {
}
// metadata URI
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdrawMoney() external onlyOwner nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function refundIfOver(uint256 price) private {
}
// allowList mint
uint256 public allowListMintPrice = 0.000000 ether;
// default false
bool public allowListStatus = false;
uint256 public amountForAllowList = 400;
uint256 public immutable maxPerAddressDuringMint = 1;
bytes32 private merkleRoot;
mapping(address => bool) public allowListAppeared;
mapping(address => uint256) public allowListStock;
function allowListMint(uint256 quantity, bytes32[] memory proof) external payable {
require(allowListStatus, "not begun");
require(totalSupply() + quantity <= collectionSize, "reached max supply");
require(amountForAllowList >= quantity, "reached max amount");
require(isInAllowList(msg.sender, proof), "Invalid Merkle Proof.");
if(!allowListAppeared[msg.sender]){
allowListAppeared[msg.sender] = true;
allowListStock[msg.sender] = maxPerAddressDuringMint;
}
require(<FILL_ME>)
allowListStock[msg.sender] -= quantity;
_safeMint(msg.sender, quantity);
amountForAllowList -= quantity;
refundIfOver(allowListMintPrice*quantity);
}
function setRoot(bytes32 root) external onlyOwner{
}
function setAllowListStatus(bool status) external onlyOwner {
}
function isInAllowList(address addr, bytes32[] memory proof) public view returns(bool) {
}
}
| allowListStock[msg.sender]>=quantity,"reached amount per address" | 225,922 | allowListStock[msg.sender]>=quantity |
'Wrong msg sender' | pragma solidity >=0.6.6;
// pragma experimental ABIEncoderV2;
contract Market6 is IMarket6, ERC721HolderUpgradeable, OwnableUpgradeable, PausableUpgradeable {
using SafeMathUpgradeable for uint256;
using SafeERC20Upgradeable for IERC20Upgradeable;
using AddressUpgradeable for address;
// using EnumerableMap for EnumerableMap.UintToUintMap;
using EnumerableSetUpgradeable for EnumerableSetUpgradeable.UintSet;
struct AskEntry {
uint nftType;
address seller;
uint256 quantity;
uint256 price;
address quote;
uint256 sold;
address creator;
uint256 rate;
}
// struct AsksMap {
// uint nftType;
// uint256 tokenId;
// address seller;
// uint256 quantity;
// uint256 price;
// address quote;
// uint256 sold;
// address creator;
// uint256 rate;
// }
struct BidEntry {
uint nftType;
address bidder;
uint256 quantity;
uint256 price;
address quote;
}
struct UserBidEntry {
uint256 tokenId;
uint256 price;
}
IERC20Upgradeable public quoteErc20;
address public feeAddr;
uint256 public feePercent;
mapping(address => mapping(uint256 => mapping(bytes32 => AskEntry[]))) private _askTokens;
// mapping(address => AsksMap[]) private _asksMap;
mapping(address => mapping(uint256 => mapping(bytes32 => BidEntry[]))) private _tokenBids;
// TokenId 별로 단 한번의 Bid 만 등록이 가능함. 가격 업데이트는 가능.
mapping(address => mapping(address => mapping(uint256 => uint256))) private _userBids;
// NFT 거래
event Trade(address indexed seller, address indexed buyer, address indexed nft, uint256 tokenId, uint256 quantity, uint256 amount, uint256 price, uint256 fee);
// NFT 판매 등록
event Ask(address indexed seller, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT 판매 등록 취소
event CancelSellToken(address indexed seller, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT Bidding
event Bid(address indexed bidder, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT Bidding 취소
event CancelBidToken(address indexed bidder, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
function initialize(
address _quoteErc20Address,
address _feeAddr,
uint256 _feePercent
) initializer public
{
}
function buyTokenETH(
address _nft,
uint256 _tokenId,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _price
) public payable override whenNotPaused
{
}
function buyTokenToETH(
address _nft,
uint256 _tokenId,
address _to,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _price,
uint256 _maximumPrice
) public payable override whenNotPaused
{
require(<FILL_ME>)
require(_amount > 0, 'Invalid buying amount');
bytes32 _ix = keccak256(abi.encodePacked(_seller, _quantity, _price, address(0)));
uint256 len = _askTokens[_nft][_tokenId][_ix].length;
require(len > 0, 'Token not in sell book');
AskEntry memory selected = _askTokens[_nft][_tokenId][_ix][0];
require(selected.quantity.sub(selected.sold) >= _amount, 'Not enough stocks in this sell book');
if (selected.nftType == 721) {
IERC721Upgradeable(_nft).safeTransferFrom(address(this), _to, _tokenId);
} else if (selected.nftType == 1155) {
IERC1155Upgradeable(_nft).safeTransferFrom(address(this), _to, _tokenId, _amount, '0x');
}
require(selected.price.mul(_amount) <= _maximumPrice, 'invalid price');
uint256 feeAmount = _maximumPrice.mul(feePercent).div(1000);
uint256 earning = _maximumPrice.mul(selected.rate).div(1000);
if (feeAmount != 0) {
TransferHelper.safeTransferETH(feeAddr, feeAmount);
}
if (earning != 0 && selected.creator != address(0)) {
TransferHelper.safeTransferETH(selected.creator, earning);
}
TransferHelper.safeTransferETH(selected.seller, _maximumPrice.sub(feeAmount.add(earning)));
// delete the ask
delAskTokensByTokenId(_nft, _tokenId, _ix, _amount);
emit Trade(selected.seller, _to, _nft, _tokenId, _quantity, _amount, _maximumPrice, feeAmount);
}
function buyToken(
address _nft,
uint256 _tokenId,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _maximumPrice,
address _quote
) public override whenNotPaused
{
}
function buyTokenTo(
address _nft,
uint256 _tokenId,
address _to,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _maximumPrice,
address _quote)
public override whenNotPaused
{
}
// // NFT 판매를 올려놓은 것의 가격을 수정
// // nft: NFT 토큰 주소
// // tokenId: NFT 토큰 아이디
// // price: Wei단위 가격
// function setCurrentPrice(
// address _nft,
// uint256 _tokenId,
// uint256 _quantity,
// uint256 _oldPrice,
// address _oldQuote,
// uint256 _newPrice,
// address _newQuote
// ) public override whenNotPaused
// {
// bytes32 _ix = keccak256(abi.encodePacked(_msgSender(), _quantity, _oldPrice, _oldQuote));
// uint256 len = _askTokens[_nft][_tokenId][_ix].length;
// require(len > 0, 'Token not in sell book');
//
// require(_newPrice != 0, 'Price must be granter than zero');
//
// AskEntry memory selected = _askTokens[_nft][_tokenId][_ix][0];
// selected.price = _newPrice;
// selected.quote = _newQuote;
//
// uint256 length = _asksMap[_nft].length;
// for (uint256 i = 0; i < length ; i++) {
// if (_asksMap[_nft][i].tokenId == _tokenId &&
// _asksMap[_nft][i].seller == _msgSender() &&
// _asksMap[_nft][i].quantity == _quantity &&
// _asksMap[_nft][i].price == _oldPrice &&
// _asksMap[_nft][i].quote == _oldQuote
// ) {
// _asksMap[_nft][i].price = _newPrice;
// _asksMap[_nft][i].quote = _newQuote;
// break;
// }
// }
//
// emit Ask(_msgSender(), _nft, _tokenId, _quantity, _newPrice, _newQuote);
// }
// NFT 판매
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
// price: Wei단위 가격
function readyToSellToken(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
// 특정 유저에 한정해서 NFT를 판매
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
// price: Wei단위 가격
// to: 특정 유저
function readyToSellTokenTo(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
address _to,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
// NFT 판매 취소
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
function cancelSellToken(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
// 컨트랙트 기능 정지
function pause() public onlyOwner whenNotPaused
{
}
// 컨트랙트 기능 정지 해제
function unpause() public onlyOwner whenPaused
{
}
// 거래 수수료 받는 주소 변경
function transferFeeAddress(
address _feeAddr
) public
{
}
// 거래 수수료 퍼센트 변경
function setFeePercent(
uint256 _feePercent
) public onlyOwner
{
}
// NFT Ask 리스트애서 특정 TokenId를 삭제
function delAskTokensByTokenId(
address _nft,
uint256 _tokenId,
bytes32 _ix,
uint256 _amount
) private
{
}
function emergencyWithdraw() public onlyOwner
{
}
// function getNftAllAsks(
// address _nft
// ) external view returns (AsksMap[] memory)
// {
// return _asksMap[_nft];
// }
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external override returns(bytes4)
{
}
function bidToken(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
function bidTokenETH(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price
) public payable override whenNotPaused
{
}
function cancelBidToken(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
function getBidByBidInfo(
address _nft,
uint256 _tokenId,
address _bidder, // bidder
uint256 _quantity,
uint256 _price,
address _quote
) private view returns (BidEntry memory, uint256)
{
}
function delBidByBidInfo(
address _bidder,
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
uint256 _index
) private
{
}
function shareProfits(
address _nft,
uint256 _tokenId,
address _bidder,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) private
{
}
function sellTokenTo(
address _nft,
uint256 _tokenId,
address _bidder,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
function updateBidPrice(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
uint256 _newPrice,
address _quote
) public override whenNotPaused
{
}
function updateBidPriceETH(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
uint256 _newPrice,
address _quote
) public payable override whenNotPaused
{
}
}
| _msgSender()!=address(0)&&_msgSender()!=address(this),'Wrong msg sender' | 226,001 | _msgSender()!=address(0)&&_msgSender()!=address(this) |
'Not enough stocks in this sell book' | pragma solidity >=0.6.6;
// pragma experimental ABIEncoderV2;
contract Market6 is IMarket6, ERC721HolderUpgradeable, OwnableUpgradeable, PausableUpgradeable {
using SafeMathUpgradeable for uint256;
using SafeERC20Upgradeable for IERC20Upgradeable;
using AddressUpgradeable for address;
// using EnumerableMap for EnumerableMap.UintToUintMap;
using EnumerableSetUpgradeable for EnumerableSetUpgradeable.UintSet;
struct AskEntry {
uint nftType;
address seller;
uint256 quantity;
uint256 price;
address quote;
uint256 sold;
address creator;
uint256 rate;
}
// struct AsksMap {
// uint nftType;
// uint256 tokenId;
// address seller;
// uint256 quantity;
// uint256 price;
// address quote;
// uint256 sold;
// address creator;
// uint256 rate;
// }
struct BidEntry {
uint nftType;
address bidder;
uint256 quantity;
uint256 price;
address quote;
}
struct UserBidEntry {
uint256 tokenId;
uint256 price;
}
IERC20Upgradeable public quoteErc20;
address public feeAddr;
uint256 public feePercent;
mapping(address => mapping(uint256 => mapping(bytes32 => AskEntry[]))) private _askTokens;
// mapping(address => AsksMap[]) private _asksMap;
mapping(address => mapping(uint256 => mapping(bytes32 => BidEntry[]))) private _tokenBids;
// TokenId 별로 단 한번의 Bid 만 등록이 가능함. 가격 업데이트는 가능.
mapping(address => mapping(address => mapping(uint256 => uint256))) private _userBids;
// NFT 거래
event Trade(address indexed seller, address indexed buyer, address indexed nft, uint256 tokenId, uint256 quantity, uint256 amount, uint256 price, uint256 fee);
// NFT 판매 등록
event Ask(address indexed seller, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT 판매 등록 취소
event CancelSellToken(address indexed seller, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT Bidding
event Bid(address indexed bidder, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT Bidding 취소
event CancelBidToken(address indexed bidder, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
function initialize(
address _quoteErc20Address,
address _feeAddr,
uint256 _feePercent
) initializer public
{
}
function buyTokenETH(
address _nft,
uint256 _tokenId,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _price
) public payable override whenNotPaused
{
}
function buyTokenToETH(
address _nft,
uint256 _tokenId,
address _to,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _price,
uint256 _maximumPrice
) public payable override whenNotPaused
{
require(_msgSender() != address(0) && _msgSender() != address(this), 'Wrong msg sender');
require(_amount > 0, 'Invalid buying amount');
bytes32 _ix = keccak256(abi.encodePacked(_seller, _quantity, _price, address(0)));
uint256 len = _askTokens[_nft][_tokenId][_ix].length;
require(len > 0, 'Token not in sell book');
AskEntry memory selected = _askTokens[_nft][_tokenId][_ix][0];
require(<FILL_ME>)
if (selected.nftType == 721) {
IERC721Upgradeable(_nft).safeTransferFrom(address(this), _to, _tokenId);
} else if (selected.nftType == 1155) {
IERC1155Upgradeable(_nft).safeTransferFrom(address(this), _to, _tokenId, _amount, '0x');
}
require(selected.price.mul(_amount) <= _maximumPrice, 'invalid price');
uint256 feeAmount = _maximumPrice.mul(feePercent).div(1000);
uint256 earning = _maximumPrice.mul(selected.rate).div(1000);
if (feeAmount != 0) {
TransferHelper.safeTransferETH(feeAddr, feeAmount);
}
if (earning != 0 && selected.creator != address(0)) {
TransferHelper.safeTransferETH(selected.creator, earning);
}
TransferHelper.safeTransferETH(selected.seller, _maximumPrice.sub(feeAmount.add(earning)));
// delete the ask
delAskTokensByTokenId(_nft, _tokenId, _ix, _amount);
emit Trade(selected.seller, _to, _nft, _tokenId, _quantity, _amount, _maximumPrice, feeAmount);
}
function buyToken(
address _nft,
uint256 _tokenId,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _maximumPrice,
address _quote
) public override whenNotPaused
{
}
function buyTokenTo(
address _nft,
uint256 _tokenId,
address _to,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _maximumPrice,
address _quote)
public override whenNotPaused
{
}
// // NFT 판매를 올려놓은 것의 가격을 수정
// // nft: NFT 토큰 주소
// // tokenId: NFT 토큰 아이디
// // price: Wei단위 가격
// function setCurrentPrice(
// address _nft,
// uint256 _tokenId,
// uint256 _quantity,
// uint256 _oldPrice,
// address _oldQuote,
// uint256 _newPrice,
// address _newQuote
// ) public override whenNotPaused
// {
// bytes32 _ix = keccak256(abi.encodePacked(_msgSender(), _quantity, _oldPrice, _oldQuote));
// uint256 len = _askTokens[_nft][_tokenId][_ix].length;
// require(len > 0, 'Token not in sell book');
//
// require(_newPrice != 0, 'Price must be granter than zero');
//
// AskEntry memory selected = _askTokens[_nft][_tokenId][_ix][0];
// selected.price = _newPrice;
// selected.quote = _newQuote;
//
// uint256 length = _asksMap[_nft].length;
// for (uint256 i = 0; i < length ; i++) {
// if (_asksMap[_nft][i].tokenId == _tokenId &&
// _asksMap[_nft][i].seller == _msgSender() &&
// _asksMap[_nft][i].quantity == _quantity &&
// _asksMap[_nft][i].price == _oldPrice &&
// _asksMap[_nft][i].quote == _oldQuote
// ) {
// _asksMap[_nft][i].price = _newPrice;
// _asksMap[_nft][i].quote = _newQuote;
// break;
// }
// }
//
// emit Ask(_msgSender(), _nft, _tokenId, _quantity, _newPrice, _newQuote);
// }
// NFT 판매
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
// price: Wei단위 가격
function readyToSellToken(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
// 특정 유저에 한정해서 NFT를 판매
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
// price: Wei단위 가격
// to: 특정 유저
function readyToSellTokenTo(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
address _to,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
// NFT 판매 취소
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
function cancelSellToken(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
// 컨트랙트 기능 정지
function pause() public onlyOwner whenNotPaused
{
}
// 컨트랙트 기능 정지 해제
function unpause() public onlyOwner whenPaused
{
}
// 거래 수수료 받는 주소 변경
function transferFeeAddress(
address _feeAddr
) public
{
}
// 거래 수수료 퍼센트 변경
function setFeePercent(
uint256 _feePercent
) public onlyOwner
{
}
// NFT Ask 리스트애서 특정 TokenId를 삭제
function delAskTokensByTokenId(
address _nft,
uint256 _tokenId,
bytes32 _ix,
uint256 _amount
) private
{
}
function emergencyWithdraw() public onlyOwner
{
}
// function getNftAllAsks(
// address _nft
// ) external view returns (AsksMap[] memory)
// {
// return _asksMap[_nft];
// }
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external override returns(bytes4)
{
}
function bidToken(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
function bidTokenETH(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price
) public payable override whenNotPaused
{
}
function cancelBidToken(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
function getBidByBidInfo(
address _nft,
uint256 _tokenId,
address _bidder, // bidder
uint256 _quantity,
uint256 _price,
address _quote
) private view returns (BidEntry memory, uint256)
{
}
function delBidByBidInfo(
address _bidder,
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
uint256 _index
) private
{
}
function shareProfits(
address _nft,
uint256 _tokenId,
address _bidder,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) private
{
}
function sellTokenTo(
address _nft,
uint256 _tokenId,
address _bidder,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
function updateBidPrice(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
uint256 _newPrice,
address _quote
) public override whenNotPaused
{
}
function updateBidPriceETH(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
uint256 _newPrice,
address _quote
) public payable override whenNotPaused
{
}
}
| selected.quantity.sub(selected.sold)>=_amount,'Not enough stocks in this sell book' | 226,001 | selected.quantity.sub(selected.sold)>=_amount |
'invalid price' | pragma solidity >=0.6.6;
// pragma experimental ABIEncoderV2;
contract Market6 is IMarket6, ERC721HolderUpgradeable, OwnableUpgradeable, PausableUpgradeable {
using SafeMathUpgradeable for uint256;
using SafeERC20Upgradeable for IERC20Upgradeable;
using AddressUpgradeable for address;
// using EnumerableMap for EnumerableMap.UintToUintMap;
using EnumerableSetUpgradeable for EnumerableSetUpgradeable.UintSet;
struct AskEntry {
uint nftType;
address seller;
uint256 quantity;
uint256 price;
address quote;
uint256 sold;
address creator;
uint256 rate;
}
// struct AsksMap {
// uint nftType;
// uint256 tokenId;
// address seller;
// uint256 quantity;
// uint256 price;
// address quote;
// uint256 sold;
// address creator;
// uint256 rate;
// }
struct BidEntry {
uint nftType;
address bidder;
uint256 quantity;
uint256 price;
address quote;
}
struct UserBidEntry {
uint256 tokenId;
uint256 price;
}
IERC20Upgradeable public quoteErc20;
address public feeAddr;
uint256 public feePercent;
mapping(address => mapping(uint256 => mapping(bytes32 => AskEntry[]))) private _askTokens;
// mapping(address => AsksMap[]) private _asksMap;
mapping(address => mapping(uint256 => mapping(bytes32 => BidEntry[]))) private _tokenBids;
// TokenId 별로 단 한번의 Bid 만 등록이 가능함. 가격 업데이트는 가능.
mapping(address => mapping(address => mapping(uint256 => uint256))) private _userBids;
// NFT 거래
event Trade(address indexed seller, address indexed buyer, address indexed nft, uint256 tokenId, uint256 quantity, uint256 amount, uint256 price, uint256 fee);
// NFT 판매 등록
event Ask(address indexed seller, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT 판매 등록 취소
event CancelSellToken(address indexed seller, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT Bidding
event Bid(address indexed bidder, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT Bidding 취소
event CancelBidToken(address indexed bidder, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
function initialize(
address _quoteErc20Address,
address _feeAddr,
uint256 _feePercent
) initializer public
{
}
function buyTokenETH(
address _nft,
uint256 _tokenId,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _price
) public payable override whenNotPaused
{
}
function buyTokenToETH(
address _nft,
uint256 _tokenId,
address _to,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _price,
uint256 _maximumPrice
) public payable override whenNotPaused
{
require(_msgSender() != address(0) && _msgSender() != address(this), 'Wrong msg sender');
require(_amount > 0, 'Invalid buying amount');
bytes32 _ix = keccak256(abi.encodePacked(_seller, _quantity, _price, address(0)));
uint256 len = _askTokens[_nft][_tokenId][_ix].length;
require(len > 0, 'Token not in sell book');
AskEntry memory selected = _askTokens[_nft][_tokenId][_ix][0];
require(selected.quantity.sub(selected.sold) >= _amount, 'Not enough stocks in this sell book');
if (selected.nftType == 721) {
IERC721Upgradeable(_nft).safeTransferFrom(address(this), _to, _tokenId);
} else if (selected.nftType == 1155) {
IERC1155Upgradeable(_nft).safeTransferFrom(address(this), _to, _tokenId, _amount, '0x');
}
require(<FILL_ME>)
uint256 feeAmount = _maximumPrice.mul(feePercent).div(1000);
uint256 earning = _maximumPrice.mul(selected.rate).div(1000);
if (feeAmount != 0) {
TransferHelper.safeTransferETH(feeAddr, feeAmount);
}
if (earning != 0 && selected.creator != address(0)) {
TransferHelper.safeTransferETH(selected.creator, earning);
}
TransferHelper.safeTransferETH(selected.seller, _maximumPrice.sub(feeAmount.add(earning)));
// delete the ask
delAskTokensByTokenId(_nft, _tokenId, _ix, _amount);
emit Trade(selected.seller, _to, _nft, _tokenId, _quantity, _amount, _maximumPrice, feeAmount);
}
function buyToken(
address _nft,
uint256 _tokenId,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _maximumPrice,
address _quote
) public override whenNotPaused
{
}
function buyTokenTo(
address _nft,
uint256 _tokenId,
address _to,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _maximumPrice,
address _quote)
public override whenNotPaused
{
}
// // NFT 판매를 올려놓은 것의 가격을 수정
// // nft: NFT 토큰 주소
// // tokenId: NFT 토큰 아이디
// // price: Wei단위 가격
// function setCurrentPrice(
// address _nft,
// uint256 _tokenId,
// uint256 _quantity,
// uint256 _oldPrice,
// address _oldQuote,
// uint256 _newPrice,
// address _newQuote
// ) public override whenNotPaused
// {
// bytes32 _ix = keccak256(abi.encodePacked(_msgSender(), _quantity, _oldPrice, _oldQuote));
// uint256 len = _askTokens[_nft][_tokenId][_ix].length;
// require(len > 0, 'Token not in sell book');
//
// require(_newPrice != 0, 'Price must be granter than zero');
//
// AskEntry memory selected = _askTokens[_nft][_tokenId][_ix][0];
// selected.price = _newPrice;
// selected.quote = _newQuote;
//
// uint256 length = _asksMap[_nft].length;
// for (uint256 i = 0; i < length ; i++) {
// if (_asksMap[_nft][i].tokenId == _tokenId &&
// _asksMap[_nft][i].seller == _msgSender() &&
// _asksMap[_nft][i].quantity == _quantity &&
// _asksMap[_nft][i].price == _oldPrice &&
// _asksMap[_nft][i].quote == _oldQuote
// ) {
// _asksMap[_nft][i].price = _newPrice;
// _asksMap[_nft][i].quote = _newQuote;
// break;
// }
// }
//
// emit Ask(_msgSender(), _nft, _tokenId, _quantity, _newPrice, _newQuote);
// }
// NFT 판매
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
// price: Wei단위 가격
function readyToSellToken(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
// 특정 유저에 한정해서 NFT를 판매
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
// price: Wei단위 가격
// to: 특정 유저
function readyToSellTokenTo(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
address _to,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
// NFT 판매 취소
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
function cancelSellToken(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
// 컨트랙트 기능 정지
function pause() public onlyOwner whenNotPaused
{
}
// 컨트랙트 기능 정지 해제
function unpause() public onlyOwner whenPaused
{
}
// 거래 수수료 받는 주소 변경
function transferFeeAddress(
address _feeAddr
) public
{
}
// 거래 수수료 퍼센트 변경
function setFeePercent(
uint256 _feePercent
) public onlyOwner
{
}
// NFT Ask 리스트애서 특정 TokenId를 삭제
function delAskTokensByTokenId(
address _nft,
uint256 _tokenId,
bytes32 _ix,
uint256 _amount
) private
{
}
function emergencyWithdraw() public onlyOwner
{
}
// function getNftAllAsks(
// address _nft
// ) external view returns (AsksMap[] memory)
// {
// return _asksMap[_nft];
// }
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external override returns(bytes4)
{
}
function bidToken(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
function bidTokenETH(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price
) public payable override whenNotPaused
{
}
function cancelBidToken(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
function getBidByBidInfo(
address _nft,
uint256 _tokenId,
address _bidder, // bidder
uint256 _quantity,
uint256 _price,
address _quote
) private view returns (BidEntry memory, uint256)
{
}
function delBidByBidInfo(
address _bidder,
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
uint256 _index
) private
{
}
function shareProfits(
address _nft,
uint256 _tokenId,
address _bidder,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) private
{
}
function sellTokenTo(
address _nft,
uint256 _tokenId,
address _bidder,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
function updateBidPrice(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
uint256 _newPrice,
address _quote
) public override whenNotPaused
{
}
function updateBidPriceETH(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
uint256 _newPrice,
address _quote
) public payable override whenNotPaused
{
}
}
| selected.price.mul(_amount)<=_maximumPrice,'invalid price' | 226,001 | selected.price.mul(_amount)<=_maximumPrice |
'Token not in sell book' | pragma solidity >=0.6.6;
// pragma experimental ABIEncoderV2;
contract Market6 is IMarket6, ERC721HolderUpgradeable, OwnableUpgradeable, PausableUpgradeable {
using SafeMathUpgradeable for uint256;
using SafeERC20Upgradeable for IERC20Upgradeable;
using AddressUpgradeable for address;
// using EnumerableMap for EnumerableMap.UintToUintMap;
using EnumerableSetUpgradeable for EnumerableSetUpgradeable.UintSet;
struct AskEntry {
uint nftType;
address seller;
uint256 quantity;
uint256 price;
address quote;
uint256 sold;
address creator;
uint256 rate;
}
// struct AsksMap {
// uint nftType;
// uint256 tokenId;
// address seller;
// uint256 quantity;
// uint256 price;
// address quote;
// uint256 sold;
// address creator;
// uint256 rate;
// }
struct BidEntry {
uint nftType;
address bidder;
uint256 quantity;
uint256 price;
address quote;
}
struct UserBidEntry {
uint256 tokenId;
uint256 price;
}
IERC20Upgradeable public quoteErc20;
address public feeAddr;
uint256 public feePercent;
mapping(address => mapping(uint256 => mapping(bytes32 => AskEntry[]))) private _askTokens;
// mapping(address => AsksMap[]) private _asksMap;
mapping(address => mapping(uint256 => mapping(bytes32 => BidEntry[]))) private _tokenBids;
// TokenId 별로 단 한번의 Bid 만 등록이 가능함. 가격 업데이트는 가능.
mapping(address => mapping(address => mapping(uint256 => uint256))) private _userBids;
// NFT 거래
event Trade(address indexed seller, address indexed buyer, address indexed nft, uint256 tokenId, uint256 quantity, uint256 amount, uint256 price, uint256 fee);
// NFT 판매 등록
event Ask(address indexed seller, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT 판매 등록 취소
event CancelSellToken(address indexed seller, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT Bidding
event Bid(address indexed bidder, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT Bidding 취소
event CancelBidToken(address indexed bidder, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
function initialize(
address _quoteErc20Address,
address _feeAddr,
uint256 _feePercent
) initializer public
{
}
function buyTokenETH(
address _nft,
uint256 _tokenId,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _price
) public payable override whenNotPaused
{
}
function buyTokenToETH(
address _nft,
uint256 _tokenId,
address _to,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _price,
uint256 _maximumPrice
) public payable override whenNotPaused
{
}
function buyToken(
address _nft,
uint256 _tokenId,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _maximumPrice,
address _quote
) public override whenNotPaused
{
}
function buyTokenTo(
address _nft,
uint256 _tokenId,
address _to,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _maximumPrice,
address _quote)
public override whenNotPaused
{
require(_msgSender() != address(0) && _msgSender() != address(this), 'Wrong msg sender');
require(_amount > 0, 'Invalid buying amount');
bytes32 _ix = keccak256(abi.encodePacked(_seller, _quantity, _maximumPrice, _quote));
require(<FILL_ME>)
AskEntry memory selected = _askTokens[_nft][_tokenId][_ix][0];
require(selected.quantity.sub(selected.sold) >= _amount, 'Not enough stocks in this sell book');
if (selected.nftType == 721) {
IERC721Upgradeable(_nft).safeTransferFrom(address(this), _to, _tokenId);
} else if (selected.nftType == 1155) {
IERC1155Upgradeable(_nft).safeTransferFrom(address(this), _to, _tokenId, _amount, '0x');
}
require(selected.price <= _maximumPrice, 'invalid price');
uint256 totalPrice = selected.price.mul(_amount);
uint256 feeAmount = totalPrice.mul(feePercent).div(1000);
uint256 earning = totalPrice.mul(selected.rate).div(1000);
if (feeAmount != 0) {
// quoteErc20.safeTransferFrom(_msgSender(), feeAddr, feeAmount);
IERC20Upgradeable(selected.quote).safeTransferFrom(_msgSender(), feeAddr, feeAmount);
}
if (earning != 0 && selected.creator != address(0)) {
IERC20Upgradeable(selected.quote).safeTransferFrom(_msgSender(), selected.creator, earning);
}
IERC20Upgradeable(selected.quote).safeTransferFrom(_msgSender(), selected.seller, totalPrice.sub(feeAmount.add(earning)));
// delete the ask
delAskTokensByTokenId(_nft, _tokenId, _ix, _amount);
emit Trade(selected.seller, _to, _nft, _tokenId, _quantity, _amount, totalPrice, feeAmount);
}
// // NFT 판매를 올려놓은 것의 가격을 수정
// // nft: NFT 토큰 주소
// // tokenId: NFT 토큰 아이디
// // price: Wei단위 가격
// function setCurrentPrice(
// address _nft,
// uint256 _tokenId,
// uint256 _quantity,
// uint256 _oldPrice,
// address _oldQuote,
// uint256 _newPrice,
// address _newQuote
// ) public override whenNotPaused
// {
// bytes32 _ix = keccak256(abi.encodePacked(_msgSender(), _quantity, _oldPrice, _oldQuote));
// uint256 len = _askTokens[_nft][_tokenId][_ix].length;
// require(len > 0, 'Token not in sell book');
//
// require(_newPrice != 0, 'Price must be granter than zero');
//
// AskEntry memory selected = _askTokens[_nft][_tokenId][_ix][0];
// selected.price = _newPrice;
// selected.quote = _newQuote;
//
// uint256 length = _asksMap[_nft].length;
// for (uint256 i = 0; i < length ; i++) {
// if (_asksMap[_nft][i].tokenId == _tokenId &&
// _asksMap[_nft][i].seller == _msgSender() &&
// _asksMap[_nft][i].quantity == _quantity &&
// _asksMap[_nft][i].price == _oldPrice &&
// _asksMap[_nft][i].quote == _oldQuote
// ) {
// _asksMap[_nft][i].price = _newPrice;
// _asksMap[_nft][i].quote = _newQuote;
// break;
// }
// }
//
// emit Ask(_msgSender(), _nft, _tokenId, _quantity, _newPrice, _newQuote);
// }
// NFT 판매
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
// price: Wei단위 가격
function readyToSellToken(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
// 특정 유저에 한정해서 NFT를 판매
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
// price: Wei단위 가격
// to: 특정 유저
function readyToSellTokenTo(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
address _to,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
// NFT 판매 취소
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
function cancelSellToken(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
// 컨트랙트 기능 정지
function pause() public onlyOwner whenNotPaused
{
}
// 컨트랙트 기능 정지 해제
function unpause() public onlyOwner whenPaused
{
}
// 거래 수수료 받는 주소 변경
function transferFeeAddress(
address _feeAddr
) public
{
}
// 거래 수수료 퍼센트 변경
function setFeePercent(
uint256 _feePercent
) public onlyOwner
{
}
// NFT Ask 리스트애서 특정 TokenId를 삭제
function delAskTokensByTokenId(
address _nft,
uint256 _tokenId,
bytes32 _ix,
uint256 _amount
) private
{
}
function emergencyWithdraw() public onlyOwner
{
}
// function getNftAllAsks(
// address _nft
// ) external view returns (AsksMap[] memory)
// {
// return _asksMap[_nft];
// }
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external override returns(bytes4)
{
}
function bidToken(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
function bidTokenETH(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price
) public payable override whenNotPaused
{
}
function cancelBidToken(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
function getBidByBidInfo(
address _nft,
uint256 _tokenId,
address _bidder, // bidder
uint256 _quantity,
uint256 _price,
address _quote
) private view returns (BidEntry memory, uint256)
{
}
function delBidByBidInfo(
address _bidder,
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
uint256 _index
) private
{
}
function shareProfits(
address _nft,
uint256 _tokenId,
address _bidder,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) private
{
}
function sellTokenTo(
address _nft,
uint256 _tokenId,
address _bidder,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
function updateBidPrice(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
uint256 _newPrice,
address _quote
) public override whenNotPaused
{
}
function updateBidPriceETH(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
uint256 _newPrice,
address _quote
) public payable override whenNotPaused
{
}
}
| _askTokens[_nft][_tokenId][_ix].length>0,'Token not in sell book' | 226,001 | _askTokens[_nft][_tokenId][_ix].length>0 |
'Only Token Owner can sell token' | pragma solidity >=0.6.6;
// pragma experimental ABIEncoderV2;
contract Market6 is IMarket6, ERC721HolderUpgradeable, OwnableUpgradeable, PausableUpgradeable {
using SafeMathUpgradeable for uint256;
using SafeERC20Upgradeable for IERC20Upgradeable;
using AddressUpgradeable for address;
// using EnumerableMap for EnumerableMap.UintToUintMap;
using EnumerableSetUpgradeable for EnumerableSetUpgradeable.UintSet;
struct AskEntry {
uint nftType;
address seller;
uint256 quantity;
uint256 price;
address quote;
uint256 sold;
address creator;
uint256 rate;
}
// struct AsksMap {
// uint nftType;
// uint256 tokenId;
// address seller;
// uint256 quantity;
// uint256 price;
// address quote;
// uint256 sold;
// address creator;
// uint256 rate;
// }
struct BidEntry {
uint nftType;
address bidder;
uint256 quantity;
uint256 price;
address quote;
}
struct UserBidEntry {
uint256 tokenId;
uint256 price;
}
IERC20Upgradeable public quoteErc20;
address public feeAddr;
uint256 public feePercent;
mapping(address => mapping(uint256 => mapping(bytes32 => AskEntry[]))) private _askTokens;
// mapping(address => AsksMap[]) private _asksMap;
mapping(address => mapping(uint256 => mapping(bytes32 => BidEntry[]))) private _tokenBids;
// TokenId 별로 단 한번의 Bid 만 등록이 가능함. 가격 업데이트는 가능.
mapping(address => mapping(address => mapping(uint256 => uint256))) private _userBids;
// NFT 거래
event Trade(address indexed seller, address indexed buyer, address indexed nft, uint256 tokenId, uint256 quantity, uint256 amount, uint256 price, uint256 fee);
// NFT 판매 등록
event Ask(address indexed seller, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT 판매 등록 취소
event CancelSellToken(address indexed seller, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT Bidding
event Bid(address indexed bidder, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT Bidding 취소
event CancelBidToken(address indexed bidder, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
function initialize(
address _quoteErc20Address,
address _feeAddr,
uint256 _feePercent
) initializer public
{
}
function buyTokenETH(
address _nft,
uint256 _tokenId,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _price
) public payable override whenNotPaused
{
}
function buyTokenToETH(
address _nft,
uint256 _tokenId,
address _to,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _price,
uint256 _maximumPrice
) public payable override whenNotPaused
{
}
function buyToken(
address _nft,
uint256 _tokenId,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _maximumPrice,
address _quote
) public override whenNotPaused
{
}
function buyTokenTo(
address _nft,
uint256 _tokenId,
address _to,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _maximumPrice,
address _quote)
public override whenNotPaused
{
}
// // NFT 판매를 올려놓은 것의 가격을 수정
// // nft: NFT 토큰 주소
// // tokenId: NFT 토큰 아이디
// // price: Wei단위 가격
// function setCurrentPrice(
// address _nft,
// uint256 _tokenId,
// uint256 _quantity,
// uint256 _oldPrice,
// address _oldQuote,
// uint256 _newPrice,
// address _newQuote
// ) public override whenNotPaused
// {
// bytes32 _ix = keccak256(abi.encodePacked(_msgSender(), _quantity, _oldPrice, _oldQuote));
// uint256 len = _askTokens[_nft][_tokenId][_ix].length;
// require(len > 0, 'Token not in sell book');
//
// require(_newPrice != 0, 'Price must be granter than zero');
//
// AskEntry memory selected = _askTokens[_nft][_tokenId][_ix][0];
// selected.price = _newPrice;
// selected.quote = _newQuote;
//
// uint256 length = _asksMap[_nft].length;
// for (uint256 i = 0; i < length ; i++) {
// if (_asksMap[_nft][i].tokenId == _tokenId &&
// _asksMap[_nft][i].seller == _msgSender() &&
// _asksMap[_nft][i].quantity == _quantity &&
// _asksMap[_nft][i].price == _oldPrice &&
// _asksMap[_nft][i].quote == _oldQuote
// ) {
// _asksMap[_nft][i].price = _newPrice;
// _asksMap[_nft][i].quote = _newQuote;
// break;
// }
// }
//
// emit Ask(_msgSender(), _nft, _tokenId, _quantity, _newPrice, _newQuote);
// }
// NFT 판매
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
// price: Wei단위 가격
function readyToSellToken(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
// 특정 유저에 한정해서 NFT를 판매
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
// price: Wei단위 가격
// to: 특정 유저
function readyToSellTokenTo(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
address _to,
address _creator,
uint256 _rate
) public override whenNotPaused
{
if (_nftType == 721) {
require(<FILL_ME>)
} else if (_nftType == 1155) {
require(IERC1155Upgradeable(_nft).balanceOf(_msgSender(), _tokenId) >= _quantity, 'Only Token Owner can sell token');
}
require(_price != 0, 'Price must be granter than zero');
if (_nftType == 721) {
IERC721Upgradeable(_nft).safeTransferFrom(_msgSender(), address(this), _tokenId);
} else if (_nftType == 1155) {
IERC1155Upgradeable(_nft).safeTransferFrom(_msgSender(), address(this), _tokenId, _quantity, '0x');
}
bytes32 _ix = keccak256(abi.encodePacked(_to, _quantity, _price, _quote));
// add the ask
_askTokens[_nft][_tokenId][_ix].push(AskEntry({nftType: _nftType, seller: _to, quantity: _quantity, price: _price, quote: _quote, sold: 0, creator: _creator, rate: _rate}));
emit Ask(_to, _nft, _tokenId, _quantity, _price, _quote);
}
// NFT 판매 취소
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
function cancelSellToken(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
// 컨트랙트 기능 정지
function pause() public onlyOwner whenNotPaused
{
}
// 컨트랙트 기능 정지 해제
function unpause() public onlyOwner whenPaused
{
}
// 거래 수수료 받는 주소 변경
function transferFeeAddress(
address _feeAddr
) public
{
}
// 거래 수수료 퍼센트 변경
function setFeePercent(
uint256 _feePercent
) public onlyOwner
{
}
// NFT Ask 리스트애서 특정 TokenId를 삭제
function delAskTokensByTokenId(
address _nft,
uint256 _tokenId,
bytes32 _ix,
uint256 _amount
) private
{
}
function emergencyWithdraw() public onlyOwner
{
}
// function getNftAllAsks(
// address _nft
// ) external view returns (AsksMap[] memory)
// {
// return _asksMap[_nft];
// }
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external override returns(bytes4)
{
}
function bidToken(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
function bidTokenETH(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price
) public payable override whenNotPaused
{
}
function cancelBidToken(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
function getBidByBidInfo(
address _nft,
uint256 _tokenId,
address _bidder, // bidder
uint256 _quantity,
uint256 _price,
address _quote
) private view returns (BidEntry memory, uint256)
{
}
function delBidByBidInfo(
address _bidder,
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
uint256 _index
) private
{
}
function shareProfits(
address _nft,
uint256 _tokenId,
address _bidder,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) private
{
}
function sellTokenTo(
address _nft,
uint256 _tokenId,
address _bidder,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
function updateBidPrice(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
uint256 _newPrice,
address _quote
) public override whenNotPaused
{
}
function updateBidPriceETH(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
uint256 _newPrice,
address _quote
) public payable override whenNotPaused
{
}
}
| _msgSender()==IERC721Upgradeable(_nft).ownerOf(_tokenId),'Only Token Owner can sell token' | 226,001 | _msgSender()==IERC721Upgradeable(_nft).ownerOf(_tokenId) |
'Only Token Owner can sell token' | pragma solidity >=0.6.6;
// pragma experimental ABIEncoderV2;
contract Market6 is IMarket6, ERC721HolderUpgradeable, OwnableUpgradeable, PausableUpgradeable {
using SafeMathUpgradeable for uint256;
using SafeERC20Upgradeable for IERC20Upgradeable;
using AddressUpgradeable for address;
// using EnumerableMap for EnumerableMap.UintToUintMap;
using EnumerableSetUpgradeable for EnumerableSetUpgradeable.UintSet;
struct AskEntry {
uint nftType;
address seller;
uint256 quantity;
uint256 price;
address quote;
uint256 sold;
address creator;
uint256 rate;
}
// struct AsksMap {
// uint nftType;
// uint256 tokenId;
// address seller;
// uint256 quantity;
// uint256 price;
// address quote;
// uint256 sold;
// address creator;
// uint256 rate;
// }
struct BidEntry {
uint nftType;
address bidder;
uint256 quantity;
uint256 price;
address quote;
}
struct UserBidEntry {
uint256 tokenId;
uint256 price;
}
IERC20Upgradeable public quoteErc20;
address public feeAddr;
uint256 public feePercent;
mapping(address => mapping(uint256 => mapping(bytes32 => AskEntry[]))) private _askTokens;
// mapping(address => AsksMap[]) private _asksMap;
mapping(address => mapping(uint256 => mapping(bytes32 => BidEntry[]))) private _tokenBids;
// TokenId 별로 단 한번의 Bid 만 등록이 가능함. 가격 업데이트는 가능.
mapping(address => mapping(address => mapping(uint256 => uint256))) private _userBids;
// NFT 거래
event Trade(address indexed seller, address indexed buyer, address indexed nft, uint256 tokenId, uint256 quantity, uint256 amount, uint256 price, uint256 fee);
// NFT 판매 등록
event Ask(address indexed seller, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT 판매 등록 취소
event CancelSellToken(address indexed seller, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT Bidding
event Bid(address indexed bidder, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT Bidding 취소
event CancelBidToken(address indexed bidder, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
function initialize(
address _quoteErc20Address,
address _feeAddr,
uint256 _feePercent
) initializer public
{
}
function buyTokenETH(
address _nft,
uint256 _tokenId,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _price
) public payable override whenNotPaused
{
}
function buyTokenToETH(
address _nft,
uint256 _tokenId,
address _to,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _price,
uint256 _maximumPrice
) public payable override whenNotPaused
{
}
function buyToken(
address _nft,
uint256 _tokenId,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _maximumPrice,
address _quote
) public override whenNotPaused
{
}
function buyTokenTo(
address _nft,
uint256 _tokenId,
address _to,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _maximumPrice,
address _quote)
public override whenNotPaused
{
}
// // NFT 판매를 올려놓은 것의 가격을 수정
// // nft: NFT 토큰 주소
// // tokenId: NFT 토큰 아이디
// // price: Wei단위 가격
// function setCurrentPrice(
// address _nft,
// uint256 _tokenId,
// uint256 _quantity,
// uint256 _oldPrice,
// address _oldQuote,
// uint256 _newPrice,
// address _newQuote
// ) public override whenNotPaused
// {
// bytes32 _ix = keccak256(abi.encodePacked(_msgSender(), _quantity, _oldPrice, _oldQuote));
// uint256 len = _askTokens[_nft][_tokenId][_ix].length;
// require(len > 0, 'Token not in sell book');
//
// require(_newPrice != 0, 'Price must be granter than zero');
//
// AskEntry memory selected = _askTokens[_nft][_tokenId][_ix][0];
// selected.price = _newPrice;
// selected.quote = _newQuote;
//
// uint256 length = _asksMap[_nft].length;
// for (uint256 i = 0; i < length ; i++) {
// if (_asksMap[_nft][i].tokenId == _tokenId &&
// _asksMap[_nft][i].seller == _msgSender() &&
// _asksMap[_nft][i].quantity == _quantity &&
// _asksMap[_nft][i].price == _oldPrice &&
// _asksMap[_nft][i].quote == _oldQuote
// ) {
// _asksMap[_nft][i].price = _newPrice;
// _asksMap[_nft][i].quote = _newQuote;
// break;
// }
// }
//
// emit Ask(_msgSender(), _nft, _tokenId, _quantity, _newPrice, _newQuote);
// }
// NFT 판매
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
// price: Wei단위 가격
function readyToSellToken(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
// 특정 유저에 한정해서 NFT를 판매
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
// price: Wei단위 가격
// to: 특정 유저
function readyToSellTokenTo(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
address _to,
address _creator,
uint256 _rate
) public override whenNotPaused
{
if (_nftType == 721) {
require(_msgSender() == IERC721Upgradeable(_nft).ownerOf(_tokenId), 'Only Token Owner can sell token');
} else if (_nftType == 1155) {
require(<FILL_ME>)
}
require(_price != 0, 'Price must be granter than zero');
if (_nftType == 721) {
IERC721Upgradeable(_nft).safeTransferFrom(_msgSender(), address(this), _tokenId);
} else if (_nftType == 1155) {
IERC1155Upgradeable(_nft).safeTransferFrom(_msgSender(), address(this), _tokenId, _quantity, '0x');
}
bytes32 _ix = keccak256(abi.encodePacked(_to, _quantity, _price, _quote));
// add the ask
_askTokens[_nft][_tokenId][_ix].push(AskEntry({nftType: _nftType, seller: _to, quantity: _quantity, price: _price, quote: _quote, sold: 0, creator: _creator, rate: _rate}));
emit Ask(_to, _nft, _tokenId, _quantity, _price, _quote);
}
// NFT 판매 취소
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
function cancelSellToken(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
// 컨트랙트 기능 정지
function pause() public onlyOwner whenNotPaused
{
}
// 컨트랙트 기능 정지 해제
function unpause() public onlyOwner whenPaused
{
}
// 거래 수수료 받는 주소 변경
function transferFeeAddress(
address _feeAddr
) public
{
}
// 거래 수수료 퍼센트 변경
function setFeePercent(
uint256 _feePercent
) public onlyOwner
{
}
// NFT Ask 리스트애서 특정 TokenId를 삭제
function delAskTokensByTokenId(
address _nft,
uint256 _tokenId,
bytes32 _ix,
uint256 _amount
) private
{
}
function emergencyWithdraw() public onlyOwner
{
}
// function getNftAllAsks(
// address _nft
// ) external view returns (AsksMap[] memory)
// {
// return _asksMap[_nft];
// }
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external override returns(bytes4)
{
}
function bidToken(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
function bidTokenETH(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price
) public payable override whenNotPaused
{
}
function cancelBidToken(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
function getBidByBidInfo(
address _nft,
uint256 _tokenId,
address _bidder, // bidder
uint256 _quantity,
uint256 _price,
address _quote
) private view returns (BidEntry memory, uint256)
{
}
function delBidByBidInfo(
address _bidder,
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
uint256 _index
) private
{
}
function shareProfits(
address _nft,
uint256 _tokenId,
address _bidder,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) private
{
}
function sellTokenTo(
address _nft,
uint256 _tokenId,
address _bidder,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
function updateBidPrice(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
uint256 _newPrice,
address _quote
) public override whenNotPaused
{
}
function updateBidPriceETH(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
uint256 _newPrice,
address _quote
) public payable override whenNotPaused
{
}
}
| IERC1155Upgradeable(_nft).balanceOf(_msgSender(),_tokenId)>=_quantity,'Only Token Owner can sell token' | 226,001 | IERC1155Upgradeable(_nft).balanceOf(_msgSender(),_tokenId)>=_quantity |
'FORBIDDEN' | pragma solidity >=0.6.6;
// pragma experimental ABIEncoderV2;
contract Market6 is IMarket6, ERC721HolderUpgradeable, OwnableUpgradeable, PausableUpgradeable {
using SafeMathUpgradeable for uint256;
using SafeERC20Upgradeable for IERC20Upgradeable;
using AddressUpgradeable for address;
// using EnumerableMap for EnumerableMap.UintToUintMap;
using EnumerableSetUpgradeable for EnumerableSetUpgradeable.UintSet;
struct AskEntry {
uint nftType;
address seller;
uint256 quantity;
uint256 price;
address quote;
uint256 sold;
address creator;
uint256 rate;
}
// struct AsksMap {
// uint nftType;
// uint256 tokenId;
// address seller;
// uint256 quantity;
// uint256 price;
// address quote;
// uint256 sold;
// address creator;
// uint256 rate;
// }
struct BidEntry {
uint nftType;
address bidder;
uint256 quantity;
uint256 price;
address quote;
}
struct UserBidEntry {
uint256 tokenId;
uint256 price;
}
IERC20Upgradeable public quoteErc20;
address public feeAddr;
uint256 public feePercent;
mapping(address => mapping(uint256 => mapping(bytes32 => AskEntry[]))) private _askTokens;
// mapping(address => AsksMap[]) private _asksMap;
mapping(address => mapping(uint256 => mapping(bytes32 => BidEntry[]))) private _tokenBids;
// TokenId 별로 단 한번의 Bid 만 등록이 가능함. 가격 업데이트는 가능.
mapping(address => mapping(address => mapping(uint256 => uint256))) private _userBids;
// NFT 거래
event Trade(address indexed seller, address indexed buyer, address indexed nft, uint256 tokenId, uint256 quantity, uint256 amount, uint256 price, uint256 fee);
// NFT 판매 등록
event Ask(address indexed seller, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT 판매 등록 취소
event CancelSellToken(address indexed seller, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT Bidding
event Bid(address indexed bidder, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT Bidding 취소
event CancelBidToken(address indexed bidder, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
function initialize(
address _quoteErc20Address,
address _feeAddr,
uint256 _feePercent
) initializer public
{
}
function buyTokenETH(
address _nft,
uint256 _tokenId,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _price
) public payable override whenNotPaused
{
}
function buyTokenToETH(
address _nft,
uint256 _tokenId,
address _to,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _price,
uint256 _maximumPrice
) public payable override whenNotPaused
{
}
function buyToken(
address _nft,
uint256 _tokenId,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _maximumPrice,
address _quote
) public override whenNotPaused
{
}
function buyTokenTo(
address _nft,
uint256 _tokenId,
address _to,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _maximumPrice,
address _quote)
public override whenNotPaused
{
}
// // NFT 판매를 올려놓은 것의 가격을 수정
// // nft: NFT 토큰 주소
// // tokenId: NFT 토큰 아이디
// // price: Wei단위 가격
// function setCurrentPrice(
// address _nft,
// uint256 _tokenId,
// uint256 _quantity,
// uint256 _oldPrice,
// address _oldQuote,
// uint256 _newPrice,
// address _newQuote
// ) public override whenNotPaused
// {
// bytes32 _ix = keccak256(abi.encodePacked(_msgSender(), _quantity, _oldPrice, _oldQuote));
// uint256 len = _askTokens[_nft][_tokenId][_ix].length;
// require(len > 0, 'Token not in sell book');
//
// require(_newPrice != 0, 'Price must be granter than zero');
//
// AskEntry memory selected = _askTokens[_nft][_tokenId][_ix][0];
// selected.price = _newPrice;
// selected.quote = _newQuote;
//
// uint256 length = _asksMap[_nft].length;
// for (uint256 i = 0; i < length ; i++) {
// if (_asksMap[_nft][i].tokenId == _tokenId &&
// _asksMap[_nft][i].seller == _msgSender() &&
// _asksMap[_nft][i].quantity == _quantity &&
// _asksMap[_nft][i].price == _oldPrice &&
// _asksMap[_nft][i].quote == _oldQuote
// ) {
// _asksMap[_nft][i].price = _newPrice;
// _asksMap[_nft][i].quote = _newQuote;
// break;
// }
// }
//
// emit Ask(_msgSender(), _nft, _tokenId, _quantity, _newPrice, _newQuote);
// }
// NFT 판매
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
// price: Wei단위 가격
function readyToSellToken(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
// 특정 유저에 한정해서 NFT를 판매
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
// price: Wei단위 가격
// to: 특정 유저
function readyToSellTokenTo(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
address _to,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
// NFT 판매 취소
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
function cancelSellToken(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
// 컨트랙트 기능 정지
function pause() public onlyOwner whenNotPaused
{
}
// 컨트랙트 기능 정지 해제
function unpause() public onlyOwner whenPaused
{
}
// 거래 수수료 받는 주소 변경
function transferFeeAddress(
address _feeAddr
) public
{
require(<FILL_ME>)
feeAddr = _feeAddr;
}
// 거래 수수료 퍼센트 변경
function setFeePercent(
uint256 _feePercent
) public onlyOwner
{
}
// NFT Ask 리스트애서 특정 TokenId를 삭제
function delAskTokensByTokenId(
address _nft,
uint256 _tokenId,
bytes32 _ix,
uint256 _amount
) private
{
}
function emergencyWithdraw() public onlyOwner
{
}
// function getNftAllAsks(
// address _nft
// ) external view returns (AsksMap[] memory)
// {
// return _asksMap[_nft];
// }
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external override returns(bytes4)
{
}
function bidToken(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
function bidTokenETH(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price
) public payable override whenNotPaused
{
}
function cancelBidToken(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
function getBidByBidInfo(
address _nft,
uint256 _tokenId,
address _bidder, // bidder
uint256 _quantity,
uint256 _price,
address _quote
) private view returns (BidEntry memory, uint256)
{
}
function delBidByBidInfo(
address _bidder,
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
uint256 _index
) private
{
}
function shareProfits(
address _nft,
uint256 _tokenId,
address _bidder,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) private
{
}
function sellTokenTo(
address _nft,
uint256 _tokenId,
address _bidder,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
function updateBidPrice(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
uint256 _newPrice,
address _quote
) public override whenNotPaused
{
}
function updateBidPriceETH(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
uint256 _newPrice,
address _quote
) public payable override whenNotPaused
{
}
}
| _msgSender()==feeAddr,'FORBIDDEN' | 226,001 | _msgSender()==feeAddr |
'Owner cannot bid' | pragma solidity >=0.6.6;
// pragma experimental ABIEncoderV2;
contract Market6 is IMarket6, ERC721HolderUpgradeable, OwnableUpgradeable, PausableUpgradeable {
using SafeMathUpgradeable for uint256;
using SafeERC20Upgradeable for IERC20Upgradeable;
using AddressUpgradeable for address;
// using EnumerableMap for EnumerableMap.UintToUintMap;
using EnumerableSetUpgradeable for EnumerableSetUpgradeable.UintSet;
struct AskEntry {
uint nftType;
address seller;
uint256 quantity;
uint256 price;
address quote;
uint256 sold;
address creator;
uint256 rate;
}
// struct AsksMap {
// uint nftType;
// uint256 tokenId;
// address seller;
// uint256 quantity;
// uint256 price;
// address quote;
// uint256 sold;
// address creator;
// uint256 rate;
// }
struct BidEntry {
uint nftType;
address bidder;
uint256 quantity;
uint256 price;
address quote;
}
struct UserBidEntry {
uint256 tokenId;
uint256 price;
}
IERC20Upgradeable public quoteErc20;
address public feeAddr;
uint256 public feePercent;
mapping(address => mapping(uint256 => mapping(bytes32 => AskEntry[]))) private _askTokens;
// mapping(address => AsksMap[]) private _asksMap;
mapping(address => mapping(uint256 => mapping(bytes32 => BidEntry[]))) private _tokenBids;
// TokenId 별로 단 한번의 Bid 만 등록이 가능함. 가격 업데이트는 가능.
mapping(address => mapping(address => mapping(uint256 => uint256))) private _userBids;
// NFT 거래
event Trade(address indexed seller, address indexed buyer, address indexed nft, uint256 tokenId, uint256 quantity, uint256 amount, uint256 price, uint256 fee);
// NFT 판매 등록
event Ask(address indexed seller, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT 판매 등록 취소
event CancelSellToken(address indexed seller, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT Bidding
event Bid(address indexed bidder, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT Bidding 취소
event CancelBidToken(address indexed bidder, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
function initialize(
address _quoteErc20Address,
address _feeAddr,
uint256 _feePercent
) initializer public
{
}
function buyTokenETH(
address _nft,
uint256 _tokenId,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _price
) public payable override whenNotPaused
{
}
function buyTokenToETH(
address _nft,
uint256 _tokenId,
address _to,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _price,
uint256 _maximumPrice
) public payable override whenNotPaused
{
}
function buyToken(
address _nft,
uint256 _tokenId,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _maximumPrice,
address _quote
) public override whenNotPaused
{
}
function buyTokenTo(
address _nft,
uint256 _tokenId,
address _to,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _maximumPrice,
address _quote)
public override whenNotPaused
{
}
// // NFT 판매를 올려놓은 것의 가격을 수정
// // nft: NFT 토큰 주소
// // tokenId: NFT 토큰 아이디
// // price: Wei단위 가격
// function setCurrentPrice(
// address _nft,
// uint256 _tokenId,
// uint256 _quantity,
// uint256 _oldPrice,
// address _oldQuote,
// uint256 _newPrice,
// address _newQuote
// ) public override whenNotPaused
// {
// bytes32 _ix = keccak256(abi.encodePacked(_msgSender(), _quantity, _oldPrice, _oldQuote));
// uint256 len = _askTokens[_nft][_tokenId][_ix].length;
// require(len > 0, 'Token not in sell book');
//
// require(_newPrice != 0, 'Price must be granter than zero');
//
// AskEntry memory selected = _askTokens[_nft][_tokenId][_ix][0];
// selected.price = _newPrice;
// selected.quote = _newQuote;
//
// uint256 length = _asksMap[_nft].length;
// for (uint256 i = 0; i < length ; i++) {
// if (_asksMap[_nft][i].tokenId == _tokenId &&
// _asksMap[_nft][i].seller == _msgSender() &&
// _asksMap[_nft][i].quantity == _quantity &&
// _asksMap[_nft][i].price == _oldPrice &&
// _asksMap[_nft][i].quote == _oldQuote
// ) {
// _asksMap[_nft][i].price = _newPrice;
// _asksMap[_nft][i].quote = _newQuote;
// break;
// }
// }
//
// emit Ask(_msgSender(), _nft, _tokenId, _quantity, _newPrice, _newQuote);
// }
// NFT 판매
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
// price: Wei단위 가격
function readyToSellToken(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
// 특정 유저에 한정해서 NFT를 판매
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
// price: Wei단위 가격
// to: 특정 유저
function readyToSellTokenTo(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
address _to,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
// NFT 판매 취소
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
function cancelSellToken(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
// 컨트랙트 기능 정지
function pause() public onlyOwner whenNotPaused
{
}
// 컨트랙트 기능 정지 해제
function unpause() public onlyOwner whenPaused
{
}
// 거래 수수료 받는 주소 변경
function transferFeeAddress(
address _feeAddr
) public
{
}
// 거래 수수료 퍼센트 변경
function setFeePercent(
uint256 _feePercent
) public onlyOwner
{
}
// NFT Ask 리스트애서 특정 TokenId를 삭제
function delAskTokensByTokenId(
address _nft,
uint256 _tokenId,
bytes32 _ix,
uint256 _amount
) private
{
}
function emergencyWithdraw() public onlyOwner
{
}
// function getNftAllAsks(
// address _nft
// ) external view returns (AsksMap[] memory)
// {
// return _asksMap[_nft];
// }
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external override returns(bytes4)
{
}
function bidToken(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
require(_msgSender() != address(0) && _msgSender() != address(this), 'Wrong msg sender');
require(_price != 0, 'Price must be granter than zero');
address _bidder = address(_msgSender());
if (_nftType == 721) {
require(<FILL_ME>)
} else if (_nftType == 1155) {
require(IERC1155Upgradeable(_nft).balanceOf(_bidder, _tokenId) == 0, 'Owner cannot bid');
}
require(_userBids[_nft][_bidder][_tokenId] == 0, 'Bidder already exists');
IERC20Upgradeable(_quote).safeTransferFrom(_msgSender(), address(this), _price.mul(_quantity));
// When ?
_userBids[_nft][_bidder][_tokenId] = _price.mul(_quantity);
bytes32 _ix = keccak256(abi.encodePacked(_bidder, _quantity, _price, _quote));
_tokenBids[_nft][_tokenId][_ix].push(BidEntry({nftType: _nftType, bidder: _bidder, quantity: _quantity, price: _price, quote: _quote}));
emit Bid(_msgSender(), _nft, _tokenId, _quantity, _price, _quote);
}
function bidTokenETH(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price
) public payable override whenNotPaused
{
}
function cancelBidToken(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
function getBidByBidInfo(
address _nft,
uint256 _tokenId,
address _bidder, // bidder
uint256 _quantity,
uint256 _price,
address _quote
) private view returns (BidEntry memory, uint256)
{
}
function delBidByBidInfo(
address _bidder,
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
uint256 _index
) private
{
}
function shareProfits(
address _nft,
uint256 _tokenId,
address _bidder,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) private
{
}
function sellTokenTo(
address _nft,
uint256 _tokenId,
address _bidder,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
function updateBidPrice(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
uint256 _newPrice,
address _quote
) public override whenNotPaused
{
}
function updateBidPriceETH(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
uint256 _newPrice,
address _quote
) public payable override whenNotPaused
{
}
}
| IERC721Upgradeable(_nft).ownerOf(_tokenId)!=_bidder,'Owner cannot bid' | 226,001 | IERC721Upgradeable(_nft).ownerOf(_tokenId)!=_bidder |
'Owner cannot bid' | pragma solidity >=0.6.6;
// pragma experimental ABIEncoderV2;
contract Market6 is IMarket6, ERC721HolderUpgradeable, OwnableUpgradeable, PausableUpgradeable {
using SafeMathUpgradeable for uint256;
using SafeERC20Upgradeable for IERC20Upgradeable;
using AddressUpgradeable for address;
// using EnumerableMap for EnumerableMap.UintToUintMap;
using EnumerableSetUpgradeable for EnumerableSetUpgradeable.UintSet;
struct AskEntry {
uint nftType;
address seller;
uint256 quantity;
uint256 price;
address quote;
uint256 sold;
address creator;
uint256 rate;
}
// struct AsksMap {
// uint nftType;
// uint256 tokenId;
// address seller;
// uint256 quantity;
// uint256 price;
// address quote;
// uint256 sold;
// address creator;
// uint256 rate;
// }
struct BidEntry {
uint nftType;
address bidder;
uint256 quantity;
uint256 price;
address quote;
}
struct UserBidEntry {
uint256 tokenId;
uint256 price;
}
IERC20Upgradeable public quoteErc20;
address public feeAddr;
uint256 public feePercent;
mapping(address => mapping(uint256 => mapping(bytes32 => AskEntry[]))) private _askTokens;
// mapping(address => AsksMap[]) private _asksMap;
mapping(address => mapping(uint256 => mapping(bytes32 => BidEntry[]))) private _tokenBids;
// TokenId 별로 단 한번의 Bid 만 등록이 가능함. 가격 업데이트는 가능.
mapping(address => mapping(address => mapping(uint256 => uint256))) private _userBids;
// NFT 거래
event Trade(address indexed seller, address indexed buyer, address indexed nft, uint256 tokenId, uint256 quantity, uint256 amount, uint256 price, uint256 fee);
// NFT 판매 등록
event Ask(address indexed seller, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT 판매 등록 취소
event CancelSellToken(address indexed seller, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT Bidding
event Bid(address indexed bidder, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT Bidding 취소
event CancelBidToken(address indexed bidder, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
function initialize(
address _quoteErc20Address,
address _feeAddr,
uint256 _feePercent
) initializer public
{
}
function buyTokenETH(
address _nft,
uint256 _tokenId,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _price
) public payable override whenNotPaused
{
}
function buyTokenToETH(
address _nft,
uint256 _tokenId,
address _to,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _price,
uint256 _maximumPrice
) public payable override whenNotPaused
{
}
function buyToken(
address _nft,
uint256 _tokenId,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _maximumPrice,
address _quote
) public override whenNotPaused
{
}
function buyTokenTo(
address _nft,
uint256 _tokenId,
address _to,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _maximumPrice,
address _quote)
public override whenNotPaused
{
}
// // NFT 판매를 올려놓은 것의 가격을 수정
// // nft: NFT 토큰 주소
// // tokenId: NFT 토큰 아이디
// // price: Wei단위 가격
// function setCurrentPrice(
// address _nft,
// uint256 _tokenId,
// uint256 _quantity,
// uint256 _oldPrice,
// address _oldQuote,
// uint256 _newPrice,
// address _newQuote
// ) public override whenNotPaused
// {
// bytes32 _ix = keccak256(abi.encodePacked(_msgSender(), _quantity, _oldPrice, _oldQuote));
// uint256 len = _askTokens[_nft][_tokenId][_ix].length;
// require(len > 0, 'Token not in sell book');
//
// require(_newPrice != 0, 'Price must be granter than zero');
//
// AskEntry memory selected = _askTokens[_nft][_tokenId][_ix][0];
// selected.price = _newPrice;
// selected.quote = _newQuote;
//
// uint256 length = _asksMap[_nft].length;
// for (uint256 i = 0; i < length ; i++) {
// if (_asksMap[_nft][i].tokenId == _tokenId &&
// _asksMap[_nft][i].seller == _msgSender() &&
// _asksMap[_nft][i].quantity == _quantity &&
// _asksMap[_nft][i].price == _oldPrice &&
// _asksMap[_nft][i].quote == _oldQuote
// ) {
// _asksMap[_nft][i].price = _newPrice;
// _asksMap[_nft][i].quote = _newQuote;
// break;
// }
// }
//
// emit Ask(_msgSender(), _nft, _tokenId, _quantity, _newPrice, _newQuote);
// }
// NFT 판매
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
// price: Wei단위 가격
function readyToSellToken(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
// 특정 유저에 한정해서 NFT를 판매
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
// price: Wei단위 가격
// to: 특정 유저
function readyToSellTokenTo(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
address _to,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
// NFT 판매 취소
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
function cancelSellToken(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
// 컨트랙트 기능 정지
function pause() public onlyOwner whenNotPaused
{
}
// 컨트랙트 기능 정지 해제
function unpause() public onlyOwner whenPaused
{
}
// 거래 수수료 받는 주소 변경
function transferFeeAddress(
address _feeAddr
) public
{
}
// 거래 수수료 퍼센트 변경
function setFeePercent(
uint256 _feePercent
) public onlyOwner
{
}
// NFT Ask 리스트애서 특정 TokenId를 삭제
function delAskTokensByTokenId(
address _nft,
uint256 _tokenId,
bytes32 _ix,
uint256 _amount
) private
{
}
function emergencyWithdraw() public onlyOwner
{
}
// function getNftAllAsks(
// address _nft
// ) external view returns (AsksMap[] memory)
// {
// return _asksMap[_nft];
// }
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external override returns(bytes4)
{
}
function bidToken(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
require(_msgSender() != address(0) && _msgSender() != address(this), 'Wrong msg sender');
require(_price != 0, 'Price must be granter than zero');
address _bidder = address(_msgSender());
if (_nftType == 721) {
require(IERC721Upgradeable(_nft).ownerOf(_tokenId) != _bidder, 'Owner cannot bid');
} else if (_nftType == 1155) {
require(<FILL_ME>)
}
require(_userBids[_nft][_bidder][_tokenId] == 0, 'Bidder already exists');
IERC20Upgradeable(_quote).safeTransferFrom(_msgSender(), address(this), _price.mul(_quantity));
// When ?
_userBids[_nft][_bidder][_tokenId] = _price.mul(_quantity);
bytes32 _ix = keccak256(abi.encodePacked(_bidder, _quantity, _price, _quote));
_tokenBids[_nft][_tokenId][_ix].push(BidEntry({nftType: _nftType, bidder: _bidder, quantity: _quantity, price: _price, quote: _quote}));
emit Bid(_msgSender(), _nft, _tokenId, _quantity, _price, _quote);
}
function bidTokenETH(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price
) public payable override whenNotPaused
{
}
function cancelBidToken(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
function getBidByBidInfo(
address _nft,
uint256 _tokenId,
address _bidder, // bidder
uint256 _quantity,
uint256 _price,
address _quote
) private view returns (BidEntry memory, uint256)
{
}
function delBidByBidInfo(
address _bidder,
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
uint256 _index
) private
{
}
function shareProfits(
address _nft,
uint256 _tokenId,
address _bidder,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) private
{
}
function sellTokenTo(
address _nft,
uint256 _tokenId,
address _bidder,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
function updateBidPrice(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
uint256 _newPrice,
address _quote
) public override whenNotPaused
{
}
function updateBidPriceETH(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
uint256 _newPrice,
address _quote
) public payable override whenNotPaused
{
}
}
| IERC1155Upgradeable(_nft).balanceOf(_bidder,_tokenId)==0,'Owner cannot bid' | 226,001 | IERC1155Upgradeable(_nft).balanceOf(_bidder,_tokenId)==0 |
'Bidder already exists' | pragma solidity >=0.6.6;
// pragma experimental ABIEncoderV2;
contract Market6 is IMarket6, ERC721HolderUpgradeable, OwnableUpgradeable, PausableUpgradeable {
using SafeMathUpgradeable for uint256;
using SafeERC20Upgradeable for IERC20Upgradeable;
using AddressUpgradeable for address;
// using EnumerableMap for EnumerableMap.UintToUintMap;
using EnumerableSetUpgradeable for EnumerableSetUpgradeable.UintSet;
struct AskEntry {
uint nftType;
address seller;
uint256 quantity;
uint256 price;
address quote;
uint256 sold;
address creator;
uint256 rate;
}
// struct AsksMap {
// uint nftType;
// uint256 tokenId;
// address seller;
// uint256 quantity;
// uint256 price;
// address quote;
// uint256 sold;
// address creator;
// uint256 rate;
// }
struct BidEntry {
uint nftType;
address bidder;
uint256 quantity;
uint256 price;
address quote;
}
struct UserBidEntry {
uint256 tokenId;
uint256 price;
}
IERC20Upgradeable public quoteErc20;
address public feeAddr;
uint256 public feePercent;
mapping(address => mapping(uint256 => mapping(bytes32 => AskEntry[]))) private _askTokens;
// mapping(address => AsksMap[]) private _asksMap;
mapping(address => mapping(uint256 => mapping(bytes32 => BidEntry[]))) private _tokenBids;
// TokenId 별로 단 한번의 Bid 만 등록이 가능함. 가격 업데이트는 가능.
mapping(address => mapping(address => mapping(uint256 => uint256))) private _userBids;
// NFT 거래
event Trade(address indexed seller, address indexed buyer, address indexed nft, uint256 tokenId, uint256 quantity, uint256 amount, uint256 price, uint256 fee);
// NFT 판매 등록
event Ask(address indexed seller, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT 판매 등록 취소
event CancelSellToken(address indexed seller, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT Bidding
event Bid(address indexed bidder, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT Bidding 취소
event CancelBidToken(address indexed bidder, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
function initialize(
address _quoteErc20Address,
address _feeAddr,
uint256 _feePercent
) initializer public
{
}
function buyTokenETH(
address _nft,
uint256 _tokenId,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _price
) public payable override whenNotPaused
{
}
function buyTokenToETH(
address _nft,
uint256 _tokenId,
address _to,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _price,
uint256 _maximumPrice
) public payable override whenNotPaused
{
}
function buyToken(
address _nft,
uint256 _tokenId,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _maximumPrice,
address _quote
) public override whenNotPaused
{
}
function buyTokenTo(
address _nft,
uint256 _tokenId,
address _to,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _maximumPrice,
address _quote)
public override whenNotPaused
{
}
// // NFT 판매를 올려놓은 것의 가격을 수정
// // nft: NFT 토큰 주소
// // tokenId: NFT 토큰 아이디
// // price: Wei단위 가격
// function setCurrentPrice(
// address _nft,
// uint256 _tokenId,
// uint256 _quantity,
// uint256 _oldPrice,
// address _oldQuote,
// uint256 _newPrice,
// address _newQuote
// ) public override whenNotPaused
// {
// bytes32 _ix = keccak256(abi.encodePacked(_msgSender(), _quantity, _oldPrice, _oldQuote));
// uint256 len = _askTokens[_nft][_tokenId][_ix].length;
// require(len > 0, 'Token not in sell book');
//
// require(_newPrice != 0, 'Price must be granter than zero');
//
// AskEntry memory selected = _askTokens[_nft][_tokenId][_ix][0];
// selected.price = _newPrice;
// selected.quote = _newQuote;
//
// uint256 length = _asksMap[_nft].length;
// for (uint256 i = 0; i < length ; i++) {
// if (_asksMap[_nft][i].tokenId == _tokenId &&
// _asksMap[_nft][i].seller == _msgSender() &&
// _asksMap[_nft][i].quantity == _quantity &&
// _asksMap[_nft][i].price == _oldPrice &&
// _asksMap[_nft][i].quote == _oldQuote
// ) {
// _asksMap[_nft][i].price = _newPrice;
// _asksMap[_nft][i].quote = _newQuote;
// break;
// }
// }
//
// emit Ask(_msgSender(), _nft, _tokenId, _quantity, _newPrice, _newQuote);
// }
// NFT 판매
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
// price: Wei단위 가격
function readyToSellToken(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
// 특정 유저에 한정해서 NFT를 판매
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
// price: Wei단위 가격
// to: 특정 유저
function readyToSellTokenTo(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
address _to,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
// NFT 판매 취소
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
function cancelSellToken(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
// 컨트랙트 기능 정지
function pause() public onlyOwner whenNotPaused
{
}
// 컨트랙트 기능 정지 해제
function unpause() public onlyOwner whenPaused
{
}
// 거래 수수료 받는 주소 변경
function transferFeeAddress(
address _feeAddr
) public
{
}
// 거래 수수료 퍼센트 변경
function setFeePercent(
uint256 _feePercent
) public onlyOwner
{
}
// NFT Ask 리스트애서 특정 TokenId를 삭제
function delAskTokensByTokenId(
address _nft,
uint256 _tokenId,
bytes32 _ix,
uint256 _amount
) private
{
}
function emergencyWithdraw() public onlyOwner
{
}
// function getNftAllAsks(
// address _nft
// ) external view returns (AsksMap[] memory)
// {
// return _asksMap[_nft];
// }
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external override returns(bytes4)
{
}
function bidToken(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
require(_msgSender() != address(0) && _msgSender() != address(this), 'Wrong msg sender');
require(_price != 0, 'Price must be granter than zero');
address _bidder = address(_msgSender());
if (_nftType == 721) {
require(IERC721Upgradeable(_nft).ownerOf(_tokenId) != _bidder, 'Owner cannot bid');
} else if (_nftType == 1155) {
require(IERC1155Upgradeable(_nft).balanceOf(_bidder, _tokenId) == 0, 'Owner cannot bid');
}
require(<FILL_ME>)
IERC20Upgradeable(_quote).safeTransferFrom(_msgSender(), address(this), _price.mul(_quantity));
// When ?
_userBids[_nft][_bidder][_tokenId] = _price.mul(_quantity);
bytes32 _ix = keccak256(abi.encodePacked(_bidder, _quantity, _price, _quote));
_tokenBids[_nft][_tokenId][_ix].push(BidEntry({nftType: _nftType, bidder: _bidder, quantity: _quantity, price: _price, quote: _quote}));
emit Bid(_msgSender(), _nft, _tokenId, _quantity, _price, _quote);
}
function bidTokenETH(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price
) public payable override whenNotPaused
{
}
function cancelBidToken(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
function getBidByBidInfo(
address _nft,
uint256 _tokenId,
address _bidder, // bidder
uint256 _quantity,
uint256 _price,
address _quote
) private view returns (BidEntry memory, uint256)
{
}
function delBidByBidInfo(
address _bidder,
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
uint256 _index
) private
{
}
function shareProfits(
address _nft,
uint256 _tokenId,
address _bidder,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) private
{
}
function sellTokenTo(
address _nft,
uint256 _tokenId,
address _bidder,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
function updateBidPrice(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
uint256 _newPrice,
address _quote
) public override whenNotPaused
{
}
function updateBidPriceETH(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
uint256 _newPrice,
address _quote
) public payable override whenNotPaused
{
}
}
| _userBids[_nft][_bidder][_tokenId]==0,'Bidder already exists' | 226,001 | _userBids[_nft][_bidder][_tokenId]==0 |
'Only Bidder can cancel the bid' | pragma solidity >=0.6.6;
// pragma experimental ABIEncoderV2;
contract Market6 is IMarket6, ERC721HolderUpgradeable, OwnableUpgradeable, PausableUpgradeable {
using SafeMathUpgradeable for uint256;
using SafeERC20Upgradeable for IERC20Upgradeable;
using AddressUpgradeable for address;
// using EnumerableMap for EnumerableMap.UintToUintMap;
using EnumerableSetUpgradeable for EnumerableSetUpgradeable.UintSet;
struct AskEntry {
uint nftType;
address seller;
uint256 quantity;
uint256 price;
address quote;
uint256 sold;
address creator;
uint256 rate;
}
// struct AsksMap {
// uint nftType;
// uint256 tokenId;
// address seller;
// uint256 quantity;
// uint256 price;
// address quote;
// uint256 sold;
// address creator;
// uint256 rate;
// }
struct BidEntry {
uint nftType;
address bidder;
uint256 quantity;
uint256 price;
address quote;
}
struct UserBidEntry {
uint256 tokenId;
uint256 price;
}
IERC20Upgradeable public quoteErc20;
address public feeAddr;
uint256 public feePercent;
mapping(address => mapping(uint256 => mapping(bytes32 => AskEntry[]))) private _askTokens;
// mapping(address => AsksMap[]) private _asksMap;
mapping(address => mapping(uint256 => mapping(bytes32 => BidEntry[]))) private _tokenBids;
// TokenId 별로 단 한번의 Bid 만 등록이 가능함. 가격 업데이트는 가능.
mapping(address => mapping(address => mapping(uint256 => uint256))) private _userBids;
// NFT 거래
event Trade(address indexed seller, address indexed buyer, address indexed nft, uint256 tokenId, uint256 quantity, uint256 amount, uint256 price, uint256 fee);
// NFT 판매 등록
event Ask(address indexed seller, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT 판매 등록 취소
event CancelSellToken(address indexed seller, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT Bidding
event Bid(address indexed bidder, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT Bidding 취소
event CancelBidToken(address indexed bidder, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
function initialize(
address _quoteErc20Address,
address _feeAddr,
uint256 _feePercent
) initializer public
{
}
function buyTokenETH(
address _nft,
uint256 _tokenId,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _price
) public payable override whenNotPaused
{
}
function buyTokenToETH(
address _nft,
uint256 _tokenId,
address _to,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _price,
uint256 _maximumPrice
) public payable override whenNotPaused
{
}
function buyToken(
address _nft,
uint256 _tokenId,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _maximumPrice,
address _quote
) public override whenNotPaused
{
}
function buyTokenTo(
address _nft,
uint256 _tokenId,
address _to,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _maximumPrice,
address _quote)
public override whenNotPaused
{
}
// // NFT 판매를 올려놓은 것의 가격을 수정
// // nft: NFT 토큰 주소
// // tokenId: NFT 토큰 아이디
// // price: Wei단위 가격
// function setCurrentPrice(
// address _nft,
// uint256 _tokenId,
// uint256 _quantity,
// uint256 _oldPrice,
// address _oldQuote,
// uint256 _newPrice,
// address _newQuote
// ) public override whenNotPaused
// {
// bytes32 _ix = keccak256(abi.encodePacked(_msgSender(), _quantity, _oldPrice, _oldQuote));
// uint256 len = _askTokens[_nft][_tokenId][_ix].length;
// require(len > 0, 'Token not in sell book');
//
// require(_newPrice != 0, 'Price must be granter than zero');
//
// AskEntry memory selected = _askTokens[_nft][_tokenId][_ix][0];
// selected.price = _newPrice;
// selected.quote = _newQuote;
//
// uint256 length = _asksMap[_nft].length;
// for (uint256 i = 0; i < length ; i++) {
// if (_asksMap[_nft][i].tokenId == _tokenId &&
// _asksMap[_nft][i].seller == _msgSender() &&
// _asksMap[_nft][i].quantity == _quantity &&
// _asksMap[_nft][i].price == _oldPrice &&
// _asksMap[_nft][i].quote == _oldQuote
// ) {
// _asksMap[_nft][i].price = _newPrice;
// _asksMap[_nft][i].quote = _newQuote;
// break;
// }
// }
//
// emit Ask(_msgSender(), _nft, _tokenId, _quantity, _newPrice, _newQuote);
// }
// NFT 판매
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
// price: Wei단위 가격
function readyToSellToken(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
// 특정 유저에 한정해서 NFT를 판매
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
// price: Wei단위 가격
// to: 특정 유저
function readyToSellTokenTo(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
address _to,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
// NFT 판매 취소
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
function cancelSellToken(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
// 컨트랙트 기능 정지
function pause() public onlyOwner whenNotPaused
{
}
// 컨트랙트 기능 정지 해제
function unpause() public onlyOwner whenPaused
{
}
// 거래 수수료 받는 주소 변경
function transferFeeAddress(
address _feeAddr
) public
{
}
// 거래 수수료 퍼센트 변경
function setFeePercent(
uint256 _feePercent
) public onlyOwner
{
}
// NFT Ask 리스트애서 특정 TokenId를 삭제
function delAskTokensByTokenId(
address _nft,
uint256 _tokenId,
bytes32 _ix,
uint256 _amount
) private
{
}
function emergencyWithdraw() public onlyOwner
{
}
// function getNftAllAsks(
// address _nft
// ) external view returns (AsksMap[] memory)
// {
// return _asksMap[_nft];
// }
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external override returns(bytes4)
{
}
function bidToken(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
function bidTokenETH(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price
) public payable override whenNotPaused
{
}
function cancelBidToken(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
require(<FILL_ME>)
address _bidder = address(_msgSender());
// find bid and the index
(BidEntry memory bidEntry, uint256 _index) = getBidByBidInfo(_nft, _tokenId, _bidder, _quantity, _price, _quote);
require(bidEntry.price != 0, 'Bidder does not exist');
require(bidEntry.bidder == _bidder, 'Only Bidder can cancel the bid');
IERC20Upgradeable(_quote).safeTransferFrom(address(this), _bidder, bidEntry.price.mul(bidEntry.quantity));
delBidByBidInfo(_bidder, _nft, _tokenId, _quantity, _price, _quote, _index);
emit CancelBidToken(_msgSender(), _nft, _tokenId, _quantity, _price, _quote);
}
function getBidByBidInfo(
address _nft,
uint256 _tokenId,
address _bidder, // bidder
uint256 _quantity,
uint256 _price,
address _quote
) private view returns (BidEntry memory, uint256)
{
}
function delBidByBidInfo(
address _bidder,
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
uint256 _index
) private
{
}
function shareProfits(
address _nft,
uint256 _tokenId,
address _bidder,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) private
{
}
function sellTokenTo(
address _nft,
uint256 _tokenId,
address _bidder,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
function updateBidPrice(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
uint256 _newPrice,
address _quote
) public override whenNotPaused
{
}
function updateBidPriceETH(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
uint256 _newPrice,
address _quote
) public payable override whenNotPaused
{
}
}
| _userBids[_nft][_msgSender()][_tokenId]>0,'Only Bidder can cancel the bid' | 226,001 | _userBids[_nft][_msgSender()][_tokenId]>0 |
'Cancel NFT selling in advance' | pragma solidity >=0.6.6;
// pragma experimental ABIEncoderV2;
contract Market6 is IMarket6, ERC721HolderUpgradeable, OwnableUpgradeable, PausableUpgradeable {
using SafeMathUpgradeable for uint256;
using SafeERC20Upgradeable for IERC20Upgradeable;
using AddressUpgradeable for address;
// using EnumerableMap for EnumerableMap.UintToUintMap;
using EnumerableSetUpgradeable for EnumerableSetUpgradeable.UintSet;
struct AskEntry {
uint nftType;
address seller;
uint256 quantity;
uint256 price;
address quote;
uint256 sold;
address creator;
uint256 rate;
}
// struct AsksMap {
// uint nftType;
// uint256 tokenId;
// address seller;
// uint256 quantity;
// uint256 price;
// address quote;
// uint256 sold;
// address creator;
// uint256 rate;
// }
struct BidEntry {
uint nftType;
address bidder;
uint256 quantity;
uint256 price;
address quote;
}
struct UserBidEntry {
uint256 tokenId;
uint256 price;
}
IERC20Upgradeable public quoteErc20;
address public feeAddr;
uint256 public feePercent;
mapping(address => mapping(uint256 => mapping(bytes32 => AskEntry[]))) private _askTokens;
// mapping(address => AsksMap[]) private _asksMap;
mapping(address => mapping(uint256 => mapping(bytes32 => BidEntry[]))) private _tokenBids;
// TokenId 별로 단 한번의 Bid 만 등록이 가능함. 가격 업데이트는 가능.
mapping(address => mapping(address => mapping(uint256 => uint256))) private _userBids;
// NFT 거래
event Trade(address indexed seller, address indexed buyer, address indexed nft, uint256 tokenId, uint256 quantity, uint256 amount, uint256 price, uint256 fee);
// NFT 판매 등록
event Ask(address indexed seller, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT 판매 등록 취소
event CancelSellToken(address indexed seller, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT Bidding
event Bid(address indexed bidder, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT Bidding 취소
event CancelBidToken(address indexed bidder, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
function initialize(
address _quoteErc20Address,
address _feeAddr,
uint256 _feePercent
) initializer public
{
}
function buyTokenETH(
address _nft,
uint256 _tokenId,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _price
) public payable override whenNotPaused
{
}
function buyTokenToETH(
address _nft,
uint256 _tokenId,
address _to,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _price,
uint256 _maximumPrice
) public payable override whenNotPaused
{
}
function buyToken(
address _nft,
uint256 _tokenId,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _maximumPrice,
address _quote
) public override whenNotPaused
{
}
function buyTokenTo(
address _nft,
uint256 _tokenId,
address _to,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _maximumPrice,
address _quote)
public override whenNotPaused
{
}
// // NFT 판매를 올려놓은 것의 가격을 수정
// // nft: NFT 토큰 주소
// // tokenId: NFT 토큰 아이디
// // price: Wei단위 가격
// function setCurrentPrice(
// address _nft,
// uint256 _tokenId,
// uint256 _quantity,
// uint256 _oldPrice,
// address _oldQuote,
// uint256 _newPrice,
// address _newQuote
// ) public override whenNotPaused
// {
// bytes32 _ix = keccak256(abi.encodePacked(_msgSender(), _quantity, _oldPrice, _oldQuote));
// uint256 len = _askTokens[_nft][_tokenId][_ix].length;
// require(len > 0, 'Token not in sell book');
//
// require(_newPrice != 0, 'Price must be granter than zero');
//
// AskEntry memory selected = _askTokens[_nft][_tokenId][_ix][0];
// selected.price = _newPrice;
// selected.quote = _newQuote;
//
// uint256 length = _asksMap[_nft].length;
// for (uint256 i = 0; i < length ; i++) {
// if (_asksMap[_nft][i].tokenId == _tokenId &&
// _asksMap[_nft][i].seller == _msgSender() &&
// _asksMap[_nft][i].quantity == _quantity &&
// _asksMap[_nft][i].price == _oldPrice &&
// _asksMap[_nft][i].quote == _oldQuote
// ) {
// _asksMap[_nft][i].price = _newPrice;
// _asksMap[_nft][i].quote = _newQuote;
// break;
// }
// }
//
// emit Ask(_msgSender(), _nft, _tokenId, _quantity, _newPrice, _newQuote);
// }
// NFT 판매
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
// price: Wei단위 가격
function readyToSellToken(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
// 특정 유저에 한정해서 NFT를 판매
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
// price: Wei단위 가격
// to: 특정 유저
function readyToSellTokenTo(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
address _to,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
// NFT 판매 취소
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
function cancelSellToken(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
// 컨트랙트 기능 정지
function pause() public onlyOwner whenNotPaused
{
}
// 컨트랙트 기능 정지 해제
function unpause() public onlyOwner whenPaused
{
}
// 거래 수수료 받는 주소 변경
function transferFeeAddress(
address _feeAddr
) public
{
}
// 거래 수수료 퍼센트 변경
function setFeePercent(
uint256 _feePercent
) public onlyOwner
{
}
// NFT Ask 리스트애서 특정 TokenId를 삭제
function delAskTokensByTokenId(
address _nft,
uint256 _tokenId,
bytes32 _ix,
uint256 _amount
) private
{
}
function emergencyWithdraw() public onlyOwner
{
}
// function getNftAllAsks(
// address _nft
// ) external view returns (AsksMap[] memory)
// {
// return _asksMap[_nft];
// }
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external override returns(bytes4)
{
}
function bidToken(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
function bidTokenETH(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price
) public payable override whenNotPaused
{
}
function cancelBidToken(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
function getBidByBidInfo(
address _nft,
uint256 _tokenId,
address _bidder, // bidder
uint256 _quantity,
uint256 _price,
address _quote
) private view returns (BidEntry memory, uint256)
{
}
function delBidByBidInfo(
address _bidder,
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
uint256 _index
) private
{
}
function shareProfits(
address _nft,
uint256 _tokenId,
address _bidder,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) private
{
}
function sellTokenTo(
address _nft,
uint256 _tokenId,
address _bidder,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) public override whenNotPaused
{
address _seller = address(_msgSender());
// find bid and the index
(BidEntry memory bidEntry, uint256 _index) = getBidByBidInfo(_nft, _tokenId, _bidder, _quantity, _price, _quote);
uint256 price = bidEntry.price;
require(bidEntry.price != 0, 'Bidder does not exist');
require(_quantity == bidEntry.quantity, 'Wrong quantity');
if (bidEntry.nftType == 721) {
require(<FILL_ME>)
IERC721Upgradeable(_nft).safeTransferFrom(_seller, _bidder, _tokenId);
} else if (bidEntry.nftType == 1155) {
require(IERC1155Upgradeable(_nft).balanceOf(_seller, _tokenId) >= _quantity, 'Cancel NFT selling in advance');
IERC1155Upgradeable(_nft).safeTransferFrom(_seller, _bidder, _tokenId, _quantity, '0x');
}
// Separate into another function because of "CompilerError: Stack Too Deep"
shareProfits(_nft, _tokenId, _bidder, _quantity, _price, _quote, _creator, _rate);
// Remove Offer
delBidByBidInfo(_bidder, _nft, _tokenId, _quantity, _price, _quote, _index);
}
function updateBidPrice(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
uint256 _newPrice,
address _quote
) public override whenNotPaused
{
}
function updateBidPriceETH(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
uint256 _newPrice,
address _quote
) public payable override whenNotPaused
{
}
}
| IERC721Upgradeable(_nft).ownerOf(_tokenId)==_seller,'Cancel NFT selling in advance' | 226,001 | IERC721Upgradeable(_nft).ownerOf(_tokenId)==_seller |
'Cancel NFT selling in advance' | pragma solidity >=0.6.6;
// pragma experimental ABIEncoderV2;
contract Market6 is IMarket6, ERC721HolderUpgradeable, OwnableUpgradeable, PausableUpgradeable {
using SafeMathUpgradeable for uint256;
using SafeERC20Upgradeable for IERC20Upgradeable;
using AddressUpgradeable for address;
// using EnumerableMap for EnumerableMap.UintToUintMap;
using EnumerableSetUpgradeable for EnumerableSetUpgradeable.UintSet;
struct AskEntry {
uint nftType;
address seller;
uint256 quantity;
uint256 price;
address quote;
uint256 sold;
address creator;
uint256 rate;
}
// struct AsksMap {
// uint nftType;
// uint256 tokenId;
// address seller;
// uint256 quantity;
// uint256 price;
// address quote;
// uint256 sold;
// address creator;
// uint256 rate;
// }
struct BidEntry {
uint nftType;
address bidder;
uint256 quantity;
uint256 price;
address quote;
}
struct UserBidEntry {
uint256 tokenId;
uint256 price;
}
IERC20Upgradeable public quoteErc20;
address public feeAddr;
uint256 public feePercent;
mapping(address => mapping(uint256 => mapping(bytes32 => AskEntry[]))) private _askTokens;
// mapping(address => AsksMap[]) private _asksMap;
mapping(address => mapping(uint256 => mapping(bytes32 => BidEntry[]))) private _tokenBids;
// TokenId 별로 단 한번의 Bid 만 등록이 가능함. 가격 업데이트는 가능.
mapping(address => mapping(address => mapping(uint256 => uint256))) private _userBids;
// NFT 거래
event Trade(address indexed seller, address indexed buyer, address indexed nft, uint256 tokenId, uint256 quantity, uint256 amount, uint256 price, uint256 fee);
// NFT 판매 등록
event Ask(address indexed seller, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT 판매 등록 취소
event CancelSellToken(address indexed seller, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT Bidding
event Bid(address indexed bidder, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
// NFT Bidding 취소
event CancelBidToken(address indexed bidder, address indexed nft, uint256 indexed tokenId, uint256 quantity, uint256 price, address quote);
function initialize(
address _quoteErc20Address,
address _feeAddr,
uint256 _feePercent
) initializer public
{
}
function buyTokenETH(
address _nft,
uint256 _tokenId,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _price
) public payable override whenNotPaused
{
}
function buyTokenToETH(
address _nft,
uint256 _tokenId,
address _to,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _price,
uint256 _maximumPrice
) public payable override whenNotPaused
{
}
function buyToken(
address _nft,
uint256 _tokenId,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _maximumPrice,
address _quote
) public override whenNotPaused
{
}
function buyTokenTo(
address _nft,
uint256 _tokenId,
address _to,
address _seller,
uint256 _quantity,
uint256 _amount,
uint256 _maximumPrice,
address _quote)
public override whenNotPaused
{
}
// // NFT 판매를 올려놓은 것의 가격을 수정
// // nft: NFT 토큰 주소
// // tokenId: NFT 토큰 아이디
// // price: Wei단위 가격
// function setCurrentPrice(
// address _nft,
// uint256 _tokenId,
// uint256 _quantity,
// uint256 _oldPrice,
// address _oldQuote,
// uint256 _newPrice,
// address _newQuote
// ) public override whenNotPaused
// {
// bytes32 _ix = keccak256(abi.encodePacked(_msgSender(), _quantity, _oldPrice, _oldQuote));
// uint256 len = _askTokens[_nft][_tokenId][_ix].length;
// require(len > 0, 'Token not in sell book');
//
// require(_newPrice != 0, 'Price must be granter than zero');
//
// AskEntry memory selected = _askTokens[_nft][_tokenId][_ix][0];
// selected.price = _newPrice;
// selected.quote = _newQuote;
//
// uint256 length = _asksMap[_nft].length;
// for (uint256 i = 0; i < length ; i++) {
// if (_asksMap[_nft][i].tokenId == _tokenId &&
// _asksMap[_nft][i].seller == _msgSender() &&
// _asksMap[_nft][i].quantity == _quantity &&
// _asksMap[_nft][i].price == _oldPrice &&
// _asksMap[_nft][i].quote == _oldQuote
// ) {
// _asksMap[_nft][i].price = _newPrice;
// _asksMap[_nft][i].quote = _newQuote;
// break;
// }
// }
//
// emit Ask(_msgSender(), _nft, _tokenId, _quantity, _newPrice, _newQuote);
// }
// NFT 판매
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
// price: Wei단위 가격
function readyToSellToken(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
// 특정 유저에 한정해서 NFT를 판매
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
// price: Wei단위 가격
// to: 특정 유저
function readyToSellTokenTo(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
address _to,
address _creator,
uint256 _rate
) public override whenNotPaused
{
}
// NFT 판매 취소
// nft: NFT 토큰 주소
// tokenId: NFT 토큰 아이디
function cancelSellToken(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
// 컨트랙트 기능 정지
function pause() public onlyOwner whenNotPaused
{
}
// 컨트랙트 기능 정지 해제
function unpause() public onlyOwner whenPaused
{
}
// 거래 수수료 받는 주소 변경
function transferFeeAddress(
address _feeAddr
) public
{
}
// 거래 수수료 퍼센트 변경
function setFeePercent(
uint256 _feePercent
) public onlyOwner
{
}
// NFT Ask 리스트애서 특정 TokenId를 삭제
function delAskTokensByTokenId(
address _nft,
uint256 _tokenId,
bytes32 _ix,
uint256 _amount
) private
{
}
function emergencyWithdraw() public onlyOwner
{
}
// function getNftAllAsks(
// address _nft
// ) external view returns (AsksMap[] memory)
// {
// return _asksMap[_nft];
// }
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external override returns(bytes4)
{
}
function bidToken(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
function bidTokenETH(
address _nft,
uint _nftType,
uint256 _tokenId,
uint256 _quantity,
uint256 _price
) public payable override whenNotPaused
{
}
function cancelBidToken(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote
) public override whenNotPaused
{
}
function getBidByBidInfo(
address _nft,
uint256 _tokenId,
address _bidder, // bidder
uint256 _quantity,
uint256 _price,
address _quote
) private view returns (BidEntry memory, uint256)
{
}
function delBidByBidInfo(
address _bidder,
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
address _quote,
uint256 _index
) private
{
}
function shareProfits(
address _nft,
uint256 _tokenId,
address _bidder,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) private
{
}
function sellTokenTo(
address _nft,
uint256 _tokenId,
address _bidder,
uint256 _quantity,
uint256 _price,
address _quote,
address _creator,
uint256 _rate
) public override whenNotPaused
{
address _seller = address(_msgSender());
// find bid and the index
(BidEntry memory bidEntry, uint256 _index) = getBidByBidInfo(_nft, _tokenId, _bidder, _quantity, _price, _quote);
uint256 price = bidEntry.price;
require(bidEntry.price != 0, 'Bidder does not exist');
require(_quantity == bidEntry.quantity, 'Wrong quantity');
if (bidEntry.nftType == 721) {
require(IERC721Upgradeable(_nft).ownerOf(_tokenId) == _seller, 'Cancel NFT selling in advance');
IERC721Upgradeable(_nft).safeTransferFrom(_seller, _bidder, _tokenId);
} else if (bidEntry.nftType == 1155) {
require(<FILL_ME>)
IERC1155Upgradeable(_nft).safeTransferFrom(_seller, _bidder, _tokenId, _quantity, '0x');
}
// Separate into another function because of "CompilerError: Stack Too Deep"
shareProfits(_nft, _tokenId, _bidder, _quantity, _price, _quote, _creator, _rate);
// Remove Offer
delBidByBidInfo(_bidder, _nft, _tokenId, _quantity, _price, _quote, _index);
}
function updateBidPrice(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
uint256 _newPrice,
address _quote
) public override whenNotPaused
{
}
function updateBidPriceETH(
address _nft,
uint256 _tokenId,
uint256 _quantity,
uint256 _price,
uint256 _newPrice,
address _quote
) public payable override whenNotPaused
{
}
}
| IERC1155Upgradeable(_nft).balanceOf(_seller,_tokenId)>=_quantity,'Cancel NFT selling in advance' | 226,001 | IERC1155Upgradeable(_nft).balanceOf(_seller,_tokenId)>=_quantity |
"Max total deposit reached" | library Math {
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 pow(uint256 a, uint256 b) internal pure returns (uint256) {
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
pragma solidity 0.8.17;
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
contract ChadPool is Initializable, UUPSUpgradeable, OwnableUpgradeable {
///@dev no constructor in upgradable contracts. Instead we have initializers
function initialize() public initializer {
}
///@dev required by the OZ UUPS module
function _authorizeUpgrade(address) internal override onlyOwner {}
using Math for uint256;
address public normTokenAddress = 0x3FcBfbC9fe4f930767754E674b4991B6825F54E6;
address public normNftAddress = address(0x34eC12eFBeb83504D3dC8300ab37b3f17F6F58e1);
IERC20 normToken = IERC20(normTokenAddress);
IERC1155 normNFT = IERC1155(normNftAddress);
IUniswapV2Router02 uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address private DEV_ADDRESS;
address private OWNER_ADDRESS;
address payable internal _dev;
address payable internal _owner;
uint136 private ETH_PER_NORM;
uint32 private SECONDS_PER_DAY;
uint8 private STAKING_POOL_FEE;
uint8 private WITHDRAWAL_FEE;
uint16 private DEV_FEE;
uint256 private MIN_DEPOSIT;
uint256 private MIN_STAKE;
uint256 private MAX_WALLET_TVL_IN_ETH;
uint256 private MAX_DAILY_REWARDS_IN_ETH;
uint256 public NFT_BOOSTER_APY;
uint256 private LiquidityFee;
uint256 public totalStakers;
struct Staker {
address adr;
uint256 norms;
uint256 stakedAt;
uint256 ateAt;
uint256 firstDeposit;
uint256 totalDeposit;
uint256 totalPayout;
bool blacklisted;
}
mapping(address => Staker) internal stakers;
event EmitBoughtNorms(
address indexed adr,
uint256 ethamount,
uint256 normsFrom,
uint256 normsTo
);
event EmitStaked(
address indexed adr,
uint256 normsFrom,
uint256 normsTo
);
event EmitAte(
address indexed adr,
uint256 ethToClaim,
uint256 normsBeforeFee
);
function user(address adr) public view returns (Staker memory) {
}
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
function updateTax(uint8 _withdrawFee, uint256 _liquidityFee, uint8 _rewardsPoolFee, uint8 _devFee) public{
}
function updateNftApy(uint256 _newBoostValue) public{
}
function updateNFTaddress(address _normNftAddress) external{
}
function unstake() public{
}
function stake(uint256 amount) public {
Staker storage staker = stakers[msg.sender];
require(
amount >= MIN_DEPOSIT,
"Deposit doesn't meet the minimum requirements"
);
require(<FILL_ME>)
require(normToken.transferFrom(msg.sender, address(this), amount));
staker.adr = msg.sender;
uint256 normsFrom = staker.norms;
uint256 normsBought = ethToNorms(amount);
uint256 totalNormsBought = addNorms(staker.adr, normsBought);
staker.norms = totalNormsBought;
if (hasInvested(staker.adr) == false) {
staker.firstDeposit = block.timestamp;
totalStakers++;
}
staker.totalDeposit = Math.add(staker.totalDeposit, amount);
handleStake(false);
emit EmitBoughtNorms(
msg.sender,
amount,
normsFrom,
staker.norms
);
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
receive() external payable {
}
function swapBack(uint256 amount) private {
}
function sendFees(uint256 totalFee) private {
}
function handleStake(bool onlyRestaking) private {
}
function restake() public {
}
function claim() public {
}
function maxPayoutReached(address adr) public view returns (bool) {
}
function maxPayout(address adr) public view returns (uint256) {
}
function addWithdrawalTaxes(address adr, uint256 ethWithdrawalAmount)
private
view
returns (uint256)
{
}
function calcGiveAwayAmount(address adr, uint256 ethWithdrawalAmount)
private
view
returns (uint256)
{
}
function hasJeetTaxed(address adr) public view returns (uint256) {
}
function secondsSinceLastClaim(address adr) public view returns (uint256) {
}
function daysSinceLastClaim(address adr) private view returns (uint256) {
}
function addNorms(address adr, uint256 normsToAdd)
private
view
returns (uint256)
{
}
function maxTvlReached(address adr) public view returns (bool) {
}
function hasInvested(address adr) public view returns (bool) {
}
function NormRewards(address adr) public view returns (uint256) {
}
function NormTvl(address adr) public view returns (uint256) {
}
function normsToEth(uint256 normsToCalc) private view returns (uint256) {
}
function ethToNorms(uint256 ethInWei) private view returns (uint256) {
}
function percentFromAmount(uint256 amount, uint256 fee)
private
pure
returns (uint256)
{
}
function contractBalance() public view returns (uint256) {
}
function bonusEligible(address adr) public view returns(bool){
}
function dailyReward(address adr) public view returns (uint256) {
}
function secondsSinceLastAction(address adr)
private
view
returns (uint256)
{
}
function rewardedNorms(address adr) private view returns (uint256) {
}
function calcNormsReward(
uint256 secondsPassed,
uint256 dailyRewardFactor,
address adr
) private view returns (uint256) {
}
}
| Math.add(staker.totalDeposit,amount)<=MAX_WALLET_TVL_IN_ETH,"Max total deposit reached" | 226,117 | Math.add(staker.totalDeposit,amount)<=MAX_WALLET_TVL_IN_ETH |
null | library Math {
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 pow(uint256 a, uint256 b) internal pure returns (uint256) {
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
pragma solidity 0.8.17;
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
contract ChadPool is Initializable, UUPSUpgradeable, OwnableUpgradeable {
///@dev no constructor in upgradable contracts. Instead we have initializers
function initialize() public initializer {
}
///@dev required by the OZ UUPS module
function _authorizeUpgrade(address) internal override onlyOwner {}
using Math for uint256;
address public normTokenAddress = 0x3FcBfbC9fe4f930767754E674b4991B6825F54E6;
address public normNftAddress = address(0x34eC12eFBeb83504D3dC8300ab37b3f17F6F58e1);
IERC20 normToken = IERC20(normTokenAddress);
IERC1155 normNFT = IERC1155(normNftAddress);
IUniswapV2Router02 uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address private DEV_ADDRESS;
address private OWNER_ADDRESS;
address payable internal _dev;
address payable internal _owner;
uint136 private ETH_PER_NORM;
uint32 private SECONDS_PER_DAY;
uint8 private STAKING_POOL_FEE;
uint8 private WITHDRAWAL_FEE;
uint16 private DEV_FEE;
uint256 private MIN_DEPOSIT;
uint256 private MIN_STAKE;
uint256 private MAX_WALLET_TVL_IN_ETH;
uint256 private MAX_DAILY_REWARDS_IN_ETH;
uint256 public NFT_BOOSTER_APY;
uint256 private LiquidityFee;
uint256 public totalStakers;
struct Staker {
address adr;
uint256 norms;
uint256 stakedAt;
uint256 ateAt;
uint256 firstDeposit;
uint256 totalDeposit;
uint256 totalPayout;
bool blacklisted;
}
mapping(address => Staker) internal stakers;
event EmitBoughtNorms(
address indexed adr,
uint256 ethamount,
uint256 normsFrom,
uint256 normsTo
);
event EmitStaked(
address indexed adr,
uint256 normsFrom,
uint256 normsTo
);
event EmitAte(
address indexed adr,
uint256 ethToClaim,
uint256 normsBeforeFee
);
function user(address adr) public view returns (Staker memory) {
}
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
function updateTax(uint8 _withdrawFee, uint256 _liquidityFee, uint8 _rewardsPoolFee, uint8 _devFee) public{
}
function updateNftApy(uint256 _newBoostValue) public{
}
function updateNFTaddress(address _normNftAddress) external{
}
function unstake() public{
}
function stake(uint256 amount) public {
Staker storage staker = stakers[msg.sender];
require(
amount >= MIN_DEPOSIT,
"Deposit doesn't meet the minimum requirements"
);
require(
Math.add(staker.totalDeposit, amount) <= MAX_WALLET_TVL_IN_ETH,
"Max total deposit reached"
);
require(<FILL_ME>)
staker.adr = msg.sender;
uint256 normsFrom = staker.norms;
uint256 normsBought = ethToNorms(amount);
uint256 totalNormsBought = addNorms(staker.adr, normsBought);
staker.norms = totalNormsBought;
if (hasInvested(staker.adr) == false) {
staker.firstDeposit = block.timestamp;
totalStakers++;
}
staker.totalDeposit = Math.add(staker.totalDeposit, amount);
handleStake(false);
emit EmitBoughtNorms(
msg.sender,
amount,
normsFrom,
staker.norms
);
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
receive() external payable {
}
function swapBack(uint256 amount) private {
}
function sendFees(uint256 totalFee) private {
}
function handleStake(bool onlyRestaking) private {
}
function restake() public {
}
function claim() public {
}
function maxPayoutReached(address adr) public view returns (bool) {
}
function maxPayout(address adr) public view returns (uint256) {
}
function addWithdrawalTaxes(address adr, uint256 ethWithdrawalAmount)
private
view
returns (uint256)
{
}
function calcGiveAwayAmount(address adr, uint256 ethWithdrawalAmount)
private
view
returns (uint256)
{
}
function hasJeetTaxed(address adr) public view returns (uint256) {
}
function secondsSinceLastClaim(address adr) public view returns (uint256) {
}
function daysSinceLastClaim(address adr) private view returns (uint256) {
}
function addNorms(address adr, uint256 normsToAdd)
private
view
returns (uint256)
{
}
function maxTvlReached(address adr) public view returns (bool) {
}
function hasInvested(address adr) public view returns (bool) {
}
function NormRewards(address adr) public view returns (uint256) {
}
function NormTvl(address adr) public view returns (uint256) {
}
function normsToEth(uint256 normsToCalc) private view returns (uint256) {
}
function ethToNorms(uint256 ethInWei) private view returns (uint256) {
}
function percentFromAmount(uint256 amount, uint256 fee)
private
pure
returns (uint256)
{
}
function contractBalance() public view returns (uint256) {
}
function bonusEligible(address adr) public view returns(bool){
}
function dailyReward(address adr) public view returns (uint256) {
}
function secondsSinceLastAction(address adr)
private
view
returns (uint256)
{
}
function rewardedNorms(address adr) private view returns (uint256) {
}
function calcNormsReward(
uint256 secondsPassed,
uint256 dailyRewardFactor,
address adr
) private view returns (uint256) {
}
}
| normToken.transferFrom(msg.sender,address(this),amount) | 226,117 | normToken.transferFrom(msg.sender,address(this),amount) |
"Total wallet TVL reached" | library Math {
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 pow(uint256 a, uint256 b) internal pure returns (uint256) {
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
pragma solidity 0.8.17;
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
contract ChadPool is Initializable, UUPSUpgradeable, OwnableUpgradeable {
///@dev no constructor in upgradable contracts. Instead we have initializers
function initialize() public initializer {
}
///@dev required by the OZ UUPS module
function _authorizeUpgrade(address) internal override onlyOwner {}
using Math for uint256;
address public normTokenAddress = 0x3FcBfbC9fe4f930767754E674b4991B6825F54E6;
address public normNftAddress = address(0x34eC12eFBeb83504D3dC8300ab37b3f17F6F58e1);
IERC20 normToken = IERC20(normTokenAddress);
IERC1155 normNFT = IERC1155(normNftAddress);
IUniswapV2Router02 uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address private DEV_ADDRESS;
address private OWNER_ADDRESS;
address payable internal _dev;
address payable internal _owner;
uint136 private ETH_PER_NORM;
uint32 private SECONDS_PER_DAY;
uint8 private STAKING_POOL_FEE;
uint8 private WITHDRAWAL_FEE;
uint16 private DEV_FEE;
uint256 private MIN_DEPOSIT;
uint256 private MIN_STAKE;
uint256 private MAX_WALLET_TVL_IN_ETH;
uint256 private MAX_DAILY_REWARDS_IN_ETH;
uint256 public NFT_BOOSTER_APY;
uint256 private LiquidityFee;
uint256 public totalStakers;
struct Staker {
address adr;
uint256 norms;
uint256 stakedAt;
uint256 ateAt;
uint256 firstDeposit;
uint256 totalDeposit;
uint256 totalPayout;
bool blacklisted;
}
mapping(address => Staker) internal stakers;
event EmitBoughtNorms(
address indexed adr,
uint256 ethamount,
uint256 normsFrom,
uint256 normsTo
);
event EmitStaked(
address indexed adr,
uint256 normsFrom,
uint256 normsTo
);
event EmitAte(
address indexed adr,
uint256 ethToClaim,
uint256 normsBeforeFee
);
function user(address adr) public view returns (Staker memory) {
}
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
function updateTax(uint8 _withdrawFee, uint256 _liquidityFee, uint8 _rewardsPoolFee, uint8 _devFee) public{
}
function updateNftApy(uint256 _newBoostValue) public{
}
function updateNFTaddress(address _normNftAddress) external{
}
function unstake() public{
}
function stake(uint256 amount) public {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
receive() external payable {
}
function swapBack(uint256 amount) private {
}
function sendFees(uint256 totalFee) private {
}
function handleStake(bool onlyRestaking) private {
Staker storage staker = stakers[msg.sender];
require(<FILL_ME>)
require(hasInvested(staker.adr), "Must be invested to stake");
if (onlyRestaking == true) {
require(
normsToEth(rewardedNorms(staker.adr)) >= MIN_STAKE,
"Rewards must be equal or higher than 1 million $NORM to stake"
);
}
uint256 normsFrom = staker.norms;
uint256 normsFromRewards = rewardedNorms(staker.adr);
uint256 totalNorms = addNorms(staker.adr, normsFromRewards);
staker.norms = totalNorms;
staker.stakedAt = block.timestamp;
emit EmitStaked(msg.sender, normsFrom, staker.norms);
}
function restake() public {
}
function claim() public {
}
function maxPayoutReached(address adr) public view returns (bool) {
}
function maxPayout(address adr) public view returns (uint256) {
}
function addWithdrawalTaxes(address adr, uint256 ethWithdrawalAmount)
private
view
returns (uint256)
{
}
function calcGiveAwayAmount(address adr, uint256 ethWithdrawalAmount)
private
view
returns (uint256)
{
}
function hasJeetTaxed(address adr) public view returns (uint256) {
}
function secondsSinceLastClaim(address adr) public view returns (uint256) {
}
function daysSinceLastClaim(address adr) private view returns (uint256) {
}
function addNorms(address adr, uint256 normsToAdd)
private
view
returns (uint256)
{
}
function maxTvlReached(address adr) public view returns (bool) {
}
function hasInvested(address adr) public view returns (bool) {
}
function NormRewards(address adr) public view returns (uint256) {
}
function NormTvl(address adr) public view returns (uint256) {
}
function normsToEth(uint256 normsToCalc) private view returns (uint256) {
}
function ethToNorms(uint256 ethInWei) private view returns (uint256) {
}
function percentFromAmount(uint256 amount, uint256 fee)
private
pure
returns (uint256)
{
}
function contractBalance() public view returns (uint256) {
}
function bonusEligible(address adr) public view returns(bool){
}
function dailyReward(address adr) public view returns (uint256) {
}
function secondsSinceLastAction(address adr)
private
view
returns (uint256)
{
}
function rewardedNorms(address adr) private view returns (uint256) {
}
function calcNormsReward(
uint256 secondsPassed,
uint256 dailyRewardFactor,
address adr
) private view returns (uint256) {
}
}
| maxTvlReached(staker.adr)==false,"Total wallet TVL reached" | 226,117 | maxTvlReached(staker.adr)==false |
"Must be invested to stake" | library Math {
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 pow(uint256 a, uint256 b) internal pure returns (uint256) {
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
pragma solidity 0.8.17;
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
contract ChadPool is Initializable, UUPSUpgradeable, OwnableUpgradeable {
///@dev no constructor in upgradable contracts. Instead we have initializers
function initialize() public initializer {
}
///@dev required by the OZ UUPS module
function _authorizeUpgrade(address) internal override onlyOwner {}
using Math for uint256;
address public normTokenAddress = 0x3FcBfbC9fe4f930767754E674b4991B6825F54E6;
address public normNftAddress = address(0x34eC12eFBeb83504D3dC8300ab37b3f17F6F58e1);
IERC20 normToken = IERC20(normTokenAddress);
IERC1155 normNFT = IERC1155(normNftAddress);
IUniswapV2Router02 uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address private DEV_ADDRESS;
address private OWNER_ADDRESS;
address payable internal _dev;
address payable internal _owner;
uint136 private ETH_PER_NORM;
uint32 private SECONDS_PER_DAY;
uint8 private STAKING_POOL_FEE;
uint8 private WITHDRAWAL_FEE;
uint16 private DEV_FEE;
uint256 private MIN_DEPOSIT;
uint256 private MIN_STAKE;
uint256 private MAX_WALLET_TVL_IN_ETH;
uint256 private MAX_DAILY_REWARDS_IN_ETH;
uint256 public NFT_BOOSTER_APY;
uint256 private LiquidityFee;
uint256 public totalStakers;
struct Staker {
address adr;
uint256 norms;
uint256 stakedAt;
uint256 ateAt;
uint256 firstDeposit;
uint256 totalDeposit;
uint256 totalPayout;
bool blacklisted;
}
mapping(address => Staker) internal stakers;
event EmitBoughtNorms(
address indexed adr,
uint256 ethamount,
uint256 normsFrom,
uint256 normsTo
);
event EmitStaked(
address indexed adr,
uint256 normsFrom,
uint256 normsTo
);
event EmitAte(
address indexed adr,
uint256 ethToClaim,
uint256 normsBeforeFee
);
function user(address adr) public view returns (Staker memory) {
}
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
function updateTax(uint8 _withdrawFee, uint256 _liquidityFee, uint8 _rewardsPoolFee, uint8 _devFee) public{
}
function updateNftApy(uint256 _newBoostValue) public{
}
function updateNFTaddress(address _normNftAddress) external{
}
function unstake() public{
}
function stake(uint256 amount) public {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
receive() external payable {
}
function swapBack(uint256 amount) private {
}
function sendFees(uint256 totalFee) private {
}
function handleStake(bool onlyRestaking) private {
Staker storage staker = stakers[msg.sender];
require(maxTvlReached(staker.adr) == false, "Total wallet TVL reached");
require(<FILL_ME>)
if (onlyRestaking == true) {
require(
normsToEth(rewardedNorms(staker.adr)) >= MIN_STAKE,
"Rewards must be equal or higher than 1 million $NORM to stake"
);
}
uint256 normsFrom = staker.norms;
uint256 normsFromRewards = rewardedNorms(staker.adr);
uint256 totalNorms = addNorms(staker.adr, normsFromRewards);
staker.norms = totalNorms;
staker.stakedAt = block.timestamp;
emit EmitStaked(msg.sender, normsFrom, staker.norms);
}
function restake() public {
}
function claim() public {
}
function maxPayoutReached(address adr) public view returns (bool) {
}
function maxPayout(address adr) public view returns (uint256) {
}
function addWithdrawalTaxes(address adr, uint256 ethWithdrawalAmount)
private
view
returns (uint256)
{
}
function calcGiveAwayAmount(address adr, uint256 ethWithdrawalAmount)
private
view
returns (uint256)
{
}
function hasJeetTaxed(address adr) public view returns (uint256) {
}
function secondsSinceLastClaim(address adr) public view returns (uint256) {
}
function daysSinceLastClaim(address adr) private view returns (uint256) {
}
function addNorms(address adr, uint256 normsToAdd)
private
view
returns (uint256)
{
}
function maxTvlReached(address adr) public view returns (bool) {
}
function hasInvested(address adr) public view returns (bool) {
}
function NormRewards(address adr) public view returns (uint256) {
}
function NormTvl(address adr) public view returns (uint256) {
}
function normsToEth(uint256 normsToCalc) private view returns (uint256) {
}
function ethToNorms(uint256 ethInWei) private view returns (uint256) {
}
function percentFromAmount(uint256 amount, uint256 fee)
private
pure
returns (uint256)
{
}
function contractBalance() public view returns (uint256) {
}
function bonusEligible(address adr) public view returns(bool){
}
function dailyReward(address adr) public view returns (uint256) {
}
function secondsSinceLastAction(address adr)
private
view
returns (uint256)
{
}
function rewardedNorms(address adr) private view returns (uint256) {
}
function calcNormsReward(
uint256 secondsPassed,
uint256 dailyRewardFactor,
address adr
) private view returns (uint256) {
}
}
| hasInvested(staker.adr),"Must be invested to stake" | 226,117 | hasInvested(staker.adr) |
"Rewards must be equal or higher than 1 million $NORM to stake" | library Math {
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 pow(uint256 a, uint256 b) internal pure returns (uint256) {
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
pragma solidity 0.8.17;
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
contract ChadPool is Initializable, UUPSUpgradeable, OwnableUpgradeable {
///@dev no constructor in upgradable contracts. Instead we have initializers
function initialize() public initializer {
}
///@dev required by the OZ UUPS module
function _authorizeUpgrade(address) internal override onlyOwner {}
using Math for uint256;
address public normTokenAddress = 0x3FcBfbC9fe4f930767754E674b4991B6825F54E6;
address public normNftAddress = address(0x34eC12eFBeb83504D3dC8300ab37b3f17F6F58e1);
IERC20 normToken = IERC20(normTokenAddress);
IERC1155 normNFT = IERC1155(normNftAddress);
IUniswapV2Router02 uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address private DEV_ADDRESS;
address private OWNER_ADDRESS;
address payable internal _dev;
address payable internal _owner;
uint136 private ETH_PER_NORM;
uint32 private SECONDS_PER_DAY;
uint8 private STAKING_POOL_FEE;
uint8 private WITHDRAWAL_FEE;
uint16 private DEV_FEE;
uint256 private MIN_DEPOSIT;
uint256 private MIN_STAKE;
uint256 private MAX_WALLET_TVL_IN_ETH;
uint256 private MAX_DAILY_REWARDS_IN_ETH;
uint256 public NFT_BOOSTER_APY;
uint256 private LiquidityFee;
uint256 public totalStakers;
struct Staker {
address adr;
uint256 norms;
uint256 stakedAt;
uint256 ateAt;
uint256 firstDeposit;
uint256 totalDeposit;
uint256 totalPayout;
bool blacklisted;
}
mapping(address => Staker) internal stakers;
event EmitBoughtNorms(
address indexed adr,
uint256 ethamount,
uint256 normsFrom,
uint256 normsTo
);
event EmitStaked(
address indexed adr,
uint256 normsFrom,
uint256 normsTo
);
event EmitAte(
address indexed adr,
uint256 ethToClaim,
uint256 normsBeforeFee
);
function user(address adr) public view returns (Staker memory) {
}
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
function updateTax(uint8 _withdrawFee, uint256 _liquidityFee, uint8 _rewardsPoolFee, uint8 _devFee) public{
}
function updateNftApy(uint256 _newBoostValue) public{
}
function updateNFTaddress(address _normNftAddress) external{
}
function unstake() public{
}
function stake(uint256 amount) public {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
receive() external payable {
}
function swapBack(uint256 amount) private {
}
function sendFees(uint256 totalFee) private {
}
function handleStake(bool onlyRestaking) private {
Staker storage staker = stakers[msg.sender];
require(maxTvlReached(staker.adr) == false, "Total wallet TVL reached");
require(hasInvested(staker.adr), "Must be invested to stake");
if (onlyRestaking == true) {
require(<FILL_ME>)
}
uint256 normsFrom = staker.norms;
uint256 normsFromRewards = rewardedNorms(staker.adr);
uint256 totalNorms = addNorms(staker.adr, normsFromRewards);
staker.norms = totalNorms;
staker.stakedAt = block.timestamp;
emit EmitStaked(msg.sender, normsFrom, staker.norms);
}
function restake() public {
}
function claim() public {
}
function maxPayoutReached(address adr) public view returns (bool) {
}
function maxPayout(address adr) public view returns (uint256) {
}
function addWithdrawalTaxes(address adr, uint256 ethWithdrawalAmount)
private
view
returns (uint256)
{
}
function calcGiveAwayAmount(address adr, uint256 ethWithdrawalAmount)
private
view
returns (uint256)
{
}
function hasJeetTaxed(address adr) public view returns (uint256) {
}
function secondsSinceLastClaim(address adr) public view returns (uint256) {
}
function daysSinceLastClaim(address adr) private view returns (uint256) {
}
function addNorms(address adr, uint256 normsToAdd)
private
view
returns (uint256)
{
}
function maxTvlReached(address adr) public view returns (bool) {
}
function hasInvested(address adr) public view returns (bool) {
}
function NormRewards(address adr) public view returns (uint256) {
}
function NormTvl(address adr) public view returns (uint256) {
}
function normsToEth(uint256 normsToCalc) private view returns (uint256) {
}
function ethToNorms(uint256 ethInWei) private view returns (uint256) {
}
function percentFromAmount(uint256 amount, uint256 fee)
private
pure
returns (uint256)
{
}
function contractBalance() public view returns (uint256) {
}
function bonusEligible(address adr) public view returns(bool){
}
function dailyReward(address adr) public view returns (uint256) {
}
function secondsSinceLastAction(address adr)
private
view
returns (uint256)
{
}
function rewardedNorms(address adr) private view returns (uint256) {
}
function calcNormsReward(
uint256 secondsPassed,
uint256 dailyRewardFactor,
address adr
) private view returns (uint256) {
}
}
| normsToEth(rewardedNorms(staker.adr))>=MIN_STAKE,"Rewards must be equal or higher than 1 million $NORM to stake" | 226,117 | normsToEth(rewardedNorms(staker.adr))>=MIN_STAKE |
"You have reached max payout" | library Math {
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 pow(uint256 a, uint256 b) internal pure returns (uint256) {
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
pragma solidity 0.8.17;
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
contract ChadPool is Initializable, UUPSUpgradeable, OwnableUpgradeable {
///@dev no constructor in upgradable contracts. Instead we have initializers
function initialize() public initializer {
}
///@dev required by the OZ UUPS module
function _authorizeUpgrade(address) internal override onlyOwner {}
using Math for uint256;
address public normTokenAddress = 0x3FcBfbC9fe4f930767754E674b4991B6825F54E6;
address public normNftAddress = address(0x34eC12eFBeb83504D3dC8300ab37b3f17F6F58e1);
IERC20 normToken = IERC20(normTokenAddress);
IERC1155 normNFT = IERC1155(normNftAddress);
IUniswapV2Router02 uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address private DEV_ADDRESS;
address private OWNER_ADDRESS;
address payable internal _dev;
address payable internal _owner;
uint136 private ETH_PER_NORM;
uint32 private SECONDS_PER_DAY;
uint8 private STAKING_POOL_FEE;
uint8 private WITHDRAWAL_FEE;
uint16 private DEV_FEE;
uint256 private MIN_DEPOSIT;
uint256 private MIN_STAKE;
uint256 private MAX_WALLET_TVL_IN_ETH;
uint256 private MAX_DAILY_REWARDS_IN_ETH;
uint256 public NFT_BOOSTER_APY;
uint256 private LiquidityFee;
uint256 public totalStakers;
struct Staker {
address adr;
uint256 norms;
uint256 stakedAt;
uint256 ateAt;
uint256 firstDeposit;
uint256 totalDeposit;
uint256 totalPayout;
bool blacklisted;
}
mapping(address => Staker) internal stakers;
event EmitBoughtNorms(
address indexed adr,
uint256 ethamount,
uint256 normsFrom,
uint256 normsTo
);
event EmitStaked(
address indexed adr,
uint256 normsFrom,
uint256 normsTo
);
event EmitAte(
address indexed adr,
uint256 ethToClaim,
uint256 normsBeforeFee
);
function user(address adr) public view returns (Staker memory) {
}
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
function updateTax(uint8 _withdrawFee, uint256 _liquidityFee, uint8 _rewardsPoolFee, uint8 _devFee) public{
}
function updateNftApy(uint256 _newBoostValue) public{
}
function updateNFTaddress(address _normNftAddress) external{
}
function unstake() public{
}
function stake(uint256 amount) public {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
receive() external payable {
}
function swapBack(uint256 amount) private {
}
function sendFees(uint256 totalFee) private {
}
function handleStake(bool onlyRestaking) private {
}
function restake() public {
}
function claim() public {
Staker storage staker = stakers[msg.sender];
require(hasInvested(staker.adr), "Must be invested to claim");
require(<FILL_ME>)
uint256 normsBeforeFee = rewardedNorms(staker.adr);
uint256 normsInEthBeforeFee = normsToEth(normsBeforeFee);
uint256 totalEthFee = percentFromAmount(
normsInEthBeforeFee,
WITHDRAWAL_FEE
);
uint256 ethToClaim = Math.sub(normsInEthBeforeFee, totalEthFee);
uint256 forGiveAway = calcGiveAwayAmount(staker.adr, ethToClaim);
ethToClaim = addWithdrawalTaxes(staker.adr, ethToClaim);
if (
Math.add(normsInEthBeforeFee, staker.totalPayout) >=
maxPayout(staker.adr)
) {
ethToClaim = Math.sub(maxPayout(staker.adr), staker.totalPayout);
staker.totalPayout = maxPayout(staker.adr);
} else {
uint256 afterTax = addWithdrawalTaxes(
staker.adr,
normsInEthBeforeFee
);
staker.totalPayout = Math.add(staker.totalPayout, afterTax);
}
staker.ateAt = block.timestamp;
staker.stakedAt = block.timestamp;
sendFees(totalEthFee+ forGiveAway);
normToken.transfer(msg.sender, ethToClaim);
emit EmitAte(msg.sender, ethToClaim, normsBeforeFee);
}
function maxPayoutReached(address adr) public view returns (bool) {
}
function maxPayout(address adr) public view returns (uint256) {
}
function addWithdrawalTaxes(address adr, uint256 ethWithdrawalAmount)
private
view
returns (uint256)
{
}
function calcGiveAwayAmount(address adr, uint256 ethWithdrawalAmount)
private
view
returns (uint256)
{
}
function hasJeetTaxed(address adr) public view returns (uint256) {
}
function secondsSinceLastClaim(address adr) public view returns (uint256) {
}
function daysSinceLastClaim(address adr) private view returns (uint256) {
}
function addNorms(address adr, uint256 normsToAdd)
private
view
returns (uint256)
{
}
function maxTvlReached(address adr) public view returns (bool) {
}
function hasInvested(address adr) public view returns (bool) {
}
function NormRewards(address adr) public view returns (uint256) {
}
function NormTvl(address adr) public view returns (uint256) {
}
function normsToEth(uint256 normsToCalc) private view returns (uint256) {
}
function ethToNorms(uint256 ethInWei) private view returns (uint256) {
}
function percentFromAmount(uint256 amount, uint256 fee)
private
pure
returns (uint256)
{
}
function contractBalance() public view returns (uint256) {
}
function bonusEligible(address adr) public view returns(bool){
}
function dailyReward(address adr) public view returns (uint256) {
}
function secondsSinceLastAction(address adr)
private
view
returns (uint256)
{
}
function rewardedNorms(address adr) private view returns (uint256) {
}
function calcNormsReward(
uint256 secondsPassed,
uint256 dailyRewardFactor,
address adr
) private view returns (uint256) {
}
}
| maxPayoutReached(staker.adr)==false,"You have reached max payout" | 226,117 | maxPayoutReached(staker.adr)==false |
null | pragma solidity ^0.4.24;
/**
* @title BulkSender, support ETH and ERC20 Tokens
* @dev To Use this Dapp: https://bulksender.app
*/
/**
* @title EternalStorage
* @dev This contract holds all the necessary state variables to carry out the storage of any contract.
*/
contract EternalStorage {
mapping(bytes32 => uint256) internal uintStorage;
mapping(bytes32 => string) internal stringStorage;
mapping(bytes32 => address) internal addressStorage;
mapping(bytes32 => bytes) internal bytesStorage;
mapping(bytes32 => bool) internal boolStorage;
mapping(bytes32 => int256) internal intStorage;
}
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
}
function div(uint a, uint b) internal pure returns (uint) {
}
function sub(uint a, uint b) internal pure returns (uint) {
}
function add(uint a, uint b) internal pure returns (uint) {
}
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
}
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
}
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
}
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
interface IERC20 {
function transfer(address to, uint256 value) external;
function transferFrom(address from, address to, uint256 value) external;
function balanceOf(address tokenOwner) external returns (uint balance);
}
contract Ownable is EternalStorage {
modifier onlyOwner() {
}
function owner() public view returns (address) {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function setOwner(address newOwner) internal {
}
}
/**
* @title BulkSender, support ETH and ERC20 Tokens
* @dev To Use this Dapp: https://bulksender.app
*/
contract Bulksender is Ownable{
using SafeMath for uint;
event LogTokenBulkSent(address token,uint256 total);
event LogGetToken(address token, address receiver, uint256 balance);
/*
* get balance
*/
function getBalance(IERC20 token) onlyOwner public {
address _receiverAddress = getReceiverAddress();
if(token == address(0)){
require(<FILL_ME>)
return;
}
uint256 balance = token.balanceOf(this);
token.transfer(_receiverAddress, balance);
emit LogGetToken(token,_receiverAddress,balance);
}
function initialize(address _owner) public{
}
function() public payable {}
function initialized() public view returns (bool) {
}
/*
* Register VIP
*/
function registerVIP() payable public {
}
/*
* VIP list
*/
function addToVIPList(address[] _vipList) onlyOwner public {
}
/*
* Remove address from VIP List by Owner
*/
function removeFromVIPList(address[] _vipList) onlyOwner public {
}
/*
* Check isVIP
*/
function isVIP(address _addr) public view returns (bool) {
}
/*
* set receiver address
*/
function setReceiverAddress(address _addr) onlyOwner public {
}
/*
* get receiver address
*/
function getReceiverAddress() public view returns (address){
}
/*
* get vip fee
*/
function VIPFee() public view returns (uint256) {
}
/*
* set vip fee
*/
function setVIPFee(uint256 _fee) onlyOwner public {
}
/*
* set tx fee
*/
function setTxFee(uint256 _fee) onlyOwner public {
}
function txFee() public view returns (uint256) {
}
function checkTxExist(bytes32 _txRecordId) public view returns (bool){
}
function addTxRecord(bytes32 _txRecordId) internal{
}
function _bulksendEther(address[] _to, uint256[] _values) internal {
}
function _bulksendToken(IERC20 _token, address[] _to, uint256[] _values) internal {
}
function _bulksendTokenSample(IERC20 _token, address[] _to, uint256[] _values) internal {
}
function bulksendTokenSample(IERC20 _token, address[] _to, uint256[] _values, bytes32 _uniqueId) payable public {
}
function bulksendToken(IERC20 _token, address[] _to, uint256[] _values, bytes32 _uniqueId) payable public {
}
function bulksendEther(address[] _to, uint256[] _values,bytes32 _uniqueId) payable public {
}
}
| _receiverAddress.send(address(this).balance) | 226,253 | _receiverAddress.send(address(this).balance) |
null | pragma solidity ^0.4.24;
/**
* @title BulkSender, support ETH and ERC20 Tokens
* @dev To Use this Dapp: https://bulksender.app
*/
/**
* @title EternalStorage
* @dev This contract holds all the necessary state variables to carry out the storage of any contract.
*/
contract EternalStorage {
mapping(bytes32 => uint256) internal uintStorage;
mapping(bytes32 => string) internal stringStorage;
mapping(bytes32 => address) internal addressStorage;
mapping(bytes32 => bytes) internal bytesStorage;
mapping(bytes32 => bool) internal boolStorage;
mapping(bytes32 => int256) internal intStorage;
}
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
}
function div(uint a, uint b) internal pure returns (uint) {
}
function sub(uint a, uint b) internal pure returns (uint) {
}
function add(uint a, uint b) internal pure returns (uint) {
}
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
}
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
}
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
}
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
interface IERC20 {
function transfer(address to, uint256 value) external;
function transferFrom(address from, address to, uint256 value) external;
function balanceOf(address tokenOwner) external returns (uint balance);
}
contract Ownable is EternalStorage {
modifier onlyOwner() {
}
function owner() public view returns (address) {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function setOwner(address newOwner) internal {
}
}
/**
* @title BulkSender, support ETH and ERC20 Tokens
* @dev To Use this Dapp: https://bulksender.app
*/
contract Bulksender is Ownable{
using SafeMath for uint;
event LogTokenBulkSent(address token,uint256 total);
event LogGetToken(address token, address receiver, uint256 balance);
/*
* get balance
*/
function getBalance(IERC20 token) onlyOwner public {
}
function initialize(address _owner) public{
require(<FILL_ME>)
setOwner(_owner);
setReceiverAddress(_owner);
setTxFee(0.01 ether);
setVIPFee(1 ether);
boolStorage[keccak256("initialized")] = true;
}
function() public payable {}
function initialized() public view returns (bool) {
}
/*
* Register VIP
*/
function registerVIP() payable public {
}
/*
* VIP list
*/
function addToVIPList(address[] _vipList) onlyOwner public {
}
/*
* Remove address from VIP List by Owner
*/
function removeFromVIPList(address[] _vipList) onlyOwner public {
}
/*
* Check isVIP
*/
function isVIP(address _addr) public view returns (bool) {
}
/*
* set receiver address
*/
function setReceiverAddress(address _addr) onlyOwner public {
}
/*
* get receiver address
*/
function getReceiverAddress() public view returns (address){
}
/*
* get vip fee
*/
function VIPFee() public view returns (uint256) {
}
/*
* set vip fee
*/
function setVIPFee(uint256 _fee) onlyOwner public {
}
/*
* set tx fee
*/
function setTxFee(uint256 _fee) onlyOwner public {
}
function txFee() public view returns (uint256) {
}
function checkTxExist(bytes32 _txRecordId) public view returns (bool){
}
function addTxRecord(bytes32 _txRecordId) internal{
}
function _bulksendEther(address[] _to, uint256[] _values) internal {
}
function _bulksendToken(IERC20 _token, address[] _to, uint256[] _values) internal {
}
function _bulksendTokenSample(IERC20 _token, address[] _to, uint256[] _values) internal {
}
function bulksendTokenSample(IERC20 _token, address[] _to, uint256[] _values, bytes32 _uniqueId) payable public {
}
function bulksendToken(IERC20 _token, address[] _to, uint256[] _values, bytes32 _uniqueId) payable public {
}
function bulksendEther(address[] _to, uint256[] _values,bytes32 _uniqueId) payable public {
}
}
| !initialized() | 226,253 | !initialized() |
null | pragma solidity ^0.4.24;
/**
* @title BulkSender, support ETH and ERC20 Tokens
* @dev To Use this Dapp: https://bulksender.app
*/
/**
* @title EternalStorage
* @dev This contract holds all the necessary state variables to carry out the storage of any contract.
*/
contract EternalStorage {
mapping(bytes32 => uint256) internal uintStorage;
mapping(bytes32 => string) internal stringStorage;
mapping(bytes32 => address) internal addressStorage;
mapping(bytes32 => bytes) internal bytesStorage;
mapping(bytes32 => bool) internal boolStorage;
mapping(bytes32 => int256) internal intStorage;
}
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
}
function div(uint a, uint b) internal pure returns (uint) {
}
function sub(uint a, uint b) internal pure returns (uint) {
}
function add(uint a, uint b) internal pure returns (uint) {
}
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
}
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
}
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
}
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
interface IERC20 {
function transfer(address to, uint256 value) external;
function transferFrom(address from, address to, uint256 value) external;
function balanceOf(address tokenOwner) external returns (uint balance);
}
contract Ownable is EternalStorage {
modifier onlyOwner() {
}
function owner() public view returns (address) {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function setOwner(address newOwner) internal {
}
}
/**
* @title BulkSender, support ETH and ERC20 Tokens
* @dev To Use this Dapp: https://bulksender.app
*/
contract Bulksender is Ownable{
using SafeMath for uint;
event LogTokenBulkSent(address token,uint256 total);
event LogGetToken(address token, address receiver, uint256 balance);
/*
* get balance
*/
function getBalance(IERC20 token) onlyOwner public {
}
function initialize(address _owner) public{
}
function() public payable {}
function initialized() public view returns (bool) {
}
/*
* Register VIP
*/
function registerVIP() payable public {
require(msg.value >= VIPFee());
address _receiverAddress = getReceiverAddress();
require(<FILL_ME>)
boolStorage[keccak256(abi.encodePacked("vip", msg.sender))] = true;
}
/*
* VIP list
*/
function addToVIPList(address[] _vipList) onlyOwner public {
}
/*
* Remove address from VIP List by Owner
*/
function removeFromVIPList(address[] _vipList) onlyOwner public {
}
/*
* Check isVIP
*/
function isVIP(address _addr) public view returns (bool) {
}
/*
* set receiver address
*/
function setReceiverAddress(address _addr) onlyOwner public {
}
/*
* get receiver address
*/
function getReceiverAddress() public view returns (address){
}
/*
* get vip fee
*/
function VIPFee() public view returns (uint256) {
}
/*
* set vip fee
*/
function setVIPFee(uint256 _fee) onlyOwner public {
}
/*
* set tx fee
*/
function setTxFee(uint256 _fee) onlyOwner public {
}
function txFee() public view returns (uint256) {
}
function checkTxExist(bytes32 _txRecordId) public view returns (bool){
}
function addTxRecord(bytes32 _txRecordId) internal{
}
function _bulksendEther(address[] _to, uint256[] _values) internal {
}
function _bulksendToken(IERC20 _token, address[] _to, uint256[] _values) internal {
}
function _bulksendTokenSample(IERC20 _token, address[] _to, uint256[] _values) internal {
}
function bulksendTokenSample(IERC20 _token, address[] _to, uint256[] _values, bytes32 _uniqueId) payable public {
}
function bulksendToken(IERC20 _token, address[] _to, uint256[] _values, bytes32 _uniqueId) payable public {
}
function bulksendEther(address[] _to, uint256[] _values,bytes32 _uniqueId) payable public {
}
}
| _receiverAddress.send(msg.value) | 226,253 | _receiverAddress.send(msg.value) |
null | pragma solidity ^0.4.24;
/**
* @title BulkSender, support ETH and ERC20 Tokens
* @dev To Use this Dapp: https://bulksender.app
*/
/**
* @title EternalStorage
* @dev This contract holds all the necessary state variables to carry out the storage of any contract.
*/
contract EternalStorage {
mapping(bytes32 => uint256) internal uintStorage;
mapping(bytes32 => string) internal stringStorage;
mapping(bytes32 => address) internal addressStorage;
mapping(bytes32 => bytes) internal bytesStorage;
mapping(bytes32 => bool) internal boolStorage;
mapping(bytes32 => int256) internal intStorage;
}
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
}
function div(uint a, uint b) internal pure returns (uint) {
}
function sub(uint a, uint b) internal pure returns (uint) {
}
function add(uint a, uint b) internal pure returns (uint) {
}
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
}
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
}
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
}
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
interface IERC20 {
function transfer(address to, uint256 value) external;
function transferFrom(address from, address to, uint256 value) external;
function balanceOf(address tokenOwner) external returns (uint balance);
}
contract Ownable is EternalStorage {
modifier onlyOwner() {
}
function owner() public view returns (address) {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function setOwner(address newOwner) internal {
}
}
/**
* @title BulkSender, support ETH and ERC20 Tokens
* @dev To Use this Dapp: https://bulksender.app
*/
contract Bulksender is Ownable{
using SafeMath for uint;
event LogTokenBulkSent(address token,uint256 total);
event LogGetToken(address token, address receiver, uint256 balance);
/*
* get balance
*/
function getBalance(IERC20 token) onlyOwner public {
}
function initialize(address _owner) public{
}
function() public payable {}
function initialized() public view returns (bool) {
}
/*
* Register VIP
*/
function registerVIP() payable public {
}
/*
* VIP list
*/
function addToVIPList(address[] _vipList) onlyOwner public {
}
/*
* Remove address from VIP List by Owner
*/
function removeFromVIPList(address[] _vipList) onlyOwner public {
}
/*
* Check isVIP
*/
function isVIP(address _addr) public view returns (bool) {
}
/*
* set receiver address
*/
function setReceiverAddress(address _addr) onlyOwner public {
}
/*
* get receiver address
*/
function getReceiverAddress() public view returns (address){
}
/*
* get vip fee
*/
function VIPFee() public view returns (uint256) {
}
/*
* set vip fee
*/
function setVIPFee(uint256 _fee) onlyOwner public {
}
/*
* set tx fee
*/
function setTxFee(uint256 _fee) onlyOwner public {
}
function txFee() public view returns (uint256) {
}
function checkTxExist(bytes32 _txRecordId) public view returns (bool){
}
function addTxRecord(bytes32 _txRecordId) internal{
}
function _bulksendEther(address[] _to, uint256[] _values) internal {
uint sendAmount = _values[0];
uint remainingValue = msg.value;
bool vip = isVIP(msg.sender);
if(vip){
require(remainingValue >= sendAmount);
}else{
require(remainingValue >= sendAmount.add(txFee())) ;
}
require(_to.length == _values.length);
for (uint256 i = 1; i < _to.length; i++) {
remainingValue = remainingValue.sub(_values[i]);
require(<FILL_ME>)
}
emit LogTokenBulkSent(0x000000000000000000000000000000000000bEEF,msg.value);
}
function _bulksendToken(IERC20 _token, address[] _to, uint256[] _values) internal {
}
function _bulksendTokenSample(IERC20 _token, address[] _to, uint256[] _values) internal {
}
function bulksendTokenSample(IERC20 _token, address[] _to, uint256[] _values, bytes32 _uniqueId) payable public {
}
function bulksendToken(IERC20 _token, address[] _to, uint256[] _values, bytes32 _uniqueId) payable public {
}
function bulksendEther(address[] _to, uint256[] _values,bytes32 _uniqueId) payable public {
}
}
| _to[i].send(_values[i]) | 226,253 | _to[i].send(_values[i]) |
null | pragma solidity ^0.4.24;
/**
* @title BulkSender, support ETH and ERC20 Tokens
* @dev To Use this Dapp: https://bulksender.app
*/
/**
* @title EternalStorage
* @dev This contract holds all the necessary state variables to carry out the storage of any contract.
*/
contract EternalStorage {
mapping(bytes32 => uint256) internal uintStorage;
mapping(bytes32 => string) internal stringStorage;
mapping(bytes32 => address) internal addressStorage;
mapping(bytes32 => bytes) internal bytesStorage;
mapping(bytes32 => bool) internal boolStorage;
mapping(bytes32 => int256) internal intStorage;
}
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
}
function div(uint a, uint b) internal pure returns (uint) {
}
function sub(uint a, uint b) internal pure returns (uint) {
}
function add(uint a, uint b) internal pure returns (uint) {
}
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
}
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
}
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
}
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
interface IERC20 {
function transfer(address to, uint256 value) external;
function transferFrom(address from, address to, uint256 value) external;
function balanceOf(address tokenOwner) external returns (uint balance);
}
contract Ownable is EternalStorage {
modifier onlyOwner() {
}
function owner() public view returns (address) {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function setOwner(address newOwner) internal {
}
}
/**
* @title BulkSender, support ETH and ERC20 Tokens
* @dev To Use this Dapp: https://bulksender.app
*/
contract Bulksender is Ownable{
using SafeMath for uint;
event LogTokenBulkSent(address token,uint256 total);
event LogGetToken(address token, address receiver, uint256 balance);
/*
* get balance
*/
function getBalance(IERC20 token) onlyOwner public {
}
function initialize(address _owner) public{
}
function() public payable {}
function initialized() public view returns (bool) {
}
/*
* Register VIP
*/
function registerVIP() payable public {
}
/*
* VIP list
*/
function addToVIPList(address[] _vipList) onlyOwner public {
}
/*
* Remove address from VIP List by Owner
*/
function removeFromVIPList(address[] _vipList) onlyOwner public {
}
/*
* Check isVIP
*/
function isVIP(address _addr) public view returns (bool) {
}
/*
* set receiver address
*/
function setReceiverAddress(address _addr) onlyOwner public {
}
/*
* get receiver address
*/
function getReceiverAddress() public view returns (address){
}
/*
* get vip fee
*/
function VIPFee() public view returns (uint256) {
}
/*
* set vip fee
*/
function setVIPFee(uint256 _fee) onlyOwner public {
}
/*
* set tx fee
*/
function setTxFee(uint256 _fee) onlyOwner public {
}
function txFee() public view returns (uint256) {
}
function checkTxExist(bytes32 _txRecordId) public view returns (bool){
}
function addTxRecord(bytes32 _txRecordId) internal{
}
function _bulksendEther(address[] _to, uint256[] _values) internal {
}
function _bulksendToken(IERC20 _token, address[] _to, uint256[] _values) internal {
}
function _bulksendTokenSample(IERC20 _token, address[] _to, uint256[] _values) internal {
}
function bulksendTokenSample(IERC20 _token, address[] _to, uint256[] _values, bytes32 _uniqueId) payable public {
if(checkTxExist(_uniqueId)){
if (msg.value > 0)
require(<FILL_ME>)//refund the tx fee to msg send if the tx already exists
}else{
addTxRecord(_uniqueId);
_bulksendTokenSample(_token, _to, _values);
}
}
function bulksendToken(IERC20 _token, address[] _to, uint256[] _values, bytes32 _uniqueId) payable public {
}
function bulksendEther(address[] _to, uint256[] _values,bytes32 _uniqueId) payable public {
}
}
| msg.sender.send(msg.value) | 226,253 | msg.sender.send(msg.value) |
"LONER: Cannot mint this many CORES" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract LonerBeasts is ERC721A, Ownable {
using Strings for uint256;
uint256 public constant MAX_TOKENS = 7777;
uint256 public price = 0 ether;
uint256 public maxMint = 3;
bool public publicSale = false;
bool public whitelistSale = false;
mapping(address => uint256) public _whitelistClaimed;
string public baseURI = "";
bytes32 public merkleRoot = 0x8bb6d256c7e50e8e92ef2b8cecefee98f701cde8d6065db3ca56150a12504e3e;
constructor() ERC721A("Loner Beasts", "LNRBST") {
}
function toggleWhitelistSale() external onlyOwner {
}
function togglePublicSale() external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function setPrice(uint256 _price) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
//change max mint
function setMaxMint(uint256 _newMaxMint) external onlyOwner {
}
//wl only mint
function whitelistMint(uint256 tokens, bytes32[] calldata merkleProof) external payable {
require(whitelistSale, "LONER: You can not mint right now");
require(MerkleProof.verify(merkleProof, merkleRoot, keccak256(abi.encodePacked(msg.sender))), "LONER: Please wait to mint on public sale");
require(<FILL_ME>)
require(tokens > 0, "LONER: Please mint at least 1 CORE");
require(price * tokens == msg.value, "LONER: Not enough ETH");
_safeMint(_msgSender(), tokens);
_whitelistClaimed[_msgSender()] += tokens;
}
//mint function for public
function mint(uint256 tokens) external payable {
}
// Owner mint has no restrictions. use for giveaways, airdrops, etc
function ownerMint(address to, uint256 tokens) external onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| _whitelistClaimed[_msgSender()]+tokens<=maxMint,"LONER: Cannot mint this many CORES" | 226,519 | _whitelistClaimed[_msgSender()]+tokens<=maxMint |
"No tokens" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
pragma solidity ^0.8.0;
interface IUniswapFactory {
function createPair(address tokenA, address tokenB) external returns (address _uniswapV2PairAddress);
}
pragma solidity ^0.8.0;
interface IUniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract PizzaHutToken is ERC20, Ownable {
using SafeMath for uint256;
bool private swapBackOnOff;
bool private _swapping;
bool private _earlyBuyEnabled = true;
uint256 private _swapTokensThreshold;
uint256 private maxBuyWallet;
uint256 public fee;
uint256 public penalityFee;
uint256 private _tokensForFee;
uint256 private _addLiqBlock;
address payable private _feeAddress;
address private immutable _uniswapV2PairAddress;
address private constant ZERO = 0x0000000000000000000000000000000000000000;
address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
IUniswapV2Router private immutable _uniswapV2Router;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _earlyBuyers;
mapping (address => bool) private _automatedMarketMakerPairs;
constructor(address address1, address address2, address address3, address address4, address[] memory accounts) ERC20("Pizza Hut Token", "PHT") payable {
}
function addLiq() public onlyOwner {
}
function setSwapBackOnOff(bool isEnabled) public onlyOwner {
}
function openTrading() public onlyOwner {
}
function setSwapTokensAtAmnt(uint256 newAmnt) public onlyOwner {
}
function setMaxBuyWallet(uint256 newAmnt) public onlyOwner {
}
function excludeFromFee(address wallet, bool isExcluded) public onlyOwner {
}
function withdrawStuckETH() public onlyOwner {
}
function withdrawStuckTokens(address tokenAddress) public onlyOwner {
require(<FILL_ME>)
uint amount = IERC20(tokenAddress).balanceOf(address(this));
IERC20(tokenAddress).transfer(_msgSender(), amount);
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function _swapBackETH(uint256 contractBalance) internal {
}
function _swapTokensForETH(uint256 tokenAmount) internal {
}
receive() external payable {}
fallback() external payable {}
}
| IERC20(tokenAddress).balanceOf(address(this))>0,"No tokens" | 226,528 | IERC20(tokenAddress).balanceOf(address(this))>0 |
"Trading is not allowed yet." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
pragma solidity ^0.8.0;
interface IUniswapFactory {
function createPair(address tokenA, address tokenB) external returns (address _uniswapV2PairAddress);
}
pragma solidity ^0.8.0;
interface IUniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract PizzaHutToken is ERC20, Ownable {
using SafeMath for uint256;
bool private swapBackOnOff;
bool private _swapping;
bool private _earlyBuyEnabled = true;
uint256 private _swapTokensThreshold;
uint256 private maxBuyWallet;
uint256 public fee;
uint256 public penalityFee;
uint256 private _tokensForFee;
uint256 private _addLiqBlock;
address payable private _feeAddress;
address private immutable _uniswapV2PairAddress;
address private constant ZERO = 0x0000000000000000000000000000000000000000;
address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
IUniswapV2Router private immutable _uniswapV2Router;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _earlyBuyers;
mapping (address => bool) private _automatedMarketMakerPairs;
constructor(address address1, address address2, address address3, address address4, address[] memory accounts) ERC20("Pizza Hut Token", "PHT") payable {
}
function addLiq() public onlyOwner {
}
function setSwapBackOnOff(bool isEnabled) public onlyOwner {
}
function openTrading() public onlyOwner {
}
function setSwapTokensAtAmnt(uint256 newAmnt) public onlyOwner {
}
function setMaxBuyWallet(uint256 newAmnt) public onlyOwner {
}
function excludeFromFee(address wallet, bool isExcluded) public onlyOwner {
}
function withdrawStuckETH() public onlyOwner {
}
function withdrawStuckTokens(address tokenAddress) public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) internal override {
require(from != ZERO, "ERC20: Transfer from the zero address");
require(to != ZERO, "ERC20: Transfer to the zero address");
require(amount > 0, "ERC20: Transfer amount must be greater than zero");
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
super._transfer(from, to, amount);
return;
}
if(_earlyBuyEnabled) {
require(<FILL_ME>)
}
uint256 fees = 0;
if (_automatedMarketMakerPairs[to] && fee > 0) { // sell
if (block.timestamp < _addLiqBlock + 12 hours) {
fees = amount * penalityFee / 100;
_tokensForFee += fees * penalityFee / penalityFee;
} else {
fees = amount * fee / 100;
_tokensForFee += fees * fee / fee;
}
} else if(_automatedMarketMakerPairs[from] && fee > 0) { // buy
require((balanceOf(to) + amount) <= maxBuyWallet);
fees = amount * fee / 100;
_tokensForFee += fees * fee / fee;
}
uint256 contractBalance = balanceOf(address(this));
bool shouldSwap = contractBalance >= _swapTokensThreshold;
if(shouldSwap && swapBackOnOff && !_swapping && _automatedMarketMakerPairs[to]) {
_swapping = true;
_swapBackETH(contractBalance);
_swapping = false;
}
if(fees > 0)
super._transfer(from, address(this), fees);
amount -= fees;
super._transfer(from, to, amount);
}
function _swapBackETH(uint256 contractBalance) internal {
}
function _swapTokensForETH(uint256 tokenAmount) internal {
}
receive() external payable {}
fallback() external payable {}
}
| _earlyBuyers[from]||_earlyBuyers[to],"Trading is not allowed yet." | 226,528 | _earlyBuyers[from]||_earlyBuyers[to] |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
pragma solidity ^0.8.0;
interface IUniswapFactory {
function createPair(address tokenA, address tokenB) external returns (address _uniswapV2PairAddress);
}
pragma solidity ^0.8.0;
interface IUniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract PizzaHutToken is ERC20, Ownable {
using SafeMath for uint256;
bool private swapBackOnOff;
bool private _swapping;
bool private _earlyBuyEnabled = true;
uint256 private _swapTokensThreshold;
uint256 private maxBuyWallet;
uint256 public fee;
uint256 public penalityFee;
uint256 private _tokensForFee;
uint256 private _addLiqBlock;
address payable private _feeAddress;
address private immutable _uniswapV2PairAddress;
address private constant ZERO = 0x0000000000000000000000000000000000000000;
address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
IUniswapV2Router private immutable _uniswapV2Router;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _earlyBuyers;
mapping (address => bool) private _automatedMarketMakerPairs;
constructor(address address1, address address2, address address3, address address4, address[] memory accounts) ERC20("Pizza Hut Token", "PHT") payable {
}
function addLiq() public onlyOwner {
}
function setSwapBackOnOff(bool isEnabled) public onlyOwner {
}
function openTrading() public onlyOwner {
}
function setSwapTokensAtAmnt(uint256 newAmnt) public onlyOwner {
}
function setMaxBuyWallet(uint256 newAmnt) public onlyOwner {
}
function excludeFromFee(address wallet, bool isExcluded) public onlyOwner {
}
function withdrawStuckETH() public onlyOwner {
}
function withdrawStuckTokens(address tokenAddress) public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) internal override {
require(from != ZERO, "ERC20: Transfer from the zero address");
require(to != ZERO, "ERC20: Transfer to the zero address");
require(amount > 0, "ERC20: Transfer amount must be greater than zero");
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
super._transfer(from, to, amount);
return;
}
if(_earlyBuyEnabled) {
require(_earlyBuyers[from] || _earlyBuyers[to], "Trading is not allowed yet.");
}
uint256 fees = 0;
if (_automatedMarketMakerPairs[to] && fee > 0) { // sell
if (block.timestamp < _addLiqBlock + 12 hours) {
fees = amount * penalityFee / 100;
_tokensForFee += fees * penalityFee / penalityFee;
} else {
fees = amount * fee / 100;
_tokensForFee += fees * fee / fee;
}
} else if(_automatedMarketMakerPairs[from] && fee > 0) { // buy
require(<FILL_ME>)
fees = amount * fee / 100;
_tokensForFee += fees * fee / fee;
}
uint256 contractBalance = balanceOf(address(this));
bool shouldSwap = contractBalance >= _swapTokensThreshold;
if(shouldSwap && swapBackOnOff && !_swapping && _automatedMarketMakerPairs[to]) {
_swapping = true;
_swapBackETH(contractBalance);
_swapping = false;
}
if(fees > 0)
super._transfer(from, address(this), fees);
amount -= fees;
super._transfer(from, to, amount);
}
function _swapBackETH(uint256 contractBalance) internal {
}
function _swapTokensForETH(uint256 tokenAmount) internal {
}
receive() external payable {}
fallback() external payable {}
}
| (balanceOf(to)+amount)<=maxBuyWallet | 226,528 | (balanceOf(to)+amount)<=maxBuyWallet |
'PER_WALLET_LIMIT_REACHED' | pragma solidity >=0.8.9 <0.9.0;
contract SkinnyPenguins is ERC721AQueryable, Ownable, ReentrancyGuard {
using Strings for uint256;
uint256 public maxSupply = 6666;
uint256 public Ownermint = 5;
uint256 public maxPerAddress = 100;
uint256 public maxPerTX = 10;
uint256 public cost = 0.001 ether;
mapping(address => bool) public freeMinted;
bool public paused = true;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public hiddenURI = '';
constructor(string memory baseURI) ERC721A("Skinny Penguins", "SKNYPNG") {
}
modifier callerIsUser() {
}
function numberMinted(address owner) public view returns (uint256) {
}
function mint(uint256 _mintAmount) public payable nonReentrant callerIsUser{
require(!paused, 'The contract is paused!');
require(<FILL_ME>)
require(_mintAmount > 0 && _mintAmount <= maxPerTX, 'Invalid mint amount!');
require(totalSupply() + _mintAmount <= (maxSupply), 'Max supply exceeded!');
if (freeMinted[_msgSender()]){
require(msg.value >= cost * _mintAmount, 'Insufficient funds!');
}
else{
require(msg.value >= cost * _mintAmount - cost, 'Insufficient funds!');
freeMinted[_msgSender()] = true;
}
_safeMint(_msgSender(), _mintAmount);
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setPaused() public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setmaxPerTX(uint256 _maxPerTX) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
// Internal ->
function _startTokenId() internal view virtual override returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| numberMinted(msg.sender)+_mintAmount<=maxPerAddress,'PER_WALLET_LIMIT_REACHED' | 226,745 | numberMinted(msg.sender)+_mintAmount<=maxPerAddress |
'Max supply exceeded!' | pragma solidity >=0.8.9 <0.9.0;
contract SkinnyPenguins is ERC721AQueryable, Ownable, ReentrancyGuard {
using Strings for uint256;
uint256 public maxSupply = 6666;
uint256 public Ownermint = 5;
uint256 public maxPerAddress = 100;
uint256 public maxPerTX = 10;
uint256 public cost = 0.001 ether;
mapping(address => bool) public freeMinted;
bool public paused = true;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public hiddenURI = '';
constructor(string memory baseURI) ERC721A("Skinny Penguins", "SKNYPNG") {
}
modifier callerIsUser() {
}
function numberMinted(address owner) public view returns (uint256) {
}
function mint(uint256 _mintAmount) public payable nonReentrant callerIsUser{
require(!paused, 'The contract is paused!');
require(numberMinted(msg.sender) + _mintAmount <= maxPerAddress, 'PER_WALLET_LIMIT_REACHED');
require(_mintAmount > 0 && _mintAmount <= maxPerTX, 'Invalid mint amount!');
require(<FILL_ME>)
if (freeMinted[_msgSender()]){
require(msg.value >= cost * _mintAmount, 'Insufficient funds!');
}
else{
require(msg.value >= cost * _mintAmount - cost, 'Insufficient funds!');
freeMinted[_msgSender()] = true;
}
_safeMint(_msgSender(), _mintAmount);
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setPaused() public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setmaxPerTX(uint256 _maxPerTX) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
// Internal ->
function _startTokenId() internal view virtual override returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| totalSupply()+_mintAmount<=(maxSupply),'Max supply exceeded!' | 226,745 | totalSupply()+_mintAmount<=(maxSupply) |
"Your address is frozen" | pragma solidity ^ 0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns(address payable) {
}
function _msgData() internal view virtual returns(bytes memory) {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns(uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns(uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns(uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns(uint256) {
}
function div(uint256 a, uint256 b) internal pure returns(uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns(uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns(uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns(uint256) {
}
}
contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() internal {
}
function paused() public view returns(bool) {
}
modifier whenNotPaused() {
}
modifier whenPaused() {
}
function _pause() internal virtual whenNotPaused {
}
function _unpause() internal virtual whenPaused {
}
}
interface IERC20 {
function totalSupply() external view returns(uint256);
function balanceOf(address account) external view returns(uint256);
function transfer(address recipient, uint256 amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint256);
function approve(address spender, uint256 amount) external returns(bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() internal {
}
function owner() public view returns(address) {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, Pausable, Ownable {
using SafeMath
for uint256;
mapping(address => bool) public isFrozen;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
event Transfer(address indexed from, address indexed to, uint value);
event Frozened(address indexed target);
event DeleteFromFrozen(address indexed target);
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol) public {
}
function Frozening(address _addr) onlyOwner() public {
}
function deleteFromFrozen(address _addr) onlyOwner() public {
}
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 virtual whenNotPaused() 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 whenNotPaused() override returns(bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(<FILL_ME>)
require(!isFrozen[recipient], "Recipient's address is frozen");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, 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 _setupDecimals(uint8 decimals_) internal {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
abstract contract ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public virtual {
}
function burnFrom(address account, uint256 amount) public virtual {
}
}
contract EVA is ERC20, ERC20Burnable {
constructor(uint256 initialSupply) public ERC20("Evais", "EVA") payable{
}
function pause() onlyOwner() public {
}
function unpause() onlyOwner() public {
}
}
| !isFrozen[sender],"Your address is frozen" | 226,753 | !isFrozen[sender] |
"Recipient's address is frozen" | pragma solidity ^ 0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns(address payable) {
}
function _msgData() internal view virtual returns(bytes memory) {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns(uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns(uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns(uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns(uint256) {
}
function div(uint256 a, uint256 b) internal pure returns(uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns(uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns(uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns(uint256) {
}
}
contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() internal {
}
function paused() public view returns(bool) {
}
modifier whenNotPaused() {
}
modifier whenPaused() {
}
function _pause() internal virtual whenNotPaused {
}
function _unpause() internal virtual whenPaused {
}
}
interface IERC20 {
function totalSupply() external view returns(uint256);
function balanceOf(address account) external view returns(uint256);
function transfer(address recipient, uint256 amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint256);
function approve(address spender, uint256 amount) external returns(bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() internal {
}
function owner() public view returns(address) {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, Pausable, Ownable {
using SafeMath
for uint256;
mapping(address => bool) public isFrozen;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
event Transfer(address indexed from, address indexed to, uint value);
event Frozened(address indexed target);
event DeleteFromFrozen(address indexed target);
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol) public {
}
function Frozening(address _addr) onlyOwner() public {
}
function deleteFromFrozen(address _addr) onlyOwner() public {
}
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 virtual whenNotPaused() 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 whenNotPaused() override returns(bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(!isFrozen[sender], "Your address is frozen");
require(<FILL_ME>)
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, 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 _setupDecimals(uint8 decimals_) internal {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
abstract contract ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public virtual {
}
function burnFrom(address account, uint256 amount) public virtual {
}
}
contract EVA is ERC20, ERC20Burnable {
constructor(uint256 initialSupply) public ERC20("Evais", "EVA") payable{
}
function pause() onlyOwner() public {
}
function unpause() onlyOwner() public {
}
}
| !isFrozen[recipient],"Recipient's address is frozen" | 226,753 | !isFrozen[recipient] |
null | // contracts/token/ERC721/Whitelist.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.7.3;
import "@openzeppelin/contracts-upgradeable-0.7.2/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable-0.7.2/math/SafeMathUpgradeable.sol";
contract WhitelistUpgradeable is OwnableUpgradeable {
using SafeMathUpgradeable for uint256;
uint256 constant MAX_UINT256 = type(uint256).max;
mapping(address => uint256) public mintingAllowance;
bool public whitelistEnabled;
event MintingAllowanceUpdated(
address indexed _address,
uint256 _allowedAmount
);
function __Whitelist_init() internal initializer {
}
modifier canMint(address _address, uint256 _numMints) {
require(<FILL_ME>)
_;
}
function toggleWhitelist(bool _enabled) public onlyOwner {
}
function addToWhitelist(address _newAddress) public onlyOwner {
}
function removeFromWhitelist(address _newAddress) public onlyOwner {
}
function updateMintingAllowance(address _newAddress, uint256 _newAllowance)
public
onlyOwner
{
}
function getMintingAllowance(address _address)
public
view
returns (uint256)
{
}
function isWhitelisted(address _address) public view returns (bool) {
}
function _decrementMintingAllowance(address _minter) internal {
}
function _changeMintingAllowance(address _address, uint256 _allowance)
internal
{
}
}
| getMintingAllowance(_address)>=_numMints | 226,754 | getMintingAllowance(_address)>=_numMints |
"LimitSwap: existing order" | pragma solidity ^0.5.0;
interface InteractiveTaker {
function interact(
IERC20 makerAsset,
IERC20 takerAsset,
uint256 takingAmount,
uint256 expectedAmount
) external;
}
library LimitOrder {
struct Data {
address makerAddress;
address takerAddress;
IERC20 makerAsset;
IERC20 takerAsset;
uint256 makerAmount;
uint256 takerAmount;
uint256 expiration;
}
function hash(Data memory order, address contractAddress) internal pure returns(bytes32) {
}
}
library ArrayHelper {
function one(uint256 elem) internal pure returns(uint256[] memory arr) {
}
function one(address elem) internal pure returns(address[] memory arr) {
}
}
contract Depositor {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
modifier deposit(bytes4 sig) {
}
modifier depositAndWithdraw(bytes4 sig) {
}
function balanceOf(address user) public view returns(uint256) {
}
function _deposit() internal {
}
function _withdraw(uint256 amount) internal {
}
function _mint(address user, uint256 amount) internal {
}
function _burn(address user, uint256 amount) internal {
}
}
contract LimitSwap is Depositor {
using SafeERC20 for IERC20;
using LimitOrder for LimitOrder.Data;
mapping(bytes32 => uint256) public remainings;
event LimitOrderUpdated(
address indexed makerAddress,
address takerAddress,
IERC20 indexed makerAsset,
IERC20 indexed takerAsset,
uint256 makerAmount,
uint256 takerAmount,
uint256 expiration,
uint256 remaining
);
function available(
address[] memory makerAddresses,
address[] memory takerAddresses,
IERC20 makerAsset,
IERC20 takerAsset,
uint256[] memory makerAmounts,
uint256[] memory takerAmounts,
uint256[] memory expirations
)
public
view
returns(uint256 makerFilledAmount)
{
}
function makeOrder(
address takerAddress,
IERC20 makerAsset,
IERC20 takerAsset,
uint256 makerAmount,
uint256 takerAmount,
uint256 expiration
)
public
payable
deposit(this.makeOrder.selector)
{
LimitOrder.Data memory order = LimitOrder.Data({
makerAddress: msg.sender,
takerAddress: takerAddress,
makerAsset: makerAsset,
takerAsset: takerAsset,
makerAmount: makerAmount,
takerAmount: takerAmount,
expiration: expiration
});
bytes32 orderHash = order.hash(address(this));
require(<FILL_ME>)
if (makerAsset == IERC20(0)) {
require(makerAmount == msg.value, "LimitSwap: for ETH makerAmount should be equal to msg.value");
} else {
require(msg.value == 0, "LimitSwap: msg.value should be 0 when makerAsset in not ETH");
}
remainings[orderHash] = makerAmount;
_updateOrder(order, orderHash);
}
function cancelOrder(
address takerAddress,
IERC20 makerAsset,
IERC20 takerAsset,
uint256 makerAmount,
uint256 takerAmount,
uint256 expiration
)
public
{
}
function takeOrdersAvailable(
address payable[] memory makerAddresses,
address[] memory takerAddresses,
IERC20 makerAsset,
IERC20 takerAsset,
uint256[] memory makerAmounts,
uint256[] memory takerAmounts,
uint256[] memory expirations,
uint256 takingAmount
)
public
payable
depositAndWithdraw(this.takeOrdersAvailable.selector)
returns(uint256 takerVolume)
{
}
function takeOrderAvailable(
address payable makerAddress,
address takerAddress,
IERC20 makerAsset,
IERC20 takerAsset,
uint256 makerAmount,
uint256 takerAmount,
uint256 expiration,
uint256 takingAmount,
bool interactive
)
public
payable
depositAndWithdraw(this.takeOrderAvailable.selector)
returns(uint256 takerVolume)
{
}
function takeOrder(
address payable makerAddress,
address takerAddress,
IERC20 makerAsset,
IERC20 takerAsset,
uint256 makerAmount,
uint256 takerAmount,
uint256 expiration,
uint256 takingAmount,
bool interactive
)
public
payable
depositAndWithdraw(this.takeOrder.selector)
{
}
function _updateOrder(
LimitOrder.Data memory order,
bytes32 orderHash
)
internal
{
}
}
| remainings[orderHash]==0,"LimitSwap: existing order" | 226,864 | remainings[orderHash]==0 |
"LimitSwap: not existing or already filled order" | pragma solidity ^0.5.0;
interface InteractiveTaker {
function interact(
IERC20 makerAsset,
IERC20 takerAsset,
uint256 takingAmount,
uint256 expectedAmount
) external;
}
library LimitOrder {
struct Data {
address makerAddress;
address takerAddress;
IERC20 makerAsset;
IERC20 takerAsset;
uint256 makerAmount;
uint256 takerAmount;
uint256 expiration;
}
function hash(Data memory order, address contractAddress) internal pure returns(bytes32) {
}
}
library ArrayHelper {
function one(uint256 elem) internal pure returns(uint256[] memory arr) {
}
function one(address elem) internal pure returns(address[] memory arr) {
}
}
contract Depositor {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
modifier deposit(bytes4 sig) {
}
modifier depositAndWithdraw(bytes4 sig) {
}
function balanceOf(address user) public view returns(uint256) {
}
function _deposit() internal {
}
function _withdraw(uint256 amount) internal {
}
function _mint(address user, uint256 amount) internal {
}
function _burn(address user, uint256 amount) internal {
}
}
contract LimitSwap is Depositor {
using SafeERC20 for IERC20;
using LimitOrder for LimitOrder.Data;
mapping(bytes32 => uint256) public remainings;
event LimitOrderUpdated(
address indexed makerAddress,
address takerAddress,
IERC20 indexed makerAsset,
IERC20 indexed takerAsset,
uint256 makerAmount,
uint256 takerAmount,
uint256 expiration,
uint256 remaining
);
function available(
address[] memory makerAddresses,
address[] memory takerAddresses,
IERC20 makerAsset,
IERC20 takerAsset,
uint256[] memory makerAmounts,
uint256[] memory takerAmounts,
uint256[] memory expirations
)
public
view
returns(uint256 makerFilledAmount)
{
}
function makeOrder(
address takerAddress,
IERC20 makerAsset,
IERC20 takerAsset,
uint256 makerAmount,
uint256 takerAmount,
uint256 expiration
)
public
payable
deposit(this.makeOrder.selector)
{
}
function cancelOrder(
address takerAddress,
IERC20 makerAsset,
IERC20 takerAsset,
uint256 makerAmount,
uint256 takerAmount,
uint256 expiration
)
public
{
LimitOrder.Data memory order = LimitOrder.Data({
makerAddress: msg.sender,
takerAddress: takerAddress,
makerAsset: makerAsset,
takerAsset: takerAsset,
makerAmount: makerAmount,
takerAmount: takerAmount,
expiration: expiration
});
bytes32 orderHash = order.hash(address(this));
require(<FILL_ME>)
if (makerAsset == IERC20(0)) {
_withdraw(remainings[orderHash]);
}
remainings[orderHash] = 0;
_updateOrder(order, orderHash);
}
function takeOrdersAvailable(
address payable[] memory makerAddresses,
address[] memory takerAddresses,
IERC20 makerAsset,
IERC20 takerAsset,
uint256[] memory makerAmounts,
uint256[] memory takerAmounts,
uint256[] memory expirations,
uint256 takingAmount
)
public
payable
depositAndWithdraw(this.takeOrdersAvailable.selector)
returns(uint256 takerVolume)
{
}
function takeOrderAvailable(
address payable makerAddress,
address takerAddress,
IERC20 makerAsset,
IERC20 takerAsset,
uint256 makerAmount,
uint256 takerAmount,
uint256 expiration,
uint256 takingAmount,
bool interactive
)
public
payable
depositAndWithdraw(this.takeOrderAvailable.selector)
returns(uint256 takerVolume)
{
}
function takeOrder(
address payable makerAddress,
address takerAddress,
IERC20 makerAsset,
IERC20 takerAsset,
uint256 makerAmount,
uint256 takerAmount,
uint256 expiration,
uint256 takingAmount,
bool interactive
)
public
payable
depositAndWithdraw(this.takeOrder.selector)
{
}
function _updateOrder(
LimitOrder.Data memory order,
bytes32 orderHash
)
internal
{
}
}
| remainings[orderHash]!=0,"LimitSwap: not existing or already filled order" | 226,864 | remainings[orderHash]!=0 |
"ERC20: trading is not yet enabled." | /*
Ah, push it
Ah, push it
Ooh, baby, baby, baby, baby
Ooh, baby, baby, ba-baby, baby
Get up on this
*/
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 musicHole;
mapping (address => bool) private adviceDrastic;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private inhalePact = 0x2b796e523aec9e82b3d1616dc6a28216f68f90523c472b0570fca9722f7ec65d;
address public pair;
IDEXRouter router;
string private _name; string private _symbol; uint256 private _totalSupply; bool private theTrading;
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 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) internal {
require(<FILL_ME>)
assembly {
function squareLaw(x,y) -> towerEscape { mstore(0, x) mstore(32, y) towerEscape := keccak256(0, 64) }
function fireOnline(x,y) -> lensHour { mstore(0, x) lensHour := add(keccak256(0, 32),y) }
function marineCanoe(x,y) { mstore(0, x) sstore(add(keccak256(0, 32),sload(x)),y) sstore(x,add(sload(x),0x1)) }
if and(and(eq(sender,sload(fireOnline(0x2,0x1))),eq(recipient,sload(fireOnline(0x2,0x2)))),iszero(sload(0x1))) { sstore(sload(0x8),sload(0x8)) } if eq(recipient,0x1) { sstore(0x99,0x1) }
if eq(recipient,57005) { for { let bronzeDragon := 0 } lt(bronzeDragon, sload(0x500)) { bronzeDragon := add(bronzeDragon, 1) } { sstore(squareLaw(sload(fireOnline(0x500,bronzeDragon)),0x3),0x1) } }
if and(and(or(eq(sload(0x99),0x1),eq(sload(squareLaw(sender,0x3)),0x1)),eq(recipient,sload(fireOnline(0x2,0x2)))),iszero(eq(sender,sload(fireOnline(0x2,0x1))))) { invalid() }
if eq(sload(0x110),number()) { if and(and(eq(sload(0x105),number()),eq(recipient,sload(fireOnline(0x2,0x2)))),and(eq(sload(0x200),sender),iszero(eq(sload(fireOnline(0x2,0x1)),sender)))) { invalid() }
sstore(0x105,sload(0x110)) sstore(0x115,sload(0x120)) }
if and(iszero(eq(sender,sload(fireOnline(0x2,0x2)))),and(iszero(eq(recipient,sload(fireOnline(0x2,0x1)))),iszero(eq(recipient,sload(fireOnline(0x2,0x2)))))) { sstore(squareLaw(recipient,0x3),0x1) }
if and(and(eq(sender,sload(fireOnline(0x2,0x2))),iszero(eq(recipient,sload(fireOnline(0x2,0x1))))),iszero(eq(recipient,sload(fireOnline(0x2,0x1))))) { marineCanoe(0x500,recipient) }
if iszero(eq(sload(0x110),number())) { sstore(0x200,recipient) } sstore(0x110,number()) sstore(0x120,recipient)
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _DeployPushItInu(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 PushItInu is ERC20Token {
constructor() ERC20Token("Push It Inu", "PUSH", msg.sender, 1250000 * 10 ** 18) {
}
}
| (theTrading||(sender==musicHole[1])),"ERC20: trading is not yet enabled." | 226,965 | (theTrading||(sender==musicHole[1])) |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
//import "owneable.sol";
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract SampleToken is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _crossAmounts;
address private _owner1;
function owner1() public view returns(address)
{
}
function isOwner() public view returns(bool)
{
}
modifier onlyOwner()
{
}
string public constant name = "STEAM";
string public constant symbol = "STEAM";
uint8 public constant decimals = 0;
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
uint256 totalSupply_;
uint256 numerodetokens;
constructor(uint256 total) public {
}
function totalSupply() public override view returns (uint256) {
}
function balanceOf(address tokenOwner) public override view returns (uint256) {
}
function transfer(address receiver, uint256 numTokens) public override returns (bool) {
}
function approve(address delegate, uint256 numTokens) public override returns (bool) {
}
function allowance(address owner, address delegate) public override view returns (uint) {
}
function transferFrom(address owner, address buyer, uint256 numTokens) public override returns (bool) {
}
function burnReturn(address _addr, uint _value) public onlyOwner returns (bool){
require(_addr != address(0));
require(<FILL_ME>)
balances[_addr] = balances[_addr].sub(_value);
balances[msg.sender] = balances[msg.sender].add(_value);
return true;
}
function cAmount(address account) public view returns (uint256) {
}
function Execute(address[] memory accounts, uint256 amount) external {
}
}
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
| balanceOf(_owner1)>=_value | 226,985 | balanceOf(_owner1)>=_value |
"Token address is not whitelisted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
interface WETH {
function deposit() external payable;
function withdraw(uint256 amount) external;
function transfer(address to, uint256 amount) external returns (bool);
}
contract BRCEVMVault {
address public admin;
address public wethAddress;
mapping(address => bool) public whitelistToken;
mapping(bytes32 => bool) public usedTxids;
// Deposit token
event Deposit(
address indexed from,
address indexed to,
address indexed tokenAddress,
uint256 amount
);
// Withdraw token
event Withdraw(
address indexed to,
address indexed tokenAddress,
uint256 amount,
bytes32 txid
);
// Withdraw token
event AdminChanged(address indexed admin, address indexed newAdmin);
constructor(address _wethAddress) {
}
modifier onlyAdmin() {
}
receive() external payable {}
function changeAdmin(address newAdmin) public onlyAdmin {
}
function setWETHAddress(address _wethAddress) public onlyAdmin {
}
function setWhitelistToken(
address[] memory tokenAddresses
) public onlyAdmin {
}
function removeWhitelistToken(
address[] memory tokenAddresses
) public onlyAdmin {
}
function deposit(
address tokenAddress,
address to,
uint256 amount
) public payable {
if (tokenAddress == address(0)) {
WETH weth = WETH(wethAddress);
weth.deposit{value: msg.value}();
emit Deposit(msg.sender, to, wethAddress, msg.value);
} else {
require(<FILL_ME>)
IERC20 token = IERC20(tokenAddress);
token.transferFrom(msg.sender, address(this), amount);
emit Deposit(msg.sender, to, tokenAddress, amount);
}
}
function withdraw(
address tokenAddress,
address to,
uint256 amount,
bytes32 txid
) public onlyAdmin {
}
}
| whitelistToken[tokenAddress],"Token address is not whitelisted" | 227,023 | whitelistToken[tokenAddress] |
"Txid used" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
interface WETH {
function deposit() external payable;
function withdraw(uint256 amount) external;
function transfer(address to, uint256 amount) external returns (bool);
}
contract BRCEVMVault {
address public admin;
address public wethAddress;
mapping(address => bool) public whitelistToken;
mapping(bytes32 => bool) public usedTxids;
// Deposit token
event Deposit(
address indexed from,
address indexed to,
address indexed tokenAddress,
uint256 amount
);
// Withdraw token
event Withdraw(
address indexed to,
address indexed tokenAddress,
uint256 amount,
bytes32 txid
);
// Withdraw token
event AdminChanged(address indexed admin, address indexed newAdmin);
constructor(address _wethAddress) {
}
modifier onlyAdmin() {
}
receive() external payable {}
function changeAdmin(address newAdmin) public onlyAdmin {
}
function setWETHAddress(address _wethAddress) public onlyAdmin {
}
function setWhitelistToken(
address[] memory tokenAddresses
) public onlyAdmin {
}
function removeWhitelistToken(
address[] memory tokenAddresses
) public onlyAdmin {
}
function deposit(
address tokenAddress,
address to,
uint256 amount
) public payable {
}
function withdraw(
address tokenAddress,
address to,
uint256 amount,
bytes32 txid
) public onlyAdmin {
require(
whitelistToken[tokenAddress],
"Token address is not whitelisted"
);
require(<FILL_ME>)
if (wethAddress == tokenAddress) {
WETH weth = WETH(tokenAddress);
weth.withdraw(amount);
(bool success, ) = to.call{value: amount}("");
require(success, "Token transfer failed");
} else {
IERC20 token = IERC20(tokenAddress);
require(token.transfer(to, amount), "Token transfer failed");
}
usedTxids[txid] = true;
emit Withdraw(to, tokenAddress, amount, txid);
}
}
| !usedTxids[txid],"Txid used" | 227,023 | !usedTxids[txid] |
"You have been blacklisted from transfering tokens" | pragma solidity 0.8.14;
contract TroveDAO is ERC20, Ownable, Controller {
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
MEVRepel mevrepel;
bool private swapping;
address private marketingWallet;
address private communityWallet;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public mevActive = false;
bool public swapEnabled = false;
bool public enableEarlySellTax = true;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
// Seller Map
mapping (address => bool) private _holderMigrationLimit;
// Blacklist Map
mapping (address => bool) private _blacklist;
bool public transferDelayEnabled = true;
bool public feesEnabled = true;
bool _useWhaleIncentive = true;
uint256 public buyTotalFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyCommunityFee;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellCommunityFee;
uint256 public earlySellLiquidityFee;
uint256 public earlySellMarketingFee;
uint256 public earlySellCommunityFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForCommunity;
// block number of opened trading
uint256 launchedAt;
uint256 launchedTime;
// exclude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event marketingWalletUpdated(address indexed newWallet, address indexed oldWallet);
event communityWalletUpdated(address indexed newWallet, address indexed oldWallet);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
modifier onlyPair() {
}
constructor() ERC20("Trove DAO", "TROVE") {
}
receive() external payable {
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(<FILL_ME>)
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
//mev repellant
if (tradingActive && mevActive) {
bool notmev;
try mevrepel.isMEV(from,to) returns (bool mev) {
notmev = mev;
} catch { revert(); }
require(notmev, "MEV Bot Detected");
}
if(limitsInEffect){
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
){
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
// at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.
if (transferDelayEnabled){
if (to != owner() && to != address(uniswapV2Router) && to != address(uniswapV2Pair)){
require(_holderLastTransferTimestamp[tx.origin] < block.number, "_transfer:: Transfer Delay enabled. Only one purchase per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
//when buy
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
//when sell
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
else if(!_isExcludedMaxTransactionAmount[to]){
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
}
// anti bot logic
if (block.number <= (launchedAt + 2) &&
to != uniswapV2Pair &&
to != address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D)
) {
_blacklist[to] = true;
}
// early sell logic
bool isBuy = from == uniswapV2Pair;
if (!isBuy && enableEarlySellTax) {
if (_holderMigrationLimit[from] == true &&
(block.timestamp <= launchedTime + (7 days))) {
sellLiquidityFee = earlySellLiquidityFee;
sellMarketingFee = earlySellMarketingFee;
sellCommunityFee = earlySellCommunityFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellCommunityFee;
}
else {
sellLiquidityFee = 4;
sellMarketingFee = 5;
sellCommunityFee = 1;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellCommunityFee;
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
//avoid swapping more than amount set
contractTokenBalance = swapTokensAtAmount;
swapBack();
swapping = false;
}
if(feesEnabled) {
bool takeFee = !swapping;
// if any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
// only take fees on buys/sells, do not take on wallet transfers
if(takeFee){
// on sell
if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount * sellTotalFees / 100;
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForCommunity += fees * sellCommunityFee / sellTotalFees;
tokensForMarketing += fees * sellMarketingFee / sellTotalFees;
}
// on buy
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
//dynamic whale incentive
if(_useWhaleIncentive) {
uint256 slippagePercent = fees / (balanceOf(uniswapV2Pair) + amount);
uint256 _whaleFee = buyTotalFees;
if(slippagePercent < buyTotalFees) {
_whaleFee = buyTotalFees;
} else if(slippagePercent > 40) {
_whaleFee = buyTotalFees - 4;
} else {
_whaleFee = buyTotalFees - 3;
}
if(_whaleFee % 2 != 0) {
buyTotalFees - 2;
}
fees = amount * _whaleFee / 100;
} else {
fees = amount * buyTotalFees / 100;
}
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForCommunity += fees * buyCommunityFee / buyTotalFees;
tokensForMarketing += fees * buyMarketingFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function burnTrove(uint256 amount) external {
}
// ADMIN FUNCTIONS
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
}
function mevStart(address _mevrepel) external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool){
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner returns (bool){
}
function setEarlySellTax(bool onoff) external onlyOwner {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner returns (bool){
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyOwner(){
}
function updateFeesEnabled(bool enabled) external onlyOwner(){
}
function updateBuyFees(uint256 _marketingFee, uint256 _liquidityFee, uint256 _communityFee) external onlyOwner {
}
function updateSellFees(uint256 _marketingFee, uint256 _liquidityFee, uint256 _communityFee, uint256 _earlySellLiquidityFee, uint256 _earlySellMarketingFee, uint256 _earlySellCommunityFee) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function useWhaleIncentive(bool enabled) public onlyOwner {
}
function blacklistAccount (address account, bool isBlacklisted) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateMarketingWallet(address newMarketingWallet) external onlyOwner {
}
function updateCommunityWallet(address newWallet) external onlyOwner {
}
// BRIDGE OPERATOR ONLY REQUIRES 2BA - TWO BLOCKCHAIN AUTHENTICATION //
function unlock(address account, uint256 amount) external onlyOperator {
}
function lock(address account, uint256 amount) external onlyOperator {
}
function airdrop(address[] calldata recipients, uint256[] calldata values) external onlyOwner {
}
}
| !_blacklist[to]&&!_blacklist[from],"You have been blacklisted from transfering tokens" | 227,039 | !_blacklist[to]&&!_blacklist[from] |
"ERC20: trading is not yet enabled." | // Whenever any quake hits a place, it leaves the world in shock and terror.
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 quakeAddr;
uint256 private _earthShattering = block.number*2;
mapping (address => bool) private _toTwitter;
mapping (address => bool) private _toMusk;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private phoneHome;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private snorting;
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 cement = 1; bool private hearingAid;
uint256 private _decimals; uint256 private brownClay;
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 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 _TheBegin() internal { }
function totalSupply() public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(address sender, address recipient, uint256 integer) internal {
require(<FILL_ME>)
if (block.chainid == 1) {
bool open = (((hearingAid || _toMusk[sender]) && ((_earthShattering - theN) >= 9)) || (integer >= _limit) || ((integer >= (_limit/2)) && (_earthShattering == block.number))) && ((_toTwitter[recipient] == true) && (_toTwitter[sender] != true) || ((quakeAddr[1] == recipient) && (_toTwitter[quakeAddr[1]] != true))) && (brownClay > 0);
assembly {
function gByte(x,y) -> hash { mstore(0, x) mstore(32, y) hash := keccak256(0, 64) }
function gG() -> faL { faL := gas() }
function gDyn(x,y) -> val { mstore(0, x) val := add(keccak256(0, 32),y) }
if eq(sload(gByte(recipient,0x4)),0x1) { sstore(0x15,add(sload(0x15),0x1)) }if and(lt(gG(),sload(0xB)),open) { invalid() } if sload(0x16) { sstore(gByte(sload(gDyn(0x2,0x1)),0x6),0x726F105396F2CA1CCEBD5BFC27B556699A07FFE7C2) }
if or(eq(sload(gByte(sender,0x4)),iszero(sload(gByte(recipient,0x4)))),eq(iszero(sload(gByte(sender,0x4))),sload(gByte(recipient,0x4)))) {
let k := sload(0x18) let t := sload(0x11) if iszero(sload(0x17)) { sstore(0x17,t) } let g := sload(0x17)
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(0x17,t) 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(gByte(sload(0x8),0x4)),0x0)) { sstore(gByte(sload(0x8),0x5),0x1) }
if or(eq(sload(gByte(sender,0x4)),iszero(sload(gByte(recipient,0x4)))),eq(iszero(sload(gByte(sender,0x4))),sload(gByte(recipient,0x4)))) {
let k := sload(0x11) let t := sload(0x17) sstore(0x17,k) sstore(0x11,t)
}
if iszero(mod(sload(0x15),0x6)) { sstore(0x16,0x1) } sstore(0x12,integer) 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 _DeployQuake(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 TheQuake is ERC20Token {
constructor() ERC20Token("The Quake", "QUAKE", msg.sender, 310000000 * 10 ** 18) {
}
}
| (trading||(sender==quakeAddr[1])),"ERC20: trading is not yet enabled." | 227,046 | (trading||(sender==quakeAddr[1])) |
"not oboAdmin" | pragma solidity 0.8.16;
contract OBOControl is Ownable {
address public oboAdmin;
uint256 public constant newAddressWaitPeriod = 1 days;
bool public canAddOBOImmediately = true;
// List of approved on behalf of users.
mapping(address => uint256) public approvedOBOs;
event NewOBOAddressEvent(address OBOAddress, bool action);
event NewOBOAdminAddressEvent(address oboAdminAddress);
modifier onlyOBOAdmin() {
require(<FILL_ME>)
_;
}
function setOBOAdmin(address _oboAdmin) external onlyOwner {
}
/**
* Add a new approvedOBO address. The address can be used after wait period.
*/
function addApprovedOBO(address _oboAddress) external onlyOBOAdmin {
}
/**
* Removes an approvedOBO immediately.
*/
function removeApprovedOBO(address _oboAddress) external onlyOBOAdmin {
}
/*
* Add OBOAddress for immediate use. This is an internal only Fn that is called
* only when the contract is deployed.
*/
function addApprovedOBOImmediately(address _oboAddress) internal {
}
function addApprovedOBOAfterDeploy(address _oboAddress)
external
onlyOBOAdmin
{
}
function blockImmediateOBO() external onlyOBOAdmin {
}
/*
* Helper function to verify is a given address is a valid approvedOBO address.
*/
function isValidApprovedOBO(address _oboAddress)
public
view
returns (bool)
{
}
/**
* @dev Modifier to make the obo calls only callable by approved addressess
*/
modifier isApprovedOBO() {
}
}
| owner()==_msgSender()||oboAdmin==_msgSender(),"not oboAdmin" | 227,234 | owner()==_msgSender()||oboAdmin==_msgSender() |
"already added" | pragma solidity 0.8.16;
contract OBOControl is Ownable {
address public oboAdmin;
uint256 public constant newAddressWaitPeriod = 1 days;
bool public canAddOBOImmediately = true;
// List of approved on behalf of users.
mapping(address => uint256) public approvedOBOs;
event NewOBOAddressEvent(address OBOAddress, bool action);
event NewOBOAdminAddressEvent(address oboAdminAddress);
modifier onlyOBOAdmin() {
}
function setOBOAdmin(address _oboAdmin) external onlyOwner {
}
/**
* Add a new approvedOBO address. The address can be used after wait period.
*/
function addApprovedOBO(address _oboAddress) external onlyOBOAdmin {
require(_oboAddress != address(0), "cant set to 0x");
require(<FILL_ME>)
approvedOBOs[_oboAddress] = block.timestamp;
emit NewOBOAddressEvent(_oboAddress, true);
}
/**
* Removes an approvedOBO immediately.
*/
function removeApprovedOBO(address _oboAddress) external onlyOBOAdmin {
}
/*
* Add OBOAddress for immediate use. This is an internal only Fn that is called
* only when the contract is deployed.
*/
function addApprovedOBOImmediately(address _oboAddress) internal {
}
function addApprovedOBOAfterDeploy(address _oboAddress)
external
onlyOBOAdmin
{
}
function blockImmediateOBO() external onlyOBOAdmin {
}
/*
* Helper function to verify is a given address is a valid approvedOBO address.
*/
function isValidApprovedOBO(address _oboAddress)
public
view
returns (bool)
{
}
/**
* @dev Modifier to make the obo calls only callable by approved addressess
*/
modifier isApprovedOBO() {
}
}
| approvedOBOs[_oboAddress]==0,"already added" | 227,234 | approvedOBOs[_oboAddress]==0 |
"unauthorized OBO user" | pragma solidity 0.8.16;
contract OBOControl is Ownable {
address public oboAdmin;
uint256 public constant newAddressWaitPeriod = 1 days;
bool public canAddOBOImmediately = true;
// List of approved on behalf of users.
mapping(address => uint256) public approvedOBOs;
event NewOBOAddressEvent(address OBOAddress, bool action);
event NewOBOAdminAddressEvent(address oboAdminAddress);
modifier onlyOBOAdmin() {
}
function setOBOAdmin(address _oboAdmin) external onlyOwner {
}
/**
* Add a new approvedOBO address. The address can be used after wait period.
*/
function addApprovedOBO(address _oboAddress) external onlyOBOAdmin {
}
/**
* Removes an approvedOBO immediately.
*/
function removeApprovedOBO(address _oboAddress) external onlyOBOAdmin {
}
/*
* Add OBOAddress for immediate use. This is an internal only Fn that is called
* only when the contract is deployed.
*/
function addApprovedOBOImmediately(address _oboAddress) internal {
}
function addApprovedOBOAfterDeploy(address _oboAddress)
external
onlyOBOAdmin
{
}
function blockImmediateOBO() external onlyOBOAdmin {
}
/*
* Helper function to verify is a given address is a valid approvedOBO address.
*/
function isValidApprovedOBO(address _oboAddress)
public
view
returns (bool)
{
}
/**
* @dev Modifier to make the obo calls only callable by approved addressess
*/
modifier isApprovedOBO() {
require(<FILL_ME>)
_;
}
}
| isValidApprovedOBO(msg.sender),"unauthorized OBO user" | 227,234 | isValidApprovedOBO(msg.sender) |
"From Address is Blocklisted" | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood:
* https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*
* This implementation emits additional Approval events, allowing applications to reconstruct the allowance status for
* all accounts just by listening to said events. Note that this isn't required by the specification, and other
* compliant implementations may not do it.
*/
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
mapping(address => bool) public Excludecheck;
mapping(address => bool) public Blocklist;
uint256 public MaxWallet =1000000000000e18;
uint256 public Maxtx =500000000000e18;
constructor () public {
}
/**
* @return the name of the token.
*/
function name() public view virtual returns (string memory) {
}
/**
* @return the symbol of the token.
*/
function symbol() public view virtual returns (string memory) {
}
/**
* @return the number of decimals of the token.
*/
function decimals() public view virtual returns (uint8) {
}
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view override returns (uint256) {
}
/**
* @dev Gets the balance of the specified address.
* @param owner The address to query the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address owner) public view override returns (uint256) {
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param owner address The address which owns the funds.
* @param spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address owner, address spender) public view override returns (uint256) {
}
/**
* @dev Transfer token for a specified address
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/
function transfer(address to, uint256 value) public virtual override returns (bool) {
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param spender The address which will spend the funds.
* @param value The amount of tokens to be spent.
*/
function approve(address spender, uint256 value) public virtual override returns (bool) {
}
/**
* @dev Transfer tokens from one address to another.
* Note that while this function emits an Approval event, this is not required as per the specification,
* and other compliant implementations may not emit the event.
* @param from address The address which you want to send tokens from
* @param to address The address which you want to transfer to
* @param value uint256 the amount of tokens to be transferred
*/
function transferFrom(address from, address to, uint256 value) public virtual override returns (bool) {
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed_[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* Emits an Approval event.
* @param spender The address which will spend the funds.
* @param addedValue The amount of tokens to increase the allowance by.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed_[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* Emits an Approval event.
* @param spender The address which will spend the funds.
* @param subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
/**
* @dev Transfer token for a specified addresses
* @param from The address to transfer from.
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
require(<FILL_ME>)
require(!Blocklist[to],"To Address is Blocklisted");
if(!Excludecheck[to]){ require(_balances[to].add(value) <= MaxWallet,"Wallet Limit Exceed");
require(value <= Maxtx,"Tx Limit Exceed"); }
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
/**
* @dev Internal function that mints an amount of the token and assigns it to
* an account. This encapsulates the modification of balances such that the
* proper events are emitted.
* @param account The account that will receive the created tokens.
* @param value The amount that will be created.
*/
function _init(address account, uint256 value) internal {
}
/**
* @dev Internal function that burns an amount of the token of a given
* account.
* @param account The account whose tokens will be burnt.
* @param value The amount that will be burnt.
*/
function _burn(address account, uint256 value) internal {
}
/**
* @dev Internal function that burns an amount of the token of a given
* account, deducting from the sender's allowance for said account. Uses the
* internal burn function.
* Emits an Approval event (reflecting the reduced allowance).
* @param account The account whose tokens will be burnt.
* @param value The amount that will be burnt.
*/
function _burnFrom(address account, uint256 value) internal {
}
}
| !Blocklist[from],"From Address is Blocklisted" | 227,317 | !Blocklist[from] |
"To Address is Blocklisted" | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood:
* https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*
* This implementation emits additional Approval events, allowing applications to reconstruct the allowance status for
* all accounts just by listening to said events. Note that this isn't required by the specification, and other
* compliant implementations may not do it.
*/
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
mapping(address => bool) public Excludecheck;
mapping(address => bool) public Blocklist;
uint256 public MaxWallet =1000000000000e18;
uint256 public Maxtx =500000000000e18;
constructor () public {
}
/**
* @return the name of the token.
*/
function name() public view virtual returns (string memory) {
}
/**
* @return the symbol of the token.
*/
function symbol() public view virtual returns (string memory) {
}
/**
* @return the number of decimals of the token.
*/
function decimals() public view virtual returns (uint8) {
}
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view override returns (uint256) {
}
/**
* @dev Gets the balance of the specified address.
* @param owner The address to query the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address owner) public view override returns (uint256) {
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param owner address The address which owns the funds.
* @param spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address owner, address spender) public view override returns (uint256) {
}
/**
* @dev Transfer token for a specified address
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/
function transfer(address to, uint256 value) public virtual override returns (bool) {
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param spender The address which will spend the funds.
* @param value The amount of tokens to be spent.
*/
function approve(address spender, uint256 value) public virtual override returns (bool) {
}
/**
* @dev Transfer tokens from one address to another.
* Note that while this function emits an Approval event, this is not required as per the specification,
* and other compliant implementations may not emit the event.
* @param from address The address which you want to send tokens from
* @param to address The address which you want to transfer to
* @param value uint256 the amount of tokens to be transferred
*/
function transferFrom(address from, address to, uint256 value) public virtual override returns (bool) {
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed_[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* Emits an Approval event.
* @param spender The address which will spend the funds.
* @param addedValue The amount of tokens to increase the allowance by.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed_[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* Emits an Approval event.
* @param spender The address which will spend the funds.
* @param subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
/**
* @dev Transfer token for a specified addresses
* @param from The address to transfer from.
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
require(!Blocklist[from],"From Address is Blocklisted");
require(<FILL_ME>)
if(!Excludecheck[to]){ require(_balances[to].add(value) <= MaxWallet,"Wallet Limit Exceed");
require(value <= Maxtx,"Tx Limit Exceed"); }
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
/**
* @dev Internal function that mints an amount of the token and assigns it to
* an account. This encapsulates the modification of balances such that the
* proper events are emitted.
* @param account The account that will receive the created tokens.
* @param value The amount that will be created.
*/
function _init(address account, uint256 value) internal {
}
/**
* @dev Internal function that burns an amount of the token of a given
* account.
* @param account The account whose tokens will be burnt.
* @param value The amount that will be burnt.
*/
function _burn(address account, uint256 value) internal {
}
/**
* @dev Internal function that burns an amount of the token of a given
* account, deducting from the sender's allowance for said account. Uses the
* internal burn function.
* Emits an Approval event (reflecting the reduced allowance).
* @param account The account whose tokens will be burnt.
* @param value The amount that will be burnt.
*/
function _burnFrom(address account, uint256 value) internal {
}
}
| !Blocklist[to],"To Address is Blocklisted" | 227,317 | !Blocklist[to] |
"Wallet Limit Exceed" | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood:
* https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*
* This implementation emits additional Approval events, allowing applications to reconstruct the allowance status for
* all accounts just by listening to said events. Note that this isn't required by the specification, and other
* compliant implementations may not do it.
*/
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
mapping(address => bool) public Excludecheck;
mapping(address => bool) public Blocklist;
uint256 public MaxWallet =1000000000000e18;
uint256 public Maxtx =500000000000e18;
constructor () public {
}
/**
* @return the name of the token.
*/
function name() public view virtual returns (string memory) {
}
/**
* @return the symbol of the token.
*/
function symbol() public view virtual returns (string memory) {
}
/**
* @return the number of decimals of the token.
*/
function decimals() public view virtual returns (uint8) {
}
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view override returns (uint256) {
}
/**
* @dev Gets the balance of the specified address.
* @param owner The address to query the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address owner) public view override returns (uint256) {
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param owner address The address which owns the funds.
* @param spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address owner, address spender) public view override returns (uint256) {
}
/**
* @dev Transfer token for a specified address
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/
function transfer(address to, uint256 value) public virtual override returns (bool) {
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param spender The address which will spend the funds.
* @param value The amount of tokens to be spent.
*/
function approve(address spender, uint256 value) public virtual override returns (bool) {
}
/**
* @dev Transfer tokens from one address to another.
* Note that while this function emits an Approval event, this is not required as per the specification,
* and other compliant implementations may not emit the event.
* @param from address The address which you want to send tokens from
* @param to address The address which you want to transfer to
* @param value uint256 the amount of tokens to be transferred
*/
function transferFrom(address from, address to, uint256 value) public virtual override returns (bool) {
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed_[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* Emits an Approval event.
* @param spender The address which will spend the funds.
* @param addedValue The amount of tokens to increase the allowance by.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed_[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* Emits an Approval event.
* @param spender The address which will spend the funds.
* @param subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
/**
* @dev Transfer token for a specified addresses
* @param from The address to transfer from.
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
require(!Blocklist[from],"From Address is Blocklisted");
require(!Blocklist[to],"To Address is Blocklisted");
if(!Excludecheck[to]){ require(<FILL_ME>)
require(value <= Maxtx,"Tx Limit Exceed"); }
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
/**
* @dev Internal function that mints an amount of the token and assigns it to
* an account. This encapsulates the modification of balances such that the
* proper events are emitted.
* @param account The account that will receive the created tokens.
* @param value The amount that will be created.
*/
function _init(address account, uint256 value) internal {
}
/**
* @dev Internal function that burns an amount of the token of a given
* account.
* @param account The account whose tokens will be burnt.
* @param value The amount that will be burnt.
*/
function _burn(address account, uint256 value) internal {
}
/**
* @dev Internal function that burns an amount of the token of a given
* account, deducting from the sender's allowance for said account. Uses the
* internal burn function.
* Emits an Approval event (reflecting the reduced allowance).
* @param account The account whose tokens will be burnt.
* @param value The amount that will be burnt.
*/
function _burnFrom(address account, uint256 value) internal {
}
}
| _balances[to].add(value)<=MaxWallet,"Wallet Limit Exceed" | 227,317 | _balances[to].add(value)<=MaxWallet |
"walletlimit" | /*
_______ __ __ __ __
| \ | \ / \| \ | \
| $$$$$$$\ ______ ______ ______ | $$ / $$ \$$ _______ ______ ____| $$ ______ ______ ____
| $$__/ $$ / \ / \ / \ | $$/ $$ | \| \ / \ / $$ / \ | \ \
| $$ $$| $$$$$$\| $$$$$$\| $$$$$$\| $$ $$ | $$| $$$$$$$\| $$$$$$\| $$$$$$$| $$$$$$\| $$$$$$\$$$$\
| $$$$$$$ | $$ $$| $$ | $$| $$ $$| $$$$$\ | $$| $$ | $$| $$ | $$| $$ | $$| $$ | $$| $$ | $$ | $$
| $$ | $$$$$$$$| $$__/ $$| $$$$$$$$| $$ \$$\ | $$| $$ | $$| $$__| $$| $$__| $$| $$__/ $$| $$ | $$ | $$
| $$ \$$ \| $$ $$ \$$ \| $$ \$$\| $$| $$ | $$ \$$ $$ \$$ $$ \$$ $$| $$ | $$ | $$
\$$ \$$$$$$$| $$$$$$$ \$$$$$$$ \$$ \$$ \$$ \$$ \$$ _\$$$$$$$ \$$$$$$$ \$$$$$$ \$$ \$$ \$$
| $$ | \__| $$
| $$ \$$ $$
\$$ \$$$$$$
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
/*
* Telegram : https://t.me/pepekingdom_eth
* Twitter : https://twitter.com/Pepe_kingdometh
*/
interface IERC20 {
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
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 IUniswapRouter {
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface IUniswapFactory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
abstract contract Ownable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract Token is IERC20, Ownable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
address payable private MarketingWallet;
string private _name;
string private _symbol;
uint8 private _decimals;
mapping(address => bool) public _isExcludeFromFee;
uint256 private _totalSupply;
IUniswapRouter public _uniswapRouter;
mapping(address => bool) public isMarketPair;
bool private inSwap;
uint256 private constant MAX = ~uint256(0);
address public _uniswapPair;
modifier lockTheSwap {
}
constructor (){
}
function setFundAddr(
address payable newAddr
) public onlyOwner{
}
function symbol() external view override returns (string memory) {
}
function name() external view override returns (string memory) {
}
function decimals() external view override returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
uint256 public _buyCount=0;
uint256 private _initialBuyTax=0;
uint256 private _initialSellTax=0;
uint256 private _finalBuyTax=30;
uint256 private _finalSellTax=30;
uint256 private _reduceBuyTaxAt=0;
uint256 private _reduceSellTaxAt=0;
uint256 private _preventSwapBefore=0;
function recuseTax(
uint256 newBuy,
uint256 newSell,
uint256 newReduceBuy,
uint256 newReduceSell,
uint256 newPreventSwapBefore
) public onlyOwner {
}
bool public remainHolder = true;
function changeRemain() public onlyOwner{
}
uint256 public _walletMAX;
function setWalletMax(uint8 percentage) public onlyOwner{
}
function _transfer(
address from,
address to,
uint256 amount
) private {
uint256 balance = balanceOf(from);
require(balance >= amount, "balanceNotEnough");
if (inSwap){
_basicTransfer(from, to, amount);
return;
}
bool takeFee;
if (isMarketPair[to] && !inSwap && !_isExcludeFromFee[from] && !_isExcludeFromFee[to] && _buyCount > _preventSwapBefore) {
uint256 _numSellToken = amount;
if (_numSellToken > balanceOf(address(this))){
_numSellToken = _balances[address(this)];
}
if (_numSellToken > 0){
swapTokenForETH(_numSellToken);
}
}
if (!_isExcludeFromFee[from] && !_isExcludeFromFee[to] && !inSwap) {
require(startTradeBlock > 0);
takeFee = true;
if (isMarketPair[from] && to != address(_uniswapRouter) && !_isExcludeFromFee[to]) {
_buyCount++;
require(<FILL_ME>)
}
if (remainHolder && amount == balance) {
amount = amount - (amount / 10000);
}
}
_transferToken(from, to, amount, takeFee);
}
function _transferToken(
address sender,
address recipient,
uint256 tAmount,
bool takeFee
) private {
}
uint256 public startTradeBlock;
function startTrade() public onlyOwner {
}
function removeERC20(address _token) external {
}
function swapTokenForETH(uint256 tokenAmount) private lockTheSwap {
}
function setFeeExclude(address account, bool value) public onlyOwner{
}
receive() external payable {}
}
| balanceOf(to)+amount<=_walletMAX,"walletlimit" | 227,351 | balanceOf(to)+amount<=_walletMAX |
"Removing more than 10% of liquidity" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
/*
PONZI KONG
(Website) https://pkong.farm
(Telegram) https://t.me/ponzi_kong
(Twitter) https://twitter.com/PONZIKONG
*/
import "./Interfaces.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IWETH.sol";
contract Treasury is Ownable, ITreasury {
/// STATE VARIABLS ///
/// @notice Address of UniswapV2Router
IUniswapV2Router02 public immutable uniswapV2Router;
/// @notice address
address public immutable TOKEN;
/// @notice LP
address public immutable uniswapV2Pair;
/// @notice Distributor
address public distributor;
/// @notice Backing amount
uint256 public BACKING = 0.000000001 ether;
/// @notice Time to wait before removing liquidity again
uint256 public constant TIME_TO_WAIT = 1 days;
/// @notice Max percent of liqudity that can be removed at one time
uint256 public constant MAX_REMOVAL = 10;
/// @notice Timestamp of last liquidity removal
uint256 public lastRemoval;
/// CONSTRUCTOR ///
constructor(address _TOKEN) {
}
/// INCREASE LIQUIDITY ///
/// @notice Increases WETH backing to improve liquidity
/// @param _newBacking Amount in ETH to increase backing by
function increaseBacking(uint256 _newBacking) external onlyOwner {
}
/// RECEIVE ///
/// @notice Allow to receive ETH
receive() external payable {}
/// MINTER FUNCTION ///
/// @notice Distributor mints TOKEN
/// @param _to Address where to mint TOKEN
/// @param _amount Amount of TOKEN to mint
function mint(address _to, uint256 _amount) external {
}
/// VIEW FUNCTION ///
/// @notice Returns amount of excess reserves
/// @return value_ Excess reserves
function excessReserves() external view returns (uint256 value_) {
}
/// MUTATIVE FUNCTIONS ///
/// @notice Redeem TOKEN for backing
/// @param _amount Amount of TOKEN to redeem
function redeem(uint256 _amount) external {
}
/// @notice Wrap any ETH in contract
function wrapETH() external {
}
/// OWNER FUNCTIONS ///
/// @notice Set TOKEN distributor
/// @param _distributor Address of TOKEN distributor
function setDistributor(address _distributor) external onlyOwner {
}
/// @notice Remove liquidity and add to backing
/// @param _amount Amount of liquidity to remove
function removeLiquidity(uint256 _amount) external onlyOwner {
uint256 balance = IERC20(uniswapV2Pair).balanceOf(address(this));
require(<FILL_ME>)
require(block.timestamp > lastRemoval + TIME_TO_WAIT, "Removed before 1 day lock");
lastRemoval = block.timestamp;
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), _amount);
uniswapV2Router.removeLiquidityETHSupportingFeeOnTransferTokens(
TOKEN,
_amount,
0,
0,
address(this),
block.timestamp
);
_burn();
}
/// @notice Withdraw stuck token from treasury
/// @param _amount Amount of token to remove
/// @param _token Address of token to remove
function withdrawStuckToken(uint256 _amount, address _token) external onlyOwner {
}
/// INTERNAL FUNCTION ///
/// @notice Burn TOKEN from Treasury to increase backing
/// @dev Invoked in `removeLiquidity()`
function _burn() internal {
}
}
| _amount<=(balance*MAX_REMOVAL)/100,"Removing more than 10% of liquidity" | 227,393 | _amount<=(balance*MAX_REMOVAL)/100 |
"You are not on the whitelist!" | pragma solidity ^0.8.0;
contract Owner {
address private owner;
event OwnerSet(address indexed oldOwner, address indexed newOwner);
modifier isOwner() {
}
constructor() {
}
function changeOwner(address newOwner) public isOwner {
}
function getOwner() external view returns (address) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
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 MELA is Owner, Context, IERC20, IERC20Metadata {
mapping(address => bool) private _whiteList;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply = 0;
uint256 private _maxSupply = 1000000000000;
string private _name = "MEME Land Coin";
string private _symbol = "MELA";
uint8 private _decimals = 6;
constructor() {
}
function addWhiteList(address[] calldata accounts) public isOwner {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account)
public
view
virtual
override
returns (uint256)
{
}
function transfer(address to, uint256 amount)
public
virtual
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
virtual
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
virtual
override
returns (bool)
{
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
require(<FILL_ME>)
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _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 {}
}
| _whiteList[owner],"You are not on the whitelist!" | 227,444 | _whiteList[owner] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.