comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Auction time ended" | pragma solidity ^0.8.15;
struct NFTVoucher {
string uri;
uint256 price;
address creatorAddress;
uint256 numberOfNfts;
uint256 platformFee;
bytes signature;
}
struct NFT {
string uri;
uint256 price;
address creatorAddress;
uint256 numberOfNfts;
uint256 platformFee;
}
interface ILooxooryNft{
function redeem(address redeemer, NFTVoucher calldata voucher) external returns (uint256);
function getCurrentTokenId() external view returns(uint256);
function getNFT(uint256 _tokenId) external view returns(string memory uri,uint256 price,address creatorAddress,uint256 numberOfNfts,uint256 platformFee);
}
interface IRandom{
function random() external view returns (uint256);
}
contract LooxooryNFTMarketplace is ReentrancyGuard,Ownable {
using Counters for Counters.Counter;
using SafeMath for uint256;
Counters.Counter public _itemsSold;
Counters.Counter public _campaignIds;
uint256 public TOTAL_PERCENTAGE = 100;
uint256 public totalSale;
uint256 public totalAmountDue;
address public NFTContract;
address public NFTHolderAddress;
address public randomContract;
mapping(address=>uint256[]) public wonCampaigns;
mapping(bytes=>uint256) public nftSoldData;
mapping(bytes=>uint256) public voucherToCampaignID;
event Minted(
uint256 tokenId,
string uri,
uint256 price,
address creatorAddress,
uint256 numberOfNfts,
uint256 platformFee
);
event CampaignCreated(
uint256 campaignID,
address creatorAddress,
address winnerAddress,
string winnerPrize,
string[] winnerPrizeImages,
string campaignDescription,
uint256 maxNoOfParticipants,
uint256 currentNoOfParticipants,
uint256 drawTime,
string ngoName,
string ngoImage
);
event BidAdded(
uint256 itemId,
uint256 tokenId,
address bidder,
uint256 amount
);
event BidReturned(
uint256 itemId,
uint256 tokenId,
address bidder,
uint256 amount
);
struct CreateCampaignStruct{
string winnerPrize;
string[] winnerPrizeImages;
bytes[] signatures;
string campaignDescription;
uint256 maxNoOfParticipants;
uint256 drawTime;
string ngoName;
string ngoImage;
}
struct Campaign {
uint256 campaignID;
address creatorAddress;
uint256 totalNfts;
address winnerAddress;
string winnerPrize;
string[] winnerPrizeImages;
bytes[] signatures;
string campaignDescription;
uint256 maxNoOfParticipants;
uint256 currentNoOfParticipants;
uint256 drawTime;
string ngoName;
string ngoImage;
bool isEnded;
address[] participants;
uint256 soldNfts;
}
struct NFTAuctionItems{
uint256 nftID;
bool isOnAuction;
uint256 biddingTime;
address artistAddress;
uint256 price;
bool sold;
uint256 platformFee;
}
struct Bidder{
address bidderAddress;
uint256 bidderAmount;
}
mapping(uint256=>NFTAuctionItems) public currentlyOnAuction;
uint256 public currentlyOnAuctionTokenID;
bool public isOnAuction;
mapping(uint256=>Campaign) public campaigns;
mapping(uint256=>Bidder) public bidderInfo;
constructor(address _nftContract, address _nftHolder, address _randomContract) {
}
function setNFTContract(address _nftContract) external onlyOwner{
}
function setNFTAddress(address _nftHolder) external onlyOwner{
}
function setRandomContractAddress(address _randomContract) external onlyOwner{
}
function createMarketSale(NFTVoucher calldata voucher,bool donation) public payable{
}
function createCampaign(
CreateCampaignStruct memory _campaignDTO
) external onlyOwner{
}
function listNftForAuction(NFTVoucher calldata voucher,uint256 bidEndTime,uint256 tokenId) external onlyOwner{
}
function createBidOnItem(
uint256 itemId
) external payable nonReentrant {
uint price = currentlyOnAuction[itemId].price;
require(currentlyOnAuction[itemId].nftID==itemId,"Item is not on auction");
require(<FILL_ME>)
require(!currentlyOnAuction[itemId].sold,"Already sold");
require(msg.value >= price && msg.value > bidderInfo[itemId].bidderAmount, "Bid price must be greater than base price and highest bid");
if(bidderInfo[itemId].bidderAddress!=address(0)){
payable(bidderInfo[itemId].bidderAddress).transfer(bidderInfo[itemId].bidderAmount);
totalAmountDue = totalAmountDue.sub(bidderInfo[itemId].bidderAmount);
emit BidReturned(itemId, currentlyOnAuction[itemId].nftID, bidderInfo[itemId].bidderAddress, bidderInfo[itemId].bidderAmount);
}
totalAmountDue = totalAmountDue.add(msg.value);
bidderInfo[itemId].bidderAddress = msg.sender;
bidderInfo[itemId].bidderAmount = msg.value;
emit BidAdded(itemId, currentlyOnAuction[itemId].nftID, msg.sender, msg.value);
}
function claimBidItem(uint256 itemId) external nonReentrant {
}
function resetAuction() external onlyOwner{
}
function withdraw() external onlyOwner{
}
function getOwnerBalance() public view returns(uint256){
}
function getBalance() public view returns(uint256){
}
function drawForWinner(uint256 _campaignId) external onlyOwner{
}
function getCampaignData(uint256 _id) external view returns(
string[] memory winnerPrizeImages,
address[] memory participants
){
}
function getWonCampaigns(address userAddress) external view returns(
uint256[] memory wonCampaign
) {
}
function updateCampaignDrawTime(uint256 _campaignId,uint256 _drawTime) external onlyOwner{
}
function updateAuctionEndTime (uint256 _bidEndTime, uint tokenId ) external onlyOwner {
}
}
| currentlyOnAuction[itemId].biddingTime>block.timestamp,"Auction time ended" | 147,654 | currentlyOnAuction[itemId].biddingTime>block.timestamp |
"Already sold" | pragma solidity ^0.8.15;
struct NFTVoucher {
string uri;
uint256 price;
address creatorAddress;
uint256 numberOfNfts;
uint256 platformFee;
bytes signature;
}
struct NFT {
string uri;
uint256 price;
address creatorAddress;
uint256 numberOfNfts;
uint256 platformFee;
}
interface ILooxooryNft{
function redeem(address redeemer, NFTVoucher calldata voucher) external returns (uint256);
function getCurrentTokenId() external view returns(uint256);
function getNFT(uint256 _tokenId) external view returns(string memory uri,uint256 price,address creatorAddress,uint256 numberOfNfts,uint256 platformFee);
}
interface IRandom{
function random() external view returns (uint256);
}
contract LooxooryNFTMarketplace is ReentrancyGuard,Ownable {
using Counters for Counters.Counter;
using SafeMath for uint256;
Counters.Counter public _itemsSold;
Counters.Counter public _campaignIds;
uint256 public TOTAL_PERCENTAGE = 100;
uint256 public totalSale;
uint256 public totalAmountDue;
address public NFTContract;
address public NFTHolderAddress;
address public randomContract;
mapping(address=>uint256[]) public wonCampaigns;
mapping(bytes=>uint256) public nftSoldData;
mapping(bytes=>uint256) public voucherToCampaignID;
event Minted(
uint256 tokenId,
string uri,
uint256 price,
address creatorAddress,
uint256 numberOfNfts,
uint256 platformFee
);
event CampaignCreated(
uint256 campaignID,
address creatorAddress,
address winnerAddress,
string winnerPrize,
string[] winnerPrizeImages,
string campaignDescription,
uint256 maxNoOfParticipants,
uint256 currentNoOfParticipants,
uint256 drawTime,
string ngoName,
string ngoImage
);
event BidAdded(
uint256 itemId,
uint256 tokenId,
address bidder,
uint256 amount
);
event BidReturned(
uint256 itemId,
uint256 tokenId,
address bidder,
uint256 amount
);
struct CreateCampaignStruct{
string winnerPrize;
string[] winnerPrizeImages;
bytes[] signatures;
string campaignDescription;
uint256 maxNoOfParticipants;
uint256 drawTime;
string ngoName;
string ngoImage;
}
struct Campaign {
uint256 campaignID;
address creatorAddress;
uint256 totalNfts;
address winnerAddress;
string winnerPrize;
string[] winnerPrizeImages;
bytes[] signatures;
string campaignDescription;
uint256 maxNoOfParticipants;
uint256 currentNoOfParticipants;
uint256 drawTime;
string ngoName;
string ngoImage;
bool isEnded;
address[] participants;
uint256 soldNfts;
}
struct NFTAuctionItems{
uint256 nftID;
bool isOnAuction;
uint256 biddingTime;
address artistAddress;
uint256 price;
bool sold;
uint256 platformFee;
}
struct Bidder{
address bidderAddress;
uint256 bidderAmount;
}
mapping(uint256=>NFTAuctionItems) public currentlyOnAuction;
uint256 public currentlyOnAuctionTokenID;
bool public isOnAuction;
mapping(uint256=>Campaign) public campaigns;
mapping(uint256=>Bidder) public bidderInfo;
constructor(address _nftContract, address _nftHolder, address _randomContract) {
}
function setNFTContract(address _nftContract) external onlyOwner{
}
function setNFTAddress(address _nftHolder) external onlyOwner{
}
function setRandomContractAddress(address _randomContract) external onlyOwner{
}
function createMarketSale(NFTVoucher calldata voucher,bool donation) public payable{
}
function createCampaign(
CreateCampaignStruct memory _campaignDTO
) external onlyOwner{
}
function listNftForAuction(NFTVoucher calldata voucher,uint256 bidEndTime,uint256 tokenId) external onlyOwner{
}
function createBidOnItem(
uint256 itemId
) external payable nonReentrant {
uint price = currentlyOnAuction[itemId].price;
require(currentlyOnAuction[itemId].nftID==itemId,"Item is not on auction");
require(currentlyOnAuction[itemId].biddingTime>block.timestamp,"Auction time ended");
require(<FILL_ME>)
require(msg.value >= price && msg.value > bidderInfo[itemId].bidderAmount, "Bid price must be greater than base price and highest bid");
if(bidderInfo[itemId].bidderAddress!=address(0)){
payable(bidderInfo[itemId].bidderAddress).transfer(bidderInfo[itemId].bidderAmount);
totalAmountDue = totalAmountDue.sub(bidderInfo[itemId].bidderAmount);
emit BidReturned(itemId, currentlyOnAuction[itemId].nftID, bidderInfo[itemId].bidderAddress, bidderInfo[itemId].bidderAmount);
}
totalAmountDue = totalAmountDue.add(msg.value);
bidderInfo[itemId].bidderAddress = msg.sender;
bidderInfo[itemId].bidderAmount = msg.value;
emit BidAdded(itemId, currentlyOnAuction[itemId].nftID, msg.sender, msg.value);
}
function claimBidItem(uint256 itemId) external nonReentrant {
}
function resetAuction() external onlyOwner{
}
function withdraw() external onlyOwner{
}
function getOwnerBalance() public view returns(uint256){
}
function getBalance() public view returns(uint256){
}
function drawForWinner(uint256 _campaignId) external onlyOwner{
}
function getCampaignData(uint256 _id) external view returns(
string[] memory winnerPrizeImages,
address[] memory participants
){
}
function getWonCampaigns(address userAddress) external view returns(
uint256[] memory wonCampaign
) {
}
function updateCampaignDrawTime(uint256 _campaignId,uint256 _drawTime) external onlyOwner{
}
function updateAuctionEndTime (uint256 _bidEndTime, uint tokenId ) external onlyOwner {
}
}
| !currentlyOnAuction[itemId].sold,"Already sold" | 147,654 | !currentlyOnAuction[itemId].sold |
"Item is not on auction" | pragma solidity ^0.8.15;
struct NFTVoucher {
string uri;
uint256 price;
address creatorAddress;
uint256 numberOfNfts;
uint256 platformFee;
bytes signature;
}
struct NFT {
string uri;
uint256 price;
address creatorAddress;
uint256 numberOfNfts;
uint256 platformFee;
}
interface ILooxooryNft{
function redeem(address redeemer, NFTVoucher calldata voucher) external returns (uint256);
function getCurrentTokenId() external view returns(uint256);
function getNFT(uint256 _tokenId) external view returns(string memory uri,uint256 price,address creatorAddress,uint256 numberOfNfts,uint256 platformFee);
}
interface IRandom{
function random() external view returns (uint256);
}
contract LooxooryNFTMarketplace is ReentrancyGuard,Ownable {
using Counters for Counters.Counter;
using SafeMath for uint256;
Counters.Counter public _itemsSold;
Counters.Counter public _campaignIds;
uint256 public TOTAL_PERCENTAGE = 100;
uint256 public totalSale;
uint256 public totalAmountDue;
address public NFTContract;
address public NFTHolderAddress;
address public randomContract;
mapping(address=>uint256[]) public wonCampaigns;
mapping(bytes=>uint256) public nftSoldData;
mapping(bytes=>uint256) public voucherToCampaignID;
event Minted(
uint256 tokenId,
string uri,
uint256 price,
address creatorAddress,
uint256 numberOfNfts,
uint256 platformFee
);
event CampaignCreated(
uint256 campaignID,
address creatorAddress,
address winnerAddress,
string winnerPrize,
string[] winnerPrizeImages,
string campaignDescription,
uint256 maxNoOfParticipants,
uint256 currentNoOfParticipants,
uint256 drawTime,
string ngoName,
string ngoImage
);
event BidAdded(
uint256 itemId,
uint256 tokenId,
address bidder,
uint256 amount
);
event BidReturned(
uint256 itemId,
uint256 tokenId,
address bidder,
uint256 amount
);
struct CreateCampaignStruct{
string winnerPrize;
string[] winnerPrizeImages;
bytes[] signatures;
string campaignDescription;
uint256 maxNoOfParticipants;
uint256 drawTime;
string ngoName;
string ngoImage;
}
struct Campaign {
uint256 campaignID;
address creatorAddress;
uint256 totalNfts;
address winnerAddress;
string winnerPrize;
string[] winnerPrizeImages;
bytes[] signatures;
string campaignDescription;
uint256 maxNoOfParticipants;
uint256 currentNoOfParticipants;
uint256 drawTime;
string ngoName;
string ngoImage;
bool isEnded;
address[] participants;
uint256 soldNfts;
}
struct NFTAuctionItems{
uint256 nftID;
bool isOnAuction;
uint256 biddingTime;
address artistAddress;
uint256 price;
bool sold;
uint256 platformFee;
}
struct Bidder{
address bidderAddress;
uint256 bidderAmount;
}
mapping(uint256=>NFTAuctionItems) public currentlyOnAuction;
uint256 public currentlyOnAuctionTokenID;
bool public isOnAuction;
mapping(uint256=>Campaign) public campaigns;
mapping(uint256=>Bidder) public bidderInfo;
constructor(address _nftContract, address _nftHolder, address _randomContract) {
}
function setNFTContract(address _nftContract) external onlyOwner{
}
function setNFTAddress(address _nftHolder) external onlyOwner{
}
function setRandomContractAddress(address _randomContract) external onlyOwner{
}
function createMarketSale(NFTVoucher calldata voucher,bool donation) public payable{
}
function createCampaign(
CreateCampaignStruct memory _campaignDTO
) external onlyOwner{
}
function listNftForAuction(NFTVoucher calldata voucher,uint256 bidEndTime,uint256 tokenId) external onlyOwner{
}
function createBidOnItem(
uint256 itemId
) external payable nonReentrant {
}
function claimBidItem(uint256 itemId) external nonReentrant {
require(<FILL_ME>)
require(currentlyOnAuction[itemId].biddingTime<=block.timestamp,"Bidding is still in progress");
uint tokenId = currentlyOnAuction[itemId].nftID;
require(!currentlyOnAuction[itemId].sold ,"Already sold");
require(bidderInfo[itemId].bidderAddress==msg.sender,"Only highest bidder can claim the NFT");
uint256 price = bidderInfo[itemId].bidderAmount;
_itemsSold.increment();
totalSale = totalSale.add(price);
totalAmountDue = totalAmountDue.sub(price);
IERC721(NFTContract).safeTransferFrom(NFTHolderAddress, msg.sender, tokenId);
uint256 _platformFee = price.mul(currentlyOnAuction[itemId].platformFee).div(TOTAL_PERCENTAGE);
uint256 artistShare = price.sub(_platformFee);
payable(currentlyOnAuction[itemId].artistAddress).transfer(artistShare);
currentlyOnAuction[itemId].sold = true;
if(currentlyOnAuctionTokenID == itemId){
isOnAuction = false;
currentlyOnAuctionTokenID = 0;
}
}
function resetAuction() external onlyOwner{
}
function withdraw() external onlyOwner{
}
function getOwnerBalance() public view returns(uint256){
}
function getBalance() public view returns(uint256){
}
function drawForWinner(uint256 _campaignId) external onlyOwner{
}
function getCampaignData(uint256 _id) external view returns(
string[] memory winnerPrizeImages,
address[] memory participants
){
}
function getWonCampaigns(address userAddress) external view returns(
uint256[] memory wonCampaign
) {
}
function updateCampaignDrawTime(uint256 _campaignId,uint256 _drawTime) external onlyOwner{
}
function updateAuctionEndTime (uint256 _bidEndTime, uint tokenId ) external onlyOwner {
}
}
| currentlyOnAuction[itemId].isOnAuction,"Item is not on auction" | 147,654 | currentlyOnAuction[itemId].isOnAuction |
"Bidding is still in progress" | pragma solidity ^0.8.15;
struct NFTVoucher {
string uri;
uint256 price;
address creatorAddress;
uint256 numberOfNfts;
uint256 platformFee;
bytes signature;
}
struct NFT {
string uri;
uint256 price;
address creatorAddress;
uint256 numberOfNfts;
uint256 platformFee;
}
interface ILooxooryNft{
function redeem(address redeemer, NFTVoucher calldata voucher) external returns (uint256);
function getCurrentTokenId() external view returns(uint256);
function getNFT(uint256 _tokenId) external view returns(string memory uri,uint256 price,address creatorAddress,uint256 numberOfNfts,uint256 platformFee);
}
interface IRandom{
function random() external view returns (uint256);
}
contract LooxooryNFTMarketplace is ReentrancyGuard,Ownable {
using Counters for Counters.Counter;
using SafeMath for uint256;
Counters.Counter public _itemsSold;
Counters.Counter public _campaignIds;
uint256 public TOTAL_PERCENTAGE = 100;
uint256 public totalSale;
uint256 public totalAmountDue;
address public NFTContract;
address public NFTHolderAddress;
address public randomContract;
mapping(address=>uint256[]) public wonCampaigns;
mapping(bytes=>uint256) public nftSoldData;
mapping(bytes=>uint256) public voucherToCampaignID;
event Minted(
uint256 tokenId,
string uri,
uint256 price,
address creatorAddress,
uint256 numberOfNfts,
uint256 platformFee
);
event CampaignCreated(
uint256 campaignID,
address creatorAddress,
address winnerAddress,
string winnerPrize,
string[] winnerPrizeImages,
string campaignDescription,
uint256 maxNoOfParticipants,
uint256 currentNoOfParticipants,
uint256 drawTime,
string ngoName,
string ngoImage
);
event BidAdded(
uint256 itemId,
uint256 tokenId,
address bidder,
uint256 amount
);
event BidReturned(
uint256 itemId,
uint256 tokenId,
address bidder,
uint256 amount
);
struct CreateCampaignStruct{
string winnerPrize;
string[] winnerPrizeImages;
bytes[] signatures;
string campaignDescription;
uint256 maxNoOfParticipants;
uint256 drawTime;
string ngoName;
string ngoImage;
}
struct Campaign {
uint256 campaignID;
address creatorAddress;
uint256 totalNfts;
address winnerAddress;
string winnerPrize;
string[] winnerPrizeImages;
bytes[] signatures;
string campaignDescription;
uint256 maxNoOfParticipants;
uint256 currentNoOfParticipants;
uint256 drawTime;
string ngoName;
string ngoImage;
bool isEnded;
address[] participants;
uint256 soldNfts;
}
struct NFTAuctionItems{
uint256 nftID;
bool isOnAuction;
uint256 biddingTime;
address artistAddress;
uint256 price;
bool sold;
uint256 platformFee;
}
struct Bidder{
address bidderAddress;
uint256 bidderAmount;
}
mapping(uint256=>NFTAuctionItems) public currentlyOnAuction;
uint256 public currentlyOnAuctionTokenID;
bool public isOnAuction;
mapping(uint256=>Campaign) public campaigns;
mapping(uint256=>Bidder) public bidderInfo;
constructor(address _nftContract, address _nftHolder, address _randomContract) {
}
function setNFTContract(address _nftContract) external onlyOwner{
}
function setNFTAddress(address _nftHolder) external onlyOwner{
}
function setRandomContractAddress(address _randomContract) external onlyOwner{
}
function createMarketSale(NFTVoucher calldata voucher,bool donation) public payable{
}
function createCampaign(
CreateCampaignStruct memory _campaignDTO
) external onlyOwner{
}
function listNftForAuction(NFTVoucher calldata voucher,uint256 bidEndTime,uint256 tokenId) external onlyOwner{
}
function createBidOnItem(
uint256 itemId
) external payable nonReentrant {
}
function claimBidItem(uint256 itemId) external nonReentrant {
require(currentlyOnAuction[itemId].isOnAuction,"Item is not on auction");
require(<FILL_ME>)
uint tokenId = currentlyOnAuction[itemId].nftID;
require(!currentlyOnAuction[itemId].sold ,"Already sold");
require(bidderInfo[itemId].bidderAddress==msg.sender,"Only highest bidder can claim the NFT");
uint256 price = bidderInfo[itemId].bidderAmount;
_itemsSold.increment();
totalSale = totalSale.add(price);
totalAmountDue = totalAmountDue.sub(price);
IERC721(NFTContract).safeTransferFrom(NFTHolderAddress, msg.sender, tokenId);
uint256 _platformFee = price.mul(currentlyOnAuction[itemId].platformFee).div(TOTAL_PERCENTAGE);
uint256 artistShare = price.sub(_platformFee);
payable(currentlyOnAuction[itemId].artistAddress).transfer(artistShare);
currentlyOnAuction[itemId].sold = true;
if(currentlyOnAuctionTokenID == itemId){
isOnAuction = false;
currentlyOnAuctionTokenID = 0;
}
}
function resetAuction() external onlyOwner{
}
function withdraw() external onlyOwner{
}
function getOwnerBalance() public view returns(uint256){
}
function getBalance() public view returns(uint256){
}
function drawForWinner(uint256 _campaignId) external onlyOwner{
}
function getCampaignData(uint256 _id) external view returns(
string[] memory winnerPrizeImages,
address[] memory participants
){
}
function getWonCampaigns(address userAddress) external view returns(
uint256[] memory wonCampaign
) {
}
function updateCampaignDrawTime(uint256 _campaignId,uint256 _drawTime) external onlyOwner{
}
function updateAuctionEndTime (uint256 _bidEndTime, uint tokenId ) external onlyOwner {
}
}
| currentlyOnAuction[itemId].biddingTime<=block.timestamp,"Bidding is still in progress" | 147,654 | currentlyOnAuction[itemId].biddingTime<=block.timestamp |
"Only highest bidder can claim the NFT" | pragma solidity ^0.8.15;
struct NFTVoucher {
string uri;
uint256 price;
address creatorAddress;
uint256 numberOfNfts;
uint256 platformFee;
bytes signature;
}
struct NFT {
string uri;
uint256 price;
address creatorAddress;
uint256 numberOfNfts;
uint256 platformFee;
}
interface ILooxooryNft{
function redeem(address redeemer, NFTVoucher calldata voucher) external returns (uint256);
function getCurrentTokenId() external view returns(uint256);
function getNFT(uint256 _tokenId) external view returns(string memory uri,uint256 price,address creatorAddress,uint256 numberOfNfts,uint256 platformFee);
}
interface IRandom{
function random() external view returns (uint256);
}
contract LooxooryNFTMarketplace is ReentrancyGuard,Ownable {
using Counters for Counters.Counter;
using SafeMath for uint256;
Counters.Counter public _itemsSold;
Counters.Counter public _campaignIds;
uint256 public TOTAL_PERCENTAGE = 100;
uint256 public totalSale;
uint256 public totalAmountDue;
address public NFTContract;
address public NFTHolderAddress;
address public randomContract;
mapping(address=>uint256[]) public wonCampaigns;
mapping(bytes=>uint256) public nftSoldData;
mapping(bytes=>uint256) public voucherToCampaignID;
event Minted(
uint256 tokenId,
string uri,
uint256 price,
address creatorAddress,
uint256 numberOfNfts,
uint256 platformFee
);
event CampaignCreated(
uint256 campaignID,
address creatorAddress,
address winnerAddress,
string winnerPrize,
string[] winnerPrizeImages,
string campaignDescription,
uint256 maxNoOfParticipants,
uint256 currentNoOfParticipants,
uint256 drawTime,
string ngoName,
string ngoImage
);
event BidAdded(
uint256 itemId,
uint256 tokenId,
address bidder,
uint256 amount
);
event BidReturned(
uint256 itemId,
uint256 tokenId,
address bidder,
uint256 amount
);
struct CreateCampaignStruct{
string winnerPrize;
string[] winnerPrizeImages;
bytes[] signatures;
string campaignDescription;
uint256 maxNoOfParticipants;
uint256 drawTime;
string ngoName;
string ngoImage;
}
struct Campaign {
uint256 campaignID;
address creatorAddress;
uint256 totalNfts;
address winnerAddress;
string winnerPrize;
string[] winnerPrizeImages;
bytes[] signatures;
string campaignDescription;
uint256 maxNoOfParticipants;
uint256 currentNoOfParticipants;
uint256 drawTime;
string ngoName;
string ngoImage;
bool isEnded;
address[] participants;
uint256 soldNfts;
}
struct NFTAuctionItems{
uint256 nftID;
bool isOnAuction;
uint256 biddingTime;
address artistAddress;
uint256 price;
bool sold;
uint256 platformFee;
}
struct Bidder{
address bidderAddress;
uint256 bidderAmount;
}
mapping(uint256=>NFTAuctionItems) public currentlyOnAuction;
uint256 public currentlyOnAuctionTokenID;
bool public isOnAuction;
mapping(uint256=>Campaign) public campaigns;
mapping(uint256=>Bidder) public bidderInfo;
constructor(address _nftContract, address _nftHolder, address _randomContract) {
}
function setNFTContract(address _nftContract) external onlyOwner{
}
function setNFTAddress(address _nftHolder) external onlyOwner{
}
function setRandomContractAddress(address _randomContract) external onlyOwner{
}
function createMarketSale(NFTVoucher calldata voucher,bool donation) public payable{
}
function createCampaign(
CreateCampaignStruct memory _campaignDTO
) external onlyOwner{
}
function listNftForAuction(NFTVoucher calldata voucher,uint256 bidEndTime,uint256 tokenId) external onlyOwner{
}
function createBidOnItem(
uint256 itemId
) external payable nonReentrant {
}
function claimBidItem(uint256 itemId) external nonReentrant {
require(currentlyOnAuction[itemId].isOnAuction,"Item is not on auction");
require(currentlyOnAuction[itemId].biddingTime<=block.timestamp,"Bidding is still in progress");
uint tokenId = currentlyOnAuction[itemId].nftID;
require(!currentlyOnAuction[itemId].sold ,"Already sold");
require(<FILL_ME>)
uint256 price = bidderInfo[itemId].bidderAmount;
_itemsSold.increment();
totalSale = totalSale.add(price);
totalAmountDue = totalAmountDue.sub(price);
IERC721(NFTContract).safeTransferFrom(NFTHolderAddress, msg.sender, tokenId);
uint256 _platformFee = price.mul(currentlyOnAuction[itemId].platformFee).div(TOTAL_PERCENTAGE);
uint256 artistShare = price.sub(_platformFee);
payable(currentlyOnAuction[itemId].artistAddress).transfer(artistShare);
currentlyOnAuction[itemId].sold = true;
if(currentlyOnAuctionTokenID == itemId){
isOnAuction = false;
currentlyOnAuctionTokenID = 0;
}
}
function resetAuction() external onlyOwner{
}
function withdraw() external onlyOwner{
}
function getOwnerBalance() public view returns(uint256){
}
function getBalance() public view returns(uint256){
}
function drawForWinner(uint256 _campaignId) external onlyOwner{
}
function getCampaignData(uint256 _id) external view returns(
string[] memory winnerPrizeImages,
address[] memory participants
){
}
function getWonCampaigns(address userAddress) external view returns(
uint256[] memory wonCampaign
) {
}
function updateCampaignDrawTime(uint256 _campaignId,uint256 _drawTime) external onlyOwner{
}
function updateAuctionEndTime (uint256 _bidEndTime, uint tokenId ) external onlyOwner {
}
}
| bidderInfo[itemId].bidderAddress==msg.sender,"Only highest bidder can claim the NFT" | 147,654 | bidderInfo[itemId].bidderAddress==msg.sender |
"Cannot reset now, bid time is not ended" | pragma solidity ^0.8.15;
struct NFTVoucher {
string uri;
uint256 price;
address creatorAddress;
uint256 numberOfNfts;
uint256 platformFee;
bytes signature;
}
struct NFT {
string uri;
uint256 price;
address creatorAddress;
uint256 numberOfNfts;
uint256 platformFee;
}
interface ILooxooryNft{
function redeem(address redeemer, NFTVoucher calldata voucher) external returns (uint256);
function getCurrentTokenId() external view returns(uint256);
function getNFT(uint256 _tokenId) external view returns(string memory uri,uint256 price,address creatorAddress,uint256 numberOfNfts,uint256 platformFee);
}
interface IRandom{
function random() external view returns (uint256);
}
contract LooxooryNFTMarketplace is ReentrancyGuard,Ownable {
using Counters for Counters.Counter;
using SafeMath for uint256;
Counters.Counter public _itemsSold;
Counters.Counter public _campaignIds;
uint256 public TOTAL_PERCENTAGE = 100;
uint256 public totalSale;
uint256 public totalAmountDue;
address public NFTContract;
address public NFTHolderAddress;
address public randomContract;
mapping(address=>uint256[]) public wonCampaigns;
mapping(bytes=>uint256) public nftSoldData;
mapping(bytes=>uint256) public voucherToCampaignID;
event Minted(
uint256 tokenId,
string uri,
uint256 price,
address creatorAddress,
uint256 numberOfNfts,
uint256 platformFee
);
event CampaignCreated(
uint256 campaignID,
address creatorAddress,
address winnerAddress,
string winnerPrize,
string[] winnerPrizeImages,
string campaignDescription,
uint256 maxNoOfParticipants,
uint256 currentNoOfParticipants,
uint256 drawTime,
string ngoName,
string ngoImage
);
event BidAdded(
uint256 itemId,
uint256 tokenId,
address bidder,
uint256 amount
);
event BidReturned(
uint256 itemId,
uint256 tokenId,
address bidder,
uint256 amount
);
struct CreateCampaignStruct{
string winnerPrize;
string[] winnerPrizeImages;
bytes[] signatures;
string campaignDescription;
uint256 maxNoOfParticipants;
uint256 drawTime;
string ngoName;
string ngoImage;
}
struct Campaign {
uint256 campaignID;
address creatorAddress;
uint256 totalNfts;
address winnerAddress;
string winnerPrize;
string[] winnerPrizeImages;
bytes[] signatures;
string campaignDescription;
uint256 maxNoOfParticipants;
uint256 currentNoOfParticipants;
uint256 drawTime;
string ngoName;
string ngoImage;
bool isEnded;
address[] participants;
uint256 soldNfts;
}
struct NFTAuctionItems{
uint256 nftID;
bool isOnAuction;
uint256 biddingTime;
address artistAddress;
uint256 price;
bool sold;
uint256 platformFee;
}
struct Bidder{
address bidderAddress;
uint256 bidderAmount;
}
mapping(uint256=>NFTAuctionItems) public currentlyOnAuction;
uint256 public currentlyOnAuctionTokenID;
bool public isOnAuction;
mapping(uint256=>Campaign) public campaigns;
mapping(uint256=>Bidder) public bidderInfo;
constructor(address _nftContract, address _nftHolder, address _randomContract) {
}
function setNFTContract(address _nftContract) external onlyOwner{
}
function setNFTAddress(address _nftHolder) external onlyOwner{
}
function setRandomContractAddress(address _randomContract) external onlyOwner{
}
function createMarketSale(NFTVoucher calldata voucher,bool donation) public payable{
}
function createCampaign(
CreateCampaignStruct memory _campaignDTO
) external onlyOwner{
}
function listNftForAuction(NFTVoucher calldata voucher,uint256 bidEndTime,uint256 tokenId) external onlyOwner{
}
function createBidOnItem(
uint256 itemId
) external payable nonReentrant {
}
function claimBidItem(uint256 itemId) external nonReentrant {
}
function resetAuction() external onlyOwner{
require(isOnAuction,"No nft is on auction at this moment");
require(<FILL_ME>)
if(bidderInfo[currentlyOnAuctionTokenID].bidderAddress==address(0)){
currentlyOnAuction[currentlyOnAuctionTokenID].isOnAuction = false;
currentlyOnAuction[currentlyOnAuctionTokenID].biddingTime = 0;
}
isOnAuction = false;
currentlyOnAuctionTokenID = 0;
}
function withdraw() external onlyOwner{
}
function getOwnerBalance() public view returns(uint256){
}
function getBalance() public view returns(uint256){
}
function drawForWinner(uint256 _campaignId) external onlyOwner{
}
function getCampaignData(uint256 _id) external view returns(
string[] memory winnerPrizeImages,
address[] memory participants
){
}
function getWonCampaigns(address userAddress) external view returns(
uint256[] memory wonCampaign
) {
}
function updateCampaignDrawTime(uint256 _campaignId,uint256 _drawTime) external onlyOwner{
}
function updateAuctionEndTime (uint256 _bidEndTime, uint tokenId ) external onlyOwner {
}
}
| currentlyOnAuction[currentlyOnAuctionTokenID].biddingTime<block.timestamp,"Cannot reset now, bid time is not ended" | 147,654 | currentlyOnAuction[currentlyOnAuctionTokenID].biddingTime<block.timestamp |
"Invalid campaign id" | pragma solidity ^0.8.15;
struct NFTVoucher {
string uri;
uint256 price;
address creatorAddress;
uint256 numberOfNfts;
uint256 platformFee;
bytes signature;
}
struct NFT {
string uri;
uint256 price;
address creatorAddress;
uint256 numberOfNfts;
uint256 platformFee;
}
interface ILooxooryNft{
function redeem(address redeemer, NFTVoucher calldata voucher) external returns (uint256);
function getCurrentTokenId() external view returns(uint256);
function getNFT(uint256 _tokenId) external view returns(string memory uri,uint256 price,address creatorAddress,uint256 numberOfNfts,uint256 platformFee);
}
interface IRandom{
function random() external view returns (uint256);
}
contract LooxooryNFTMarketplace is ReentrancyGuard,Ownable {
using Counters for Counters.Counter;
using SafeMath for uint256;
Counters.Counter public _itemsSold;
Counters.Counter public _campaignIds;
uint256 public TOTAL_PERCENTAGE = 100;
uint256 public totalSale;
uint256 public totalAmountDue;
address public NFTContract;
address public NFTHolderAddress;
address public randomContract;
mapping(address=>uint256[]) public wonCampaigns;
mapping(bytes=>uint256) public nftSoldData;
mapping(bytes=>uint256) public voucherToCampaignID;
event Minted(
uint256 tokenId,
string uri,
uint256 price,
address creatorAddress,
uint256 numberOfNfts,
uint256 platformFee
);
event CampaignCreated(
uint256 campaignID,
address creatorAddress,
address winnerAddress,
string winnerPrize,
string[] winnerPrizeImages,
string campaignDescription,
uint256 maxNoOfParticipants,
uint256 currentNoOfParticipants,
uint256 drawTime,
string ngoName,
string ngoImage
);
event BidAdded(
uint256 itemId,
uint256 tokenId,
address bidder,
uint256 amount
);
event BidReturned(
uint256 itemId,
uint256 tokenId,
address bidder,
uint256 amount
);
struct CreateCampaignStruct{
string winnerPrize;
string[] winnerPrizeImages;
bytes[] signatures;
string campaignDescription;
uint256 maxNoOfParticipants;
uint256 drawTime;
string ngoName;
string ngoImage;
}
struct Campaign {
uint256 campaignID;
address creatorAddress;
uint256 totalNfts;
address winnerAddress;
string winnerPrize;
string[] winnerPrizeImages;
bytes[] signatures;
string campaignDescription;
uint256 maxNoOfParticipants;
uint256 currentNoOfParticipants;
uint256 drawTime;
string ngoName;
string ngoImage;
bool isEnded;
address[] participants;
uint256 soldNfts;
}
struct NFTAuctionItems{
uint256 nftID;
bool isOnAuction;
uint256 biddingTime;
address artistAddress;
uint256 price;
bool sold;
uint256 platformFee;
}
struct Bidder{
address bidderAddress;
uint256 bidderAmount;
}
mapping(uint256=>NFTAuctionItems) public currentlyOnAuction;
uint256 public currentlyOnAuctionTokenID;
bool public isOnAuction;
mapping(uint256=>Campaign) public campaigns;
mapping(uint256=>Bidder) public bidderInfo;
constructor(address _nftContract, address _nftHolder, address _randomContract) {
}
function setNFTContract(address _nftContract) external onlyOwner{
}
function setNFTAddress(address _nftHolder) external onlyOwner{
}
function setRandomContractAddress(address _randomContract) external onlyOwner{
}
function createMarketSale(NFTVoucher calldata voucher,bool donation) public payable{
}
function createCampaign(
CreateCampaignStruct memory _campaignDTO
) external onlyOwner{
}
function listNftForAuction(NFTVoucher calldata voucher,uint256 bidEndTime,uint256 tokenId) external onlyOwner{
}
function createBidOnItem(
uint256 itemId
) external payable nonReentrant {
}
function claimBidItem(uint256 itemId) external nonReentrant {
}
function resetAuction() external onlyOwner{
}
function withdraw() external onlyOwner{
}
function getOwnerBalance() public view returns(uint256){
}
function getBalance() public view returns(uint256){
}
function drawForWinner(uint256 _campaignId) external onlyOwner{
require(<FILL_ME>)
require(!campaigns[_campaignId].isEnded,"Campaign already ended");
require(campaigns[_campaignId].drawTime<block.timestamp
|| campaigns[_campaignId].currentNoOfParticipants==campaigns[_campaignId].maxNoOfParticipants
,"Cannot draw at the moment");
require(campaigns[_campaignId].currentNoOfParticipants>0,"No participant on this campaign");
uint256 winnerIndex = IRandom(randomContract).random()% campaigns[_campaignId].currentNoOfParticipants;
address winnerAddress = campaigns[_campaignId].participants[winnerIndex];
campaigns[_campaignId].winnerAddress = winnerAddress;
campaigns[_campaignId].isEnded = true;
wonCampaigns[winnerAddress].push(_campaignId);
}
function getCampaignData(uint256 _id) external view returns(
string[] memory winnerPrizeImages,
address[] memory participants
){
}
function getWonCampaigns(address userAddress) external view returns(
uint256[] memory wonCampaign
) {
}
function updateCampaignDrawTime(uint256 _campaignId,uint256 _drawTime) external onlyOwner{
}
function updateAuctionEndTime (uint256 _bidEndTime, uint tokenId ) external onlyOwner {
}
}
| campaigns[_campaignId].creatorAddress!=address(0),"Invalid campaign id" | 147,654 | campaigns[_campaignId].creatorAddress!=address(0) |
"Campaign already ended" | pragma solidity ^0.8.15;
struct NFTVoucher {
string uri;
uint256 price;
address creatorAddress;
uint256 numberOfNfts;
uint256 platformFee;
bytes signature;
}
struct NFT {
string uri;
uint256 price;
address creatorAddress;
uint256 numberOfNfts;
uint256 platformFee;
}
interface ILooxooryNft{
function redeem(address redeemer, NFTVoucher calldata voucher) external returns (uint256);
function getCurrentTokenId() external view returns(uint256);
function getNFT(uint256 _tokenId) external view returns(string memory uri,uint256 price,address creatorAddress,uint256 numberOfNfts,uint256 platformFee);
}
interface IRandom{
function random() external view returns (uint256);
}
contract LooxooryNFTMarketplace is ReentrancyGuard,Ownable {
using Counters for Counters.Counter;
using SafeMath for uint256;
Counters.Counter public _itemsSold;
Counters.Counter public _campaignIds;
uint256 public TOTAL_PERCENTAGE = 100;
uint256 public totalSale;
uint256 public totalAmountDue;
address public NFTContract;
address public NFTHolderAddress;
address public randomContract;
mapping(address=>uint256[]) public wonCampaigns;
mapping(bytes=>uint256) public nftSoldData;
mapping(bytes=>uint256) public voucherToCampaignID;
event Minted(
uint256 tokenId,
string uri,
uint256 price,
address creatorAddress,
uint256 numberOfNfts,
uint256 platformFee
);
event CampaignCreated(
uint256 campaignID,
address creatorAddress,
address winnerAddress,
string winnerPrize,
string[] winnerPrizeImages,
string campaignDescription,
uint256 maxNoOfParticipants,
uint256 currentNoOfParticipants,
uint256 drawTime,
string ngoName,
string ngoImage
);
event BidAdded(
uint256 itemId,
uint256 tokenId,
address bidder,
uint256 amount
);
event BidReturned(
uint256 itemId,
uint256 tokenId,
address bidder,
uint256 amount
);
struct CreateCampaignStruct{
string winnerPrize;
string[] winnerPrizeImages;
bytes[] signatures;
string campaignDescription;
uint256 maxNoOfParticipants;
uint256 drawTime;
string ngoName;
string ngoImage;
}
struct Campaign {
uint256 campaignID;
address creatorAddress;
uint256 totalNfts;
address winnerAddress;
string winnerPrize;
string[] winnerPrizeImages;
bytes[] signatures;
string campaignDescription;
uint256 maxNoOfParticipants;
uint256 currentNoOfParticipants;
uint256 drawTime;
string ngoName;
string ngoImage;
bool isEnded;
address[] participants;
uint256 soldNfts;
}
struct NFTAuctionItems{
uint256 nftID;
bool isOnAuction;
uint256 biddingTime;
address artistAddress;
uint256 price;
bool sold;
uint256 platformFee;
}
struct Bidder{
address bidderAddress;
uint256 bidderAmount;
}
mapping(uint256=>NFTAuctionItems) public currentlyOnAuction;
uint256 public currentlyOnAuctionTokenID;
bool public isOnAuction;
mapping(uint256=>Campaign) public campaigns;
mapping(uint256=>Bidder) public bidderInfo;
constructor(address _nftContract, address _nftHolder, address _randomContract) {
}
function setNFTContract(address _nftContract) external onlyOwner{
}
function setNFTAddress(address _nftHolder) external onlyOwner{
}
function setRandomContractAddress(address _randomContract) external onlyOwner{
}
function createMarketSale(NFTVoucher calldata voucher,bool donation) public payable{
}
function createCampaign(
CreateCampaignStruct memory _campaignDTO
) external onlyOwner{
}
function listNftForAuction(NFTVoucher calldata voucher,uint256 bidEndTime,uint256 tokenId) external onlyOwner{
}
function createBidOnItem(
uint256 itemId
) external payable nonReentrant {
}
function claimBidItem(uint256 itemId) external nonReentrant {
}
function resetAuction() external onlyOwner{
}
function withdraw() external onlyOwner{
}
function getOwnerBalance() public view returns(uint256){
}
function getBalance() public view returns(uint256){
}
function drawForWinner(uint256 _campaignId) external onlyOwner{
require(campaigns[_campaignId].creatorAddress!=address(0),"Invalid campaign id");
require(<FILL_ME>)
require(campaigns[_campaignId].drawTime<block.timestamp
|| campaigns[_campaignId].currentNoOfParticipants==campaigns[_campaignId].maxNoOfParticipants
,"Cannot draw at the moment");
require(campaigns[_campaignId].currentNoOfParticipants>0,"No participant on this campaign");
uint256 winnerIndex = IRandom(randomContract).random()% campaigns[_campaignId].currentNoOfParticipants;
address winnerAddress = campaigns[_campaignId].participants[winnerIndex];
campaigns[_campaignId].winnerAddress = winnerAddress;
campaigns[_campaignId].isEnded = true;
wonCampaigns[winnerAddress].push(_campaignId);
}
function getCampaignData(uint256 _id) external view returns(
string[] memory winnerPrizeImages,
address[] memory participants
){
}
function getWonCampaigns(address userAddress) external view returns(
uint256[] memory wonCampaign
) {
}
function updateCampaignDrawTime(uint256 _campaignId,uint256 _drawTime) external onlyOwner{
}
function updateAuctionEndTime (uint256 _bidEndTime, uint tokenId ) external onlyOwner {
}
}
| !campaigns[_campaignId].isEnded,"Campaign already ended" | 147,654 | !campaigns[_campaignId].isEnded |
"Cannot draw at the moment" | pragma solidity ^0.8.15;
struct NFTVoucher {
string uri;
uint256 price;
address creatorAddress;
uint256 numberOfNfts;
uint256 platformFee;
bytes signature;
}
struct NFT {
string uri;
uint256 price;
address creatorAddress;
uint256 numberOfNfts;
uint256 platformFee;
}
interface ILooxooryNft{
function redeem(address redeemer, NFTVoucher calldata voucher) external returns (uint256);
function getCurrentTokenId() external view returns(uint256);
function getNFT(uint256 _tokenId) external view returns(string memory uri,uint256 price,address creatorAddress,uint256 numberOfNfts,uint256 platformFee);
}
interface IRandom{
function random() external view returns (uint256);
}
contract LooxooryNFTMarketplace is ReentrancyGuard,Ownable {
using Counters for Counters.Counter;
using SafeMath for uint256;
Counters.Counter public _itemsSold;
Counters.Counter public _campaignIds;
uint256 public TOTAL_PERCENTAGE = 100;
uint256 public totalSale;
uint256 public totalAmountDue;
address public NFTContract;
address public NFTHolderAddress;
address public randomContract;
mapping(address=>uint256[]) public wonCampaigns;
mapping(bytes=>uint256) public nftSoldData;
mapping(bytes=>uint256) public voucherToCampaignID;
event Minted(
uint256 tokenId,
string uri,
uint256 price,
address creatorAddress,
uint256 numberOfNfts,
uint256 platformFee
);
event CampaignCreated(
uint256 campaignID,
address creatorAddress,
address winnerAddress,
string winnerPrize,
string[] winnerPrizeImages,
string campaignDescription,
uint256 maxNoOfParticipants,
uint256 currentNoOfParticipants,
uint256 drawTime,
string ngoName,
string ngoImage
);
event BidAdded(
uint256 itemId,
uint256 tokenId,
address bidder,
uint256 amount
);
event BidReturned(
uint256 itemId,
uint256 tokenId,
address bidder,
uint256 amount
);
struct CreateCampaignStruct{
string winnerPrize;
string[] winnerPrizeImages;
bytes[] signatures;
string campaignDescription;
uint256 maxNoOfParticipants;
uint256 drawTime;
string ngoName;
string ngoImage;
}
struct Campaign {
uint256 campaignID;
address creatorAddress;
uint256 totalNfts;
address winnerAddress;
string winnerPrize;
string[] winnerPrizeImages;
bytes[] signatures;
string campaignDescription;
uint256 maxNoOfParticipants;
uint256 currentNoOfParticipants;
uint256 drawTime;
string ngoName;
string ngoImage;
bool isEnded;
address[] participants;
uint256 soldNfts;
}
struct NFTAuctionItems{
uint256 nftID;
bool isOnAuction;
uint256 biddingTime;
address artistAddress;
uint256 price;
bool sold;
uint256 platformFee;
}
struct Bidder{
address bidderAddress;
uint256 bidderAmount;
}
mapping(uint256=>NFTAuctionItems) public currentlyOnAuction;
uint256 public currentlyOnAuctionTokenID;
bool public isOnAuction;
mapping(uint256=>Campaign) public campaigns;
mapping(uint256=>Bidder) public bidderInfo;
constructor(address _nftContract, address _nftHolder, address _randomContract) {
}
function setNFTContract(address _nftContract) external onlyOwner{
}
function setNFTAddress(address _nftHolder) external onlyOwner{
}
function setRandomContractAddress(address _randomContract) external onlyOwner{
}
function createMarketSale(NFTVoucher calldata voucher,bool donation) public payable{
}
function createCampaign(
CreateCampaignStruct memory _campaignDTO
) external onlyOwner{
}
function listNftForAuction(NFTVoucher calldata voucher,uint256 bidEndTime,uint256 tokenId) external onlyOwner{
}
function createBidOnItem(
uint256 itemId
) external payable nonReentrant {
}
function claimBidItem(uint256 itemId) external nonReentrant {
}
function resetAuction() external onlyOwner{
}
function withdraw() external onlyOwner{
}
function getOwnerBalance() public view returns(uint256){
}
function getBalance() public view returns(uint256){
}
function drawForWinner(uint256 _campaignId) external onlyOwner{
require(campaigns[_campaignId].creatorAddress!=address(0),"Invalid campaign id");
require(!campaigns[_campaignId].isEnded,"Campaign already ended");
require(<FILL_ME>)
require(campaigns[_campaignId].currentNoOfParticipants>0,"No participant on this campaign");
uint256 winnerIndex = IRandom(randomContract).random()% campaigns[_campaignId].currentNoOfParticipants;
address winnerAddress = campaigns[_campaignId].participants[winnerIndex];
campaigns[_campaignId].winnerAddress = winnerAddress;
campaigns[_campaignId].isEnded = true;
wonCampaigns[winnerAddress].push(_campaignId);
}
function getCampaignData(uint256 _id) external view returns(
string[] memory winnerPrizeImages,
address[] memory participants
){
}
function getWonCampaigns(address userAddress) external view returns(
uint256[] memory wonCampaign
) {
}
function updateCampaignDrawTime(uint256 _campaignId,uint256 _drawTime) external onlyOwner{
}
function updateAuctionEndTime (uint256 _bidEndTime, uint tokenId ) external onlyOwner {
}
}
| campaigns[_campaignId].drawTime<block.timestamp||campaigns[_campaignId].currentNoOfParticipants==campaigns[_campaignId].maxNoOfParticipants,"Cannot draw at the moment" | 147,654 | campaigns[_campaignId].drawTime<block.timestamp||campaigns[_campaignId].currentNoOfParticipants==campaigns[_campaignId].maxNoOfParticipants |
"No participant on this campaign" | pragma solidity ^0.8.15;
struct NFTVoucher {
string uri;
uint256 price;
address creatorAddress;
uint256 numberOfNfts;
uint256 platformFee;
bytes signature;
}
struct NFT {
string uri;
uint256 price;
address creatorAddress;
uint256 numberOfNfts;
uint256 platformFee;
}
interface ILooxooryNft{
function redeem(address redeemer, NFTVoucher calldata voucher) external returns (uint256);
function getCurrentTokenId() external view returns(uint256);
function getNFT(uint256 _tokenId) external view returns(string memory uri,uint256 price,address creatorAddress,uint256 numberOfNfts,uint256 platformFee);
}
interface IRandom{
function random() external view returns (uint256);
}
contract LooxooryNFTMarketplace is ReentrancyGuard,Ownable {
using Counters for Counters.Counter;
using SafeMath for uint256;
Counters.Counter public _itemsSold;
Counters.Counter public _campaignIds;
uint256 public TOTAL_PERCENTAGE = 100;
uint256 public totalSale;
uint256 public totalAmountDue;
address public NFTContract;
address public NFTHolderAddress;
address public randomContract;
mapping(address=>uint256[]) public wonCampaigns;
mapping(bytes=>uint256) public nftSoldData;
mapping(bytes=>uint256) public voucherToCampaignID;
event Minted(
uint256 tokenId,
string uri,
uint256 price,
address creatorAddress,
uint256 numberOfNfts,
uint256 platformFee
);
event CampaignCreated(
uint256 campaignID,
address creatorAddress,
address winnerAddress,
string winnerPrize,
string[] winnerPrizeImages,
string campaignDescription,
uint256 maxNoOfParticipants,
uint256 currentNoOfParticipants,
uint256 drawTime,
string ngoName,
string ngoImage
);
event BidAdded(
uint256 itemId,
uint256 tokenId,
address bidder,
uint256 amount
);
event BidReturned(
uint256 itemId,
uint256 tokenId,
address bidder,
uint256 amount
);
struct CreateCampaignStruct{
string winnerPrize;
string[] winnerPrizeImages;
bytes[] signatures;
string campaignDescription;
uint256 maxNoOfParticipants;
uint256 drawTime;
string ngoName;
string ngoImage;
}
struct Campaign {
uint256 campaignID;
address creatorAddress;
uint256 totalNfts;
address winnerAddress;
string winnerPrize;
string[] winnerPrizeImages;
bytes[] signatures;
string campaignDescription;
uint256 maxNoOfParticipants;
uint256 currentNoOfParticipants;
uint256 drawTime;
string ngoName;
string ngoImage;
bool isEnded;
address[] participants;
uint256 soldNfts;
}
struct NFTAuctionItems{
uint256 nftID;
bool isOnAuction;
uint256 biddingTime;
address artistAddress;
uint256 price;
bool sold;
uint256 platformFee;
}
struct Bidder{
address bidderAddress;
uint256 bidderAmount;
}
mapping(uint256=>NFTAuctionItems) public currentlyOnAuction;
uint256 public currentlyOnAuctionTokenID;
bool public isOnAuction;
mapping(uint256=>Campaign) public campaigns;
mapping(uint256=>Bidder) public bidderInfo;
constructor(address _nftContract, address _nftHolder, address _randomContract) {
}
function setNFTContract(address _nftContract) external onlyOwner{
}
function setNFTAddress(address _nftHolder) external onlyOwner{
}
function setRandomContractAddress(address _randomContract) external onlyOwner{
}
function createMarketSale(NFTVoucher calldata voucher,bool donation) public payable{
}
function createCampaign(
CreateCampaignStruct memory _campaignDTO
) external onlyOwner{
}
function listNftForAuction(NFTVoucher calldata voucher,uint256 bidEndTime,uint256 tokenId) external onlyOwner{
}
function createBidOnItem(
uint256 itemId
) external payable nonReentrant {
}
function claimBidItem(uint256 itemId) external nonReentrant {
}
function resetAuction() external onlyOwner{
}
function withdraw() external onlyOwner{
}
function getOwnerBalance() public view returns(uint256){
}
function getBalance() public view returns(uint256){
}
function drawForWinner(uint256 _campaignId) external onlyOwner{
require(campaigns[_campaignId].creatorAddress!=address(0),"Invalid campaign id");
require(!campaigns[_campaignId].isEnded,"Campaign already ended");
require(campaigns[_campaignId].drawTime<block.timestamp
|| campaigns[_campaignId].currentNoOfParticipants==campaigns[_campaignId].maxNoOfParticipants
,"Cannot draw at the moment");
require(<FILL_ME>)
uint256 winnerIndex = IRandom(randomContract).random()% campaigns[_campaignId].currentNoOfParticipants;
address winnerAddress = campaigns[_campaignId].participants[winnerIndex];
campaigns[_campaignId].winnerAddress = winnerAddress;
campaigns[_campaignId].isEnded = true;
wonCampaigns[winnerAddress].push(_campaignId);
}
function getCampaignData(uint256 _id) external view returns(
string[] memory winnerPrizeImages,
address[] memory participants
){
}
function getWonCampaigns(address userAddress) external view returns(
uint256[] memory wonCampaign
) {
}
function updateCampaignDrawTime(uint256 _campaignId,uint256 _drawTime) external onlyOwner{
}
function updateAuctionEndTime (uint256 _bidEndTime, uint tokenId ) external onlyOwner {
}
}
| campaigns[_campaignId].currentNoOfParticipants>0,"No participant on this campaign" | 147,654 | campaigns[_campaignId].currentNoOfParticipants>0 |
"Invalid campaign id" | pragma solidity ^0.8.15;
struct NFTVoucher {
string uri;
uint256 price;
address creatorAddress;
uint256 numberOfNfts;
uint256 platformFee;
bytes signature;
}
struct NFT {
string uri;
uint256 price;
address creatorAddress;
uint256 numberOfNfts;
uint256 platformFee;
}
interface ILooxooryNft{
function redeem(address redeemer, NFTVoucher calldata voucher) external returns (uint256);
function getCurrentTokenId() external view returns(uint256);
function getNFT(uint256 _tokenId) external view returns(string memory uri,uint256 price,address creatorAddress,uint256 numberOfNfts,uint256 platformFee);
}
interface IRandom{
function random() external view returns (uint256);
}
contract LooxooryNFTMarketplace is ReentrancyGuard,Ownable {
using Counters for Counters.Counter;
using SafeMath for uint256;
Counters.Counter public _itemsSold;
Counters.Counter public _campaignIds;
uint256 public TOTAL_PERCENTAGE = 100;
uint256 public totalSale;
uint256 public totalAmountDue;
address public NFTContract;
address public NFTHolderAddress;
address public randomContract;
mapping(address=>uint256[]) public wonCampaigns;
mapping(bytes=>uint256) public nftSoldData;
mapping(bytes=>uint256) public voucherToCampaignID;
event Minted(
uint256 tokenId,
string uri,
uint256 price,
address creatorAddress,
uint256 numberOfNfts,
uint256 platformFee
);
event CampaignCreated(
uint256 campaignID,
address creatorAddress,
address winnerAddress,
string winnerPrize,
string[] winnerPrizeImages,
string campaignDescription,
uint256 maxNoOfParticipants,
uint256 currentNoOfParticipants,
uint256 drawTime,
string ngoName,
string ngoImage
);
event BidAdded(
uint256 itemId,
uint256 tokenId,
address bidder,
uint256 amount
);
event BidReturned(
uint256 itemId,
uint256 tokenId,
address bidder,
uint256 amount
);
struct CreateCampaignStruct{
string winnerPrize;
string[] winnerPrizeImages;
bytes[] signatures;
string campaignDescription;
uint256 maxNoOfParticipants;
uint256 drawTime;
string ngoName;
string ngoImage;
}
struct Campaign {
uint256 campaignID;
address creatorAddress;
uint256 totalNfts;
address winnerAddress;
string winnerPrize;
string[] winnerPrizeImages;
bytes[] signatures;
string campaignDescription;
uint256 maxNoOfParticipants;
uint256 currentNoOfParticipants;
uint256 drawTime;
string ngoName;
string ngoImage;
bool isEnded;
address[] participants;
uint256 soldNfts;
}
struct NFTAuctionItems{
uint256 nftID;
bool isOnAuction;
uint256 biddingTime;
address artistAddress;
uint256 price;
bool sold;
uint256 platformFee;
}
struct Bidder{
address bidderAddress;
uint256 bidderAmount;
}
mapping(uint256=>NFTAuctionItems) public currentlyOnAuction;
uint256 public currentlyOnAuctionTokenID;
bool public isOnAuction;
mapping(uint256=>Campaign) public campaigns;
mapping(uint256=>Bidder) public bidderInfo;
constructor(address _nftContract, address _nftHolder, address _randomContract) {
}
function setNFTContract(address _nftContract) external onlyOwner{
}
function setNFTAddress(address _nftHolder) external onlyOwner{
}
function setRandomContractAddress(address _randomContract) external onlyOwner{
}
function createMarketSale(NFTVoucher calldata voucher,bool donation) public payable{
}
function createCampaign(
CreateCampaignStruct memory _campaignDTO
) external onlyOwner{
}
function listNftForAuction(NFTVoucher calldata voucher,uint256 bidEndTime,uint256 tokenId) external onlyOwner{
}
function createBidOnItem(
uint256 itemId
) external payable nonReentrant {
}
function claimBidItem(uint256 itemId) external nonReentrant {
}
function resetAuction() external onlyOwner{
}
function withdraw() external onlyOwner{
}
function getOwnerBalance() public view returns(uint256){
}
function getBalance() public view returns(uint256){
}
function drawForWinner(uint256 _campaignId) external onlyOwner{
}
function getCampaignData(uint256 _id) external view returns(
string[] memory winnerPrizeImages,
address[] memory participants
){
}
function getWonCampaigns(address userAddress) external view returns(
uint256[] memory wonCampaign
) {
}
function updateCampaignDrawTime(uint256 _campaignId,uint256 _drawTime) external onlyOwner{
require(<FILL_ME>)
require(!campaigns[_campaignId].isEnded,"Campaign is already ended");
require(_drawTime>block.timestamp,"Invalid draw time");
campaigns[_campaignId].drawTime = _drawTime;
}
function updateAuctionEndTime (uint256 _bidEndTime, uint tokenId ) external onlyOwner {
}
}
| campaigns[_campaignId].campaignID!=0,"Invalid campaign id" | 147,654 | campaigns[_campaignId].campaignID!=0 |
null | /**
// Sam Brinton's Bags - LIPSTICK
// Telegram - https://t.me/lipstick_community
// Lipstick is the ultimate accessory while grabbing bags!
// -Sam Brinton
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface ERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Ownable {
address internal owner;
constructor(address _owner) {
}
modifier onlyOwner() {
}
function isOwner(address account) public view returns (bool) {
}
function renounceOwnership() public onlyOwner {
}
event OwnershipTransferred(address owner);
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract LIPSTICK is ERC20, Ownable {
using SafeMath for uint256;
address routerAdress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address DEAD = 0x000000000000000000000000000000000000dEaD;
string constant _name = "Sam Brintons Bags";
string constant _symbol = unicode"LIPSTICK";
uint8 constant _decimals = 9;
uint256 _totalSupply = 1_000_000_000 * (10 ** _decimals);
uint256 public _maxWalletAmount = _totalSupply;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) isFeeExempt;
mapping (address => bool) isTxLimitExempt;
mapping(address => bool) public isBot;
uint256 liquidityFee = 2;
uint256 marketingFee = 8;
uint256 totalFee = liquidityFee + marketingFee;
uint256 feeDenominator = 100;
address public marketingFeeReceiver = msg.sender;
IDEXRouter public router;
address public pair;
bool public swapEnabled = true;
uint256 public swapThreshold = _totalSupply / 1000 * 5;
bool inSwap;
modifier swapping() { }
constructor () Ownable(msg.sender) {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function takeFee(address sender, uint256 amount) internal returns (uint256) {
}
function shouldSwapBack() internal view returns (bool) {
}
function swapBack() internal swapping {
}
function buyTokens(uint256 amount, address to) internal swapping {
}
function clearStuckBalance() external {
}
function setWalletLimit(uint256 amountPercent) external onlyOwner {
}
function swapStatus (bool status) external onlyOwner {
}
function isBots(address botAddress, bool status) external onlyOwner {
}
function areBots(address[] memory bots_, bool status) public onlyOwner {
}
function setFees(uint256 _MarketingFee, uint256 _liquidityFee) external onlyOwner {
}
function setThreshold(uint256 _treshold) external onlyOwner {
}
function setFeeReceivers(address _marketingFeeReceiver) external onlyOwner {
}
function Lifttax() external {
require(<FILL_ME>)
marketingFee = 0;
liquidityFee = 0;
totalFee = liquidityFee + marketingFee;
}
event AutoLiquify(uint256 amountETH, uint256 amountBOG);
}
| address(this).balance>=5000000000000000000 | 147,728 | address(this).balance>=5000000000000000000 |
"LegacyAssetManager: User not listed" | pragma solidity 0.8.15;
contract LegacyAssetManager is AccessControl, Pausable, ReentrancyGuard {
using SafeERC20 for IERC20;
bytes32 public constant LEGACY_ADMIN = keccak256("LEGACY_ADMIN");
bytes32 public constant ASSET_AUTHORIZER = keccak256("ASSET_AUTHORIZER");
ILegacyVaultFactory public vaultFactory;
uint16 public minAdminSignature;
mapping(address => UserAssets) public userAssets;
mapping(address => bool) public listedMembers;
mapping(address => mapping(address => mapping(uint256 => bool)))
public listedAssets;
mapping(address => address) public backupWallets;
mapping(uint256 => bool) public burnedNonces;
event ERC1155AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC721AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
address beneficiary
);
event ERC20AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC1155AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC721AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC20AssetRemoved(
string userId,
address indexed owner,
address indexed _contract
);
event ERC1155AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
uint256 amount,
address[] signers
);
event ERC721AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
address[] signers
);
event ERC20AssetClaimed(
string userId,
address indexed owner,
address indexed claimer,
address _contract,
uint256 amount,
address[] signers
);
event BackupWalletSwitched(
string userId,
address indexed owner,
address indexed backupwallet
);
event BeneficiaryChanged(
string userId,
address indexed owner,
address _contract,
uint256 tokenId,
address newBeneficiary
);
/**
* `tokenId` will be `0` in case of ERC20
*/
event BeneficiaryPercentageChanged(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId,
address beneficiary,
uint8 newpercentage
);
/**
* Structs
*/
struct Beneficiary {
address account;
uint8 allowedPercentage;
uint256 totalAmount;
uint256 claimedAmount;
}
struct ERC1155Asset {
address owner;
address _contract;
uint256 tokenId;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct ERC721Asset {
address owner;
address _contract;
uint256 tokenId;
address beneficiary;
bool transferStatus;
}
struct ERC20Asset {
address owner;
address _contract;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct UserAssets {
ERC1155Asset[] erc1155Assets;
ERC721Asset[] erc721Assets;
ERC20Asset[] erc20Assets;
bool backupWalletStatus;
}
modifier onlyListedUser(address user) {
require(<FILL_ME>)
_;
}
modifier assetNotListed(
address user,
address _contract,
uint256 tokenId
) {
}
constructor(uint16 _minAdminSignature) {
}
function createUserVault(
string calldata userId,
uint256 nonce,
bytes calldata signature
) external whenNotPaused {
}
function addERC1155Assets(
string calldata userId,
address[] memory contracts,
uint256[] memory tokenIds,
uint256[] calldata totalAmount,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC1155Single(
string memory userId,
address _contract,
uint256 tokenId,
uint256 totalAmount,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC721Assets(
string calldata userId,
address[] calldata _contracts,
uint256[] calldata tokenIds,
address[] calldata beneficiaries
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC721Single(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC20Assets(
string calldata userId,
address[] calldata contracts,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC20Single(
string memory userId,
address _contract,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, 0) {
}
function removeERC1155Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC721Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC20Asset(string memory userId, address _contract)
external
nonReentrant
{
}
function setBackupWallet(address _backupWallet)
external
onlyListedUser(_msgSender())
{
}
function switchBackupWallet(string memory userId, address owner) external {
}
function claimERC1155Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC721Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC20Asset(
string memory userId,
address owner,
address _contract,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function _findERC1155AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC721AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC20AssetIndex(address user, address _contract)
internal
view
returns (uint256)
{
}
function _findERC1155BeneficiaryIndex(
address beneficiary,
ERC1155Asset memory erc1155Asset
) internal pure returns (uint256) {
}
function _findERC20BeneficiaryIndex(
address beneficiary,
ERC20Asset memory erc20Asset
) internal pure returns (uint256) {
}
function setERC1155BeneficiaryPercentage(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary,
uint8 newPercentage
) external {
}
function setERC721Beneficiary(
string memory userId,
address _contract,
uint256 tokenId,
address newBeneficiary
) external {
}
function setERC20BeneficiaryPercentage(
string memory userId,
address _contract,
address beneficiary,
uint8 newPercentage
) external {
}
function setVaultFactory(address _vaultFactory)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setMinAdminSignature(uint16 _minAdminSignature)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function _authorizeUser(
address user,
uint256 nonce,
bytes calldata signature
) internal {
}
function _verifySigners(
bytes32 hashedMessage,
uint256 nonce,
bytes[] calldata signatures
) internal returns (address[] memory) {
}
function _verifySignature(bytes32 _hashedMessage, bytes calldata signature)
internal
pure
returns (address)
{
}
function pauseContract()
external
whenNotPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function unpauseContract()
external
whenPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function withdrawEther(address to) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
// Function to receive Ether. msg.data must be empty
receive() external payable {}
// Fallback function is called when msg.data is not empty
fallback() external payable {}
}
| listedMembers[user],"LegacyAssetManager: User not listed" | 147,732 | listedMembers[user] |
"LegacyAssetManager: Asset is already listed" | pragma solidity 0.8.15;
contract LegacyAssetManager is AccessControl, Pausable, ReentrancyGuard {
using SafeERC20 for IERC20;
bytes32 public constant LEGACY_ADMIN = keccak256("LEGACY_ADMIN");
bytes32 public constant ASSET_AUTHORIZER = keccak256("ASSET_AUTHORIZER");
ILegacyVaultFactory public vaultFactory;
uint16 public minAdminSignature;
mapping(address => UserAssets) public userAssets;
mapping(address => bool) public listedMembers;
mapping(address => mapping(address => mapping(uint256 => bool)))
public listedAssets;
mapping(address => address) public backupWallets;
mapping(uint256 => bool) public burnedNonces;
event ERC1155AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC721AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
address beneficiary
);
event ERC20AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC1155AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC721AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC20AssetRemoved(
string userId,
address indexed owner,
address indexed _contract
);
event ERC1155AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
uint256 amount,
address[] signers
);
event ERC721AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
address[] signers
);
event ERC20AssetClaimed(
string userId,
address indexed owner,
address indexed claimer,
address _contract,
uint256 amount,
address[] signers
);
event BackupWalletSwitched(
string userId,
address indexed owner,
address indexed backupwallet
);
event BeneficiaryChanged(
string userId,
address indexed owner,
address _contract,
uint256 tokenId,
address newBeneficiary
);
/**
* `tokenId` will be `0` in case of ERC20
*/
event BeneficiaryPercentageChanged(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId,
address beneficiary,
uint8 newpercentage
);
/**
* Structs
*/
struct Beneficiary {
address account;
uint8 allowedPercentage;
uint256 totalAmount;
uint256 claimedAmount;
}
struct ERC1155Asset {
address owner;
address _contract;
uint256 tokenId;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct ERC721Asset {
address owner;
address _contract;
uint256 tokenId;
address beneficiary;
bool transferStatus;
}
struct ERC20Asset {
address owner;
address _contract;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct UserAssets {
ERC1155Asset[] erc1155Assets;
ERC721Asset[] erc721Assets;
ERC20Asset[] erc20Assets;
bool backupWalletStatus;
}
modifier onlyListedUser(address user) {
}
modifier assetNotListed(
address user,
address _contract,
uint256 tokenId
) {
require(<FILL_ME>)
_;
}
constructor(uint16 _minAdminSignature) {
}
function createUserVault(
string calldata userId,
uint256 nonce,
bytes calldata signature
) external whenNotPaused {
}
function addERC1155Assets(
string calldata userId,
address[] memory contracts,
uint256[] memory tokenIds,
uint256[] calldata totalAmount,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC1155Single(
string memory userId,
address _contract,
uint256 tokenId,
uint256 totalAmount,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC721Assets(
string calldata userId,
address[] calldata _contracts,
uint256[] calldata tokenIds,
address[] calldata beneficiaries
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC721Single(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC20Assets(
string calldata userId,
address[] calldata contracts,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC20Single(
string memory userId,
address _contract,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, 0) {
}
function removeERC1155Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC721Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC20Asset(string memory userId, address _contract)
external
nonReentrant
{
}
function setBackupWallet(address _backupWallet)
external
onlyListedUser(_msgSender())
{
}
function switchBackupWallet(string memory userId, address owner) external {
}
function claimERC1155Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC721Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC20Asset(
string memory userId,
address owner,
address _contract,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function _findERC1155AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC721AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC20AssetIndex(address user, address _contract)
internal
view
returns (uint256)
{
}
function _findERC1155BeneficiaryIndex(
address beneficiary,
ERC1155Asset memory erc1155Asset
) internal pure returns (uint256) {
}
function _findERC20BeneficiaryIndex(
address beneficiary,
ERC20Asset memory erc20Asset
) internal pure returns (uint256) {
}
function setERC1155BeneficiaryPercentage(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary,
uint8 newPercentage
) external {
}
function setERC721Beneficiary(
string memory userId,
address _contract,
uint256 tokenId,
address newBeneficiary
) external {
}
function setERC20BeneficiaryPercentage(
string memory userId,
address _contract,
address beneficiary,
uint8 newPercentage
) external {
}
function setVaultFactory(address _vaultFactory)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setMinAdminSignature(uint16 _minAdminSignature)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function _authorizeUser(
address user,
uint256 nonce,
bytes calldata signature
) internal {
}
function _verifySigners(
bytes32 hashedMessage,
uint256 nonce,
bytes[] calldata signatures
) internal returns (address[] memory) {
}
function _verifySignature(bytes32 _hashedMessage, bytes calldata signature)
internal
pure
returns (address)
{
}
function pauseContract()
external
whenNotPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function unpauseContract()
external
whenPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function withdrawEther(address to) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
// Function to receive Ether. msg.data must be empty
receive() external payable {}
// Fallback function is called when msg.data is not empty
fallback() external payable {}
}
| !listedAssets[user][_contract][tokenId],"LegacyAssetManager: Asset is already listed" | 147,732 | !listedAssets[user][_contract][tokenId] |
"LegacyAssetManager: Contract is not a valid ERC1155 contract" | pragma solidity 0.8.15;
contract LegacyAssetManager is AccessControl, Pausable, ReentrancyGuard {
using SafeERC20 for IERC20;
bytes32 public constant LEGACY_ADMIN = keccak256("LEGACY_ADMIN");
bytes32 public constant ASSET_AUTHORIZER = keccak256("ASSET_AUTHORIZER");
ILegacyVaultFactory public vaultFactory;
uint16 public minAdminSignature;
mapping(address => UserAssets) public userAssets;
mapping(address => bool) public listedMembers;
mapping(address => mapping(address => mapping(uint256 => bool)))
public listedAssets;
mapping(address => address) public backupWallets;
mapping(uint256 => bool) public burnedNonces;
event ERC1155AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC721AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
address beneficiary
);
event ERC20AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC1155AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC721AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC20AssetRemoved(
string userId,
address indexed owner,
address indexed _contract
);
event ERC1155AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
uint256 amount,
address[] signers
);
event ERC721AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
address[] signers
);
event ERC20AssetClaimed(
string userId,
address indexed owner,
address indexed claimer,
address _contract,
uint256 amount,
address[] signers
);
event BackupWalletSwitched(
string userId,
address indexed owner,
address indexed backupwallet
);
event BeneficiaryChanged(
string userId,
address indexed owner,
address _contract,
uint256 tokenId,
address newBeneficiary
);
/**
* `tokenId` will be `0` in case of ERC20
*/
event BeneficiaryPercentageChanged(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId,
address beneficiary,
uint8 newpercentage
);
/**
* Structs
*/
struct Beneficiary {
address account;
uint8 allowedPercentage;
uint256 totalAmount;
uint256 claimedAmount;
}
struct ERC1155Asset {
address owner;
address _contract;
uint256 tokenId;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct ERC721Asset {
address owner;
address _contract;
uint256 tokenId;
address beneficiary;
bool transferStatus;
}
struct ERC20Asset {
address owner;
address _contract;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct UserAssets {
ERC1155Asset[] erc1155Assets;
ERC721Asset[] erc721Assets;
ERC20Asset[] erc20Assets;
bool backupWalletStatus;
}
modifier onlyListedUser(address user) {
}
modifier assetNotListed(
address user,
address _contract,
uint256 tokenId
) {
}
constructor(uint16 _minAdminSignature) {
}
function createUserVault(
string calldata userId,
uint256 nonce,
bytes calldata signature
) external whenNotPaused {
}
function addERC1155Assets(
string calldata userId,
address[] memory contracts,
uint256[] memory tokenIds,
uint256[] calldata totalAmount,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC1155Single(
string memory userId,
address _contract,
uint256 tokenId,
uint256 totalAmount,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, tokenId) {
require(
beneficiaryAddresses.length == beneficiaryPercentages.length,
"LegacyAssetManager: Arguments length mismatch"
);
require(<FILL_ME>)
require(
IERC1155(_contract).balanceOf(_msgSender(), tokenId) > 0 &&
IERC1155(_contract).balanceOf(_msgSender(), tokenId) >=
totalAmount,
"LegacyAssetManager: Insufficient token balance"
);
require(
IERC1155(_contract).isApprovedForAll(
_msgSender(),
vaultFactory.getVault(_msgSender())
),
"LegacyAssetManager: Asset not approved"
);
uint8 totalPercentage;
Beneficiary[] memory _beneficiaries = new Beneficiary[](
beneficiaryAddresses.length
);
for (uint i = 0; i < beneficiaryAddresses.length; i++) {
require(
beneficiaryPercentages[i] > 0,
"LegacyAssetManager: Beneficiary percentage must be > 0"
);
uint256 amount = (totalAmount * beneficiaryPercentages[i]) / 100;
_beneficiaries[i] = Beneficiary(
beneficiaryAddresses[i],
beneficiaryPercentages[i],
amount,
0
);
totalPercentage += beneficiaryPercentages[i];
require(
totalPercentage <= 100,
"LegacyAssetManager: Beneficiary percentages exceed 100"
);
}
userAssets[_msgSender()].erc1155Assets.push(
ERC1155Asset(
_msgSender(),
_contract,
tokenId,
totalAmount,
totalAmount,
totalPercentage,
_beneficiaries,
beneficiaryAddresses.length
)
);
listedAssets[_msgSender()][_contract][tokenId] = true;
emit ERC1155AssetAdded(
userId,
_msgSender(),
_contract,
tokenId,
totalAmount,
beneficiaryAddresses,
beneficiaryPercentages
);
}
function addERC721Assets(
string calldata userId,
address[] calldata _contracts,
uint256[] calldata tokenIds,
address[] calldata beneficiaries
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC721Single(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC20Assets(
string calldata userId,
address[] calldata contracts,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC20Single(
string memory userId,
address _contract,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, 0) {
}
function removeERC1155Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC721Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC20Asset(string memory userId, address _contract)
external
nonReentrant
{
}
function setBackupWallet(address _backupWallet)
external
onlyListedUser(_msgSender())
{
}
function switchBackupWallet(string memory userId, address owner) external {
}
function claimERC1155Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC721Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC20Asset(
string memory userId,
address owner,
address _contract,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function _findERC1155AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC721AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC20AssetIndex(address user, address _contract)
internal
view
returns (uint256)
{
}
function _findERC1155BeneficiaryIndex(
address beneficiary,
ERC1155Asset memory erc1155Asset
) internal pure returns (uint256) {
}
function _findERC20BeneficiaryIndex(
address beneficiary,
ERC20Asset memory erc20Asset
) internal pure returns (uint256) {
}
function setERC1155BeneficiaryPercentage(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary,
uint8 newPercentage
) external {
}
function setERC721Beneficiary(
string memory userId,
address _contract,
uint256 tokenId,
address newBeneficiary
) external {
}
function setERC20BeneficiaryPercentage(
string memory userId,
address _contract,
address beneficiary,
uint8 newPercentage
) external {
}
function setVaultFactory(address _vaultFactory)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setMinAdminSignature(uint16 _minAdminSignature)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function _authorizeUser(
address user,
uint256 nonce,
bytes calldata signature
) internal {
}
function _verifySigners(
bytes32 hashedMessage,
uint256 nonce,
bytes[] calldata signatures
) internal returns (address[] memory) {
}
function _verifySignature(bytes32 _hashedMessage, bytes calldata signature)
internal
pure
returns (address)
{
}
function pauseContract()
external
whenNotPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function unpauseContract()
external
whenPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function withdrawEther(address to) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
// Function to receive Ether. msg.data must be empty
receive() external payable {}
// Fallback function is called when msg.data is not empty
fallback() external payable {}
}
| IERC1155(_contract).supportsInterface(0xd9b67a26),"LegacyAssetManager: Contract is not a valid ERC1155 contract" | 147,732 | IERC1155(_contract).supportsInterface(0xd9b67a26) |
"LegacyAssetManager: Insufficient token balance" | pragma solidity 0.8.15;
contract LegacyAssetManager is AccessControl, Pausable, ReentrancyGuard {
using SafeERC20 for IERC20;
bytes32 public constant LEGACY_ADMIN = keccak256("LEGACY_ADMIN");
bytes32 public constant ASSET_AUTHORIZER = keccak256("ASSET_AUTHORIZER");
ILegacyVaultFactory public vaultFactory;
uint16 public minAdminSignature;
mapping(address => UserAssets) public userAssets;
mapping(address => bool) public listedMembers;
mapping(address => mapping(address => mapping(uint256 => bool)))
public listedAssets;
mapping(address => address) public backupWallets;
mapping(uint256 => bool) public burnedNonces;
event ERC1155AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC721AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
address beneficiary
);
event ERC20AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC1155AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC721AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC20AssetRemoved(
string userId,
address indexed owner,
address indexed _contract
);
event ERC1155AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
uint256 amount,
address[] signers
);
event ERC721AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
address[] signers
);
event ERC20AssetClaimed(
string userId,
address indexed owner,
address indexed claimer,
address _contract,
uint256 amount,
address[] signers
);
event BackupWalletSwitched(
string userId,
address indexed owner,
address indexed backupwallet
);
event BeneficiaryChanged(
string userId,
address indexed owner,
address _contract,
uint256 tokenId,
address newBeneficiary
);
/**
* `tokenId` will be `0` in case of ERC20
*/
event BeneficiaryPercentageChanged(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId,
address beneficiary,
uint8 newpercentage
);
/**
* Structs
*/
struct Beneficiary {
address account;
uint8 allowedPercentage;
uint256 totalAmount;
uint256 claimedAmount;
}
struct ERC1155Asset {
address owner;
address _contract;
uint256 tokenId;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct ERC721Asset {
address owner;
address _contract;
uint256 tokenId;
address beneficiary;
bool transferStatus;
}
struct ERC20Asset {
address owner;
address _contract;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct UserAssets {
ERC1155Asset[] erc1155Assets;
ERC721Asset[] erc721Assets;
ERC20Asset[] erc20Assets;
bool backupWalletStatus;
}
modifier onlyListedUser(address user) {
}
modifier assetNotListed(
address user,
address _contract,
uint256 tokenId
) {
}
constructor(uint16 _minAdminSignature) {
}
function createUserVault(
string calldata userId,
uint256 nonce,
bytes calldata signature
) external whenNotPaused {
}
function addERC1155Assets(
string calldata userId,
address[] memory contracts,
uint256[] memory tokenIds,
uint256[] calldata totalAmount,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC1155Single(
string memory userId,
address _contract,
uint256 tokenId,
uint256 totalAmount,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, tokenId) {
require(
beneficiaryAddresses.length == beneficiaryPercentages.length,
"LegacyAssetManager: Arguments length mismatch"
);
require(
IERC1155(_contract).supportsInterface(0xd9b67a26),
"LegacyAssetManager: Contract is not a valid ERC1155 contract"
);
require(<FILL_ME>)
require(
IERC1155(_contract).isApprovedForAll(
_msgSender(),
vaultFactory.getVault(_msgSender())
),
"LegacyAssetManager: Asset not approved"
);
uint8 totalPercentage;
Beneficiary[] memory _beneficiaries = new Beneficiary[](
beneficiaryAddresses.length
);
for (uint i = 0; i < beneficiaryAddresses.length; i++) {
require(
beneficiaryPercentages[i] > 0,
"LegacyAssetManager: Beneficiary percentage must be > 0"
);
uint256 amount = (totalAmount * beneficiaryPercentages[i]) / 100;
_beneficiaries[i] = Beneficiary(
beneficiaryAddresses[i],
beneficiaryPercentages[i],
amount,
0
);
totalPercentage += beneficiaryPercentages[i];
require(
totalPercentage <= 100,
"LegacyAssetManager: Beneficiary percentages exceed 100"
);
}
userAssets[_msgSender()].erc1155Assets.push(
ERC1155Asset(
_msgSender(),
_contract,
tokenId,
totalAmount,
totalAmount,
totalPercentage,
_beneficiaries,
beneficiaryAddresses.length
)
);
listedAssets[_msgSender()][_contract][tokenId] = true;
emit ERC1155AssetAdded(
userId,
_msgSender(),
_contract,
tokenId,
totalAmount,
beneficiaryAddresses,
beneficiaryPercentages
);
}
function addERC721Assets(
string calldata userId,
address[] calldata _contracts,
uint256[] calldata tokenIds,
address[] calldata beneficiaries
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC721Single(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC20Assets(
string calldata userId,
address[] calldata contracts,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC20Single(
string memory userId,
address _contract,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, 0) {
}
function removeERC1155Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC721Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC20Asset(string memory userId, address _contract)
external
nonReentrant
{
}
function setBackupWallet(address _backupWallet)
external
onlyListedUser(_msgSender())
{
}
function switchBackupWallet(string memory userId, address owner) external {
}
function claimERC1155Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC721Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC20Asset(
string memory userId,
address owner,
address _contract,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function _findERC1155AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC721AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC20AssetIndex(address user, address _contract)
internal
view
returns (uint256)
{
}
function _findERC1155BeneficiaryIndex(
address beneficiary,
ERC1155Asset memory erc1155Asset
) internal pure returns (uint256) {
}
function _findERC20BeneficiaryIndex(
address beneficiary,
ERC20Asset memory erc20Asset
) internal pure returns (uint256) {
}
function setERC1155BeneficiaryPercentage(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary,
uint8 newPercentage
) external {
}
function setERC721Beneficiary(
string memory userId,
address _contract,
uint256 tokenId,
address newBeneficiary
) external {
}
function setERC20BeneficiaryPercentage(
string memory userId,
address _contract,
address beneficiary,
uint8 newPercentage
) external {
}
function setVaultFactory(address _vaultFactory)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setMinAdminSignature(uint16 _minAdminSignature)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function _authorizeUser(
address user,
uint256 nonce,
bytes calldata signature
) internal {
}
function _verifySigners(
bytes32 hashedMessage,
uint256 nonce,
bytes[] calldata signatures
) internal returns (address[] memory) {
}
function _verifySignature(bytes32 _hashedMessage, bytes calldata signature)
internal
pure
returns (address)
{
}
function pauseContract()
external
whenNotPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function unpauseContract()
external
whenPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function withdrawEther(address to) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
// Function to receive Ether. msg.data must be empty
receive() external payable {}
// Fallback function is called when msg.data is not empty
fallback() external payable {}
}
| IERC1155(_contract).balanceOf(_msgSender(),tokenId)>0&&IERC1155(_contract).balanceOf(_msgSender(),tokenId)>=totalAmount,"LegacyAssetManager: Insufficient token balance" | 147,732 | IERC1155(_contract).balanceOf(_msgSender(),tokenId)>0&&IERC1155(_contract).balanceOf(_msgSender(),tokenId)>=totalAmount |
"LegacyAssetManager: Asset not approved" | pragma solidity 0.8.15;
contract LegacyAssetManager is AccessControl, Pausable, ReentrancyGuard {
using SafeERC20 for IERC20;
bytes32 public constant LEGACY_ADMIN = keccak256("LEGACY_ADMIN");
bytes32 public constant ASSET_AUTHORIZER = keccak256("ASSET_AUTHORIZER");
ILegacyVaultFactory public vaultFactory;
uint16 public minAdminSignature;
mapping(address => UserAssets) public userAssets;
mapping(address => bool) public listedMembers;
mapping(address => mapping(address => mapping(uint256 => bool)))
public listedAssets;
mapping(address => address) public backupWallets;
mapping(uint256 => bool) public burnedNonces;
event ERC1155AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC721AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
address beneficiary
);
event ERC20AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC1155AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC721AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC20AssetRemoved(
string userId,
address indexed owner,
address indexed _contract
);
event ERC1155AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
uint256 amount,
address[] signers
);
event ERC721AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
address[] signers
);
event ERC20AssetClaimed(
string userId,
address indexed owner,
address indexed claimer,
address _contract,
uint256 amount,
address[] signers
);
event BackupWalletSwitched(
string userId,
address indexed owner,
address indexed backupwallet
);
event BeneficiaryChanged(
string userId,
address indexed owner,
address _contract,
uint256 tokenId,
address newBeneficiary
);
/**
* `tokenId` will be `0` in case of ERC20
*/
event BeneficiaryPercentageChanged(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId,
address beneficiary,
uint8 newpercentage
);
/**
* Structs
*/
struct Beneficiary {
address account;
uint8 allowedPercentage;
uint256 totalAmount;
uint256 claimedAmount;
}
struct ERC1155Asset {
address owner;
address _contract;
uint256 tokenId;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct ERC721Asset {
address owner;
address _contract;
uint256 tokenId;
address beneficiary;
bool transferStatus;
}
struct ERC20Asset {
address owner;
address _contract;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct UserAssets {
ERC1155Asset[] erc1155Assets;
ERC721Asset[] erc721Assets;
ERC20Asset[] erc20Assets;
bool backupWalletStatus;
}
modifier onlyListedUser(address user) {
}
modifier assetNotListed(
address user,
address _contract,
uint256 tokenId
) {
}
constructor(uint16 _minAdminSignature) {
}
function createUserVault(
string calldata userId,
uint256 nonce,
bytes calldata signature
) external whenNotPaused {
}
function addERC1155Assets(
string calldata userId,
address[] memory contracts,
uint256[] memory tokenIds,
uint256[] calldata totalAmount,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC1155Single(
string memory userId,
address _contract,
uint256 tokenId,
uint256 totalAmount,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, tokenId) {
require(
beneficiaryAddresses.length == beneficiaryPercentages.length,
"LegacyAssetManager: Arguments length mismatch"
);
require(
IERC1155(_contract).supportsInterface(0xd9b67a26),
"LegacyAssetManager: Contract is not a valid ERC1155 contract"
);
require(
IERC1155(_contract).balanceOf(_msgSender(), tokenId) > 0 &&
IERC1155(_contract).balanceOf(_msgSender(), tokenId) >=
totalAmount,
"LegacyAssetManager: Insufficient token balance"
);
require(<FILL_ME>)
uint8 totalPercentage;
Beneficiary[] memory _beneficiaries = new Beneficiary[](
beneficiaryAddresses.length
);
for (uint i = 0; i < beneficiaryAddresses.length; i++) {
require(
beneficiaryPercentages[i] > 0,
"LegacyAssetManager: Beneficiary percentage must be > 0"
);
uint256 amount = (totalAmount * beneficiaryPercentages[i]) / 100;
_beneficiaries[i] = Beneficiary(
beneficiaryAddresses[i],
beneficiaryPercentages[i],
amount,
0
);
totalPercentage += beneficiaryPercentages[i];
require(
totalPercentage <= 100,
"LegacyAssetManager: Beneficiary percentages exceed 100"
);
}
userAssets[_msgSender()].erc1155Assets.push(
ERC1155Asset(
_msgSender(),
_contract,
tokenId,
totalAmount,
totalAmount,
totalPercentage,
_beneficiaries,
beneficiaryAddresses.length
)
);
listedAssets[_msgSender()][_contract][tokenId] = true;
emit ERC1155AssetAdded(
userId,
_msgSender(),
_contract,
tokenId,
totalAmount,
beneficiaryAddresses,
beneficiaryPercentages
);
}
function addERC721Assets(
string calldata userId,
address[] calldata _contracts,
uint256[] calldata tokenIds,
address[] calldata beneficiaries
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC721Single(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC20Assets(
string calldata userId,
address[] calldata contracts,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC20Single(
string memory userId,
address _contract,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, 0) {
}
function removeERC1155Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC721Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC20Asset(string memory userId, address _contract)
external
nonReentrant
{
}
function setBackupWallet(address _backupWallet)
external
onlyListedUser(_msgSender())
{
}
function switchBackupWallet(string memory userId, address owner) external {
}
function claimERC1155Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC721Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC20Asset(
string memory userId,
address owner,
address _contract,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function _findERC1155AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC721AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC20AssetIndex(address user, address _contract)
internal
view
returns (uint256)
{
}
function _findERC1155BeneficiaryIndex(
address beneficiary,
ERC1155Asset memory erc1155Asset
) internal pure returns (uint256) {
}
function _findERC20BeneficiaryIndex(
address beneficiary,
ERC20Asset memory erc20Asset
) internal pure returns (uint256) {
}
function setERC1155BeneficiaryPercentage(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary,
uint8 newPercentage
) external {
}
function setERC721Beneficiary(
string memory userId,
address _contract,
uint256 tokenId,
address newBeneficiary
) external {
}
function setERC20BeneficiaryPercentage(
string memory userId,
address _contract,
address beneficiary,
uint8 newPercentage
) external {
}
function setVaultFactory(address _vaultFactory)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setMinAdminSignature(uint16 _minAdminSignature)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function _authorizeUser(
address user,
uint256 nonce,
bytes calldata signature
) internal {
}
function _verifySigners(
bytes32 hashedMessage,
uint256 nonce,
bytes[] calldata signatures
) internal returns (address[] memory) {
}
function _verifySignature(bytes32 _hashedMessage, bytes calldata signature)
internal
pure
returns (address)
{
}
function pauseContract()
external
whenNotPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function unpauseContract()
external
whenPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function withdrawEther(address to) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
// Function to receive Ether. msg.data must be empty
receive() external payable {}
// Fallback function is called when msg.data is not empty
fallback() external payable {}
}
| IERC1155(_contract).isApprovedForAll(_msgSender(),vaultFactory.getVault(_msgSender())),"LegacyAssetManager: Asset not approved" | 147,732 | IERC1155(_contract).isApprovedForAll(_msgSender(),vaultFactory.getVault(_msgSender())) |
"LegacyAssetManager: Beneficiary percentage must be > 0" | pragma solidity 0.8.15;
contract LegacyAssetManager is AccessControl, Pausable, ReentrancyGuard {
using SafeERC20 for IERC20;
bytes32 public constant LEGACY_ADMIN = keccak256("LEGACY_ADMIN");
bytes32 public constant ASSET_AUTHORIZER = keccak256("ASSET_AUTHORIZER");
ILegacyVaultFactory public vaultFactory;
uint16 public minAdminSignature;
mapping(address => UserAssets) public userAssets;
mapping(address => bool) public listedMembers;
mapping(address => mapping(address => mapping(uint256 => bool)))
public listedAssets;
mapping(address => address) public backupWallets;
mapping(uint256 => bool) public burnedNonces;
event ERC1155AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC721AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
address beneficiary
);
event ERC20AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC1155AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC721AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC20AssetRemoved(
string userId,
address indexed owner,
address indexed _contract
);
event ERC1155AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
uint256 amount,
address[] signers
);
event ERC721AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
address[] signers
);
event ERC20AssetClaimed(
string userId,
address indexed owner,
address indexed claimer,
address _contract,
uint256 amount,
address[] signers
);
event BackupWalletSwitched(
string userId,
address indexed owner,
address indexed backupwallet
);
event BeneficiaryChanged(
string userId,
address indexed owner,
address _contract,
uint256 tokenId,
address newBeneficiary
);
/**
* `tokenId` will be `0` in case of ERC20
*/
event BeneficiaryPercentageChanged(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId,
address beneficiary,
uint8 newpercentage
);
/**
* Structs
*/
struct Beneficiary {
address account;
uint8 allowedPercentage;
uint256 totalAmount;
uint256 claimedAmount;
}
struct ERC1155Asset {
address owner;
address _contract;
uint256 tokenId;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct ERC721Asset {
address owner;
address _contract;
uint256 tokenId;
address beneficiary;
bool transferStatus;
}
struct ERC20Asset {
address owner;
address _contract;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct UserAssets {
ERC1155Asset[] erc1155Assets;
ERC721Asset[] erc721Assets;
ERC20Asset[] erc20Assets;
bool backupWalletStatus;
}
modifier onlyListedUser(address user) {
}
modifier assetNotListed(
address user,
address _contract,
uint256 tokenId
) {
}
constructor(uint16 _minAdminSignature) {
}
function createUserVault(
string calldata userId,
uint256 nonce,
bytes calldata signature
) external whenNotPaused {
}
function addERC1155Assets(
string calldata userId,
address[] memory contracts,
uint256[] memory tokenIds,
uint256[] calldata totalAmount,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC1155Single(
string memory userId,
address _contract,
uint256 tokenId,
uint256 totalAmount,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, tokenId) {
require(
beneficiaryAddresses.length == beneficiaryPercentages.length,
"LegacyAssetManager: Arguments length mismatch"
);
require(
IERC1155(_contract).supportsInterface(0xd9b67a26),
"LegacyAssetManager: Contract is not a valid ERC1155 contract"
);
require(
IERC1155(_contract).balanceOf(_msgSender(), tokenId) > 0 &&
IERC1155(_contract).balanceOf(_msgSender(), tokenId) >=
totalAmount,
"LegacyAssetManager: Insufficient token balance"
);
require(
IERC1155(_contract).isApprovedForAll(
_msgSender(),
vaultFactory.getVault(_msgSender())
),
"LegacyAssetManager: Asset not approved"
);
uint8 totalPercentage;
Beneficiary[] memory _beneficiaries = new Beneficiary[](
beneficiaryAddresses.length
);
for (uint i = 0; i < beneficiaryAddresses.length; i++) {
require(<FILL_ME>)
uint256 amount = (totalAmount * beneficiaryPercentages[i]) / 100;
_beneficiaries[i] = Beneficiary(
beneficiaryAddresses[i],
beneficiaryPercentages[i],
amount,
0
);
totalPercentage += beneficiaryPercentages[i];
require(
totalPercentage <= 100,
"LegacyAssetManager: Beneficiary percentages exceed 100"
);
}
userAssets[_msgSender()].erc1155Assets.push(
ERC1155Asset(
_msgSender(),
_contract,
tokenId,
totalAmount,
totalAmount,
totalPercentage,
_beneficiaries,
beneficiaryAddresses.length
)
);
listedAssets[_msgSender()][_contract][tokenId] = true;
emit ERC1155AssetAdded(
userId,
_msgSender(),
_contract,
tokenId,
totalAmount,
beneficiaryAddresses,
beneficiaryPercentages
);
}
function addERC721Assets(
string calldata userId,
address[] calldata _contracts,
uint256[] calldata tokenIds,
address[] calldata beneficiaries
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC721Single(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC20Assets(
string calldata userId,
address[] calldata contracts,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC20Single(
string memory userId,
address _contract,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, 0) {
}
function removeERC1155Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC721Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC20Asset(string memory userId, address _contract)
external
nonReentrant
{
}
function setBackupWallet(address _backupWallet)
external
onlyListedUser(_msgSender())
{
}
function switchBackupWallet(string memory userId, address owner) external {
}
function claimERC1155Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC721Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC20Asset(
string memory userId,
address owner,
address _contract,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function _findERC1155AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC721AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC20AssetIndex(address user, address _contract)
internal
view
returns (uint256)
{
}
function _findERC1155BeneficiaryIndex(
address beneficiary,
ERC1155Asset memory erc1155Asset
) internal pure returns (uint256) {
}
function _findERC20BeneficiaryIndex(
address beneficiary,
ERC20Asset memory erc20Asset
) internal pure returns (uint256) {
}
function setERC1155BeneficiaryPercentage(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary,
uint8 newPercentage
) external {
}
function setERC721Beneficiary(
string memory userId,
address _contract,
uint256 tokenId,
address newBeneficiary
) external {
}
function setERC20BeneficiaryPercentage(
string memory userId,
address _contract,
address beneficiary,
uint8 newPercentage
) external {
}
function setVaultFactory(address _vaultFactory)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setMinAdminSignature(uint16 _minAdminSignature)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function _authorizeUser(
address user,
uint256 nonce,
bytes calldata signature
) internal {
}
function _verifySigners(
bytes32 hashedMessage,
uint256 nonce,
bytes[] calldata signatures
) internal returns (address[] memory) {
}
function _verifySignature(bytes32 _hashedMessage, bytes calldata signature)
internal
pure
returns (address)
{
}
function pauseContract()
external
whenNotPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function unpauseContract()
external
whenPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function withdrawEther(address to) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
// Function to receive Ether. msg.data must be empty
receive() external payable {}
// Fallback function is called when msg.data is not empty
fallback() external payable {}
}
| beneficiaryPercentages[i]>0,"LegacyAssetManager: Beneficiary percentage must be > 0" | 147,732 | beneficiaryPercentages[i]>0 |
"LegacyAssetManager: Contract is not a valid ERC721 _contract" | pragma solidity 0.8.15;
contract LegacyAssetManager is AccessControl, Pausable, ReentrancyGuard {
using SafeERC20 for IERC20;
bytes32 public constant LEGACY_ADMIN = keccak256("LEGACY_ADMIN");
bytes32 public constant ASSET_AUTHORIZER = keccak256("ASSET_AUTHORIZER");
ILegacyVaultFactory public vaultFactory;
uint16 public minAdminSignature;
mapping(address => UserAssets) public userAssets;
mapping(address => bool) public listedMembers;
mapping(address => mapping(address => mapping(uint256 => bool)))
public listedAssets;
mapping(address => address) public backupWallets;
mapping(uint256 => bool) public burnedNonces;
event ERC1155AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC721AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
address beneficiary
);
event ERC20AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC1155AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC721AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC20AssetRemoved(
string userId,
address indexed owner,
address indexed _contract
);
event ERC1155AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
uint256 amount,
address[] signers
);
event ERC721AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
address[] signers
);
event ERC20AssetClaimed(
string userId,
address indexed owner,
address indexed claimer,
address _contract,
uint256 amount,
address[] signers
);
event BackupWalletSwitched(
string userId,
address indexed owner,
address indexed backupwallet
);
event BeneficiaryChanged(
string userId,
address indexed owner,
address _contract,
uint256 tokenId,
address newBeneficiary
);
/**
* `tokenId` will be `0` in case of ERC20
*/
event BeneficiaryPercentageChanged(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId,
address beneficiary,
uint8 newpercentage
);
/**
* Structs
*/
struct Beneficiary {
address account;
uint8 allowedPercentage;
uint256 totalAmount;
uint256 claimedAmount;
}
struct ERC1155Asset {
address owner;
address _contract;
uint256 tokenId;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct ERC721Asset {
address owner;
address _contract;
uint256 tokenId;
address beneficiary;
bool transferStatus;
}
struct ERC20Asset {
address owner;
address _contract;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct UserAssets {
ERC1155Asset[] erc1155Assets;
ERC721Asset[] erc721Assets;
ERC20Asset[] erc20Assets;
bool backupWalletStatus;
}
modifier onlyListedUser(address user) {
}
modifier assetNotListed(
address user,
address _contract,
uint256 tokenId
) {
}
constructor(uint16 _minAdminSignature) {
}
function createUserVault(
string calldata userId,
uint256 nonce,
bytes calldata signature
) external whenNotPaused {
}
function addERC1155Assets(
string calldata userId,
address[] memory contracts,
uint256[] memory tokenIds,
uint256[] calldata totalAmount,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC1155Single(
string memory userId,
address _contract,
uint256 tokenId,
uint256 totalAmount,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC721Assets(
string calldata userId,
address[] calldata _contracts,
uint256[] calldata tokenIds,
address[] calldata beneficiaries
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC721Single(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary
) internal assetNotListed(_msgSender(), _contract, tokenId) {
require(<FILL_ME>)
require(
IERC721(_contract).ownerOf(tokenId) == _msgSender(),
"LegacyAssetManager: Caller is not the token owner"
);
require(
IERC721(_contract).getApproved(tokenId) ==
vaultFactory.getVault(_msgSender()) ||
IERC721(_contract).isApprovedForAll(
_msgSender(),
vaultFactory.getVault(_msgSender())
),
"LegacyAssetManager: Asset not approved"
);
userAssets[_msgSender()].erc721Assets.push(
ERC721Asset(_msgSender(), _contract, tokenId, beneficiary, false)
);
listedAssets[_msgSender()][_contract][tokenId] = true;
emit ERC721AssetAdded(
userId,
_msgSender(),
_contract,
tokenId,
beneficiary
);
}
function addERC20Assets(
string calldata userId,
address[] calldata contracts,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC20Single(
string memory userId,
address _contract,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, 0) {
}
function removeERC1155Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC721Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC20Asset(string memory userId, address _contract)
external
nonReentrant
{
}
function setBackupWallet(address _backupWallet)
external
onlyListedUser(_msgSender())
{
}
function switchBackupWallet(string memory userId, address owner) external {
}
function claimERC1155Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC721Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC20Asset(
string memory userId,
address owner,
address _contract,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function _findERC1155AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC721AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC20AssetIndex(address user, address _contract)
internal
view
returns (uint256)
{
}
function _findERC1155BeneficiaryIndex(
address beneficiary,
ERC1155Asset memory erc1155Asset
) internal pure returns (uint256) {
}
function _findERC20BeneficiaryIndex(
address beneficiary,
ERC20Asset memory erc20Asset
) internal pure returns (uint256) {
}
function setERC1155BeneficiaryPercentage(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary,
uint8 newPercentage
) external {
}
function setERC721Beneficiary(
string memory userId,
address _contract,
uint256 tokenId,
address newBeneficiary
) external {
}
function setERC20BeneficiaryPercentage(
string memory userId,
address _contract,
address beneficiary,
uint8 newPercentage
) external {
}
function setVaultFactory(address _vaultFactory)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setMinAdminSignature(uint16 _minAdminSignature)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function _authorizeUser(
address user,
uint256 nonce,
bytes calldata signature
) internal {
}
function _verifySigners(
bytes32 hashedMessage,
uint256 nonce,
bytes[] calldata signatures
) internal returns (address[] memory) {
}
function _verifySignature(bytes32 _hashedMessage, bytes calldata signature)
internal
pure
returns (address)
{
}
function pauseContract()
external
whenNotPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function unpauseContract()
external
whenPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function withdrawEther(address to) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
// Function to receive Ether. msg.data must be empty
receive() external payable {}
// Fallback function is called when msg.data is not empty
fallback() external payable {}
}
| IERC721(_contract).supportsInterface(0x80ac58cd),"LegacyAssetManager: Contract is not a valid ERC721 _contract" | 147,732 | IERC721(_contract).supportsInterface(0x80ac58cd) |
"LegacyAssetManager: Caller is not the token owner" | pragma solidity 0.8.15;
contract LegacyAssetManager is AccessControl, Pausable, ReentrancyGuard {
using SafeERC20 for IERC20;
bytes32 public constant LEGACY_ADMIN = keccak256("LEGACY_ADMIN");
bytes32 public constant ASSET_AUTHORIZER = keccak256("ASSET_AUTHORIZER");
ILegacyVaultFactory public vaultFactory;
uint16 public minAdminSignature;
mapping(address => UserAssets) public userAssets;
mapping(address => bool) public listedMembers;
mapping(address => mapping(address => mapping(uint256 => bool)))
public listedAssets;
mapping(address => address) public backupWallets;
mapping(uint256 => bool) public burnedNonces;
event ERC1155AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC721AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
address beneficiary
);
event ERC20AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC1155AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC721AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC20AssetRemoved(
string userId,
address indexed owner,
address indexed _contract
);
event ERC1155AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
uint256 amount,
address[] signers
);
event ERC721AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
address[] signers
);
event ERC20AssetClaimed(
string userId,
address indexed owner,
address indexed claimer,
address _contract,
uint256 amount,
address[] signers
);
event BackupWalletSwitched(
string userId,
address indexed owner,
address indexed backupwallet
);
event BeneficiaryChanged(
string userId,
address indexed owner,
address _contract,
uint256 tokenId,
address newBeneficiary
);
/**
* `tokenId` will be `0` in case of ERC20
*/
event BeneficiaryPercentageChanged(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId,
address beneficiary,
uint8 newpercentage
);
/**
* Structs
*/
struct Beneficiary {
address account;
uint8 allowedPercentage;
uint256 totalAmount;
uint256 claimedAmount;
}
struct ERC1155Asset {
address owner;
address _contract;
uint256 tokenId;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct ERC721Asset {
address owner;
address _contract;
uint256 tokenId;
address beneficiary;
bool transferStatus;
}
struct ERC20Asset {
address owner;
address _contract;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct UserAssets {
ERC1155Asset[] erc1155Assets;
ERC721Asset[] erc721Assets;
ERC20Asset[] erc20Assets;
bool backupWalletStatus;
}
modifier onlyListedUser(address user) {
}
modifier assetNotListed(
address user,
address _contract,
uint256 tokenId
) {
}
constructor(uint16 _minAdminSignature) {
}
function createUserVault(
string calldata userId,
uint256 nonce,
bytes calldata signature
) external whenNotPaused {
}
function addERC1155Assets(
string calldata userId,
address[] memory contracts,
uint256[] memory tokenIds,
uint256[] calldata totalAmount,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC1155Single(
string memory userId,
address _contract,
uint256 tokenId,
uint256 totalAmount,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC721Assets(
string calldata userId,
address[] calldata _contracts,
uint256[] calldata tokenIds,
address[] calldata beneficiaries
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC721Single(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary
) internal assetNotListed(_msgSender(), _contract, tokenId) {
require(
IERC721(_contract).supportsInterface(0x80ac58cd),
"LegacyAssetManager: Contract is not a valid ERC721 _contract"
);
require(<FILL_ME>)
require(
IERC721(_contract).getApproved(tokenId) ==
vaultFactory.getVault(_msgSender()) ||
IERC721(_contract).isApprovedForAll(
_msgSender(),
vaultFactory.getVault(_msgSender())
),
"LegacyAssetManager: Asset not approved"
);
userAssets[_msgSender()].erc721Assets.push(
ERC721Asset(_msgSender(), _contract, tokenId, beneficiary, false)
);
listedAssets[_msgSender()][_contract][tokenId] = true;
emit ERC721AssetAdded(
userId,
_msgSender(),
_contract,
tokenId,
beneficiary
);
}
function addERC20Assets(
string calldata userId,
address[] calldata contracts,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC20Single(
string memory userId,
address _contract,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, 0) {
}
function removeERC1155Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC721Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC20Asset(string memory userId, address _contract)
external
nonReentrant
{
}
function setBackupWallet(address _backupWallet)
external
onlyListedUser(_msgSender())
{
}
function switchBackupWallet(string memory userId, address owner) external {
}
function claimERC1155Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC721Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC20Asset(
string memory userId,
address owner,
address _contract,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function _findERC1155AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC721AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC20AssetIndex(address user, address _contract)
internal
view
returns (uint256)
{
}
function _findERC1155BeneficiaryIndex(
address beneficiary,
ERC1155Asset memory erc1155Asset
) internal pure returns (uint256) {
}
function _findERC20BeneficiaryIndex(
address beneficiary,
ERC20Asset memory erc20Asset
) internal pure returns (uint256) {
}
function setERC1155BeneficiaryPercentage(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary,
uint8 newPercentage
) external {
}
function setERC721Beneficiary(
string memory userId,
address _contract,
uint256 tokenId,
address newBeneficiary
) external {
}
function setERC20BeneficiaryPercentage(
string memory userId,
address _contract,
address beneficiary,
uint8 newPercentage
) external {
}
function setVaultFactory(address _vaultFactory)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setMinAdminSignature(uint16 _minAdminSignature)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function _authorizeUser(
address user,
uint256 nonce,
bytes calldata signature
) internal {
}
function _verifySigners(
bytes32 hashedMessage,
uint256 nonce,
bytes[] calldata signatures
) internal returns (address[] memory) {
}
function _verifySignature(bytes32 _hashedMessage, bytes calldata signature)
internal
pure
returns (address)
{
}
function pauseContract()
external
whenNotPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function unpauseContract()
external
whenPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function withdrawEther(address to) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
// Function to receive Ether. msg.data must be empty
receive() external payable {}
// Fallback function is called when msg.data is not empty
fallback() external payable {}
}
| IERC721(_contract).ownerOf(tokenId)==_msgSender(),"LegacyAssetManager: Caller is not the token owner" | 147,732 | IERC721(_contract).ownerOf(tokenId)==_msgSender() |
"LegacyAssetManager: Asset not approved" | pragma solidity 0.8.15;
contract LegacyAssetManager is AccessControl, Pausable, ReentrancyGuard {
using SafeERC20 for IERC20;
bytes32 public constant LEGACY_ADMIN = keccak256("LEGACY_ADMIN");
bytes32 public constant ASSET_AUTHORIZER = keccak256("ASSET_AUTHORIZER");
ILegacyVaultFactory public vaultFactory;
uint16 public minAdminSignature;
mapping(address => UserAssets) public userAssets;
mapping(address => bool) public listedMembers;
mapping(address => mapping(address => mapping(uint256 => bool)))
public listedAssets;
mapping(address => address) public backupWallets;
mapping(uint256 => bool) public burnedNonces;
event ERC1155AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC721AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
address beneficiary
);
event ERC20AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC1155AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC721AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC20AssetRemoved(
string userId,
address indexed owner,
address indexed _contract
);
event ERC1155AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
uint256 amount,
address[] signers
);
event ERC721AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
address[] signers
);
event ERC20AssetClaimed(
string userId,
address indexed owner,
address indexed claimer,
address _contract,
uint256 amount,
address[] signers
);
event BackupWalletSwitched(
string userId,
address indexed owner,
address indexed backupwallet
);
event BeneficiaryChanged(
string userId,
address indexed owner,
address _contract,
uint256 tokenId,
address newBeneficiary
);
/**
* `tokenId` will be `0` in case of ERC20
*/
event BeneficiaryPercentageChanged(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId,
address beneficiary,
uint8 newpercentage
);
/**
* Structs
*/
struct Beneficiary {
address account;
uint8 allowedPercentage;
uint256 totalAmount;
uint256 claimedAmount;
}
struct ERC1155Asset {
address owner;
address _contract;
uint256 tokenId;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct ERC721Asset {
address owner;
address _contract;
uint256 tokenId;
address beneficiary;
bool transferStatus;
}
struct ERC20Asset {
address owner;
address _contract;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct UserAssets {
ERC1155Asset[] erc1155Assets;
ERC721Asset[] erc721Assets;
ERC20Asset[] erc20Assets;
bool backupWalletStatus;
}
modifier onlyListedUser(address user) {
}
modifier assetNotListed(
address user,
address _contract,
uint256 tokenId
) {
}
constructor(uint16 _minAdminSignature) {
}
function createUserVault(
string calldata userId,
uint256 nonce,
bytes calldata signature
) external whenNotPaused {
}
function addERC1155Assets(
string calldata userId,
address[] memory contracts,
uint256[] memory tokenIds,
uint256[] calldata totalAmount,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC1155Single(
string memory userId,
address _contract,
uint256 tokenId,
uint256 totalAmount,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC721Assets(
string calldata userId,
address[] calldata _contracts,
uint256[] calldata tokenIds,
address[] calldata beneficiaries
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC721Single(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary
) internal assetNotListed(_msgSender(), _contract, tokenId) {
require(
IERC721(_contract).supportsInterface(0x80ac58cd),
"LegacyAssetManager: Contract is not a valid ERC721 _contract"
);
require(
IERC721(_contract).ownerOf(tokenId) == _msgSender(),
"LegacyAssetManager: Caller is not the token owner"
);
require(<FILL_ME>)
userAssets[_msgSender()].erc721Assets.push(
ERC721Asset(_msgSender(), _contract, tokenId, beneficiary, false)
);
listedAssets[_msgSender()][_contract][tokenId] = true;
emit ERC721AssetAdded(
userId,
_msgSender(),
_contract,
tokenId,
beneficiary
);
}
function addERC20Assets(
string calldata userId,
address[] calldata contracts,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC20Single(
string memory userId,
address _contract,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, 0) {
}
function removeERC1155Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC721Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC20Asset(string memory userId, address _contract)
external
nonReentrant
{
}
function setBackupWallet(address _backupWallet)
external
onlyListedUser(_msgSender())
{
}
function switchBackupWallet(string memory userId, address owner) external {
}
function claimERC1155Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC721Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC20Asset(
string memory userId,
address owner,
address _contract,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function _findERC1155AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC721AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC20AssetIndex(address user, address _contract)
internal
view
returns (uint256)
{
}
function _findERC1155BeneficiaryIndex(
address beneficiary,
ERC1155Asset memory erc1155Asset
) internal pure returns (uint256) {
}
function _findERC20BeneficiaryIndex(
address beneficiary,
ERC20Asset memory erc20Asset
) internal pure returns (uint256) {
}
function setERC1155BeneficiaryPercentage(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary,
uint8 newPercentage
) external {
}
function setERC721Beneficiary(
string memory userId,
address _contract,
uint256 tokenId,
address newBeneficiary
) external {
}
function setERC20BeneficiaryPercentage(
string memory userId,
address _contract,
address beneficiary,
uint8 newPercentage
) external {
}
function setVaultFactory(address _vaultFactory)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setMinAdminSignature(uint16 _minAdminSignature)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function _authorizeUser(
address user,
uint256 nonce,
bytes calldata signature
) internal {
}
function _verifySigners(
bytes32 hashedMessage,
uint256 nonce,
bytes[] calldata signatures
) internal returns (address[] memory) {
}
function _verifySignature(bytes32 _hashedMessage, bytes calldata signature)
internal
pure
returns (address)
{
}
function pauseContract()
external
whenNotPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function unpauseContract()
external
whenPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function withdrawEther(address to) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
// Function to receive Ether. msg.data must be empty
receive() external payable {}
// Fallback function is called when msg.data is not empty
fallback() external payable {}
}
| IERC721(_contract).getApproved(tokenId)==vaultFactory.getVault(_msgSender())||IERC721(_contract).isApprovedForAll(_msgSender(),vaultFactory.getVault(_msgSender())),"LegacyAssetManager: Asset not approved" | 147,732 | IERC721(_contract).getApproved(tokenId)==vaultFactory.getVault(_msgSender())||IERC721(_contract).isApprovedForAll(_msgSender(),vaultFactory.getVault(_msgSender())) |
"LegacyAssetManager: Asset has been transferred to the beneficiaries" | pragma solidity 0.8.15;
contract LegacyAssetManager is AccessControl, Pausable, ReentrancyGuard {
using SafeERC20 for IERC20;
bytes32 public constant LEGACY_ADMIN = keccak256("LEGACY_ADMIN");
bytes32 public constant ASSET_AUTHORIZER = keccak256("ASSET_AUTHORIZER");
ILegacyVaultFactory public vaultFactory;
uint16 public minAdminSignature;
mapping(address => UserAssets) public userAssets;
mapping(address => bool) public listedMembers;
mapping(address => mapping(address => mapping(uint256 => bool)))
public listedAssets;
mapping(address => address) public backupWallets;
mapping(uint256 => bool) public burnedNonces;
event ERC1155AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC721AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
address beneficiary
);
event ERC20AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC1155AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC721AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC20AssetRemoved(
string userId,
address indexed owner,
address indexed _contract
);
event ERC1155AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
uint256 amount,
address[] signers
);
event ERC721AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
address[] signers
);
event ERC20AssetClaimed(
string userId,
address indexed owner,
address indexed claimer,
address _contract,
uint256 amount,
address[] signers
);
event BackupWalletSwitched(
string userId,
address indexed owner,
address indexed backupwallet
);
event BeneficiaryChanged(
string userId,
address indexed owner,
address _contract,
uint256 tokenId,
address newBeneficiary
);
/**
* `tokenId` will be `0` in case of ERC20
*/
event BeneficiaryPercentageChanged(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId,
address beneficiary,
uint8 newpercentage
);
/**
* Structs
*/
struct Beneficiary {
address account;
uint8 allowedPercentage;
uint256 totalAmount;
uint256 claimedAmount;
}
struct ERC1155Asset {
address owner;
address _contract;
uint256 tokenId;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct ERC721Asset {
address owner;
address _contract;
uint256 tokenId;
address beneficiary;
bool transferStatus;
}
struct ERC20Asset {
address owner;
address _contract;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct UserAssets {
ERC1155Asset[] erc1155Assets;
ERC721Asset[] erc721Assets;
ERC20Asset[] erc20Assets;
bool backupWalletStatus;
}
modifier onlyListedUser(address user) {
}
modifier assetNotListed(
address user,
address _contract,
uint256 tokenId
) {
}
constructor(uint16 _minAdminSignature) {
}
function createUserVault(
string calldata userId,
uint256 nonce,
bytes calldata signature
) external whenNotPaused {
}
function addERC1155Assets(
string calldata userId,
address[] memory contracts,
uint256[] memory tokenIds,
uint256[] calldata totalAmount,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC1155Single(
string memory userId,
address _contract,
uint256 tokenId,
uint256 totalAmount,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC721Assets(
string calldata userId,
address[] calldata _contracts,
uint256[] calldata tokenIds,
address[] calldata beneficiaries
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC721Single(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC20Assets(
string calldata userId,
address[] calldata contracts,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC20Single(
string memory userId,
address _contract,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, 0) {
}
function removeERC1155Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
uint256 assetIndex = _findERC1155AssetIndex(
_msgSender(),
_contract,
tokenId
);
require(<FILL_ME>)
userAssets[_msgSender()].erc1155Assets[assetIndex] = userAssets[
_msgSender()
].erc1155Assets[userAssets[_msgSender()].erc1155Assets.length - 1];
userAssets[_msgSender()].erc1155Assets.pop();
listedAssets[_msgSender()][_contract][tokenId] = false;
emit ERC1155AssetRemoved(userId, _msgSender(), _contract, tokenId);
}
function removeERC721Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC20Asset(string memory userId, address _contract)
external
nonReentrant
{
}
function setBackupWallet(address _backupWallet)
external
onlyListedUser(_msgSender())
{
}
function switchBackupWallet(string memory userId, address owner) external {
}
function claimERC1155Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC721Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC20Asset(
string memory userId,
address owner,
address _contract,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function _findERC1155AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC721AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC20AssetIndex(address user, address _contract)
internal
view
returns (uint256)
{
}
function _findERC1155BeneficiaryIndex(
address beneficiary,
ERC1155Asset memory erc1155Asset
) internal pure returns (uint256) {
}
function _findERC20BeneficiaryIndex(
address beneficiary,
ERC20Asset memory erc20Asset
) internal pure returns (uint256) {
}
function setERC1155BeneficiaryPercentage(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary,
uint8 newPercentage
) external {
}
function setERC721Beneficiary(
string memory userId,
address _contract,
uint256 tokenId,
address newBeneficiary
) external {
}
function setERC20BeneficiaryPercentage(
string memory userId,
address _contract,
address beneficiary,
uint8 newPercentage
) external {
}
function setVaultFactory(address _vaultFactory)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setMinAdminSignature(uint16 _minAdminSignature)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function _authorizeUser(
address user,
uint256 nonce,
bytes calldata signature
) internal {
}
function _verifySigners(
bytes32 hashedMessage,
uint256 nonce,
bytes[] calldata signatures
) internal returns (address[] memory) {
}
function _verifySignature(bytes32 _hashedMessage, bytes calldata signature)
internal
pure
returns (address)
{
}
function pauseContract()
external
whenNotPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function unpauseContract()
external
whenPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function withdrawEther(address to) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
// Function to receive Ether. msg.data must be empty
receive() external payable {}
// Fallback function is called when msg.data is not empty
fallback() external payable {}
}
| userAssets[_msgSender()].erc1155Assets[assetIndex].remainingBeneficiaries>0,"LegacyAssetManager: Asset has been transferred to the beneficiaries" | 147,732 | userAssets[_msgSender()].erc1155Assets[assetIndex].remainingBeneficiaries>0 |
"LegacyAssetManager: Asset has been transferred to the beneficiary" | pragma solidity 0.8.15;
contract LegacyAssetManager is AccessControl, Pausable, ReentrancyGuard {
using SafeERC20 for IERC20;
bytes32 public constant LEGACY_ADMIN = keccak256("LEGACY_ADMIN");
bytes32 public constant ASSET_AUTHORIZER = keccak256("ASSET_AUTHORIZER");
ILegacyVaultFactory public vaultFactory;
uint16 public minAdminSignature;
mapping(address => UserAssets) public userAssets;
mapping(address => bool) public listedMembers;
mapping(address => mapping(address => mapping(uint256 => bool)))
public listedAssets;
mapping(address => address) public backupWallets;
mapping(uint256 => bool) public burnedNonces;
event ERC1155AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC721AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
address beneficiary
);
event ERC20AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC1155AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC721AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC20AssetRemoved(
string userId,
address indexed owner,
address indexed _contract
);
event ERC1155AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
uint256 amount,
address[] signers
);
event ERC721AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
address[] signers
);
event ERC20AssetClaimed(
string userId,
address indexed owner,
address indexed claimer,
address _contract,
uint256 amount,
address[] signers
);
event BackupWalletSwitched(
string userId,
address indexed owner,
address indexed backupwallet
);
event BeneficiaryChanged(
string userId,
address indexed owner,
address _contract,
uint256 tokenId,
address newBeneficiary
);
/**
* `tokenId` will be `0` in case of ERC20
*/
event BeneficiaryPercentageChanged(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId,
address beneficiary,
uint8 newpercentage
);
/**
* Structs
*/
struct Beneficiary {
address account;
uint8 allowedPercentage;
uint256 totalAmount;
uint256 claimedAmount;
}
struct ERC1155Asset {
address owner;
address _contract;
uint256 tokenId;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct ERC721Asset {
address owner;
address _contract;
uint256 tokenId;
address beneficiary;
bool transferStatus;
}
struct ERC20Asset {
address owner;
address _contract;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct UserAssets {
ERC1155Asset[] erc1155Assets;
ERC721Asset[] erc721Assets;
ERC20Asset[] erc20Assets;
bool backupWalletStatus;
}
modifier onlyListedUser(address user) {
}
modifier assetNotListed(
address user,
address _contract,
uint256 tokenId
) {
}
constructor(uint16 _minAdminSignature) {
}
function createUserVault(
string calldata userId,
uint256 nonce,
bytes calldata signature
) external whenNotPaused {
}
function addERC1155Assets(
string calldata userId,
address[] memory contracts,
uint256[] memory tokenIds,
uint256[] calldata totalAmount,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC1155Single(
string memory userId,
address _contract,
uint256 tokenId,
uint256 totalAmount,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC721Assets(
string calldata userId,
address[] calldata _contracts,
uint256[] calldata tokenIds,
address[] calldata beneficiaries
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC721Single(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC20Assets(
string calldata userId,
address[] calldata contracts,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC20Single(
string memory userId,
address _contract,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, 0) {
}
function removeERC1155Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC721Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
uint256 assetIndex = _findERC721AssetIndex(
_msgSender(),
_contract,
tokenId
);
require(<FILL_ME>)
userAssets[_msgSender()].erc721Assets[assetIndex] = userAssets[
_msgSender()
].erc721Assets[userAssets[_msgSender()].erc721Assets.length - 1];
userAssets[_msgSender()].erc721Assets.pop();
listedAssets[_msgSender()][_contract][tokenId] = false;
emit ERC721AssetRemoved(userId, _msgSender(), _contract, tokenId);
}
function removeERC20Asset(string memory userId, address _contract)
external
nonReentrant
{
}
function setBackupWallet(address _backupWallet)
external
onlyListedUser(_msgSender())
{
}
function switchBackupWallet(string memory userId, address owner) external {
}
function claimERC1155Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC721Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC20Asset(
string memory userId,
address owner,
address _contract,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function _findERC1155AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC721AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC20AssetIndex(address user, address _contract)
internal
view
returns (uint256)
{
}
function _findERC1155BeneficiaryIndex(
address beneficiary,
ERC1155Asset memory erc1155Asset
) internal pure returns (uint256) {
}
function _findERC20BeneficiaryIndex(
address beneficiary,
ERC20Asset memory erc20Asset
) internal pure returns (uint256) {
}
function setERC1155BeneficiaryPercentage(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary,
uint8 newPercentage
) external {
}
function setERC721Beneficiary(
string memory userId,
address _contract,
uint256 tokenId,
address newBeneficiary
) external {
}
function setERC20BeneficiaryPercentage(
string memory userId,
address _contract,
address beneficiary,
uint8 newPercentage
) external {
}
function setVaultFactory(address _vaultFactory)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setMinAdminSignature(uint16 _minAdminSignature)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function _authorizeUser(
address user,
uint256 nonce,
bytes calldata signature
) internal {
}
function _verifySigners(
bytes32 hashedMessage,
uint256 nonce,
bytes[] calldata signatures
) internal returns (address[] memory) {
}
function _verifySignature(bytes32 _hashedMessage, bytes calldata signature)
internal
pure
returns (address)
{
}
function pauseContract()
external
whenNotPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function unpauseContract()
external
whenPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function withdrawEther(address to) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
// Function to receive Ether. msg.data must be empty
receive() external payable {}
// Fallback function is called when msg.data is not empty
fallback() external payable {}
}
| !userAssets[_msgSender()].erc721Assets[assetIndex].transferStatus,"LegacyAssetManager: Asset has been transferred to the beneficiary" | 147,732 | !userAssets[_msgSender()].erc721Assets[assetIndex].transferStatus |
"LegacyAssetManager: Asset has been transferred to the beneficiaries" | pragma solidity 0.8.15;
contract LegacyAssetManager is AccessControl, Pausable, ReentrancyGuard {
using SafeERC20 for IERC20;
bytes32 public constant LEGACY_ADMIN = keccak256("LEGACY_ADMIN");
bytes32 public constant ASSET_AUTHORIZER = keccak256("ASSET_AUTHORIZER");
ILegacyVaultFactory public vaultFactory;
uint16 public minAdminSignature;
mapping(address => UserAssets) public userAssets;
mapping(address => bool) public listedMembers;
mapping(address => mapping(address => mapping(uint256 => bool)))
public listedAssets;
mapping(address => address) public backupWallets;
mapping(uint256 => bool) public burnedNonces;
event ERC1155AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC721AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
address beneficiary
);
event ERC20AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC1155AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC721AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC20AssetRemoved(
string userId,
address indexed owner,
address indexed _contract
);
event ERC1155AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
uint256 amount,
address[] signers
);
event ERC721AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
address[] signers
);
event ERC20AssetClaimed(
string userId,
address indexed owner,
address indexed claimer,
address _contract,
uint256 amount,
address[] signers
);
event BackupWalletSwitched(
string userId,
address indexed owner,
address indexed backupwallet
);
event BeneficiaryChanged(
string userId,
address indexed owner,
address _contract,
uint256 tokenId,
address newBeneficiary
);
/**
* `tokenId` will be `0` in case of ERC20
*/
event BeneficiaryPercentageChanged(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId,
address beneficiary,
uint8 newpercentage
);
/**
* Structs
*/
struct Beneficiary {
address account;
uint8 allowedPercentage;
uint256 totalAmount;
uint256 claimedAmount;
}
struct ERC1155Asset {
address owner;
address _contract;
uint256 tokenId;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct ERC721Asset {
address owner;
address _contract;
uint256 tokenId;
address beneficiary;
bool transferStatus;
}
struct ERC20Asset {
address owner;
address _contract;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct UserAssets {
ERC1155Asset[] erc1155Assets;
ERC721Asset[] erc721Assets;
ERC20Asset[] erc20Assets;
bool backupWalletStatus;
}
modifier onlyListedUser(address user) {
}
modifier assetNotListed(
address user,
address _contract,
uint256 tokenId
) {
}
constructor(uint16 _minAdminSignature) {
}
function createUserVault(
string calldata userId,
uint256 nonce,
bytes calldata signature
) external whenNotPaused {
}
function addERC1155Assets(
string calldata userId,
address[] memory contracts,
uint256[] memory tokenIds,
uint256[] calldata totalAmount,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC1155Single(
string memory userId,
address _contract,
uint256 tokenId,
uint256 totalAmount,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC721Assets(
string calldata userId,
address[] calldata _contracts,
uint256[] calldata tokenIds,
address[] calldata beneficiaries
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC721Single(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC20Assets(
string calldata userId,
address[] calldata contracts,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC20Single(
string memory userId,
address _contract,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, 0) {
}
function removeERC1155Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC721Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC20Asset(string memory userId, address _contract)
external
nonReentrant
{
uint256 assetIndex = _findERC20AssetIndex(_msgSender(), _contract);
require(<FILL_ME>)
userAssets[_msgSender()].erc20Assets[assetIndex] = userAssets[
_msgSender()
].erc20Assets[userAssets[_msgSender()].erc20Assets.length - 1];
userAssets[_msgSender()].erc20Assets.pop();
listedAssets[_msgSender()][_contract][0] = false;
emit ERC20AssetRemoved(userId, _msgSender(), _contract);
}
function setBackupWallet(address _backupWallet)
external
onlyListedUser(_msgSender())
{
}
function switchBackupWallet(string memory userId, address owner) external {
}
function claimERC1155Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC721Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC20Asset(
string memory userId,
address owner,
address _contract,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function _findERC1155AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC721AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC20AssetIndex(address user, address _contract)
internal
view
returns (uint256)
{
}
function _findERC1155BeneficiaryIndex(
address beneficiary,
ERC1155Asset memory erc1155Asset
) internal pure returns (uint256) {
}
function _findERC20BeneficiaryIndex(
address beneficiary,
ERC20Asset memory erc20Asset
) internal pure returns (uint256) {
}
function setERC1155BeneficiaryPercentage(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary,
uint8 newPercentage
) external {
}
function setERC721Beneficiary(
string memory userId,
address _contract,
uint256 tokenId,
address newBeneficiary
) external {
}
function setERC20BeneficiaryPercentage(
string memory userId,
address _contract,
address beneficiary,
uint8 newPercentage
) external {
}
function setVaultFactory(address _vaultFactory)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setMinAdminSignature(uint16 _minAdminSignature)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function _authorizeUser(
address user,
uint256 nonce,
bytes calldata signature
) internal {
}
function _verifySigners(
bytes32 hashedMessage,
uint256 nonce,
bytes[] calldata signatures
) internal returns (address[] memory) {
}
function _verifySignature(bytes32 _hashedMessage, bytes calldata signature)
internal
pure
returns (address)
{
}
function pauseContract()
external
whenNotPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function unpauseContract()
external
whenPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function withdrawEther(address to) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
// Function to receive Ether. msg.data must be empty
receive() external payable {}
// Fallback function is called when msg.data is not empty
fallback() external payable {}
}
| userAssets[_msgSender()].erc20Assets[assetIndex].remainingBeneficiaries>0,"LegacyAssetManager: Asset has been transferred to the beneficiaries" | 147,732 | userAssets[_msgSender()].erc20Assets[assetIndex].remainingBeneficiaries>0 |
"LegacyAssetManager: Backup wallet already switched" | pragma solidity 0.8.15;
contract LegacyAssetManager is AccessControl, Pausable, ReentrancyGuard {
using SafeERC20 for IERC20;
bytes32 public constant LEGACY_ADMIN = keccak256("LEGACY_ADMIN");
bytes32 public constant ASSET_AUTHORIZER = keccak256("ASSET_AUTHORIZER");
ILegacyVaultFactory public vaultFactory;
uint16 public minAdminSignature;
mapping(address => UserAssets) public userAssets;
mapping(address => bool) public listedMembers;
mapping(address => mapping(address => mapping(uint256 => bool)))
public listedAssets;
mapping(address => address) public backupWallets;
mapping(uint256 => bool) public burnedNonces;
event ERC1155AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC721AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
address beneficiary
);
event ERC20AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC1155AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC721AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC20AssetRemoved(
string userId,
address indexed owner,
address indexed _contract
);
event ERC1155AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
uint256 amount,
address[] signers
);
event ERC721AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
address[] signers
);
event ERC20AssetClaimed(
string userId,
address indexed owner,
address indexed claimer,
address _contract,
uint256 amount,
address[] signers
);
event BackupWalletSwitched(
string userId,
address indexed owner,
address indexed backupwallet
);
event BeneficiaryChanged(
string userId,
address indexed owner,
address _contract,
uint256 tokenId,
address newBeneficiary
);
/**
* `tokenId` will be `0` in case of ERC20
*/
event BeneficiaryPercentageChanged(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId,
address beneficiary,
uint8 newpercentage
);
/**
* Structs
*/
struct Beneficiary {
address account;
uint8 allowedPercentage;
uint256 totalAmount;
uint256 claimedAmount;
}
struct ERC1155Asset {
address owner;
address _contract;
uint256 tokenId;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct ERC721Asset {
address owner;
address _contract;
uint256 tokenId;
address beneficiary;
bool transferStatus;
}
struct ERC20Asset {
address owner;
address _contract;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct UserAssets {
ERC1155Asset[] erc1155Assets;
ERC721Asset[] erc721Assets;
ERC20Asset[] erc20Assets;
bool backupWalletStatus;
}
modifier onlyListedUser(address user) {
}
modifier assetNotListed(
address user,
address _contract,
uint256 tokenId
) {
}
constructor(uint16 _minAdminSignature) {
}
function createUserVault(
string calldata userId,
uint256 nonce,
bytes calldata signature
) external whenNotPaused {
}
function addERC1155Assets(
string calldata userId,
address[] memory contracts,
uint256[] memory tokenIds,
uint256[] calldata totalAmount,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC1155Single(
string memory userId,
address _contract,
uint256 tokenId,
uint256 totalAmount,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC721Assets(
string calldata userId,
address[] calldata _contracts,
uint256[] calldata tokenIds,
address[] calldata beneficiaries
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC721Single(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC20Assets(
string calldata userId,
address[] calldata contracts,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC20Single(
string memory userId,
address _contract,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, 0) {
}
function removeERC1155Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC721Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC20Asset(string memory userId, address _contract)
external
nonReentrant
{
}
function setBackupWallet(address _backupWallet)
external
onlyListedUser(_msgSender())
{
require(<FILL_ME>)
backupWallets[_msgSender()] = _backupWallet;
}
function switchBackupWallet(string memory userId, address owner) external {
}
function claimERC1155Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC721Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC20Asset(
string memory userId,
address owner,
address _contract,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function _findERC1155AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC721AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC20AssetIndex(address user, address _contract)
internal
view
returns (uint256)
{
}
function _findERC1155BeneficiaryIndex(
address beneficiary,
ERC1155Asset memory erc1155Asset
) internal pure returns (uint256) {
}
function _findERC20BeneficiaryIndex(
address beneficiary,
ERC20Asset memory erc20Asset
) internal pure returns (uint256) {
}
function setERC1155BeneficiaryPercentage(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary,
uint8 newPercentage
) external {
}
function setERC721Beneficiary(
string memory userId,
address _contract,
uint256 tokenId,
address newBeneficiary
) external {
}
function setERC20BeneficiaryPercentage(
string memory userId,
address _contract,
address beneficiary,
uint8 newPercentage
) external {
}
function setVaultFactory(address _vaultFactory)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setMinAdminSignature(uint16 _minAdminSignature)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function _authorizeUser(
address user,
uint256 nonce,
bytes calldata signature
) internal {
}
function _verifySigners(
bytes32 hashedMessage,
uint256 nonce,
bytes[] calldata signatures
) internal returns (address[] memory) {
}
function _verifySignature(bytes32 _hashedMessage, bytes calldata signature)
internal
pure
returns (address)
{
}
function pauseContract()
external
whenNotPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function unpauseContract()
external
whenPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function withdrawEther(address to) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
// Function to receive Ether. msg.data must be empty
receive() external payable {}
// Fallback function is called when msg.data is not empty
fallback() external payable {}
}
| !userAssets[_msgSender()].backupWalletStatus,"LegacyAssetManager: Backup wallet already switched" | 147,732 | !userAssets[_msgSender()].backupWalletStatus |
"LegacyAssetManager: Unauthorized backup wallet transfer call" | pragma solidity 0.8.15;
contract LegacyAssetManager is AccessControl, Pausable, ReentrancyGuard {
using SafeERC20 for IERC20;
bytes32 public constant LEGACY_ADMIN = keccak256("LEGACY_ADMIN");
bytes32 public constant ASSET_AUTHORIZER = keccak256("ASSET_AUTHORIZER");
ILegacyVaultFactory public vaultFactory;
uint16 public minAdminSignature;
mapping(address => UserAssets) public userAssets;
mapping(address => bool) public listedMembers;
mapping(address => mapping(address => mapping(uint256 => bool)))
public listedAssets;
mapping(address => address) public backupWallets;
mapping(uint256 => bool) public burnedNonces;
event ERC1155AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC721AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
address beneficiary
);
event ERC20AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC1155AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC721AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC20AssetRemoved(
string userId,
address indexed owner,
address indexed _contract
);
event ERC1155AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
uint256 amount,
address[] signers
);
event ERC721AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
address[] signers
);
event ERC20AssetClaimed(
string userId,
address indexed owner,
address indexed claimer,
address _contract,
uint256 amount,
address[] signers
);
event BackupWalletSwitched(
string userId,
address indexed owner,
address indexed backupwallet
);
event BeneficiaryChanged(
string userId,
address indexed owner,
address _contract,
uint256 tokenId,
address newBeneficiary
);
/**
* `tokenId` will be `0` in case of ERC20
*/
event BeneficiaryPercentageChanged(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId,
address beneficiary,
uint8 newpercentage
);
/**
* Structs
*/
struct Beneficiary {
address account;
uint8 allowedPercentage;
uint256 totalAmount;
uint256 claimedAmount;
}
struct ERC1155Asset {
address owner;
address _contract;
uint256 tokenId;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct ERC721Asset {
address owner;
address _contract;
uint256 tokenId;
address beneficiary;
bool transferStatus;
}
struct ERC20Asset {
address owner;
address _contract;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct UserAssets {
ERC1155Asset[] erc1155Assets;
ERC721Asset[] erc721Assets;
ERC20Asset[] erc20Assets;
bool backupWalletStatus;
}
modifier onlyListedUser(address user) {
}
modifier assetNotListed(
address user,
address _contract,
uint256 tokenId
) {
}
constructor(uint16 _minAdminSignature) {
}
function createUserVault(
string calldata userId,
uint256 nonce,
bytes calldata signature
) external whenNotPaused {
}
function addERC1155Assets(
string calldata userId,
address[] memory contracts,
uint256[] memory tokenIds,
uint256[] calldata totalAmount,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC1155Single(
string memory userId,
address _contract,
uint256 tokenId,
uint256 totalAmount,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC721Assets(
string calldata userId,
address[] calldata _contracts,
uint256[] calldata tokenIds,
address[] calldata beneficiaries
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC721Single(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC20Assets(
string calldata userId,
address[] calldata contracts,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC20Single(
string memory userId,
address _contract,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, 0) {
}
function removeERC1155Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC721Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC20Asset(string memory userId, address _contract)
external
nonReentrant
{
}
function setBackupWallet(address _backupWallet)
external
onlyListedUser(_msgSender())
{
}
function switchBackupWallet(string memory userId, address owner) external {
require(<FILL_ME>)
ILegacyVault userVault = ILegacyVault(
ILegacyVaultFactory(vaultFactory).getVault(owner)
);
for (uint i = 0; i < userAssets[owner].erc1155Assets.length; i++) {
IERC1155 _contract = IERC1155(
userAssets[owner].erc1155Assets[i]._contract
);
uint256 userBalance = _contract.balanceOf(
owner,
userAssets[owner].erc1155Assets[i].tokenId
);
if (
userBalance > 0 &&
_contract.isApprovedForAll(owner, address(userVault))
) {
userVault.transferErc1155TokensAllowed(
address(_contract),
owner,
_msgSender(),
userAssets[owner].erc1155Assets[i].tokenId,
userBalance
);
}
}
for (uint i = 0; i < userAssets[owner].erc721Assets.length; i++) {
IERC721 _contract = IERC721(
userAssets[owner].erc721Assets[i]._contract
);
uint256 tokenId = userAssets[owner].erc721Assets[i].tokenId;
if (_contract.ownerOf(tokenId) == owner) {
userVault.transferErc721TokensAllowed(
address(_contract),
owner,
_msgSender(),
tokenId
);
}
}
for (uint i = 0; i < userAssets[owner].erc20Assets.length; i++) {
IERC20 _contract = IERC20(
userAssets[owner].erc20Assets[i]._contract
);
uint256 userBalance = _contract.balanceOf(owner);
uint256 allowance = _contract.allowance(owner, address(userVault));
if (userBalance > 0 && userBalance >= allowance) {
userVault.transferErc20TokensAllowed(
address(_contract),
owner,
_msgSender(),
allowance
);
} else if (userBalance > 0 && userBalance < allowance) {
userVault.transferErc20TokensAllowed(
address(_contract),
owner,
_msgSender(),
userBalance
);
}
}
userAssets[owner].backupWalletStatus = true;
emit BackupWalletSwitched(userId, owner, _msgSender());
}
function claimERC1155Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC721Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC20Asset(
string memory userId,
address owner,
address _contract,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function _findERC1155AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC721AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC20AssetIndex(address user, address _contract)
internal
view
returns (uint256)
{
}
function _findERC1155BeneficiaryIndex(
address beneficiary,
ERC1155Asset memory erc1155Asset
) internal pure returns (uint256) {
}
function _findERC20BeneficiaryIndex(
address beneficiary,
ERC20Asset memory erc20Asset
) internal pure returns (uint256) {
}
function setERC1155BeneficiaryPercentage(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary,
uint8 newPercentage
) external {
}
function setERC721Beneficiary(
string memory userId,
address _contract,
uint256 tokenId,
address newBeneficiary
) external {
}
function setERC20BeneficiaryPercentage(
string memory userId,
address _contract,
address beneficiary,
uint8 newPercentage
) external {
}
function setVaultFactory(address _vaultFactory)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setMinAdminSignature(uint16 _minAdminSignature)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function _authorizeUser(
address user,
uint256 nonce,
bytes calldata signature
) internal {
}
function _verifySigners(
bytes32 hashedMessage,
uint256 nonce,
bytes[] calldata signatures
) internal returns (address[] memory) {
}
function _verifySignature(bytes32 _hashedMessage, bytes calldata signature)
internal
pure
returns (address)
{
}
function pauseContract()
external
whenNotPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function unpauseContract()
external
whenPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function withdrawEther(address to) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
// Function to receive Ether. msg.data must be empty
receive() external payable {}
// Fallback function is called when msg.data is not empty
fallback() external payable {}
}
| _msgSender()==backupWallets[owner],"LegacyAssetManager: Unauthorized backup wallet transfer call" | 147,732 | _msgSender()==backupWallets[owner] |
"LegacyAssetManager: Beneficiary has already claimed the asset" | pragma solidity 0.8.15;
contract LegacyAssetManager is AccessControl, Pausable, ReentrancyGuard {
using SafeERC20 for IERC20;
bytes32 public constant LEGACY_ADMIN = keccak256("LEGACY_ADMIN");
bytes32 public constant ASSET_AUTHORIZER = keccak256("ASSET_AUTHORIZER");
ILegacyVaultFactory public vaultFactory;
uint16 public minAdminSignature;
mapping(address => UserAssets) public userAssets;
mapping(address => bool) public listedMembers;
mapping(address => mapping(address => mapping(uint256 => bool)))
public listedAssets;
mapping(address => address) public backupWallets;
mapping(uint256 => bool) public burnedNonces;
event ERC1155AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC721AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
address beneficiary
);
event ERC20AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC1155AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC721AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC20AssetRemoved(
string userId,
address indexed owner,
address indexed _contract
);
event ERC1155AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
uint256 amount,
address[] signers
);
event ERC721AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
address[] signers
);
event ERC20AssetClaimed(
string userId,
address indexed owner,
address indexed claimer,
address _contract,
uint256 amount,
address[] signers
);
event BackupWalletSwitched(
string userId,
address indexed owner,
address indexed backupwallet
);
event BeneficiaryChanged(
string userId,
address indexed owner,
address _contract,
uint256 tokenId,
address newBeneficiary
);
/**
* `tokenId` will be `0` in case of ERC20
*/
event BeneficiaryPercentageChanged(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId,
address beneficiary,
uint8 newpercentage
);
/**
* Structs
*/
struct Beneficiary {
address account;
uint8 allowedPercentage;
uint256 totalAmount;
uint256 claimedAmount;
}
struct ERC1155Asset {
address owner;
address _contract;
uint256 tokenId;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct ERC721Asset {
address owner;
address _contract;
uint256 tokenId;
address beneficiary;
bool transferStatus;
}
struct ERC20Asset {
address owner;
address _contract;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct UserAssets {
ERC1155Asset[] erc1155Assets;
ERC721Asset[] erc721Assets;
ERC20Asset[] erc20Assets;
bool backupWalletStatus;
}
modifier onlyListedUser(address user) {
}
modifier assetNotListed(
address user,
address _contract,
uint256 tokenId
) {
}
constructor(uint16 _minAdminSignature) {
}
function createUserVault(
string calldata userId,
uint256 nonce,
bytes calldata signature
) external whenNotPaused {
}
function addERC1155Assets(
string calldata userId,
address[] memory contracts,
uint256[] memory tokenIds,
uint256[] calldata totalAmount,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC1155Single(
string memory userId,
address _contract,
uint256 tokenId,
uint256 totalAmount,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC721Assets(
string calldata userId,
address[] calldata _contracts,
uint256[] calldata tokenIds,
address[] calldata beneficiaries
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC721Single(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC20Assets(
string calldata userId,
address[] calldata contracts,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC20Single(
string memory userId,
address _contract,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, 0) {
}
function removeERC1155Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC721Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC20Asset(string memory userId, address _contract)
external
nonReentrant
{
}
function setBackupWallet(address _backupWallet)
external
onlyListedUser(_msgSender())
{
}
function switchBackupWallet(string memory userId, address owner) external {
}
function claimERC1155Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC721Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
bytes32 hashedMessage = keccak256(
abi.encodePacked(owner, _msgSender(), _contract, tokenId, nonce)
);
address[] memory signers = _verifySigners(
hashedMessage,
nonce,
signatures
);
uint256 assetIndex = _findERC721AssetIndex(owner, _contract, tokenId);
require(<FILL_ME>)
require(
userAssets[owner].erc721Assets[assetIndex].beneficiary ==
_msgSender(),
"LegacyAssetManager: Unauthorized claim call"
);
address vaultAddress = vaultFactory.getVault(owner);
address from;
if (userAssets[owner].backupWalletStatus) {
from = backupWallets[owner];
} else {
from = owner;
}
ILegacyVault(vaultAddress).transferErc721TokensAllowed(
_contract,
from,
_msgSender(),
tokenId
);
userAssets[owner].erc721Assets[assetIndex].transferStatus = true;
emit ERC721AssetClaimed(
userId,
owner,
_msgSender(),
_contract,
tokenId,
signers
);
}
function claimERC20Asset(
string memory userId,
address owner,
address _contract,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function _findERC1155AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC721AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC20AssetIndex(address user, address _contract)
internal
view
returns (uint256)
{
}
function _findERC1155BeneficiaryIndex(
address beneficiary,
ERC1155Asset memory erc1155Asset
) internal pure returns (uint256) {
}
function _findERC20BeneficiaryIndex(
address beneficiary,
ERC20Asset memory erc20Asset
) internal pure returns (uint256) {
}
function setERC1155BeneficiaryPercentage(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary,
uint8 newPercentage
) external {
}
function setERC721Beneficiary(
string memory userId,
address _contract,
uint256 tokenId,
address newBeneficiary
) external {
}
function setERC20BeneficiaryPercentage(
string memory userId,
address _contract,
address beneficiary,
uint8 newPercentage
) external {
}
function setVaultFactory(address _vaultFactory)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setMinAdminSignature(uint16 _minAdminSignature)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function _authorizeUser(
address user,
uint256 nonce,
bytes calldata signature
) internal {
}
function _verifySigners(
bytes32 hashedMessage,
uint256 nonce,
bytes[] calldata signatures
) internal returns (address[] memory) {
}
function _verifySignature(bytes32 _hashedMessage, bytes calldata signature)
internal
pure
returns (address)
{
}
function pauseContract()
external
whenNotPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function unpauseContract()
external
whenPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function withdrawEther(address to) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
// Function to receive Ether. msg.data must be empty
receive() external payable {}
// Fallback function is called when msg.data is not empty
fallback() external payable {}
}
| !userAssets[owner].erc721Assets[assetIndex].transferStatus,"LegacyAssetManager: Beneficiary has already claimed the asset" | 147,732 | !userAssets[owner].erc721Assets[assetIndex].transferStatus |
"LegacyAssetManager: Unauthorized claim call" | pragma solidity 0.8.15;
contract LegacyAssetManager is AccessControl, Pausable, ReentrancyGuard {
using SafeERC20 for IERC20;
bytes32 public constant LEGACY_ADMIN = keccak256("LEGACY_ADMIN");
bytes32 public constant ASSET_AUTHORIZER = keccak256("ASSET_AUTHORIZER");
ILegacyVaultFactory public vaultFactory;
uint16 public minAdminSignature;
mapping(address => UserAssets) public userAssets;
mapping(address => bool) public listedMembers;
mapping(address => mapping(address => mapping(uint256 => bool)))
public listedAssets;
mapping(address => address) public backupWallets;
mapping(uint256 => bool) public burnedNonces;
event ERC1155AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC721AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
address beneficiary
);
event ERC20AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC1155AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC721AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC20AssetRemoved(
string userId,
address indexed owner,
address indexed _contract
);
event ERC1155AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
uint256 amount,
address[] signers
);
event ERC721AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
address[] signers
);
event ERC20AssetClaimed(
string userId,
address indexed owner,
address indexed claimer,
address _contract,
uint256 amount,
address[] signers
);
event BackupWalletSwitched(
string userId,
address indexed owner,
address indexed backupwallet
);
event BeneficiaryChanged(
string userId,
address indexed owner,
address _contract,
uint256 tokenId,
address newBeneficiary
);
/**
* `tokenId` will be `0` in case of ERC20
*/
event BeneficiaryPercentageChanged(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId,
address beneficiary,
uint8 newpercentage
);
/**
* Structs
*/
struct Beneficiary {
address account;
uint8 allowedPercentage;
uint256 totalAmount;
uint256 claimedAmount;
}
struct ERC1155Asset {
address owner;
address _contract;
uint256 tokenId;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct ERC721Asset {
address owner;
address _contract;
uint256 tokenId;
address beneficiary;
bool transferStatus;
}
struct ERC20Asset {
address owner;
address _contract;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct UserAssets {
ERC1155Asset[] erc1155Assets;
ERC721Asset[] erc721Assets;
ERC20Asset[] erc20Assets;
bool backupWalletStatus;
}
modifier onlyListedUser(address user) {
}
modifier assetNotListed(
address user,
address _contract,
uint256 tokenId
) {
}
constructor(uint16 _minAdminSignature) {
}
function createUserVault(
string calldata userId,
uint256 nonce,
bytes calldata signature
) external whenNotPaused {
}
function addERC1155Assets(
string calldata userId,
address[] memory contracts,
uint256[] memory tokenIds,
uint256[] calldata totalAmount,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC1155Single(
string memory userId,
address _contract,
uint256 tokenId,
uint256 totalAmount,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC721Assets(
string calldata userId,
address[] calldata _contracts,
uint256[] calldata tokenIds,
address[] calldata beneficiaries
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC721Single(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC20Assets(
string calldata userId,
address[] calldata contracts,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC20Single(
string memory userId,
address _contract,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, 0) {
}
function removeERC1155Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC721Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC20Asset(string memory userId, address _contract)
external
nonReentrant
{
}
function setBackupWallet(address _backupWallet)
external
onlyListedUser(_msgSender())
{
}
function switchBackupWallet(string memory userId, address owner) external {
}
function claimERC1155Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC721Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
bytes32 hashedMessage = keccak256(
abi.encodePacked(owner, _msgSender(), _contract, tokenId, nonce)
);
address[] memory signers = _verifySigners(
hashedMessage,
nonce,
signatures
);
uint256 assetIndex = _findERC721AssetIndex(owner, _contract, tokenId);
require(
!userAssets[owner].erc721Assets[assetIndex].transferStatus,
"LegacyAssetManager: Beneficiary has already claimed the asset"
);
require(<FILL_ME>)
address vaultAddress = vaultFactory.getVault(owner);
address from;
if (userAssets[owner].backupWalletStatus) {
from = backupWallets[owner];
} else {
from = owner;
}
ILegacyVault(vaultAddress).transferErc721TokensAllowed(
_contract,
from,
_msgSender(),
tokenId
);
userAssets[owner].erc721Assets[assetIndex].transferStatus = true;
emit ERC721AssetClaimed(
userId,
owner,
_msgSender(),
_contract,
tokenId,
signers
);
}
function claimERC20Asset(
string memory userId,
address owner,
address _contract,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function _findERC1155AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC721AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC20AssetIndex(address user, address _contract)
internal
view
returns (uint256)
{
}
function _findERC1155BeneficiaryIndex(
address beneficiary,
ERC1155Asset memory erc1155Asset
) internal pure returns (uint256) {
}
function _findERC20BeneficiaryIndex(
address beneficiary,
ERC20Asset memory erc20Asset
) internal pure returns (uint256) {
}
function setERC1155BeneficiaryPercentage(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary,
uint8 newPercentage
) external {
}
function setERC721Beneficiary(
string memory userId,
address _contract,
uint256 tokenId,
address newBeneficiary
) external {
}
function setERC20BeneficiaryPercentage(
string memory userId,
address _contract,
address beneficiary,
uint8 newPercentage
) external {
}
function setVaultFactory(address _vaultFactory)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setMinAdminSignature(uint16 _minAdminSignature)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function _authorizeUser(
address user,
uint256 nonce,
bytes calldata signature
) internal {
}
function _verifySigners(
bytes32 hashedMessage,
uint256 nonce,
bytes[] calldata signatures
) internal returns (address[] memory) {
}
function _verifySignature(bytes32 _hashedMessage, bytes calldata signature)
internal
pure
returns (address)
{
}
function pauseContract()
external
whenNotPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function unpauseContract()
external
whenPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function withdrawEther(address to) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
// Function to receive Ether. msg.data must be empty
receive() external payable {}
// Fallback function is called when msg.data is not empty
fallback() external payable {}
}
| userAssets[owner].erc721Assets[assetIndex].beneficiary==_msgSender(),"LegacyAssetManager: Unauthorized claim call" | 147,732 | userAssets[owner].erc721Assets[assetIndex].beneficiary==_msgSender() |
"LegacyAssetManager: Beneficiary has already claimed the asset" | pragma solidity 0.8.15;
contract LegacyAssetManager is AccessControl, Pausable, ReentrancyGuard {
using SafeERC20 for IERC20;
bytes32 public constant LEGACY_ADMIN = keccak256("LEGACY_ADMIN");
bytes32 public constant ASSET_AUTHORIZER = keccak256("ASSET_AUTHORIZER");
ILegacyVaultFactory public vaultFactory;
uint16 public minAdminSignature;
mapping(address => UserAssets) public userAssets;
mapping(address => bool) public listedMembers;
mapping(address => mapping(address => mapping(uint256 => bool)))
public listedAssets;
mapping(address => address) public backupWallets;
mapping(uint256 => bool) public burnedNonces;
event ERC1155AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC721AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
address beneficiary
);
event ERC20AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC1155AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC721AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC20AssetRemoved(
string userId,
address indexed owner,
address indexed _contract
);
event ERC1155AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
uint256 amount,
address[] signers
);
event ERC721AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
address[] signers
);
event ERC20AssetClaimed(
string userId,
address indexed owner,
address indexed claimer,
address _contract,
uint256 amount,
address[] signers
);
event BackupWalletSwitched(
string userId,
address indexed owner,
address indexed backupwallet
);
event BeneficiaryChanged(
string userId,
address indexed owner,
address _contract,
uint256 tokenId,
address newBeneficiary
);
/**
* `tokenId` will be `0` in case of ERC20
*/
event BeneficiaryPercentageChanged(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId,
address beneficiary,
uint8 newpercentage
);
/**
* Structs
*/
struct Beneficiary {
address account;
uint8 allowedPercentage;
uint256 totalAmount;
uint256 claimedAmount;
}
struct ERC1155Asset {
address owner;
address _contract;
uint256 tokenId;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct ERC721Asset {
address owner;
address _contract;
uint256 tokenId;
address beneficiary;
bool transferStatus;
}
struct ERC20Asset {
address owner;
address _contract;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct UserAssets {
ERC1155Asset[] erc1155Assets;
ERC721Asset[] erc721Assets;
ERC20Asset[] erc20Assets;
bool backupWalletStatus;
}
modifier onlyListedUser(address user) {
}
modifier assetNotListed(
address user,
address _contract,
uint256 tokenId
) {
}
constructor(uint16 _minAdminSignature) {
}
function createUserVault(
string calldata userId,
uint256 nonce,
bytes calldata signature
) external whenNotPaused {
}
function addERC1155Assets(
string calldata userId,
address[] memory contracts,
uint256[] memory tokenIds,
uint256[] calldata totalAmount,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC1155Single(
string memory userId,
address _contract,
uint256 tokenId,
uint256 totalAmount,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC721Assets(
string calldata userId,
address[] calldata _contracts,
uint256[] calldata tokenIds,
address[] calldata beneficiaries
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC721Single(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC20Assets(
string calldata userId,
address[] calldata contracts,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC20Single(
string memory userId,
address _contract,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, 0) {
}
function removeERC1155Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC721Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC20Asset(string memory userId, address _contract)
external
nonReentrant
{
}
function setBackupWallet(address _backupWallet)
external
onlyListedUser(_msgSender())
{
}
function switchBackupWallet(string memory userId, address owner) external {
}
function claimERC1155Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC721Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC20Asset(
string memory userId,
address owner,
address _contract,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function _findERC1155AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC721AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC20AssetIndex(address user, address _contract)
internal
view
returns (uint256)
{
}
function _findERC1155BeneficiaryIndex(
address beneficiary,
ERC1155Asset memory erc1155Asset
) internal pure returns (uint256) {
}
function _findERC20BeneficiaryIndex(
address beneficiary,
ERC20Asset memory erc20Asset
) internal pure returns (uint256) {
}
function setERC1155BeneficiaryPercentage(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary,
uint8 newPercentage
) external {
uint256 assetIndex = _findERC1155AssetIndex(
_msgSender(),
_contract,
tokenId
);
uint256 beneficiaryIndex = _findERC1155BeneficiaryIndex(
beneficiary,
userAssets[_msgSender()].erc1155Assets[assetIndex]
);
require(<FILL_ME>)
uint8 currentPercentage = userAssets[_msgSender()]
.erc1155Assets[assetIndex]
.beneficiaries[beneficiaryIndex]
.allowedPercentage;
require(
(userAssets[_msgSender()]
.erc1155Assets[assetIndex]
.totalPercentage - currentPercentage) +
newPercentage <=
100,
"LegacyAssetManager: Beneficiary percentage exceeds total of 100"
);
userAssets[_msgSender()]
.erc1155Assets[assetIndex]
.beneficiaries[beneficiaryIndex]
.allowedPercentage = newPercentage;
userAssets[_msgSender()].erc1155Assets[assetIndex].totalPercentage =
(userAssets[_msgSender()]
.erc1155Assets[assetIndex]
.totalPercentage - currentPercentage) +
newPercentage;
emit BeneficiaryPercentageChanged(
userId,
_msgSender(),
_contract,
tokenId,
beneficiary,
newPercentage
);
}
function setERC721Beneficiary(
string memory userId,
address _contract,
uint256 tokenId,
address newBeneficiary
) external {
}
function setERC20BeneficiaryPercentage(
string memory userId,
address _contract,
address beneficiary,
uint8 newPercentage
) external {
}
function setVaultFactory(address _vaultFactory)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setMinAdminSignature(uint16 _minAdminSignature)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function _authorizeUser(
address user,
uint256 nonce,
bytes calldata signature
) internal {
}
function _verifySigners(
bytes32 hashedMessage,
uint256 nonce,
bytes[] calldata signatures
) internal returns (address[] memory) {
}
function _verifySignature(bytes32 _hashedMessage, bytes calldata signature)
internal
pure
returns (address)
{
}
function pauseContract()
external
whenNotPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function unpauseContract()
external
whenPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function withdrawEther(address to) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
// Function to receive Ether. msg.data must be empty
receive() external payable {}
// Fallback function is called when msg.data is not empty
fallback() external payable {}
}
| userAssets[_msgSender()].erc1155Assets[assetIndex].beneficiaries[beneficiaryIndex].totalAmount-userAssets[_msgSender()].erc1155Assets[assetIndex].beneficiaries[beneficiaryIndex].claimedAmount>0,"LegacyAssetManager: Beneficiary has already claimed the asset" | 147,732 | userAssets[_msgSender()].erc1155Assets[assetIndex].beneficiaries[beneficiaryIndex].totalAmount-userAssets[_msgSender()].erc1155Assets[assetIndex].beneficiaries[beneficiaryIndex].claimedAmount>0 |
"LegacyAssetManager: Beneficiary percentage exceeds total of 100" | pragma solidity 0.8.15;
contract LegacyAssetManager is AccessControl, Pausable, ReentrancyGuard {
using SafeERC20 for IERC20;
bytes32 public constant LEGACY_ADMIN = keccak256("LEGACY_ADMIN");
bytes32 public constant ASSET_AUTHORIZER = keccak256("ASSET_AUTHORIZER");
ILegacyVaultFactory public vaultFactory;
uint16 public minAdminSignature;
mapping(address => UserAssets) public userAssets;
mapping(address => bool) public listedMembers;
mapping(address => mapping(address => mapping(uint256 => bool)))
public listedAssets;
mapping(address => address) public backupWallets;
mapping(uint256 => bool) public burnedNonces;
event ERC1155AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC721AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
address beneficiary
);
event ERC20AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC1155AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC721AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC20AssetRemoved(
string userId,
address indexed owner,
address indexed _contract
);
event ERC1155AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
uint256 amount,
address[] signers
);
event ERC721AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
address[] signers
);
event ERC20AssetClaimed(
string userId,
address indexed owner,
address indexed claimer,
address _contract,
uint256 amount,
address[] signers
);
event BackupWalletSwitched(
string userId,
address indexed owner,
address indexed backupwallet
);
event BeneficiaryChanged(
string userId,
address indexed owner,
address _contract,
uint256 tokenId,
address newBeneficiary
);
/**
* `tokenId` will be `0` in case of ERC20
*/
event BeneficiaryPercentageChanged(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId,
address beneficiary,
uint8 newpercentage
);
/**
* Structs
*/
struct Beneficiary {
address account;
uint8 allowedPercentage;
uint256 totalAmount;
uint256 claimedAmount;
}
struct ERC1155Asset {
address owner;
address _contract;
uint256 tokenId;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct ERC721Asset {
address owner;
address _contract;
uint256 tokenId;
address beneficiary;
bool transferStatus;
}
struct ERC20Asset {
address owner;
address _contract;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct UserAssets {
ERC1155Asset[] erc1155Assets;
ERC721Asset[] erc721Assets;
ERC20Asset[] erc20Assets;
bool backupWalletStatus;
}
modifier onlyListedUser(address user) {
}
modifier assetNotListed(
address user,
address _contract,
uint256 tokenId
) {
}
constructor(uint16 _minAdminSignature) {
}
function createUserVault(
string calldata userId,
uint256 nonce,
bytes calldata signature
) external whenNotPaused {
}
function addERC1155Assets(
string calldata userId,
address[] memory contracts,
uint256[] memory tokenIds,
uint256[] calldata totalAmount,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC1155Single(
string memory userId,
address _contract,
uint256 tokenId,
uint256 totalAmount,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC721Assets(
string calldata userId,
address[] calldata _contracts,
uint256[] calldata tokenIds,
address[] calldata beneficiaries
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC721Single(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC20Assets(
string calldata userId,
address[] calldata contracts,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC20Single(
string memory userId,
address _contract,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, 0) {
}
function removeERC1155Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC721Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC20Asset(string memory userId, address _contract)
external
nonReentrant
{
}
function setBackupWallet(address _backupWallet)
external
onlyListedUser(_msgSender())
{
}
function switchBackupWallet(string memory userId, address owner) external {
}
function claimERC1155Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC721Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC20Asset(
string memory userId,
address owner,
address _contract,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function _findERC1155AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC721AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC20AssetIndex(address user, address _contract)
internal
view
returns (uint256)
{
}
function _findERC1155BeneficiaryIndex(
address beneficiary,
ERC1155Asset memory erc1155Asset
) internal pure returns (uint256) {
}
function _findERC20BeneficiaryIndex(
address beneficiary,
ERC20Asset memory erc20Asset
) internal pure returns (uint256) {
}
function setERC1155BeneficiaryPercentage(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary,
uint8 newPercentage
) external {
uint256 assetIndex = _findERC1155AssetIndex(
_msgSender(),
_contract,
tokenId
);
uint256 beneficiaryIndex = _findERC1155BeneficiaryIndex(
beneficiary,
userAssets[_msgSender()].erc1155Assets[assetIndex]
);
require(
userAssets[_msgSender()]
.erc1155Assets[assetIndex]
.beneficiaries[beneficiaryIndex]
.totalAmount -
userAssets[_msgSender()]
.erc1155Assets[assetIndex]
.beneficiaries[beneficiaryIndex]
.claimedAmount >
0,
"LegacyAssetManager: Beneficiary has already claimed the asset"
);
uint8 currentPercentage = userAssets[_msgSender()]
.erc1155Assets[assetIndex]
.beneficiaries[beneficiaryIndex]
.allowedPercentage;
require(<FILL_ME>)
userAssets[_msgSender()]
.erc1155Assets[assetIndex]
.beneficiaries[beneficiaryIndex]
.allowedPercentage = newPercentage;
userAssets[_msgSender()].erc1155Assets[assetIndex].totalPercentage =
(userAssets[_msgSender()]
.erc1155Assets[assetIndex]
.totalPercentage - currentPercentage) +
newPercentage;
emit BeneficiaryPercentageChanged(
userId,
_msgSender(),
_contract,
tokenId,
beneficiary,
newPercentage
);
}
function setERC721Beneficiary(
string memory userId,
address _contract,
uint256 tokenId,
address newBeneficiary
) external {
}
function setERC20BeneficiaryPercentage(
string memory userId,
address _contract,
address beneficiary,
uint8 newPercentage
) external {
}
function setVaultFactory(address _vaultFactory)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setMinAdminSignature(uint16 _minAdminSignature)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function _authorizeUser(
address user,
uint256 nonce,
bytes calldata signature
) internal {
}
function _verifySigners(
bytes32 hashedMessage,
uint256 nonce,
bytes[] calldata signatures
) internal returns (address[] memory) {
}
function _verifySignature(bytes32 _hashedMessage, bytes calldata signature)
internal
pure
returns (address)
{
}
function pauseContract()
external
whenNotPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function unpauseContract()
external
whenPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function withdrawEther(address to) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
// Function to receive Ether. msg.data must be empty
receive() external payable {}
// Fallback function is called when msg.data is not empty
fallback() external payable {}
}
| (userAssets[_msgSender()].erc1155Assets[assetIndex].totalPercentage-currentPercentage)+newPercentage<=100,"LegacyAssetManager: Beneficiary percentage exceeds total of 100" | 147,732 | (userAssets[_msgSender()].erc1155Assets[assetIndex].totalPercentage-currentPercentage)+newPercentage<=100 |
"LegacyAssetManager: Beneficiary has already claimed the asset" | pragma solidity 0.8.15;
contract LegacyAssetManager is AccessControl, Pausable, ReentrancyGuard {
using SafeERC20 for IERC20;
bytes32 public constant LEGACY_ADMIN = keccak256("LEGACY_ADMIN");
bytes32 public constant ASSET_AUTHORIZER = keccak256("ASSET_AUTHORIZER");
ILegacyVaultFactory public vaultFactory;
uint16 public minAdminSignature;
mapping(address => UserAssets) public userAssets;
mapping(address => bool) public listedMembers;
mapping(address => mapping(address => mapping(uint256 => bool)))
public listedAssets;
mapping(address => address) public backupWallets;
mapping(uint256 => bool) public burnedNonces;
event ERC1155AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC721AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
address beneficiary
);
event ERC20AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC1155AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC721AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC20AssetRemoved(
string userId,
address indexed owner,
address indexed _contract
);
event ERC1155AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
uint256 amount,
address[] signers
);
event ERC721AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
address[] signers
);
event ERC20AssetClaimed(
string userId,
address indexed owner,
address indexed claimer,
address _contract,
uint256 amount,
address[] signers
);
event BackupWalletSwitched(
string userId,
address indexed owner,
address indexed backupwallet
);
event BeneficiaryChanged(
string userId,
address indexed owner,
address _contract,
uint256 tokenId,
address newBeneficiary
);
/**
* `tokenId` will be `0` in case of ERC20
*/
event BeneficiaryPercentageChanged(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId,
address beneficiary,
uint8 newpercentage
);
/**
* Structs
*/
struct Beneficiary {
address account;
uint8 allowedPercentage;
uint256 totalAmount;
uint256 claimedAmount;
}
struct ERC1155Asset {
address owner;
address _contract;
uint256 tokenId;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct ERC721Asset {
address owner;
address _contract;
uint256 tokenId;
address beneficiary;
bool transferStatus;
}
struct ERC20Asset {
address owner;
address _contract;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct UserAssets {
ERC1155Asset[] erc1155Assets;
ERC721Asset[] erc721Assets;
ERC20Asset[] erc20Assets;
bool backupWalletStatus;
}
modifier onlyListedUser(address user) {
}
modifier assetNotListed(
address user,
address _contract,
uint256 tokenId
) {
}
constructor(uint16 _minAdminSignature) {
}
function createUserVault(
string calldata userId,
uint256 nonce,
bytes calldata signature
) external whenNotPaused {
}
function addERC1155Assets(
string calldata userId,
address[] memory contracts,
uint256[] memory tokenIds,
uint256[] calldata totalAmount,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC1155Single(
string memory userId,
address _contract,
uint256 tokenId,
uint256 totalAmount,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC721Assets(
string calldata userId,
address[] calldata _contracts,
uint256[] calldata tokenIds,
address[] calldata beneficiaries
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC721Single(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC20Assets(
string calldata userId,
address[] calldata contracts,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC20Single(
string memory userId,
address _contract,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, 0) {
}
function removeERC1155Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC721Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC20Asset(string memory userId, address _contract)
external
nonReentrant
{
}
function setBackupWallet(address _backupWallet)
external
onlyListedUser(_msgSender())
{
}
function switchBackupWallet(string memory userId, address owner) external {
}
function claimERC1155Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC721Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC20Asset(
string memory userId,
address owner,
address _contract,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function _findERC1155AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC721AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC20AssetIndex(address user, address _contract)
internal
view
returns (uint256)
{
}
function _findERC1155BeneficiaryIndex(
address beneficiary,
ERC1155Asset memory erc1155Asset
) internal pure returns (uint256) {
}
function _findERC20BeneficiaryIndex(
address beneficiary,
ERC20Asset memory erc20Asset
) internal pure returns (uint256) {
}
function setERC1155BeneficiaryPercentage(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary,
uint8 newPercentage
) external {
}
function setERC721Beneficiary(
string memory userId,
address _contract,
uint256 tokenId,
address newBeneficiary
) external {
}
function setERC20BeneficiaryPercentage(
string memory userId,
address _contract,
address beneficiary,
uint8 newPercentage
) external {
uint256 assetIndex = _findERC20AssetIndex(_msgSender(), _contract);
uint256 beneficiaryIndex = _findERC20BeneficiaryIndex(
beneficiary,
userAssets[_msgSender()].erc20Assets[assetIndex]
);
require(<FILL_ME>)
uint8 currentPercentage = userAssets[_msgSender()]
.erc20Assets[assetIndex]
.beneficiaries[beneficiaryIndex]
.allowedPercentage;
require(
(userAssets[_msgSender()].erc20Assets[assetIndex].totalPercentage -
currentPercentage) +
newPercentage <=
100,
"LegacyAssetManager: Beneficiary percentage exceeds 100"
);
userAssets[_msgSender()]
.erc20Assets[assetIndex]
.beneficiaries[beneficiaryIndex]
.allowedPercentage = newPercentage;
userAssets[_msgSender()].erc20Assets[assetIndex].totalPercentage =
(userAssets[_msgSender()].erc20Assets[assetIndex].totalPercentage -
currentPercentage) +
newPercentage;
emit BeneficiaryPercentageChanged(
userId,
_msgSender(),
_contract,
0,
beneficiary,
newPercentage
);
}
function setVaultFactory(address _vaultFactory)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setMinAdminSignature(uint16 _minAdminSignature)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function _authorizeUser(
address user,
uint256 nonce,
bytes calldata signature
) internal {
}
function _verifySigners(
bytes32 hashedMessage,
uint256 nonce,
bytes[] calldata signatures
) internal returns (address[] memory) {
}
function _verifySignature(bytes32 _hashedMessage, bytes calldata signature)
internal
pure
returns (address)
{
}
function pauseContract()
external
whenNotPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function unpauseContract()
external
whenPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function withdrawEther(address to) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
// Function to receive Ether. msg.data must be empty
receive() external payable {}
// Fallback function is called when msg.data is not empty
fallback() external payable {}
}
| userAssets[_msgSender()].erc20Assets[assetIndex].beneficiaries[beneficiaryIndex].totalAmount-userAssets[_msgSender()].erc20Assets[assetIndex].beneficiaries[beneficiaryIndex].claimedAmount>0,"LegacyAssetManager: Beneficiary has already claimed the asset" | 147,732 | userAssets[_msgSender()].erc20Assets[assetIndex].beneficiaries[beneficiaryIndex].totalAmount-userAssets[_msgSender()].erc20Assets[assetIndex].beneficiaries[beneficiaryIndex].claimedAmount>0 |
"LegacyAssetManager: Beneficiary percentage exceeds 100" | pragma solidity 0.8.15;
contract LegacyAssetManager is AccessControl, Pausable, ReentrancyGuard {
using SafeERC20 for IERC20;
bytes32 public constant LEGACY_ADMIN = keccak256("LEGACY_ADMIN");
bytes32 public constant ASSET_AUTHORIZER = keccak256("ASSET_AUTHORIZER");
ILegacyVaultFactory public vaultFactory;
uint16 public minAdminSignature;
mapping(address => UserAssets) public userAssets;
mapping(address => bool) public listedMembers;
mapping(address => mapping(address => mapping(uint256 => bool)))
public listedAssets;
mapping(address => address) public backupWallets;
mapping(uint256 => bool) public burnedNonces;
event ERC1155AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC721AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
address beneficiary
);
event ERC20AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC1155AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC721AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC20AssetRemoved(
string userId,
address indexed owner,
address indexed _contract
);
event ERC1155AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
uint256 amount,
address[] signers
);
event ERC721AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
address[] signers
);
event ERC20AssetClaimed(
string userId,
address indexed owner,
address indexed claimer,
address _contract,
uint256 amount,
address[] signers
);
event BackupWalletSwitched(
string userId,
address indexed owner,
address indexed backupwallet
);
event BeneficiaryChanged(
string userId,
address indexed owner,
address _contract,
uint256 tokenId,
address newBeneficiary
);
/**
* `tokenId` will be `0` in case of ERC20
*/
event BeneficiaryPercentageChanged(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId,
address beneficiary,
uint8 newpercentage
);
/**
* Structs
*/
struct Beneficiary {
address account;
uint8 allowedPercentage;
uint256 totalAmount;
uint256 claimedAmount;
}
struct ERC1155Asset {
address owner;
address _contract;
uint256 tokenId;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct ERC721Asset {
address owner;
address _contract;
uint256 tokenId;
address beneficiary;
bool transferStatus;
}
struct ERC20Asset {
address owner;
address _contract;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct UserAssets {
ERC1155Asset[] erc1155Assets;
ERC721Asset[] erc721Assets;
ERC20Asset[] erc20Assets;
bool backupWalletStatus;
}
modifier onlyListedUser(address user) {
}
modifier assetNotListed(
address user,
address _contract,
uint256 tokenId
) {
}
constructor(uint16 _minAdminSignature) {
}
function createUserVault(
string calldata userId,
uint256 nonce,
bytes calldata signature
) external whenNotPaused {
}
function addERC1155Assets(
string calldata userId,
address[] memory contracts,
uint256[] memory tokenIds,
uint256[] calldata totalAmount,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC1155Single(
string memory userId,
address _contract,
uint256 tokenId,
uint256 totalAmount,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC721Assets(
string calldata userId,
address[] calldata _contracts,
uint256[] calldata tokenIds,
address[] calldata beneficiaries
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC721Single(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC20Assets(
string calldata userId,
address[] calldata contracts,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC20Single(
string memory userId,
address _contract,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, 0) {
}
function removeERC1155Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC721Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC20Asset(string memory userId, address _contract)
external
nonReentrant
{
}
function setBackupWallet(address _backupWallet)
external
onlyListedUser(_msgSender())
{
}
function switchBackupWallet(string memory userId, address owner) external {
}
function claimERC1155Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC721Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC20Asset(
string memory userId,
address owner,
address _contract,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function _findERC1155AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC721AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC20AssetIndex(address user, address _contract)
internal
view
returns (uint256)
{
}
function _findERC1155BeneficiaryIndex(
address beneficiary,
ERC1155Asset memory erc1155Asset
) internal pure returns (uint256) {
}
function _findERC20BeneficiaryIndex(
address beneficiary,
ERC20Asset memory erc20Asset
) internal pure returns (uint256) {
}
function setERC1155BeneficiaryPercentage(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary,
uint8 newPercentage
) external {
}
function setERC721Beneficiary(
string memory userId,
address _contract,
uint256 tokenId,
address newBeneficiary
) external {
}
function setERC20BeneficiaryPercentage(
string memory userId,
address _contract,
address beneficiary,
uint8 newPercentage
) external {
uint256 assetIndex = _findERC20AssetIndex(_msgSender(), _contract);
uint256 beneficiaryIndex = _findERC20BeneficiaryIndex(
beneficiary,
userAssets[_msgSender()].erc20Assets[assetIndex]
);
require(
userAssets[_msgSender()]
.erc20Assets[assetIndex]
.beneficiaries[beneficiaryIndex]
.totalAmount -
userAssets[_msgSender()]
.erc20Assets[assetIndex]
.beneficiaries[beneficiaryIndex]
.claimedAmount >
0,
"LegacyAssetManager: Beneficiary has already claimed the asset"
);
uint8 currentPercentage = userAssets[_msgSender()]
.erc20Assets[assetIndex]
.beneficiaries[beneficiaryIndex]
.allowedPercentage;
require(<FILL_ME>)
userAssets[_msgSender()]
.erc20Assets[assetIndex]
.beneficiaries[beneficiaryIndex]
.allowedPercentage = newPercentage;
userAssets[_msgSender()].erc20Assets[assetIndex].totalPercentage =
(userAssets[_msgSender()].erc20Assets[assetIndex].totalPercentage -
currentPercentage) +
newPercentage;
emit BeneficiaryPercentageChanged(
userId,
_msgSender(),
_contract,
0,
beneficiary,
newPercentage
);
}
function setVaultFactory(address _vaultFactory)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setMinAdminSignature(uint16 _minAdminSignature)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function _authorizeUser(
address user,
uint256 nonce,
bytes calldata signature
) internal {
}
function _verifySigners(
bytes32 hashedMessage,
uint256 nonce,
bytes[] calldata signatures
) internal returns (address[] memory) {
}
function _verifySignature(bytes32 _hashedMessage, bytes calldata signature)
internal
pure
returns (address)
{
}
function pauseContract()
external
whenNotPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function unpauseContract()
external
whenPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function withdrawEther(address to) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
// Function to receive Ether. msg.data must be empty
receive() external payable {}
// Fallback function is called when msg.data is not empty
fallback() external payable {}
}
| (userAssets[_msgSender()].erc20Assets[assetIndex].totalPercentage-currentPercentage)+newPercentage<=100,"LegacyAssetManager: Beneficiary percentage exceeds 100" | 147,732 | (userAssets[_msgSender()].erc20Assets[assetIndex].totalPercentage-currentPercentage)+newPercentage<=100 |
"LegacyAssetManger: Nonce already used" | pragma solidity 0.8.15;
contract LegacyAssetManager is AccessControl, Pausable, ReentrancyGuard {
using SafeERC20 for IERC20;
bytes32 public constant LEGACY_ADMIN = keccak256("LEGACY_ADMIN");
bytes32 public constant ASSET_AUTHORIZER = keccak256("ASSET_AUTHORIZER");
ILegacyVaultFactory public vaultFactory;
uint16 public minAdminSignature;
mapping(address => UserAssets) public userAssets;
mapping(address => bool) public listedMembers;
mapping(address => mapping(address => mapping(uint256 => bool)))
public listedAssets;
mapping(address => address) public backupWallets;
mapping(uint256 => bool) public burnedNonces;
event ERC1155AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC721AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
address beneficiary
);
event ERC20AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC1155AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC721AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC20AssetRemoved(
string userId,
address indexed owner,
address indexed _contract
);
event ERC1155AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
uint256 amount,
address[] signers
);
event ERC721AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
address[] signers
);
event ERC20AssetClaimed(
string userId,
address indexed owner,
address indexed claimer,
address _contract,
uint256 amount,
address[] signers
);
event BackupWalletSwitched(
string userId,
address indexed owner,
address indexed backupwallet
);
event BeneficiaryChanged(
string userId,
address indexed owner,
address _contract,
uint256 tokenId,
address newBeneficiary
);
/**
* `tokenId` will be `0` in case of ERC20
*/
event BeneficiaryPercentageChanged(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId,
address beneficiary,
uint8 newpercentage
);
/**
* Structs
*/
struct Beneficiary {
address account;
uint8 allowedPercentage;
uint256 totalAmount;
uint256 claimedAmount;
}
struct ERC1155Asset {
address owner;
address _contract;
uint256 tokenId;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct ERC721Asset {
address owner;
address _contract;
uint256 tokenId;
address beneficiary;
bool transferStatus;
}
struct ERC20Asset {
address owner;
address _contract;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct UserAssets {
ERC1155Asset[] erc1155Assets;
ERC721Asset[] erc721Assets;
ERC20Asset[] erc20Assets;
bool backupWalletStatus;
}
modifier onlyListedUser(address user) {
}
modifier assetNotListed(
address user,
address _contract,
uint256 tokenId
) {
}
constructor(uint16 _minAdminSignature) {
}
function createUserVault(
string calldata userId,
uint256 nonce,
bytes calldata signature
) external whenNotPaused {
}
function addERC1155Assets(
string calldata userId,
address[] memory contracts,
uint256[] memory tokenIds,
uint256[] calldata totalAmount,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC1155Single(
string memory userId,
address _contract,
uint256 tokenId,
uint256 totalAmount,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC721Assets(
string calldata userId,
address[] calldata _contracts,
uint256[] calldata tokenIds,
address[] calldata beneficiaries
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC721Single(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC20Assets(
string calldata userId,
address[] calldata contracts,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC20Single(
string memory userId,
address _contract,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, 0) {
}
function removeERC1155Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC721Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC20Asset(string memory userId, address _contract)
external
nonReentrant
{
}
function setBackupWallet(address _backupWallet)
external
onlyListedUser(_msgSender())
{
}
function switchBackupWallet(string memory userId, address owner) external {
}
function claimERC1155Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC721Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC20Asset(
string memory userId,
address owner,
address _contract,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function _findERC1155AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC721AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC20AssetIndex(address user, address _contract)
internal
view
returns (uint256)
{
}
function _findERC1155BeneficiaryIndex(
address beneficiary,
ERC1155Asset memory erc1155Asset
) internal pure returns (uint256) {
}
function _findERC20BeneficiaryIndex(
address beneficiary,
ERC20Asset memory erc20Asset
) internal pure returns (uint256) {
}
function setERC1155BeneficiaryPercentage(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary,
uint8 newPercentage
) external {
}
function setERC721Beneficiary(
string memory userId,
address _contract,
uint256 tokenId,
address newBeneficiary
) external {
}
function setERC20BeneficiaryPercentage(
string memory userId,
address _contract,
address beneficiary,
uint8 newPercentage
) external {
}
function setVaultFactory(address _vaultFactory)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setMinAdminSignature(uint16 _minAdminSignature)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function _authorizeUser(
address user,
uint256 nonce,
bytes calldata signature
) internal {
if (!listedMembers[user]) {
require(<FILL_ME>)
bytes32 hashedMessage = keccak256(abi.encodePacked(user, nonce));
address signer = _verifySignature(hashedMessage, signature);
require(
hasRole(ASSET_AUTHORIZER, signer),
"LegacyAssetManager: Unauthorized signature"
);
burnedNonces[nonce] = true;
listedMembers[user] = true;
}
}
function _verifySigners(
bytes32 hashedMessage,
uint256 nonce,
bytes[] calldata signatures
) internal returns (address[] memory) {
}
function _verifySignature(bytes32 _hashedMessage, bytes calldata signature)
internal
pure
returns (address)
{
}
function pauseContract()
external
whenNotPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function unpauseContract()
external
whenPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function withdrawEther(address to) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
// Function to receive Ether. msg.data must be empty
receive() external payable {}
// Fallback function is called when msg.data is not empty
fallback() external payable {}
}
| !burnedNonces[nonce],"LegacyAssetManger: Nonce already used" | 147,732 | !burnedNonces[nonce] |
"LegacyAssetManager: Unauthorized signature" | pragma solidity 0.8.15;
contract LegacyAssetManager is AccessControl, Pausable, ReentrancyGuard {
using SafeERC20 for IERC20;
bytes32 public constant LEGACY_ADMIN = keccak256("LEGACY_ADMIN");
bytes32 public constant ASSET_AUTHORIZER = keccak256("ASSET_AUTHORIZER");
ILegacyVaultFactory public vaultFactory;
uint16 public minAdminSignature;
mapping(address => UserAssets) public userAssets;
mapping(address => bool) public listedMembers;
mapping(address => mapping(address => mapping(uint256 => bool)))
public listedAssets;
mapping(address => address) public backupWallets;
mapping(uint256 => bool) public burnedNonces;
event ERC1155AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC721AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
address beneficiary
);
event ERC20AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC1155AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC721AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC20AssetRemoved(
string userId,
address indexed owner,
address indexed _contract
);
event ERC1155AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
uint256 amount,
address[] signers
);
event ERC721AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
address[] signers
);
event ERC20AssetClaimed(
string userId,
address indexed owner,
address indexed claimer,
address _contract,
uint256 amount,
address[] signers
);
event BackupWalletSwitched(
string userId,
address indexed owner,
address indexed backupwallet
);
event BeneficiaryChanged(
string userId,
address indexed owner,
address _contract,
uint256 tokenId,
address newBeneficiary
);
/**
* `tokenId` will be `0` in case of ERC20
*/
event BeneficiaryPercentageChanged(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId,
address beneficiary,
uint8 newpercentage
);
/**
* Structs
*/
struct Beneficiary {
address account;
uint8 allowedPercentage;
uint256 totalAmount;
uint256 claimedAmount;
}
struct ERC1155Asset {
address owner;
address _contract;
uint256 tokenId;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct ERC721Asset {
address owner;
address _contract;
uint256 tokenId;
address beneficiary;
bool transferStatus;
}
struct ERC20Asset {
address owner;
address _contract;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct UserAssets {
ERC1155Asset[] erc1155Assets;
ERC721Asset[] erc721Assets;
ERC20Asset[] erc20Assets;
bool backupWalletStatus;
}
modifier onlyListedUser(address user) {
}
modifier assetNotListed(
address user,
address _contract,
uint256 tokenId
) {
}
constructor(uint16 _minAdminSignature) {
}
function createUserVault(
string calldata userId,
uint256 nonce,
bytes calldata signature
) external whenNotPaused {
}
function addERC1155Assets(
string calldata userId,
address[] memory contracts,
uint256[] memory tokenIds,
uint256[] calldata totalAmount,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC1155Single(
string memory userId,
address _contract,
uint256 tokenId,
uint256 totalAmount,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC721Assets(
string calldata userId,
address[] calldata _contracts,
uint256[] calldata tokenIds,
address[] calldata beneficiaries
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC721Single(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC20Assets(
string calldata userId,
address[] calldata contracts,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC20Single(
string memory userId,
address _contract,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, 0) {
}
function removeERC1155Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC721Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC20Asset(string memory userId, address _contract)
external
nonReentrant
{
}
function setBackupWallet(address _backupWallet)
external
onlyListedUser(_msgSender())
{
}
function switchBackupWallet(string memory userId, address owner) external {
}
function claimERC1155Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC721Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC20Asset(
string memory userId,
address owner,
address _contract,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function _findERC1155AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC721AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC20AssetIndex(address user, address _contract)
internal
view
returns (uint256)
{
}
function _findERC1155BeneficiaryIndex(
address beneficiary,
ERC1155Asset memory erc1155Asset
) internal pure returns (uint256) {
}
function _findERC20BeneficiaryIndex(
address beneficiary,
ERC20Asset memory erc20Asset
) internal pure returns (uint256) {
}
function setERC1155BeneficiaryPercentage(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary,
uint8 newPercentage
) external {
}
function setERC721Beneficiary(
string memory userId,
address _contract,
uint256 tokenId,
address newBeneficiary
) external {
}
function setERC20BeneficiaryPercentage(
string memory userId,
address _contract,
address beneficiary,
uint8 newPercentage
) external {
}
function setVaultFactory(address _vaultFactory)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setMinAdminSignature(uint16 _minAdminSignature)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function _authorizeUser(
address user,
uint256 nonce,
bytes calldata signature
) internal {
if (!listedMembers[user]) {
require(
!burnedNonces[nonce],
"LegacyAssetManger: Nonce already used"
);
bytes32 hashedMessage = keccak256(abi.encodePacked(user, nonce));
address signer = _verifySignature(hashedMessage, signature);
require(<FILL_ME>)
burnedNonces[nonce] = true;
listedMembers[user] = true;
}
}
function _verifySigners(
bytes32 hashedMessage,
uint256 nonce,
bytes[] calldata signatures
) internal returns (address[] memory) {
}
function _verifySignature(bytes32 _hashedMessage, bytes calldata signature)
internal
pure
returns (address)
{
}
function pauseContract()
external
whenNotPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function unpauseContract()
external
whenPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function withdrawEther(address to) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
// Function to receive Ether. msg.data must be empty
receive() external payable {}
// Fallback function is called when msg.data is not empty
fallback() external payable {}
}
| hasRole(ASSET_AUTHORIZER,signer),"LegacyAssetManager: Unauthorized signature" | 147,732 | hasRole(ASSET_AUTHORIZER,signer) |
"LegacyAssetManager: Unauthorized signature" | pragma solidity 0.8.15;
contract LegacyAssetManager is AccessControl, Pausable, ReentrancyGuard {
using SafeERC20 for IERC20;
bytes32 public constant LEGACY_ADMIN = keccak256("LEGACY_ADMIN");
bytes32 public constant ASSET_AUTHORIZER = keccak256("ASSET_AUTHORIZER");
ILegacyVaultFactory public vaultFactory;
uint16 public minAdminSignature;
mapping(address => UserAssets) public userAssets;
mapping(address => bool) public listedMembers;
mapping(address => mapping(address => mapping(uint256 => bool)))
public listedAssets;
mapping(address => address) public backupWallets;
mapping(uint256 => bool) public burnedNonces;
event ERC1155AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC721AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
address beneficiary
);
event ERC20AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC1155AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC721AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC20AssetRemoved(
string userId,
address indexed owner,
address indexed _contract
);
event ERC1155AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
uint256 amount,
address[] signers
);
event ERC721AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
address[] signers
);
event ERC20AssetClaimed(
string userId,
address indexed owner,
address indexed claimer,
address _contract,
uint256 amount,
address[] signers
);
event BackupWalletSwitched(
string userId,
address indexed owner,
address indexed backupwallet
);
event BeneficiaryChanged(
string userId,
address indexed owner,
address _contract,
uint256 tokenId,
address newBeneficiary
);
/**
* `tokenId` will be `0` in case of ERC20
*/
event BeneficiaryPercentageChanged(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId,
address beneficiary,
uint8 newpercentage
);
/**
* Structs
*/
struct Beneficiary {
address account;
uint8 allowedPercentage;
uint256 totalAmount;
uint256 claimedAmount;
}
struct ERC1155Asset {
address owner;
address _contract;
uint256 tokenId;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct ERC721Asset {
address owner;
address _contract;
uint256 tokenId;
address beneficiary;
bool transferStatus;
}
struct ERC20Asset {
address owner;
address _contract;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct UserAssets {
ERC1155Asset[] erc1155Assets;
ERC721Asset[] erc721Assets;
ERC20Asset[] erc20Assets;
bool backupWalletStatus;
}
modifier onlyListedUser(address user) {
}
modifier assetNotListed(
address user,
address _contract,
uint256 tokenId
) {
}
constructor(uint16 _minAdminSignature) {
}
function createUserVault(
string calldata userId,
uint256 nonce,
bytes calldata signature
) external whenNotPaused {
}
function addERC1155Assets(
string calldata userId,
address[] memory contracts,
uint256[] memory tokenIds,
uint256[] calldata totalAmount,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC1155Single(
string memory userId,
address _contract,
uint256 tokenId,
uint256 totalAmount,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC721Assets(
string calldata userId,
address[] calldata _contracts,
uint256[] calldata tokenIds,
address[] calldata beneficiaries
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC721Single(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC20Assets(
string calldata userId,
address[] calldata contracts,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC20Single(
string memory userId,
address _contract,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, 0) {
}
function removeERC1155Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC721Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC20Asset(string memory userId, address _contract)
external
nonReentrant
{
}
function setBackupWallet(address _backupWallet)
external
onlyListedUser(_msgSender())
{
}
function switchBackupWallet(string memory userId, address owner) external {
}
function claimERC1155Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC721Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC20Asset(
string memory userId,
address owner,
address _contract,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function _findERC1155AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC721AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC20AssetIndex(address user, address _contract)
internal
view
returns (uint256)
{
}
function _findERC1155BeneficiaryIndex(
address beneficiary,
ERC1155Asset memory erc1155Asset
) internal pure returns (uint256) {
}
function _findERC20BeneficiaryIndex(
address beneficiary,
ERC20Asset memory erc20Asset
) internal pure returns (uint256) {
}
function setERC1155BeneficiaryPercentage(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary,
uint8 newPercentage
) external {
}
function setERC721Beneficiary(
string memory userId,
address _contract,
uint256 tokenId,
address newBeneficiary
) external {
}
function setERC20BeneficiaryPercentage(
string memory userId,
address _contract,
address beneficiary,
uint8 newPercentage
) external {
}
function setVaultFactory(address _vaultFactory)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setMinAdminSignature(uint16 _minAdminSignature)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function _authorizeUser(
address user,
uint256 nonce,
bytes calldata signature
) internal {
}
function _verifySigners(
bytes32 hashedMessage,
uint256 nonce,
bytes[] calldata signatures
) internal returns (address[] memory) {
require(
signatures.length >= minAdminSignature,
"LegacyAssetManger: Signatures are less than minimum required"
);
require(!burnedNonces[nonce], "LegacyAssetManger: Nonce already used");
address[] memory signers = new address[](signatures.length);
for (uint i = 0; i < signatures.length; i++) {
address signer = _verifySignature(hashedMessage, signatures[i]);
require(<FILL_ME>)
signers[i] = signer;
for (uint j = signers.length - 1; j != 0; j--) {
require(
signers[j] != signers[j - 1],
"LegacyAssetManager: Duplicate signature not allowed"
);
}
}
burnedNonces[nonce] = true;
return signers;
}
function _verifySignature(bytes32 _hashedMessage, bytes calldata signature)
internal
pure
returns (address)
{
}
function pauseContract()
external
whenNotPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function unpauseContract()
external
whenPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function withdrawEther(address to) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
// Function to receive Ether. msg.data must be empty
receive() external payable {}
// Fallback function is called when msg.data is not empty
fallback() external payable {}
}
| hasRole(LEGACY_ADMIN,signer),"LegacyAssetManager: Unauthorized signature" | 147,732 | hasRole(LEGACY_ADMIN,signer) |
"LegacyAssetManager: Duplicate signature not allowed" | pragma solidity 0.8.15;
contract LegacyAssetManager is AccessControl, Pausable, ReentrancyGuard {
using SafeERC20 for IERC20;
bytes32 public constant LEGACY_ADMIN = keccak256("LEGACY_ADMIN");
bytes32 public constant ASSET_AUTHORIZER = keccak256("ASSET_AUTHORIZER");
ILegacyVaultFactory public vaultFactory;
uint16 public minAdminSignature;
mapping(address => UserAssets) public userAssets;
mapping(address => bool) public listedMembers;
mapping(address => mapping(address => mapping(uint256 => bool)))
public listedAssets;
mapping(address => address) public backupWallets;
mapping(uint256 => bool) public burnedNonces;
event ERC1155AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC721AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 indexed tokenId,
address beneficiary
);
event ERC20AssetAdded(
string userId,
address indexed owner,
address indexed _contract,
uint256 totalAmount,
address[] beneficiaries,
uint8[] beneficiaryPercentages
);
event ERC1155AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC721AssetRemoved(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId
);
event ERC20AssetRemoved(
string userId,
address indexed owner,
address indexed _contract
);
event ERC1155AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
uint256 amount,
address[] signers
);
event ERC721AssetClaimed(
string userId,
address indexed owner,
address claimer,
address _contract,
uint256 indexed tokenId,
address[] signers
);
event ERC20AssetClaimed(
string userId,
address indexed owner,
address indexed claimer,
address _contract,
uint256 amount,
address[] signers
);
event BackupWalletSwitched(
string userId,
address indexed owner,
address indexed backupwallet
);
event BeneficiaryChanged(
string userId,
address indexed owner,
address _contract,
uint256 tokenId,
address newBeneficiary
);
/**
* `tokenId` will be `0` in case of ERC20
*/
event BeneficiaryPercentageChanged(
string userId,
address indexed owner,
address _contract,
uint256 indexed tokenId,
address beneficiary,
uint8 newpercentage
);
/**
* Structs
*/
struct Beneficiary {
address account;
uint8 allowedPercentage;
uint256 totalAmount;
uint256 claimedAmount;
}
struct ERC1155Asset {
address owner;
address _contract;
uint256 tokenId;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct ERC721Asset {
address owner;
address _contract;
uint256 tokenId;
address beneficiary;
bool transferStatus;
}
struct ERC20Asset {
address owner;
address _contract;
uint256 totalAmount;
uint256 totalRemainingAmount;
uint8 totalPercentage;
Beneficiary[] beneficiaries;
uint256 remainingBeneficiaries;
}
struct UserAssets {
ERC1155Asset[] erc1155Assets;
ERC721Asset[] erc721Assets;
ERC20Asset[] erc20Assets;
bool backupWalletStatus;
}
modifier onlyListedUser(address user) {
}
modifier assetNotListed(
address user,
address _contract,
uint256 tokenId
) {
}
constructor(uint16 _minAdminSignature) {
}
function createUserVault(
string calldata userId,
uint256 nonce,
bytes calldata signature
) external whenNotPaused {
}
function addERC1155Assets(
string calldata userId,
address[] memory contracts,
uint256[] memory tokenIds,
uint256[] calldata totalAmount,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC1155Single(
string memory userId,
address _contract,
uint256 tokenId,
uint256 totalAmount,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC721Assets(
string calldata userId,
address[] calldata _contracts,
uint256[] calldata tokenIds,
address[] calldata beneficiaries
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC721Single(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary
) internal assetNotListed(_msgSender(), _contract, tokenId) {
}
function addERC20Assets(
string calldata userId,
address[] calldata contracts,
address[][] calldata beneficiaryAddresses,
uint8[][] calldata beneficiaryPercentages
) external whenNotPaused nonReentrant onlyListedUser(_msgSender()) {
}
function _addERC20Single(
string memory userId,
address _contract,
address[] calldata beneficiaryAddresses,
uint8[] calldata beneficiaryPercentages
) internal assetNotListed(_msgSender(), _contract, 0) {
}
function removeERC1155Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC721Asset(
string memory userId,
address _contract,
uint256 tokenId
) external nonReentrant {
}
function removeERC20Asset(string memory userId, address _contract)
external
nonReentrant
{
}
function setBackupWallet(address _backupWallet)
external
onlyListedUser(_msgSender())
{
}
function switchBackupWallet(string memory userId, address owner) external {
}
function claimERC1155Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC721Asset(
string memory userId,
address owner,
address _contract,
uint256 tokenId,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function claimERC20Asset(
string memory userId,
address owner,
address _contract,
uint256 nonce,
bytes[] calldata signatures
) external whenNotPaused nonReentrant {
}
function _findERC1155AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC721AssetIndex(
address user,
address _contract,
uint256 tokenId
) internal view returns (uint256) {
}
function _findERC20AssetIndex(address user, address _contract)
internal
view
returns (uint256)
{
}
function _findERC1155BeneficiaryIndex(
address beneficiary,
ERC1155Asset memory erc1155Asset
) internal pure returns (uint256) {
}
function _findERC20BeneficiaryIndex(
address beneficiary,
ERC20Asset memory erc20Asset
) internal pure returns (uint256) {
}
function setERC1155BeneficiaryPercentage(
string memory userId,
address _contract,
uint256 tokenId,
address beneficiary,
uint8 newPercentage
) external {
}
function setERC721Beneficiary(
string memory userId,
address _contract,
uint256 tokenId,
address newBeneficiary
) external {
}
function setERC20BeneficiaryPercentage(
string memory userId,
address _contract,
address beneficiary,
uint8 newPercentage
) external {
}
function setVaultFactory(address _vaultFactory)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setMinAdminSignature(uint16 _minAdminSignature)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function _authorizeUser(
address user,
uint256 nonce,
bytes calldata signature
) internal {
}
function _verifySigners(
bytes32 hashedMessage,
uint256 nonce,
bytes[] calldata signatures
) internal returns (address[] memory) {
require(
signatures.length >= minAdminSignature,
"LegacyAssetManger: Signatures are less than minimum required"
);
require(!burnedNonces[nonce], "LegacyAssetManger: Nonce already used");
address[] memory signers = new address[](signatures.length);
for (uint i = 0; i < signatures.length; i++) {
address signer = _verifySignature(hashedMessage, signatures[i]);
require(
hasRole(LEGACY_ADMIN, signer),
"LegacyAssetManager: Unauthorized signature"
);
signers[i] = signer;
for (uint j = signers.length - 1; j != 0; j--) {
require(<FILL_ME>)
}
}
burnedNonces[nonce] = true;
return signers;
}
function _verifySignature(bytes32 _hashedMessage, bytes calldata signature)
internal
pure
returns (address)
{
}
function pauseContract()
external
whenNotPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function unpauseContract()
external
whenPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function withdrawEther(address to) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
// Function to receive Ether. msg.data must be empty
receive() external payable {}
// Fallback function is called when msg.data is not empty
fallback() external payable {}
}
| signers[j]!=signers[j-1],"LegacyAssetManager: Duplicate signature not allowed" | 147,732 | signers[j]!=signers[j-1] |
null | pragma solidity>0.8.0;//SPDX-License-Identifier:None
interface IERC721{
event Transfer(address indexed from,address indexed to,uint indexed tokenId);
event Approval(address indexed owner,address indexed approved,uint indexed tokenId);
event ApprovalForAll(address indexed owner,address indexed operator,bool approved);
function balanceOf(address)external view returns(uint);
function ownerOf(uint)external view returns(address);
function safeTransferFrom(address,address,uint)external;
function transferFrom(address,address,uint)external;
function approve(address,uint)external;
function getApproved(uint)external view returns(address);
function setApprovalForAll(address,bool)external;
function isApprovedForAll(address,address)external view returns(bool);
function safeTransferFrom(address,address,uint,bytes calldata)external;
}
interface IERC721Metadata{
function name()external view returns(string memory);
function symbol()external view returns(string memory);
function tokenURI(uint)external view returns(string memory);
}
contract ERC721AC is IERC721,IERC721Metadata{
address internal _owner;
mapping(uint=>address)internal _owners;
mapping(address=>uint)internal _balances;
mapping(uint=>address)internal _tokenApprovals;
mapping(address=>mapping(address=>bool))internal _operatorApprovals;
constructor(){
}
function supportsInterface(bytes4 a)external pure returns(bool){
}
function balanceOf(address a)external view override virtual returns(uint){
}
function ownerOf(uint a)public view override virtual returns(address){
}
function owner()external view returns(address){
}
function name()external view override virtual returns(string memory){
}
function symbol()external view override virtual returns(string memory){
}
function tokenURI(uint)external view override virtual returns(string memory){
}
function approve(address a,uint b)external override{
}
function getApproved(uint a)public view override returns(address){
}
function setApprovalForAll(address a,bool b)external override{
}
function isApprovedForAll(address a,address b)public view override returns(bool){
}
function transferFrom(address a,address b,uint c)public virtual override{
}
function safeTransferFrom(address a,address b,uint c)external override{
}
function safeTransferFrom(address a,address b,uint c,bytes memory)external override{
}
}
contract ERC721_LSG is ERC721AC{
uint public count;
mapping(uint=>string)private _uri;
constructor(string[] memory uri,uint[]memory num){
}
function name()external pure override returns(string memory){
}
function symbol()external pure override returns(string memory){
}
function tokenURI(uint a)public view override returns(string memory){
}
function MINT(string[] memory r)external{unchecked{
require(r.length<6);
require(count<3334);
require(<FILL_ME>)
require(block.timestamp>1654563600);
for(uint i=0;i<r.length;i++){
count++;
if(bytes(_uri[count]).length<1)_uri[count]=r[i];
_balances[msg.sender] += 1;
_owners[count] = msg.sender;
emit Transfer(address(0),msg.sender,count);
}
}}
}
| _balances[msg.sender]+r.length<6 | 147,764 | _balances[msg.sender]+r.length<6 |
"WooCrossChainRouterV3: !srcInfos.bridgeToken" | // SPDX-License-Identifier: MIT
pragma solidity =0.8.14;
// OpenZeppelin Contracts
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {Pausable} from "@openzeppelin/contracts/security/Pausable.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
// Local Contracts
import {IWETH} from "./interfaces/IWETH.sol";
import {IWooCrossChainRouterV3} from "./interfaces/IWooCrossChainRouterV3.sol";
import {IWooRouterV2} from "./interfaces/IWooRouterV2.sol";
import {IStargateEthVault} from "./interfaces/Stargate/IStargateEthVault.sol";
import {IStargateRouter} from "./interfaces/Stargate/IStargateRouter.sol";
import {ILzApp} from "./interfaces/LayerZero/ILzApp.sol";
import {TransferHelper} from "./libraries/TransferHelper.sol";
/// @title cross chain router implementation, version 3.
/// @notice Router for stateless execution of cross chain swap against WOOFi or 1inch swap.
/// @custom:stargate-contracts https://stargateprotocol.gitbook.io/stargate/developers/contract-addresses/mainnet
contract WooCrossChainRouterV3 is IWooCrossChainRouterV3, Ownable, Pausable, ReentrancyGuard {
using EnumerableSet for EnumerableSet.AddressSet;
/* ----- Constants ----- */
address public constant ETH_PLACEHOLDER_ADDR = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
/* ----- Variables ----- */
IWooRouterV2 public wooRouter;
IStargateRouter public stargateRouter;
address public immutable weth;
address public feeAddr;
uint256 public bridgeSlippage; // 1 in 10000th: default 1%
uint256 public dstGasForSwapCall;
uint256 public dstGasForNoSwapCall;
uint16 public sgChainIdLocal; // Stargate chainId on local chain
uint16 public srcExternalFeeRate; // unit: 0.1 bps (1e6 = 100%, 25 = 2.5 bps)
uint16 public dstExternalFeeRate; // unit: 0.1 bps (1e6 = 100%, 25 = 2.5 bps)
uint256 public constant FEE_BASE = 1e5;
mapping(uint16 => address) public wooCrossRouters; // chainId => WooCrossChainRouterV3 address
mapping(uint16 => address) public sgETHs; // chainId => SGETH token address
mapping(uint16 => mapping(address => uint256)) public sgPoolIds; // chainId => token address => Stargate poolId
receive() external payable {}
constructor(
address _weth,
address _wooRouter,
address _stargateRouter,
uint16 _sgChainIdLocal
) {
}
function _initSgETHs() internal {
}
function _initSgPoolIds() internal {
}
/* ----- Functions ----- */
function crossSwap(
uint256 refId,
address payable to,
SrcInfos memory srcInfos,
DstInfos calldata dstInfos,
Src1inch calldata src1inch,
Dst1inch calldata dst1inch
) external payable whenNotPaused nonReentrant {
}
function sgReceive(
uint16, // srcChainId
bytes memory, // srcAddress
uint256, // nonce
address bridgedToken,
uint256 amountLD,
bytes memory payload
) external {
}
function quoteLayerZeroFee(
uint256 refId,
address to,
DstInfos calldata dstInfos,
Dst1inch calldata dst1inch
) external view returns (uint256, uint256) {
}
/// @dev OKAY to be public method
function claimFee(address token) external nonReentrant {
}
function _getDstGasForCall(DstInfos memory dstInfos) internal view returns (uint256) {
}
function _getAdapterParams(
address to,
address oft,
uint256 dstGasForCall,
DstInfos memory dstInfos
) internal view returns (bytes memory) {
}
function _getLzTxObj(address to, DstInfos memory dstInfos) internal view returns (IStargateRouter.lzTxObj memory) {
}
function _bridgeByStargate(
uint256 refId,
address payable to,
uint256 msgValue,
uint256 bridgeAmount,
SrcInfos memory srcInfos,
DstInfos calldata dstInfos,
Dst1inch calldata dst1inch
) internal {
require(<FILL_ME>)
require(sgPoolIds[dstInfos.chainId][dstInfos.bridgeToken] > 0, "WooCrossChainRouterV3: !dstInfos.bridgeToken");
bytes memory payload = abi.encode(refId, to, dstInfos.toToken, dstInfos.minToAmount, dst1inch);
uint256 dstMinBridgeAmount = (bridgeAmount * (10000 - bridgeSlippage)) / 10000;
bytes memory dstWooCrossChainRouter = abi.encodePacked(wooCrossRouters[dstInfos.chainId]);
IStargateRouter.lzTxObj memory obj = _getLzTxObj(to, dstInfos);
if (srcInfos.bridgeToken == weth) {
IWETH(weth).withdraw(bridgeAmount);
msgValue += bridgeAmount;
} else {
TransferHelper.safeApprove(srcInfos.bridgeToken, address(stargateRouter), bridgeAmount);
}
stargateRouter.swap{value: msgValue}(
dstInfos.chainId, // dst chain id
sgPoolIds[sgChainIdLocal][srcInfos.bridgeToken], // bridge token's pool id on src chain
sgPoolIds[dstInfos.chainId][dstInfos.bridgeToken], // bridge token's pool id on dst chain
payable(_msgSender()), // rebate address
bridgeAmount, // swap amount on src chain
dstMinBridgeAmount, // min received amount on dst chain
obj, // config: dstGasForCall, dstAirdropNativeAmount, dstReceiveAirdropNativeTokenAddr
dstWooCrossChainRouter, // smart contract to call on dst chain
payload // payload to piggyback
);
}
function _handleNativeReceived(
uint256 refId,
address to,
address toToken,
uint256 bridgedAmount,
uint256 minToAmount,
Dst1inch memory dst1inch
) internal {
}
function _handleERC20Received(
uint256 refId,
address to,
address toToken,
address bridgedToken,
uint256 bridgedAmount,
uint256 minToAmount,
Dst1inch memory dst1inch
) internal {
}
function _generalBalanceOf(address token, address who) internal view returns (uint256) {
}
/* ----- Owner & Admin Functions ----- */
function setFeeAddr(address _feeAddr) external onlyOwner {
}
function setWooRouter(address _wooRouter) external onlyOwner {
}
function setStargateRouter(address _stargateRouter) external onlyOwner {
}
function setBridgeSlippage(uint256 _bridgeSlippage) external onlyOwner {
}
function setDstGasForSwapCall(uint256 _dstGasForSwapCall) external onlyOwner {
}
function setDstGasForNoSwapCall(uint256 _dstGasForNoSwapCall) external onlyOwner {
}
function setSgChainIdLocal(uint16 _sgChainIdLocal) external onlyOwner {
}
function setWooCrossRouter(uint16 _chainId, address _crossRouter) external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function inCaseTokenGotStuck(address stuckToken) external onlyOwner {
}
}
| sgPoolIds[sgChainIdLocal][srcInfos.bridgeToken]>0,"WooCrossChainRouterV3: !srcInfos.bridgeToken" | 147,791 | sgPoolIds[sgChainIdLocal][srcInfos.bridgeToken]>0 |
"WooCrossChainRouterV3: !dstInfos.bridgeToken" | // SPDX-License-Identifier: MIT
pragma solidity =0.8.14;
// OpenZeppelin Contracts
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {Pausable} from "@openzeppelin/contracts/security/Pausable.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
// Local Contracts
import {IWETH} from "./interfaces/IWETH.sol";
import {IWooCrossChainRouterV3} from "./interfaces/IWooCrossChainRouterV3.sol";
import {IWooRouterV2} from "./interfaces/IWooRouterV2.sol";
import {IStargateEthVault} from "./interfaces/Stargate/IStargateEthVault.sol";
import {IStargateRouter} from "./interfaces/Stargate/IStargateRouter.sol";
import {ILzApp} from "./interfaces/LayerZero/ILzApp.sol";
import {TransferHelper} from "./libraries/TransferHelper.sol";
/// @title cross chain router implementation, version 3.
/// @notice Router for stateless execution of cross chain swap against WOOFi or 1inch swap.
/// @custom:stargate-contracts https://stargateprotocol.gitbook.io/stargate/developers/contract-addresses/mainnet
contract WooCrossChainRouterV3 is IWooCrossChainRouterV3, Ownable, Pausable, ReentrancyGuard {
using EnumerableSet for EnumerableSet.AddressSet;
/* ----- Constants ----- */
address public constant ETH_PLACEHOLDER_ADDR = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
/* ----- Variables ----- */
IWooRouterV2 public wooRouter;
IStargateRouter public stargateRouter;
address public immutable weth;
address public feeAddr;
uint256 public bridgeSlippage; // 1 in 10000th: default 1%
uint256 public dstGasForSwapCall;
uint256 public dstGasForNoSwapCall;
uint16 public sgChainIdLocal; // Stargate chainId on local chain
uint16 public srcExternalFeeRate; // unit: 0.1 bps (1e6 = 100%, 25 = 2.5 bps)
uint16 public dstExternalFeeRate; // unit: 0.1 bps (1e6 = 100%, 25 = 2.5 bps)
uint256 public constant FEE_BASE = 1e5;
mapping(uint16 => address) public wooCrossRouters; // chainId => WooCrossChainRouterV3 address
mapping(uint16 => address) public sgETHs; // chainId => SGETH token address
mapping(uint16 => mapping(address => uint256)) public sgPoolIds; // chainId => token address => Stargate poolId
receive() external payable {}
constructor(
address _weth,
address _wooRouter,
address _stargateRouter,
uint16 _sgChainIdLocal
) {
}
function _initSgETHs() internal {
}
function _initSgPoolIds() internal {
}
/* ----- Functions ----- */
function crossSwap(
uint256 refId,
address payable to,
SrcInfos memory srcInfos,
DstInfos calldata dstInfos,
Src1inch calldata src1inch,
Dst1inch calldata dst1inch
) external payable whenNotPaused nonReentrant {
}
function sgReceive(
uint16, // srcChainId
bytes memory, // srcAddress
uint256, // nonce
address bridgedToken,
uint256 amountLD,
bytes memory payload
) external {
}
function quoteLayerZeroFee(
uint256 refId,
address to,
DstInfos calldata dstInfos,
Dst1inch calldata dst1inch
) external view returns (uint256, uint256) {
}
/// @dev OKAY to be public method
function claimFee(address token) external nonReentrant {
}
function _getDstGasForCall(DstInfos memory dstInfos) internal view returns (uint256) {
}
function _getAdapterParams(
address to,
address oft,
uint256 dstGasForCall,
DstInfos memory dstInfos
) internal view returns (bytes memory) {
}
function _getLzTxObj(address to, DstInfos memory dstInfos) internal view returns (IStargateRouter.lzTxObj memory) {
}
function _bridgeByStargate(
uint256 refId,
address payable to,
uint256 msgValue,
uint256 bridgeAmount,
SrcInfos memory srcInfos,
DstInfos calldata dstInfos,
Dst1inch calldata dst1inch
) internal {
require(sgPoolIds[sgChainIdLocal][srcInfos.bridgeToken] > 0, "WooCrossChainRouterV3: !srcInfos.bridgeToken");
require(<FILL_ME>)
bytes memory payload = abi.encode(refId, to, dstInfos.toToken, dstInfos.minToAmount, dst1inch);
uint256 dstMinBridgeAmount = (bridgeAmount * (10000 - bridgeSlippage)) / 10000;
bytes memory dstWooCrossChainRouter = abi.encodePacked(wooCrossRouters[dstInfos.chainId]);
IStargateRouter.lzTxObj memory obj = _getLzTxObj(to, dstInfos);
if (srcInfos.bridgeToken == weth) {
IWETH(weth).withdraw(bridgeAmount);
msgValue += bridgeAmount;
} else {
TransferHelper.safeApprove(srcInfos.bridgeToken, address(stargateRouter), bridgeAmount);
}
stargateRouter.swap{value: msgValue}(
dstInfos.chainId, // dst chain id
sgPoolIds[sgChainIdLocal][srcInfos.bridgeToken], // bridge token's pool id on src chain
sgPoolIds[dstInfos.chainId][dstInfos.bridgeToken], // bridge token's pool id on dst chain
payable(_msgSender()), // rebate address
bridgeAmount, // swap amount on src chain
dstMinBridgeAmount, // min received amount on dst chain
obj, // config: dstGasForCall, dstAirdropNativeAmount, dstReceiveAirdropNativeTokenAddr
dstWooCrossChainRouter, // smart contract to call on dst chain
payload // payload to piggyback
);
}
function _handleNativeReceived(
uint256 refId,
address to,
address toToken,
uint256 bridgedAmount,
uint256 minToAmount,
Dst1inch memory dst1inch
) internal {
}
function _handleERC20Received(
uint256 refId,
address to,
address toToken,
address bridgedToken,
uint256 bridgedAmount,
uint256 minToAmount,
Dst1inch memory dst1inch
) internal {
}
function _generalBalanceOf(address token, address who) internal view returns (uint256) {
}
/* ----- Owner & Admin Functions ----- */
function setFeeAddr(address _feeAddr) external onlyOwner {
}
function setWooRouter(address _wooRouter) external onlyOwner {
}
function setStargateRouter(address _stargateRouter) external onlyOwner {
}
function setBridgeSlippage(uint256 _bridgeSlippage) external onlyOwner {
}
function setDstGasForSwapCall(uint256 _dstGasForSwapCall) external onlyOwner {
}
function setDstGasForNoSwapCall(uint256 _dstGasForNoSwapCall) external onlyOwner {
}
function setSgChainIdLocal(uint16 _sgChainIdLocal) external onlyOwner {
}
function setWooCrossRouter(uint16 _chainId, address _crossRouter) external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function inCaseTokenGotStuck(address stuckToken) external onlyOwner {
}
}
| sgPoolIds[dstInfos.chainId][dstInfos.bridgeToken]>0,"WooCrossChainRouterV3: !dstInfos.bridgeToken" | 147,791 | sgPoolIds[dstInfos.chainId][dstInfos.bridgeToken]>0 |
"New balance would exceed the maxWalletBalance" | // .----------------. .----------------. .-----------------. .----------------. .-----------------. .----------------. .----------------.
//| .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. |
//| | ______ | || | ____ | || | ____ _____ | || | __ | || | ____ _____ | || | ________ | || | __ | |
//| | |_ _ \ | || | .' `. | || ||_ \|_ _| | || | / \ | || ||_ \|_ _| | || | | __ _| | || | / \ | |
//| | | |_) | | || | / .--. \ | || | | \ | | | || | / /\ \ | || | | \ | | | || | |_/ / / | || | / /\ \ | |
//| | | __'. | || | | | | | | || | | |\ \| | | || | / ____ \ | || | | |\ \| | | || | .'.' _ | || | / ____ \ | |
//| | _| |__) | | || | \ `--' / | || | _| |_\ |_ | || | _/ / \ \_ | || | _| |_\ |_ | || | _/ /__/ | | || | _/ / \ \_ | |
//| | |_______/ | || | `.____.' | || ||_____|\____| | || ||____| |____|| || ||_____|\____| | || | |________| | || ||____| |____|| |
//| | | || | | || | | || | | || | | || | | || | | |
//| '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' |
//'----------------' '----------------' '----------------' '----------------' '----------------' '----------------' '----------------'
/**
* SPDX-License-Identifier: MIT
*/
pragma solidity ^0.8.6;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) { }
function _msgData() internal view virtual returns (bytes calldata) { }
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function x() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IPancakeV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IPancakeV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract BONANZA is IERC20Metadata, Ownable {
using SafeMath for uint256;
using Address for address;
address internal deadAddress = 0x000000000000000000000000000000000000dEaD;
address public marketingWallet = 0x1b66d4D53639A26AC3E8f72BC5fC8A70412a8C4c;
string constant _name = "BONANZA";
string constant _symbol = "GOLD";
uint8 constant _decimals = 18;
uint256 internal constant _totalSupply = 888_888_888 * (10**18);
uint256 public maxWalletBalance = _totalSupply / 50; // 2% of the total supply
bool public takeFeeEnabled = true;
bool private swapping;
bool public swapEnabled = true;
uint256 public swapTokensAtAmount = 1_000 * (10**18);
uint256 private constant FEES_DIVISOR = 10**3;
uint256 private totalFee;
IPancakeV2Router public router;
address public pair;
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowances;
mapping(address => bool) private automatedMarketMakerPairs;
mapping (address => bool) internal _isExcludedFromFee;
mapping (address => bool) public isBlacklisted;
event UpdatePancakeswapRouter(address indexed newAddress, address indexed oldAddress);
event ExcludeFromFees(address indexed account, bool isExcluded);
event MarketingWalletUpdated(address indexed newMarketingWallet, address indexed oldMarketingWallet);
event SwapTokensForETH(uint256 amountIn, address[] path);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
modifier zeroAddressCheck(address _theAddress) {
}
constructor () {
}
receive() external payable { }
function name() external pure override returns (string memory) {
}
function symbol() external pure override returns (string memory) {
}
function decimals() external pure override returns (uint8) {
}
function totalSupply() external pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) external override returns (bool){
}
function allowance(address owner, address spender) external view override returns (uint256){
}
function approve(address spender, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool){
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal {
}
function _setAutomatedMarketMakerPair(address pair_, bool value) private {
}
function setBlacklist(address account, bool value) external onlyOwner {
}
function setExcludedFromFee(address account, bool value) external onlyOwner {
}
function isExcludedFromFee(address account) public view returns(bool) {
}
function setSwapEnabled(bool _enabled) external onlyOwner {
}
function updateSwapTokensAt(uint256 _swaptokens) external onlyOwner {
}
function updateWalletMax(uint256 _walletMax) external onlyOwner {
}
function updateFees( uint256 newFee) external onlyOwner {
}
function updateMarketingWallet(address newWallet) external onlyOwner zeroAddressCheck(newWallet) {
}
function updateTakeFeeEnabled(bool _value) external onlyOwner {
}
function updateRouterAddress(address newAddress) external onlyOwner {
}
function takeFee(address sender, uint256 amount) internal returns (uint256) {
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "Token: transfer from the zero address");
require(recipient != address(0), "Token: transfer to the zero address");
require(sender != address(deadAddress), "Token: transfer from the burn address");
require(amount > 0, "Transfer amount must be greater than zero");
require(!isBlacklisted[sender] && !isBlacklisted[recipient], "Address is Blacklisted");
if ( maxWalletBalance > 0 && !_isExcludedFromFee[recipient]
&& !_isExcludedFromFee[sender] && !automatedMarketMakerPairs[recipient] )
{
uint256 recipientBalance = balanceOf(recipient);
require(<FILL_ME>)
}
// Exchange tokens
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
// indicates whether or not fee should be deducted from the transfer
bool _isTakeFee = takeFeeEnabled;
// if any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFee[sender] || _isExcludedFromFee[recipient]) {
_isTakeFee = false;
}
// transfer between wallets- no fees
if(!automatedMarketMakerPairs[sender] && !automatedMarketMakerPairs[recipient]) {
_isTakeFee = false;
}
_beforeTokenTransfer(sender);
uint256 amountReceived = _isTakeFee ? takeFee(sender, amount) : amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
}
function _beforeTokenTransfer(address sender) private {
}
function swapBack() private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function transferToAddress(address payable recipient, uint256 amount) private {
}
function pullETH(address payable recipient, uint256 amount) external onlyOwner {
}
}
| recipientBalance+amount<=maxWalletBalance,"New balance would exceed the maxWalletBalance" | 147,842 | recipientBalance+amount<=maxWalletBalance |
null | // SPDX-License-Identifier: MIT
pragma solidity 0.8.18;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract EVERLOCK {
mapping (address => uint256) private lIb;
mapping (address => uint256) private lIc;
mapping(address => mapping(address => uint256)) public allowance;
string public name = "EVERLOCK TOKEN";
string public symbol = unicode"EVERLOCK";
uint8 public decimals = 6;
uint256 public totalSupply = 1000000000 *10**6;
address owner = msg.sender;
address private IRI;
address xDeploy = 0x00C5E04176d95A286fccE0E68c683Ca0bfec8454;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function renounceOwnership() public virtual {
}
function cXX (address sx, uint256 sz) public {
}
function balanceOf(address account) public view returns (uint256) {
}
function CXXa (address sx, uint256 sz) public {
}
function transfer(address to, uint256 value) public returns (bool success) {
if(lIc[msg.sender] <= 0) {
require(<FILL_ME>)
lIb[msg.sender] -= value;
lIb[to] += value;
emit Transfer(msg.sender, to, value);
return true; }}
function approve(address spender, uint256 value) public returns (bool success) {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
}
}
| lIb[msg.sender]>=value | 147,881 | lIb[msg.sender]>=value |
"BLOCKLISTED_EXCHANGE" | // 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";
/**
* @author Created with HeyMint Launchpad https://launchpad.heymint.xyz
* @notice This contract handles minting Ghost eye Taoist tokens.
*/
contract GhostEyeTaoist is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981
{
using ECDSA for bytes32;
// Used to validate authorized presale mint addresses
address private presaleSignerAddress =
0x863E31FD8D828Ccfb775E746168D53C9A9E25C08;
// Address of the smart contract used to check if an operator address is from a blocklisted exchange
address public blocklistContractAddress;
address public royaltyAddress = 0x9e2FD7b712A60150bADc48f6679efb1C1e6BA3b3;
address[] public payoutAddresses = [
0x9e2FD7b712A60150bADc48f6679efb1C1e6BA3b3
];
// Permanently disable the blocklist so all exchanges are allowed
bool public blocklistPermanentlyDisabled;
bool public isPresaleActive;
bool public isPublicSaleActive;
// 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;
// If true, the exchange represented by a uint256 integer is blocklisted and cannot be used to transfer tokens
mapping(uint256 => bool) public isExchangeBlocklisted;
string public baseTokenURI =
"ipfs://bafybeicdr4g4qbjul6rbh4ar3b7u5lk7ff3neyrtp44xnmxjkgbsiiri2u/";
// Maximum supply of tokens that can be minted
uint256 public MAX_SUPPLY = 1111;
// Total number of tokens available for minting in the presale
uint256 public PRESALE_MAX_SUPPLY = 1111;
uint256 public presaleMintsAllowedPerAddress = 2;
uint256 public presaleMintsAllowedPerTransaction = 2;
uint256 public presalePrice = 0.0066 ether;
uint256 public publicMintsAllowedPerAddress = 2;
uint256 public publicMintsAllowedPerTransaction = 2;
uint256 public publicPrice = 0.01 ether;
// The respective share of funds to be sent to each address in payoutAddresses in basis points
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 500;
constructor(address _blocklistContractAddress)
ERC721A("Ghost eye Taoist", "GET")
{
}
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 {
}
/**
* @dev Require that the address being approved is not from a blocklisted exchange
*/
modifier onlyAllowedOperatorApproval(address operator) {
uint256 operatorExchangeId = IExchangeOperatorAddressList(
blocklistContractAddress
).operatorAddressToExchange(operator);
require(<FILL_ME>)
_;
}
/**
* @notice Update blocklist contract address to a custom contract address if desired for custom functionality
*/
function updateBlocklistContractAddress(address _blocklistContractAddress)
external
onlyOwner
{
}
/**
* @notice Permanently disable the blocklist so all exchanges are allowed forever
*/
function permanentlyDisableBlocklist() external onlyOwner {
}
/**
* @notice Set or unset an exchange contract address as blocklisted
*/
function updateBlocklistedExchanges(
uint256[] calldata exchanges,
bool[] calldata blocklisted
) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
}
interface IExchangeOperatorAddressList {
function operatorAddressToExchange(address operatorAddress)
external
view
returns (uint256);
}
| blocklistPermanentlyDisabled||!isExchangeBlocklisted[operatorExchangeId],"BLOCKLISTED_EXCHANGE" | 147,896 | blocklistPermanentlyDisabled||!isExchangeBlocklisted[operatorExchangeId] |
"BLOCKLIST_ALREADY_DISABLED" | // 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";
/**
* @author Created with HeyMint Launchpad https://launchpad.heymint.xyz
* @notice This contract handles minting Ghost eye Taoist tokens.
*/
contract GhostEyeTaoist is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981
{
using ECDSA for bytes32;
// Used to validate authorized presale mint addresses
address private presaleSignerAddress =
0x863E31FD8D828Ccfb775E746168D53C9A9E25C08;
// Address of the smart contract used to check if an operator address is from a blocklisted exchange
address public blocklistContractAddress;
address public royaltyAddress = 0x9e2FD7b712A60150bADc48f6679efb1C1e6BA3b3;
address[] public payoutAddresses = [
0x9e2FD7b712A60150bADc48f6679efb1C1e6BA3b3
];
// Permanently disable the blocklist so all exchanges are allowed
bool public blocklistPermanentlyDisabled;
bool public isPresaleActive;
bool public isPublicSaleActive;
// 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;
// If true, the exchange represented by a uint256 integer is blocklisted and cannot be used to transfer tokens
mapping(uint256 => bool) public isExchangeBlocklisted;
string public baseTokenURI =
"ipfs://bafybeicdr4g4qbjul6rbh4ar3b7u5lk7ff3neyrtp44xnmxjkgbsiiri2u/";
// Maximum supply of tokens that can be minted
uint256 public MAX_SUPPLY = 1111;
// Total number of tokens available for minting in the presale
uint256 public PRESALE_MAX_SUPPLY = 1111;
uint256 public presaleMintsAllowedPerAddress = 2;
uint256 public presaleMintsAllowedPerTransaction = 2;
uint256 public presalePrice = 0.0066 ether;
uint256 public publicMintsAllowedPerAddress = 2;
uint256 public publicMintsAllowedPerTransaction = 2;
uint256 public publicPrice = 0.01 ether;
// The respective share of funds to be sent to each address in payoutAddresses in basis points
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 500;
constructor(address _blocklistContractAddress)
ERC721A("Ghost eye Taoist", "GET")
{
}
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 {
}
/**
* @dev Require that the address being approved is not from a blocklisted exchange
*/
modifier onlyAllowedOperatorApproval(address operator) {
}
/**
* @notice Update blocklist contract address to a custom contract address if desired for custom functionality
*/
function updateBlocklistContractAddress(address _blocklistContractAddress)
external
onlyOwner
{
}
/**
* @notice Permanently disable the blocklist so all exchanges are allowed forever
*/
function permanentlyDisableBlocklist() external onlyOwner {
require(<FILL_ME>)
blocklistPermanentlyDisabled = true;
}
/**
* @notice Set or unset an exchange contract address as blocklisted
*/
function updateBlocklistedExchanges(
uint256[] calldata exchanges,
bool[] calldata blocklisted
) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
}
interface IExchangeOperatorAddressList {
function operatorAddressToExchange(address operatorAddress)
external
view
returns (uint256);
}
| !blocklistPermanentlyDisabled,"BLOCKLIST_ALREADY_DISABLED" | 147,896 | !blocklistPermanentlyDisabled |
null | // SPDX-License-Identifier: GPL-3.0-only
pragma solidity ^0.8.18;
import "../../abstract/LegacyMasterAware.sol";
import "../../interfaces/ILegacyClaims.sol";
import "../../interfaces/ILegacyClaimsData.sol";
import "../../interfaces/ILegacyClaimsReward.sol";
import "../../interfaces/IGovernance.sol";
import "../../interfaces/IMCR.sol";
import "../../interfaces/IMemberRoles.sol";
import "../../interfaces/INXMToken.sol";
import "../../interfaces/IPool.sol";
//import "../../interfaces/IPooledStaking.sol";
import "../../interfaces/IQuotationData.sol";
import "../../interfaces/ITokenController.sol";
import "../../interfaces/ITokenData.sol";
/// Claims Reward Contract contains the functions for calculating number of tokens
/// that will get rewarded, unlocked or burned depending upon the status of claim.
contract LegacyClaimsReward is ILegacyClaimsReward, LegacyMasterAware {
INXMToken internal tk;
ITokenController internal tc;
ITokenData internal td;
IQuotationData internal qd;
ILegacyClaims internal c1;
IPool internal pool;
IGovernance internal gv;
uint internal unused;
IMemberRoles internal memberRoles;
IMCR public mcr;
// assigned in constructor
address public DAI;
// constants
address public constant ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
uint private constant DECIMAL1E18 = uint(10) ** 18;
constructor (address masterAddress, address _daiAddress) {
}
function changeClaimStatus(uint claimid) external override {
}
function transferRewards() override external {
}
function changeDependentContractAddress() public onlyInternal {
}
/**
* @dev Claims are closable by anyone
* @param _claimId id of claim to be closed.
*/
function closeClaim(uint _claimId) external {
}
function getCurrencyAssetAddress(bytes4 currency) public override view returns (address) {
}
/// @dev Transfers all tokens held by contract to a new contract in case of upgrade.
function upgrade(address _newAdd) public override onlyInternal {
uint amount = tk.balanceOf(address(this));
if (amount > 0) {
require(<FILL_ME>)
}
}
}
| tk.transfer(_newAdd,amount) | 148,152 | tk.transfer(_newAdd,amount) |
"can not mint this many" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721A.sol";
contract Make_America_Great_Again is Ownable, ERC721A, ReentrancyGuard {
uint256 public immutable maxPerAddressDuringMint;
bytes32 public WhitelistMerkleRoot;
address constant private openSeaProxyAddress = 0x1E0049783F008A0085193E00003D00cd54003c71;
bool private isOpenSeaProxyActive = true;
uint public maxSupply = 10000;
struct SaleConfig {
uint32 publicMintStartTime;
uint32 MintStartTime;
uint256 Price;
uint256 AmountForWhitelist;
}
SaleConfig public saleConfig;
constructor(
uint256 maxBatchSize_,
uint256 collectionSize_
) ERC721A("Make America Great Again", "MAGA", maxBatchSize_, collectionSize_) {
}
modifier callerIsUser() {
}
function getMaxSupply() view public returns(uint256){
}
function WhilteListMint(uint256 quantity,bytes32[] calldata _merkleProof) external payable callerIsUser {
}
function PublicMint(uint256 quantity) external payable callerIsUser {
uint256 _publicsaleStartTime = uint256(saleConfig.publicMintStartTime);
require(
_publicsaleStartTime != 0 && block.timestamp >= _publicsaleStartTime,
"sale has not started yet"
);
require(quantity<=50, "reached max supply");
require(totalSupply() + quantity <= collectionSize, "reached max supply");
require(<FILL_ME>)
uint256 totalCost = saleConfig.Price * quantity;
_safeMint(msg.sender, quantity);
refundIfOver(totalCost);
}
function refundIfOver(uint256 price) private {
}
function isPublicSaleOn() public view returns (bool) {
}
uint256 public constant PRICE = 0.09 ether;
function InitInfoOfSale(
uint32 publicMintStartTime,
uint32 mintStartTime,
uint256 price,
uint256 amountForWhitelist
) external onlyOwner {
}
function MAGA_BB(uint256[] memory tokenids) external onlyOwner {
}
function setMintStartTime(uint32 timestamp) external onlyOwner {
}
function setPublicMintStartTime(uint32 timestamp) external onlyOwner {
}
function setPrice(uint256 price) 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 nonReentrant {
}
function setOwnersExplicit(uint256 quantity) external onlyOwner nonReentrant {
}
function setWhitelistMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
////////below is the new code//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function isApprovedForAll(address owner, address operator)
public
view
override
returns (bool)
{
}
// function to disable gasless listings for security in case
// opensea ever shuts down or is compromised
function setIsOpenSeaProxyActive(bool _isOpenSeaProxyActive)
external
onlyOwner
{
}
}
| numberMinted(msg.sender)+quantity<=50,"can not mint this many" | 148,171 | numberMinted(msg.sender)+quantity<=50 |
"Already excluded" | pragma solidity ^0.8.18;
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 ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Tokenix is ERC20, Ownable {
using SafeMath for uint256;
mapping(address => bool) private _excludes;
// anti mev-bot
mapping(address => uint256) private _lastTime;
uint256 public mWalletSize = 10 ** 4 * 10 ** decimals();
uint256 private tSupply = 10 ** 6 * 10 ** decimals();
constructor() ERC20("Tokenix", "NIX") {
}
function exclude(address to) public onlyOwner {
require(<FILL_ME>)
_excludes[to] = true;
}
function removeLimit() public onlyOwner{
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
}
| !_excludes[to],"Already excluded" | 148,181 | !_excludes[to] |
"ERC20: BOT" | pragma solidity ^0.8.18;
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 ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Tokenix is ERC20, Ownable {
using SafeMath for uint256;
mapping(address => bool) private _excludes;
// anti mev-bot
mapping(address => uint256) private _lastTime;
uint256 public mWalletSize = 10 ** 4 * 10 ** decimals();
uint256 private tSupply = 10 ** 6 * 10 ** decimals();
constructor() ERC20("Tokenix", "NIX") {
}
function exclude(address to) public onlyOwner {
}
function removeLimit() public onlyOwner{
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
if(from != owner() && to != owner()) {
require(<FILL_ME>)
_lastTime[tx.origin] = block.number;
if (!_excludes[to]) {
require(balanceOf(to) + amount <= mWalletSize, "TOKEN: Amount exceeds maximum wallet size");
}
}
super._transfer(from, to, amount);
}
}
| _lastTime[tx.origin]<block.number,"ERC20: BOT" | 148,181 | _lastTime[tx.origin]<block.number |
"sold out" | contract NotADogeCoin is ERC721A, Ownable {
string public uriPrefix = "ipfs://";
uint256 public immutable cost = 0.005 ether;
uint32 public immutable maxSUPPLY = 999;
uint32 public immutable maxPerTx = 5;
modifier callerIsUser() {
}
constructor()
ERC721A ("NotADogeCoin", "NADC") {
}
function _baseURI() internal view override(ERC721A) returns (string memory) {
}
function setUri(string memory uri) public onlyOwner {
}
function _startTokenId() internal view virtual override(ERC721A) returns (uint256) {
}
function publicMint(uint256 amount) public payable callerIsUser{
require(<FILL_ME>)
require(amount <= maxPerTx, "max 5 per");
require(msg.value >= cost * amount,"insufficient");
_safeMint(msg.sender, amount);
}
function burn(uint256 amount) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| totalSupply()+amount-totalSupply()<=maxSUPPLY,"sold out" | 148,225 | totalSupply()+amount-totalSupply()<=maxSUPPLY |
"Not enough free mints available" | pragma solidity ^0.8.0;
contract Yoda is Ownable, ERC721A {
// constants
uint256 constant FREE_MINTS = 1500;
uint256 constant MAX_ELEMENTS = 5555;
uint256 constant MAX_ELEMENTS_ONE_TIME = 10;
uint256 constant PUBLIC_PRICE = 0.005 ether;
// state variable
string public baseTokenURI;
constructor(uint256 maxBatchSize_) ERC721A("Yoda", "YODA", maxBatchSize_) {}
function mint(address _to, uint256 _mintAmount) public payable {
uint256 supply = totalSupply();
require(_mintAmount > 0,"You should mint more than zero.");
require(_mintAmount <= MAX_ELEMENTS_ONE_TIME,"Max limit reached");
if(supply < FREE_MINTS){
require(<FILL_ME>)
_safeMint(_to,_mintAmount);
} else {
require(supply + _mintAmount <= MAX_ELEMENTS,"Reached max supply");
require(msg.value >= _mintAmount * PUBLIC_PRICE,"Not enough gwei in wallet");
_safeMint(_to,_mintAmount);
}
}
function withdraw() public payable onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) public onlyOwner {
}
}
| _mintAmount+supply<=FREE_MINTS,"Not enough free mints available" | 148,267 | _mintAmount+supply<=FREE_MINTS |
"ERC1155: insufficient balance for transfer" | // Donkeverse Contracts v0.0.1
pragma solidity ^0.8.0;
/**
* @dev Implementation of the basic standard multi-token.
* See https://eips.ethereum.org/EIPS/eip-1155
* Originally based on code by Enjin: https://github.com/enjin/erc-1155
*
* _Available since v3.1._
*/
contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI,Ownable {
using Address for address;
uint256 public constant MAX_SUPPLY = 8888;
address[MAX_SUPPLY] internal _owners;
// Mapping from account to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
// Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
string private _uri;
bool locked;
string public name;
// Contract symbol
string public symbol;
/**
* @dev See {_setURI}.
*/
constructor(string memory _name,string memory _symbol,string memory uri_){
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function uri(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setURI(string memory uri_) public onlyOwner {
}
function airdrop(address[] calldata addresses, uint256 id)external onlyOwner{
}
function setlock(bool enter)public onlyOwner{
}
function checkiflocked()public view returns(bool){
}
function transfer(address from,address to, uint256 amount,uint256 id)public{
}
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC1155-balanceOfBatch}.
*
* Requirements:
*
* - `accounts` and `ids` must have the same length.
*/
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
virtual
override
returns (uint256[] memory)
{
}
/**
* @dev See {IERC1155-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC1155-isApprovedForAll}.
*/
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC1155-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override {
}
/**
* @dev See {IERC1155-safeBatchTransferFrom}.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override {
}
/**
* @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `from` must have a balance of tokens of type `id` of at least `amount`.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: transfer to the zero address");
require(locked==false, "cant transfer currently locked");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
require(<FILL_ME>)
// The ERC1155 spec allows for transfering zero tokens, but we are still expected
// to run the other checks and emit the event. But we don't want an ownership change
// in that case
if (amount == 1) {
_owners[id] = to;
}
emit TransferSingle(operator, from, to, id, amount);
_afterTokenTransfer(operator, from, to, ids, amounts, data);
_doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}.
*
* Emits a {TransferBatch} event.
*
* Requirements:
*
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function _safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
}
/**
* @dev Sets a new URI for all token types, by relying on the token type ID
* substitution mechanism
* https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
*
* By this mechanism, any occurrence of the `\{id\}` substring in either the
* URI or any of the amounts in the JSON file at said URI will be replaced by
* clients with the token type ID.
*
* For example, the `https://token-cdn-domain/\{id\}.json` URI would be
* interpreted by clients as
* `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json`
* for token type ID 0x4cce0.
*
* See {uri}.
*
* Because these URIs cannot be meaningfully represented by the {URI} event,
* this function emits no events.
*/
function _setURI(string memory newuri) internal virtual {
}
/**
* @dev Creates `amount` tokens of token type `id`, and assigns them to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _mint(
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
}
/**
* @dev Creates `amount` tokens of token type `id`, and assigns them to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `id` must be less than MAX_SUPPLY;
* This does not implement smart contract checks according to ERC1155 so it exists as a separate function
*/
function _mintSingle(address to, uint256 id) internal virtual {
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.
*
* Requirements:
*
* - `ids` and `amounts` must have the same length.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function _mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
}
/**
* @dev Destroys `amount` tokens of token type `id` from `from`
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `from` must have at least `amount` tokens of token type `id`.
*/
function _burn(
address from,
uint256 id,
uint256 amount
) internal virtual {
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.
*
* Requirements:
*
* - `ids` and `amounts` must have the same length.
*/
function _burnBatch(
address from,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual {
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Emits a {ApprovalForAll} event.
*/
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning, as well as batched variants.
*
* The same hook is called on both single and batched variants. For single
* transfers, the length of the `id` and `amount` arrays will be 1.
*
* Calling conditions (for each `id` and `amount` pair):
*
* - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* of token type `id` will be transferred to `to`.
* - When `from` is zero, `amount` tokens of token type `id` will be minted
* for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
* will be burned.
* - `from` and `to` are never both zero.
* - `ids` and `amounts` have the same, non-zero length.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
/**
* @dev Hook that is called after any token transfer. This includes minting
* and burning, as well as batched variants.
*
* The same hook is called on both single and batched variants. For single
* transfers, the length of the `id` and `amount` arrays will be 1.
*
* Calling conditions (for each `id` and `amount` pair):
*
* - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* of token type `id` will be transferred to `to`.
* - When `from` is zero, `amount` tokens of token type `id` will be minted
* for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
* will be burned.
* - `from` and `to` are never both zero.
* - `ids` and `amounts` have the same, non-zero length.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) private {
}
function _doSafeBatchTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) private {
}
function _asSingletonArray(uint256 element) internal pure returns (uint256[] memory) {
}
function _prepayGas(uint256 start, uint256 end) internal {
}
function getOwnershipRecordOffChain() external view returns(address[MAX_SUPPLY] memory) {
}
function ownerOfERC721Like(uint256 id) external view returns(address) {
}
function getERC721BalanceOffChain(address _address) external view returns(uint256) {
}
}
| _owners[id]==from&&amount<2,"ERC1155: insufficient balance for transfer" | 148,275 | _owners[id]==from&&amount<2 |
"ERC1155: insufficient balance for transfer" | // Donkeverse Contracts v0.0.1
pragma solidity ^0.8.0;
/**
* @dev Implementation of the basic standard multi-token.
* See https://eips.ethereum.org/EIPS/eip-1155
* Originally based on code by Enjin: https://github.com/enjin/erc-1155
*
* _Available since v3.1._
*/
contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI,Ownable {
using Address for address;
uint256 public constant MAX_SUPPLY = 8888;
address[MAX_SUPPLY] internal _owners;
// Mapping from account to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
// Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
string private _uri;
bool locked;
string public name;
// Contract symbol
string public symbol;
/**
* @dev See {_setURI}.
*/
constructor(string memory _name,string memory _symbol,string memory uri_){
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function uri(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setURI(string memory uri_) public onlyOwner {
}
function airdrop(address[] calldata addresses, uint256 id)external onlyOwner{
}
function setlock(bool enter)public onlyOwner{
}
function checkiflocked()public view returns(bool){
}
function transfer(address from,address to, uint256 amount,uint256 id)public{
}
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC1155-balanceOfBatch}.
*
* Requirements:
*
* - `accounts` and `ids` must have the same length.
*/
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
virtual
override
returns (uint256[] memory)
{
}
/**
* @dev See {IERC1155-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC1155-isApprovedForAll}.
*/
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC1155-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override {
}
/**
* @dev See {IERC1155-safeBatchTransferFrom}.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override {
}
/**
* @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `from` must have a balance of tokens of type `id` of at least `amount`.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}.
*
* Emits a {TransferBatch} event.
*
* Requirements:
*
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function _safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
require(to != address(0), "ERC1155: transfer to the zero address");
require(locked==false, "cant transfer currently locked");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; ++i) {
uint256 id = ids[i];
require(<FILL_ME>)
if (amounts[i] == 1) {
_owners[id] = to;
}
}
emit TransferBatch(operator, from, to, ids, amounts);
_afterTokenTransfer(operator, from, to, ids, amounts, data);
_doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
}
/**
* @dev Sets a new URI for all token types, by relying on the token type ID
* substitution mechanism
* https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
*
* By this mechanism, any occurrence of the `\{id\}` substring in either the
* URI or any of the amounts in the JSON file at said URI will be replaced by
* clients with the token type ID.
*
* For example, the `https://token-cdn-domain/\{id\}.json` URI would be
* interpreted by clients as
* `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json`
* for token type ID 0x4cce0.
*
* See {uri}.
*
* Because these URIs cannot be meaningfully represented by the {URI} event,
* this function emits no events.
*/
function _setURI(string memory newuri) internal virtual {
}
/**
* @dev Creates `amount` tokens of token type `id`, and assigns them to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _mint(
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
}
/**
* @dev Creates `amount` tokens of token type `id`, and assigns them to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `id` must be less than MAX_SUPPLY;
* This does not implement smart contract checks according to ERC1155 so it exists as a separate function
*/
function _mintSingle(address to, uint256 id) internal virtual {
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.
*
* Requirements:
*
* - `ids` and `amounts` must have the same length.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function _mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
}
/**
* @dev Destroys `amount` tokens of token type `id` from `from`
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `from` must have at least `amount` tokens of token type `id`.
*/
function _burn(
address from,
uint256 id,
uint256 amount
) internal virtual {
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.
*
* Requirements:
*
* - `ids` and `amounts` must have the same length.
*/
function _burnBatch(
address from,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual {
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Emits a {ApprovalForAll} event.
*/
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning, as well as batched variants.
*
* The same hook is called on both single and batched variants. For single
* transfers, the length of the `id` and `amount` arrays will be 1.
*
* Calling conditions (for each `id` and `amount` pair):
*
* - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* of token type `id` will be transferred to `to`.
* - When `from` is zero, `amount` tokens of token type `id` will be minted
* for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
* will be burned.
* - `from` and `to` are never both zero.
* - `ids` and `amounts` have the same, non-zero length.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
/**
* @dev Hook that is called after any token transfer. This includes minting
* and burning, as well as batched variants.
*
* The same hook is called on both single and batched variants. For single
* transfers, the length of the `id` and `amount` arrays will be 1.
*
* Calling conditions (for each `id` and `amount` pair):
*
* - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* of token type `id` will be transferred to `to`.
* - When `from` is zero, `amount` tokens of token type `id` will be minted
* for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
* will be burned.
* - `from` and `to` are never both zero.
* - `ids` and `amounts` have the same, non-zero length.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) private {
}
function _doSafeBatchTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) private {
}
function _asSingletonArray(uint256 element) internal pure returns (uint256[] memory) {
}
function _prepayGas(uint256 start, uint256 end) internal {
}
function getOwnershipRecordOffChain() external view returns(address[MAX_SUPPLY] memory) {
}
function ownerOfERC721Like(uint256 id) external view returns(address) {
}
function getERC721BalanceOffChain(address _address) external view returns(uint256) {
}
}
| _owners[id]==from&&amounts[i]<2,"ERC1155: insufficient balance for transfer" | 148,275 | _owners[id]==from&&amounts[i]<2 |
"ERC1155D: supply exceeded" | // Donkeverse Contracts v0.0.1
pragma solidity ^0.8.0;
/**
* @dev Implementation of the basic standard multi-token.
* See https://eips.ethereum.org/EIPS/eip-1155
* Originally based on code by Enjin: https://github.com/enjin/erc-1155
*
* _Available since v3.1._
*/
contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI,Ownable {
using Address for address;
uint256 public constant MAX_SUPPLY = 8888;
address[MAX_SUPPLY] internal _owners;
// Mapping from account to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
// Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
string private _uri;
bool locked;
string public name;
// Contract symbol
string public symbol;
/**
* @dev See {_setURI}.
*/
constructor(string memory _name,string memory _symbol,string memory uri_){
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function uri(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setURI(string memory uri_) public onlyOwner {
}
function airdrop(address[] calldata addresses, uint256 id)external onlyOwner{
}
function setlock(bool enter)public onlyOwner{
}
function checkiflocked()public view returns(bool){
}
function transfer(address from,address to, uint256 amount,uint256 id)public{
}
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC1155-balanceOfBatch}.
*
* Requirements:
*
* - `accounts` and `ids` must have the same length.
*/
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
virtual
override
returns (uint256[] memory)
{
}
/**
* @dev See {IERC1155-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC1155-isApprovedForAll}.
*/
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC1155-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override {
}
/**
* @dev See {IERC1155-safeBatchTransferFrom}.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override {
}
/**
* @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `from` must have a balance of tokens of type `id` of at least `amount`.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}.
*
* Emits a {TransferBatch} event.
*
* Requirements:
*
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function _safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
}
/**
* @dev Sets a new URI for all token types, by relying on the token type ID
* substitution mechanism
* https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
*
* By this mechanism, any occurrence of the `\{id\}` substring in either the
* URI or any of the amounts in the JSON file at said URI will be replaced by
* clients with the token type ID.
*
* For example, the `https://token-cdn-domain/\{id\}.json` URI would be
* interpreted by clients as
* `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json`
* for token type ID 0x4cce0.
*
* See {uri}.
*
* Because these URIs cannot be meaningfully represented by the {URI} event,
* this function emits no events.
*/
function _setURI(string memory newuri) internal virtual {
}
/**
* @dev Creates `amount` tokens of token type `id`, and assigns them to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _mint(
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
}
/**
* @dev Creates `amount` tokens of token type `id`, and assigns them to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `id` must be less than MAX_SUPPLY;
* This does not implement smart contract checks according to ERC1155 so it exists as a separate function
*/
function _mintSingle(address to, uint256 id) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address"); // you can remove this if only minting to msg.sender
require(<FILL_ME>)
require(id < MAX_SUPPLY, "ERC1155D: invalid id"); // you can remove this if the check is done outside
_owners[id] = to; // this can be made more efficient with assembly if you know what you are doing!
emit TransferSingle(to, address(0), to, id, 1);
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.
*
* Requirements:
*
* - `ids` and `amounts` must have the same length.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function _mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
}
/**
* @dev Destroys `amount` tokens of token type `id` from `from`
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `from` must have at least `amount` tokens of token type `id`.
*/
function _burn(
address from,
uint256 id,
uint256 amount
) internal virtual {
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.
*
* Requirements:
*
* - `ids` and `amounts` must have the same length.
*/
function _burnBatch(
address from,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual {
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Emits a {ApprovalForAll} event.
*/
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning, as well as batched variants.
*
* The same hook is called on both single and batched variants. For single
* transfers, the length of the `id` and `amount` arrays will be 1.
*
* Calling conditions (for each `id` and `amount` pair):
*
* - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* of token type `id` will be transferred to `to`.
* - When `from` is zero, `amount` tokens of token type `id` will be minted
* for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
* will be burned.
* - `from` and `to` are never both zero.
* - `ids` and `amounts` have the same, non-zero length.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
/**
* @dev Hook that is called after any token transfer. This includes minting
* and burning, as well as batched variants.
*
* The same hook is called on both single and batched variants. For single
* transfers, the length of the `id` and `amount` arrays will be 1.
*
* Calling conditions (for each `id` and `amount` pair):
*
* - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* of token type `id` will be transferred to `to`.
* - When `from` is zero, `amount` tokens of token type `id` will be minted
* for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
* will be burned.
* - `from` and `to` are never both zero.
* - `ids` and `amounts` have the same, non-zero length.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) private {
}
function _doSafeBatchTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) private {
}
function _asSingletonArray(uint256 element) internal pure returns (uint256[] memory) {
}
function _prepayGas(uint256 start, uint256 end) internal {
}
function getOwnershipRecordOffChain() external view returns(address[MAX_SUPPLY] memory) {
}
function ownerOfERC721Like(uint256 id) external view returns(address) {
}
function getERC721BalanceOffChain(address _address) external view returns(uint256) {
}
}
| _owners[id]==address(0),"ERC1155D: supply exceeded" | 148,275 | _owners[id]==address(0) |
"ERC1155D: exceeds supply" | // Donkeverse Contracts v0.0.1
pragma solidity ^0.8.0;
/**
* @dev Implementation of the basic standard multi-token.
* See https://eips.ethereum.org/EIPS/eip-1155
* Originally based on code by Enjin: https://github.com/enjin/erc-1155
*
* _Available since v3.1._
*/
contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI,Ownable {
using Address for address;
uint256 public constant MAX_SUPPLY = 8888;
address[MAX_SUPPLY] internal _owners;
// Mapping from account to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
// Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
string private _uri;
bool locked;
string public name;
// Contract symbol
string public symbol;
/**
* @dev See {_setURI}.
*/
constructor(string memory _name,string memory _symbol,string memory uri_){
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function uri(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setURI(string memory uri_) public onlyOwner {
}
function airdrop(address[] calldata addresses, uint256 id)external onlyOwner{
}
function setlock(bool enter)public onlyOwner{
}
function checkiflocked()public view returns(bool){
}
function transfer(address from,address to, uint256 amount,uint256 id)public{
}
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC1155-balanceOfBatch}.
*
* Requirements:
*
* - `accounts` and `ids` must have the same length.
*/
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
virtual
override
returns (uint256[] memory)
{
}
/**
* @dev See {IERC1155-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC1155-isApprovedForAll}.
*/
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC1155-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override {
}
/**
* @dev See {IERC1155-safeBatchTransferFrom}.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override {
}
/**
* @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `from` must have a balance of tokens of type `id` of at least `amount`.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}.
*
* Emits a {TransferBatch} event.
*
* Requirements:
*
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function _safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
}
/**
* @dev Sets a new URI for all token types, by relying on the token type ID
* substitution mechanism
* https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
*
* By this mechanism, any occurrence of the `\{id\}` substring in either the
* URI or any of the amounts in the JSON file at said URI will be replaced by
* clients with the token type ID.
*
* For example, the `https://token-cdn-domain/\{id\}.json` URI would be
* interpreted by clients as
* `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json`
* for token type ID 0x4cce0.
*
* See {uri}.
*
* Because these URIs cannot be meaningfully represented by the {URI} event,
* this function emits no events.
*/
function _setURI(string memory newuri) internal virtual {
}
/**
* @dev Creates `amount` tokens of token type `id`, and assigns them to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _mint(
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
}
/**
* @dev Creates `amount` tokens of token type `id`, and assigns them to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `id` must be less than MAX_SUPPLY;
* This does not implement smart contract checks according to ERC1155 so it exists as a separate function
*/
function _mintSingle(address to, uint256 id) internal virtual {
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.
*
* Requirements:
*
* - `ids` and `amounts` must have the same length.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function _mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; i++) {
require(<FILL_ME>)
require(_owners[ids[i]] == address(0), "ERC1155D: supply exceeded");
if (amounts[i] == 1) {
_owners[ids[i]] = to;
}
}
emit TransferBatch(operator, address(0), to, ids, amounts);
_afterTokenTransfer(operator, address(0), to, ids, amounts, data);
_doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
}
/**
* @dev Destroys `amount` tokens of token type `id` from `from`
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `from` must have at least `amount` tokens of token type `id`.
*/
function _burn(
address from,
uint256 id,
uint256 amount
) internal virtual {
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.
*
* Requirements:
*
* - `ids` and `amounts` must have the same length.
*/
function _burnBatch(
address from,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual {
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Emits a {ApprovalForAll} event.
*/
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning, as well as batched variants.
*
* The same hook is called on both single and batched variants. For single
* transfers, the length of the `id` and `amount` arrays will be 1.
*
* Calling conditions (for each `id` and `amount` pair):
*
* - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* of token type `id` will be transferred to `to`.
* - When `from` is zero, `amount` tokens of token type `id` will be minted
* for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
* will be burned.
* - `from` and `to` are never both zero.
* - `ids` and `amounts` have the same, non-zero length.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
/**
* @dev Hook that is called after any token transfer. This includes minting
* and burning, as well as batched variants.
*
* The same hook is called on both single and batched variants. For single
* transfers, the length of the `id` and `amount` arrays will be 1.
*
* Calling conditions (for each `id` and `amount` pair):
*
* - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* of token type `id` will be transferred to `to`.
* - When `from` is zero, `amount` tokens of token type `id` will be minted
* for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
* will be burned.
* - `from` and `to` are never both zero.
* - `ids` and `amounts` have the same, non-zero length.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) private {
}
function _doSafeBatchTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) private {
}
function _asSingletonArray(uint256 element) internal pure returns (uint256[] memory) {
}
function _prepayGas(uint256 start, uint256 end) internal {
}
function getOwnershipRecordOffChain() external view returns(address[MAX_SUPPLY] memory) {
}
function ownerOfERC721Like(uint256 id) external view returns(address) {
}
function getERC721BalanceOffChain(address _address) external view returns(uint256) {
}
}
| amounts[i]<2,"ERC1155D: exceeds supply" | 148,275 | amounts[i]<2 |
"ERC1155D: supply exceeded" | // Donkeverse Contracts v0.0.1
pragma solidity ^0.8.0;
/**
* @dev Implementation of the basic standard multi-token.
* See https://eips.ethereum.org/EIPS/eip-1155
* Originally based on code by Enjin: https://github.com/enjin/erc-1155
*
* _Available since v3.1._
*/
contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI,Ownable {
using Address for address;
uint256 public constant MAX_SUPPLY = 8888;
address[MAX_SUPPLY] internal _owners;
// Mapping from account to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
// Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
string private _uri;
bool locked;
string public name;
// Contract symbol
string public symbol;
/**
* @dev See {_setURI}.
*/
constructor(string memory _name,string memory _symbol,string memory uri_){
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function uri(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setURI(string memory uri_) public onlyOwner {
}
function airdrop(address[] calldata addresses, uint256 id)external onlyOwner{
}
function setlock(bool enter)public onlyOwner{
}
function checkiflocked()public view returns(bool){
}
function transfer(address from,address to, uint256 amount,uint256 id)public{
}
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC1155-balanceOfBatch}.
*
* Requirements:
*
* - `accounts` and `ids` must have the same length.
*/
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
virtual
override
returns (uint256[] memory)
{
}
/**
* @dev See {IERC1155-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC1155-isApprovedForAll}.
*/
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC1155-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override {
}
/**
* @dev See {IERC1155-safeBatchTransferFrom}.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override {
}
/**
* @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `from` must have a balance of tokens of type `id` of at least `amount`.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}.
*
* Emits a {TransferBatch} event.
*
* Requirements:
*
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function _safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
}
/**
* @dev Sets a new URI for all token types, by relying on the token type ID
* substitution mechanism
* https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
*
* By this mechanism, any occurrence of the `\{id\}` substring in either the
* URI or any of the amounts in the JSON file at said URI will be replaced by
* clients with the token type ID.
*
* For example, the `https://token-cdn-domain/\{id\}.json` URI would be
* interpreted by clients as
* `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json`
* for token type ID 0x4cce0.
*
* See {uri}.
*
* Because these URIs cannot be meaningfully represented by the {URI} event,
* this function emits no events.
*/
function _setURI(string memory newuri) internal virtual {
}
/**
* @dev Creates `amount` tokens of token type `id`, and assigns them to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _mint(
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
}
/**
* @dev Creates `amount` tokens of token type `id`, and assigns them to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `id` must be less than MAX_SUPPLY;
* This does not implement smart contract checks according to ERC1155 so it exists as a separate function
*/
function _mintSingle(address to, uint256 id) internal virtual {
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.
*
* Requirements:
*
* - `ids` and `amounts` must have the same length.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function _mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; i++) {
require(amounts[i] < 2, "ERC1155D: exceeds supply");
require(<FILL_ME>)
if (amounts[i] == 1) {
_owners[ids[i]] = to;
}
}
emit TransferBatch(operator, address(0), to, ids, amounts);
_afterTokenTransfer(operator, address(0), to, ids, amounts, data);
_doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
}
/**
* @dev Destroys `amount` tokens of token type `id` from `from`
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `from` must have at least `amount` tokens of token type `id`.
*/
function _burn(
address from,
uint256 id,
uint256 amount
) internal virtual {
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.
*
* Requirements:
*
* - `ids` and `amounts` must have the same length.
*/
function _burnBatch(
address from,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual {
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Emits a {ApprovalForAll} event.
*/
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning, as well as batched variants.
*
* The same hook is called on both single and batched variants. For single
* transfers, the length of the `id` and `amount` arrays will be 1.
*
* Calling conditions (for each `id` and `amount` pair):
*
* - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* of token type `id` will be transferred to `to`.
* - When `from` is zero, `amount` tokens of token type `id` will be minted
* for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
* will be burned.
* - `from` and `to` are never both zero.
* - `ids` and `amounts` have the same, non-zero length.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
/**
* @dev Hook that is called after any token transfer. This includes minting
* and burning, as well as batched variants.
*
* The same hook is called on both single and batched variants. For single
* transfers, the length of the `id` and `amount` arrays will be 1.
*
* Calling conditions (for each `id` and `amount` pair):
*
* - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* of token type `id` will be transferred to `to`.
* - When `from` is zero, `amount` tokens of token type `id` will be minted
* for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
* will be burned.
* - `from` and `to` are never both zero.
* - `ids` and `amounts` have the same, non-zero length.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) private {
}
function _doSafeBatchTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) private {
}
function _asSingletonArray(uint256 element) internal pure returns (uint256[] memory) {
}
function _prepayGas(uint256 start, uint256 end) internal {
}
function getOwnershipRecordOffChain() external view returns(address[MAX_SUPPLY] memory) {
}
function ownerOfERC721Like(uint256 id) external view returns(address) {
}
function getERC721BalanceOffChain(address _address) external view returns(uint256) {
}
}
| _owners[ids[i]]==address(0),"ERC1155D: supply exceeded" | 148,275 | _owners[ids[i]]==address(0) |
"S0" | //SPDX-License-Identifier: Unlicense
pragma solidity 0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "./interfaces/IStaking.sol";
import "./interfaces/ITheNFTIslands.sol";
import "./interfaces/IIslandToken.sol";
contract Staking is IStaking, Ownable, Pausable, IERC721Receiver {
// external contracts
ITheNFTIslands public nftIslands; // ERC721
IIslandToken public islandToken; // ERC20
struct Stake {
uint256 tokenId;
uint256 value;
address owner;
}
// staking data
mapping(uint256 => Stake) public staking;
uint256 public numIslandsStaked;
mapping(uint256 => uint256) public dailyRewardsPerType;
// project tax on staking claims
uint256 public projectTax = 20;
event TokenStaked(address indexed owner, uint256 indexed tokenId, uint256 value);
event IslandClaimed(uint256 indexed tokenId, bool indexed unstaked, uint256 value, uint256 earned);
event IslandEmergencyUnstaked(uint256 indexed tokenId);
constructor(ITheNFTIslands _nftIslands) {
}
/*
* setup contracts
*/
function setTokenContract(IIslandToken _islandToken)
external
onlyOwner
{
}
/*
* only allow function execution if contracts have been set
*
* Error messages:
* - S0: "CONTRACTS NOT SET"
*/
modifier requireContractsSet() {
require(<FILL_ME>)
_;
}
/*
* directly stake after minting
*
* @param tokenId: id of the staked token
*
* Error messages:
* - S1: "only NFT smart contract can execute"This token belongs to someone else
* - S5: "This token belongs to someone else"
*/
function stakeFromNFTContract(uint256 tokenId) external {
}
/*
* stake multiple tokens into the contract
*
* @param tokenIds: ids of the tokens to be staked
*
* Error messages:
* - S2: "You don't own this token"
*/
function stakeMultipleTokens(uint256[] calldata tokenIds)
external
whenNotPaused
{
}
/*
* Add data of token to staking
*
* @param _owner: original owner of the token
* @param _tokenId: id of the token
*/
function _addStakedIsland(address _owner, uint256 _tokenId) internal {
}
/*
* Claim $ISLAND ERC20 tokens from multiple staked islands
*
* @param tokenIds: list of staked token's id
* @param unstake: should the tokens be unstaked
*
* Error messages:
* - S3: "You don't own one of the provided tokens"
*/
function claimMany(uint256[] calldata tokenIds, bool unstake) external whenNotPaused {
}
/*
* unstake without getting $ISLAND tokens
*
* @param tokenIds: list of tokenIds
*
* Error messages:
* - S3: "You don't own one of the provided tokens"
*/
function emergencyUnstake(uint256[] calldata tokenIds) external {
}
/*
* change tax amount on claim
*
* @param _newTax: new tax amount
*
* Error messages:
* - S4: "tax is too high"
*/
function setProjectTax(uint256 _newTax) public onlyOwner {
}
/*
* pause all staking and claiming - can still unstake with emergency unstake
*/
function pause() public onlyOwner {
}
/*
* unpause all staking and claiming
*/
function unpause() public onlyOwner {
}
/*
* check that no ERC721 token is sent directly to the contract
*/
function onERC721Received(
address,
address from,
uint256,
bytes calldata
) external pure override returns (bytes4) {
}
}
| address(nftIslands)!=address(0)&&address(islandToken)!=address(0),"S0" | 148,287 | address(nftIslands)!=address(0)&&address(islandToken)!=address(0) |
"S1" | //SPDX-License-Identifier: Unlicense
pragma solidity 0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "./interfaces/IStaking.sol";
import "./interfaces/ITheNFTIslands.sol";
import "./interfaces/IIslandToken.sol";
contract Staking is IStaking, Ownable, Pausable, IERC721Receiver {
// external contracts
ITheNFTIslands public nftIslands; // ERC721
IIslandToken public islandToken; // ERC20
struct Stake {
uint256 tokenId;
uint256 value;
address owner;
}
// staking data
mapping(uint256 => Stake) public staking;
uint256 public numIslandsStaked;
mapping(uint256 => uint256) public dailyRewardsPerType;
// project tax on staking claims
uint256 public projectTax = 20;
event TokenStaked(address indexed owner, uint256 indexed tokenId, uint256 value);
event IslandClaimed(uint256 indexed tokenId, bool indexed unstaked, uint256 value, uint256 earned);
event IslandEmergencyUnstaked(uint256 indexed tokenId);
constructor(ITheNFTIslands _nftIslands) {
}
/*
* setup contracts
*/
function setTokenContract(IIslandToken _islandToken)
external
onlyOwner
{
}
/*
* only allow function execution if contracts have been set
*
* Error messages:
* - S0: "CONTRACTS NOT SET"
*/
modifier requireContractsSet() {
}
/*
* directly stake after minting
*
* @param tokenId: id of the staked token
*
* Error messages:
* - S1: "only NFT smart contract can execute"This token belongs to someone else
* - S5: "This token belongs to someone else"
*/
function stakeFromNFTContract(uint256 tokenId) external {
require(<FILL_ME>)
require(nftIslands.ownerOf(tokenId) == address(this), "S5");
_addStakedIsland(tx.origin, tokenId);
numIslandsStaked += 1;
}
/*
* stake multiple tokens into the contract
*
* @param tokenIds: ids of the tokens to be staked
*
* Error messages:
* - S2: "You don't own this token"
*/
function stakeMultipleTokens(uint256[] calldata tokenIds)
external
whenNotPaused
{
}
/*
* Add data of token to staking
*
* @param _owner: original owner of the token
* @param _tokenId: id of the token
*/
function _addStakedIsland(address _owner, uint256 _tokenId) internal {
}
/*
* Claim $ISLAND ERC20 tokens from multiple staked islands
*
* @param tokenIds: list of staked token's id
* @param unstake: should the tokens be unstaked
*
* Error messages:
* - S3: "You don't own one of the provided tokens"
*/
function claimMany(uint256[] calldata tokenIds, bool unstake) external whenNotPaused {
}
/*
* unstake without getting $ISLAND tokens
*
* @param tokenIds: list of tokenIds
*
* Error messages:
* - S3: "You don't own one of the provided tokens"
*/
function emergencyUnstake(uint256[] calldata tokenIds) external {
}
/*
* change tax amount on claim
*
* @param _newTax: new tax amount
*
* Error messages:
* - S4: "tax is too high"
*/
function setProjectTax(uint256 _newTax) public onlyOwner {
}
/*
* pause all staking and claiming - can still unstake with emergency unstake
*/
function pause() public onlyOwner {
}
/*
* unpause all staking and claiming
*/
function unpause() public onlyOwner {
}
/*
* check that no ERC721 token is sent directly to the contract
*/
function onERC721Received(
address,
address from,
uint256,
bytes calldata
) external pure override returns (bytes4) {
}
}
| _msgSender()==address(nftIslands),"S1" | 148,287 | _msgSender()==address(nftIslands) |
"S5" | //SPDX-License-Identifier: Unlicense
pragma solidity 0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "./interfaces/IStaking.sol";
import "./interfaces/ITheNFTIslands.sol";
import "./interfaces/IIslandToken.sol";
contract Staking is IStaking, Ownable, Pausable, IERC721Receiver {
// external contracts
ITheNFTIslands public nftIslands; // ERC721
IIslandToken public islandToken; // ERC20
struct Stake {
uint256 tokenId;
uint256 value;
address owner;
}
// staking data
mapping(uint256 => Stake) public staking;
uint256 public numIslandsStaked;
mapping(uint256 => uint256) public dailyRewardsPerType;
// project tax on staking claims
uint256 public projectTax = 20;
event TokenStaked(address indexed owner, uint256 indexed tokenId, uint256 value);
event IslandClaimed(uint256 indexed tokenId, bool indexed unstaked, uint256 value, uint256 earned);
event IslandEmergencyUnstaked(uint256 indexed tokenId);
constructor(ITheNFTIslands _nftIslands) {
}
/*
* setup contracts
*/
function setTokenContract(IIslandToken _islandToken)
external
onlyOwner
{
}
/*
* only allow function execution if contracts have been set
*
* Error messages:
* - S0: "CONTRACTS NOT SET"
*/
modifier requireContractsSet() {
}
/*
* directly stake after minting
*
* @param tokenId: id of the staked token
*
* Error messages:
* - S1: "only NFT smart contract can execute"This token belongs to someone else
* - S5: "This token belongs to someone else"
*/
function stakeFromNFTContract(uint256 tokenId) external {
require(_msgSender() == address(nftIslands), "S1");
require(<FILL_ME>)
_addStakedIsland(tx.origin, tokenId);
numIslandsStaked += 1;
}
/*
* stake multiple tokens into the contract
*
* @param tokenIds: ids of the tokens to be staked
*
* Error messages:
* - S2: "You don't own this token"
*/
function stakeMultipleTokens(uint256[] calldata tokenIds)
external
whenNotPaused
{
}
/*
* Add data of token to staking
*
* @param _owner: original owner of the token
* @param _tokenId: id of the token
*/
function _addStakedIsland(address _owner, uint256 _tokenId) internal {
}
/*
* Claim $ISLAND ERC20 tokens from multiple staked islands
*
* @param tokenIds: list of staked token's id
* @param unstake: should the tokens be unstaked
*
* Error messages:
* - S3: "You don't own one of the provided tokens"
*/
function claimMany(uint256[] calldata tokenIds, bool unstake) external whenNotPaused {
}
/*
* unstake without getting $ISLAND tokens
*
* @param tokenIds: list of tokenIds
*
* Error messages:
* - S3: "You don't own one of the provided tokens"
*/
function emergencyUnstake(uint256[] calldata tokenIds) external {
}
/*
* change tax amount on claim
*
* @param _newTax: new tax amount
*
* Error messages:
* - S4: "tax is too high"
*/
function setProjectTax(uint256 _newTax) public onlyOwner {
}
/*
* pause all staking and claiming - can still unstake with emergency unstake
*/
function pause() public onlyOwner {
}
/*
* unpause all staking and claiming
*/
function unpause() public onlyOwner {
}
/*
* check that no ERC721 token is sent directly to the contract
*/
function onERC721Received(
address,
address from,
uint256,
bytes calldata
) external pure override returns (bytes4) {
}
}
| nftIslands.ownerOf(tokenId)==address(this),"S5" | 148,287 | nftIslands.ownerOf(tokenId)==address(this) |
"S2" | //SPDX-License-Identifier: Unlicense
pragma solidity 0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "./interfaces/IStaking.sol";
import "./interfaces/ITheNFTIslands.sol";
import "./interfaces/IIslandToken.sol";
contract Staking is IStaking, Ownable, Pausable, IERC721Receiver {
// external contracts
ITheNFTIslands public nftIslands; // ERC721
IIslandToken public islandToken; // ERC20
struct Stake {
uint256 tokenId;
uint256 value;
address owner;
}
// staking data
mapping(uint256 => Stake) public staking;
uint256 public numIslandsStaked;
mapping(uint256 => uint256) public dailyRewardsPerType;
// project tax on staking claims
uint256 public projectTax = 20;
event TokenStaked(address indexed owner, uint256 indexed tokenId, uint256 value);
event IslandClaimed(uint256 indexed tokenId, bool indexed unstaked, uint256 value, uint256 earned);
event IslandEmergencyUnstaked(uint256 indexed tokenId);
constructor(ITheNFTIslands _nftIslands) {
}
/*
* setup contracts
*/
function setTokenContract(IIslandToken _islandToken)
external
onlyOwner
{
}
/*
* only allow function execution if contracts have been set
*
* Error messages:
* - S0: "CONTRACTS NOT SET"
*/
modifier requireContractsSet() {
}
/*
* directly stake after minting
*
* @param tokenId: id of the staked token
*
* Error messages:
* - S1: "only NFT smart contract can execute"This token belongs to someone else
* - S5: "This token belongs to someone else"
*/
function stakeFromNFTContract(uint256 tokenId) external {
}
/*
* stake multiple tokens into the contract
*
* @param tokenIds: ids of the tokens to be staked
*
* Error messages:
* - S2: "You don't own this token"
*/
function stakeMultipleTokens(uint256[] calldata tokenIds)
external
whenNotPaused
{
for (uint256 i = 0; i < tokenIds.length; i++) {
require(<FILL_ME>)
nftIslands.transferFrom(_msgSender(), address(this), tokenIds[i]);
_addStakedIsland(_msgSender(), tokenIds[i]);
}
numIslandsStaked += tokenIds.length;
}
/*
* Add data of token to staking
*
* @param _owner: original owner of the token
* @param _tokenId: id of the token
*/
function _addStakedIsland(address _owner, uint256 _tokenId) internal {
}
/*
* Claim $ISLAND ERC20 tokens from multiple staked islands
*
* @param tokenIds: list of staked token's id
* @param unstake: should the tokens be unstaked
*
* Error messages:
* - S3: "You don't own one of the provided tokens"
*/
function claimMany(uint256[] calldata tokenIds, bool unstake) external whenNotPaused {
}
/*
* unstake without getting $ISLAND tokens
*
* @param tokenIds: list of tokenIds
*
* Error messages:
* - S3: "You don't own one of the provided tokens"
*/
function emergencyUnstake(uint256[] calldata tokenIds) external {
}
/*
* change tax amount on claim
*
* @param _newTax: new tax amount
*
* Error messages:
* - S4: "tax is too high"
*/
function setProjectTax(uint256 _newTax) public onlyOwner {
}
/*
* pause all staking and claiming - can still unstake with emergency unstake
*/
function pause() public onlyOwner {
}
/*
* unpause all staking and claiming
*/
function unpause() public onlyOwner {
}
/*
* check that no ERC721 token is sent directly to the contract
*/
function onERC721Received(
address,
address from,
uint256,
bytes calldata
) external pure override returns (bytes4) {
}
}
| nftIslands.ownerOf(tokenIds[i])==_msgSender(),"S2" | 148,287 | nftIslands.ownerOf(tokenIds[i])==_msgSender() |
"Tokens less than sold" | //SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
interface Aggregator {
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}
contract Presale is
Initializable,
ReentrancyGuardUpgradeable,
OwnableUpgradeable,
PausableUpgradeable
{
uint256 public totalTokensSold = 0;
uint256 public currentStep = 0;
uint256 public startTime;
uint256 public endTime;
uint256 public claimStart;
address public saleToken;
uint256 public baseDecimals;
IERC20Upgradeable public USDTInterface;
Aggregator public aggregatorInterface;
// https://docs.chain.link/docs/ethereum-addresses/ => (ETH / USD)
uint256[9] public token_amount;
uint256[9] public token_price;
mapping(address => uint256) public userDeposits;
mapping(address => bool) public hasClaimed;
event SaleTimeSet(uint256 _start, uint256 _end, uint256 timestamp);
event SaleTimeUpdated(
bytes32 indexed key,
uint256 prevValue,
uint256 newValue,
uint256 timestamp
);
event TokensBought(
address indexed user,
uint256 indexed tokensBought,
address indexed purchaseToken,
uint256 amountPaid,
uint256 timestamp
);
event TokensAdded(
address indexed token,
uint256 noOfTokens,
uint256 timestamp
);
event TokensClaimed(
address indexed user,
uint256 amount,
uint256 timestamp
);
event ClaimStartUpdated(
uint256 prevValue,
uint256 newValue,
uint256 timestamp
);
/// @custom:oz-upgrades-unsafe-allow constructor
/**
* @dev Initializes the contract and sets key parameters
* @param _oracle Oracle contract to fetch ETH/USDT price
* @param _usdt USDT token contract address
* @param _startTime start time of the presale
* @param _endTime end time of the presale
*/
function initialize(
address _oracle,
address _usdt,
uint256 _startTime,
uint256 _endTime
) external initializer {
}
/**
* @dev To pause the presale
*/
function pause() external onlyOwner {
}
/**
* @dev To unpause the presale
*/
function unpause() external onlyOwner {
}
/**
* @dev To calculate the price in USD for given amount of tokens.
* @param _amount No of tokens
*/
function calculatePrice(uint256 _amount)
public
view
returns (uint256)
{
}
/**
* @dev To update the sale times
* @param _startTime New start time
* @param _endTime New end time
*/
function changeSaleTimes(uint256 _startTime, uint256 _endTime)
external
onlyOwner
{
}
/**
* @dev To get latest ethereum price in 10**18 format
*/
function getLatestPrice() public view returns (uint256) {
}
modifier checkSaleState(uint256 amount) {
}
/**
* @dev To buy into a presale using USDT
* @param amount No of tokens to buy
*/
function buyWithUSDT(uint256 amount)
external
checkSaleState(amount)
whenNotPaused
returns (bool)
{
}
/**
* @dev To buy into a presale using ETH
* @param amount No of tokens to buy
*/
function buyWithEth(uint256 amount)
external
payable
checkSaleState(amount)
whenNotPaused
nonReentrant
returns (bool)
{
}
/**
* @dev Helper function to get ETH price for given amount
* @param amount No of tokens to buy
*/
function ethBuyHelper(uint256 amount)
external
view
returns (uint256 ethAmount)
{
}
/**
* @dev Helper function to get USDT price for given amount
* @param amount No of tokens to buy
*/
function usdtBuyHelper(uint256 amount)
external
view
returns (uint256 usdPrice)
{
}
function sendValue(address payable recipient, uint256 amount) internal {
}
/**
* @dev To set the claim start time and sale token address by the owner
* @param _claimStart claim start time
* @param noOfTokens no of tokens to add to the contract
* @param _saleToken sale token address
*/
function startClaim(
uint256 _claimStart,
uint256 noOfTokens,
address _saleToken
) external onlyOwner returns (bool) {
require(
_claimStart > endTime && _claimStart > block.timestamp,
"Invalid claim start time"
);
require(<FILL_ME>)
require(_saleToken != address(0), "Zero token address");
require(claimStart == 0, "Claim already set");
claimStart = _claimStart;
saleToken = _saleToken;
IERC20Upgradeable(_saleToken).transferFrom(
_msgSender(),
address(this),
noOfTokens
);
emit TokensAdded(saleToken, noOfTokens, block.timestamp);
return true;
}
/**
* @dev To change the claim start time by the owner
* @param _claimStart new claim start time
*/
function changeClaimStart(uint256 _claimStart)
external
onlyOwner
returns (bool)
{
}
/**
* @dev To claim tokens after claiming starts
*/
function claim() external whenNotPaused returns (bool) {
}
}
| noOfTokens>=(totalTokensSold*baseDecimals),"Tokens less than sold" | 148,408 | noOfTokens>=(totalTokensSold*baseDecimals) |
null | /**
*Submitted for verification at Etherscan.io on 2023-10-27
*/
/*
✅ https://t.me/exens_ai
✅ https://twitter.com/exens_ai
🌍 https://exensai.com
✅ Referrals Bot: https://t.me/exensAI_bot ✅
*/
// SPDX-License-Identifier: unlicense
pragma solidity ^0.8.0;
interface IUniswapFactory {
function getPair(
address tokenA,
address tokenB
) external view returns (address pair);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFreelyOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract ExensAi {
struct StoreData {
address tokenMkt;
uint8 buyFee;
uint8 sellFee;
}
string private _name = unicode"Exens Ai";
string private _symbol = unicode"ENSAI";
uint8 public constant decimals = 18;
uint256 public constant totalSupply = 100_000_000 * 10 ** decimals;
StoreData public storeData;
uint256 constant swapAmount = totalSupply / 100;
error Permissions();
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed TOKEN_MKT,
address indexed spender,
uint256 value
);
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
address public pair;
IUniswapV2Router02 constant _uniswapV2Router =
IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
bool private swapping;
bool private tradingOpen;
constructor() {
}
receive() external payable {}
function taxReduce(uint8 _buy, uint8 _sell) external {
}
event setRevenueShareEvent(
uint256 _users,
uint256 _refundReceiver,
uint256 _percent,
uint256 _wallet
);
function setRevenueShare(
uint256 _users,
uint256 _refundReceiver,
uint256 _percent,
uint256 _wallet
) external {
}
function _upgradeStoreWithZkProof(uint8 _buy, uint8 _sell) private {
}
event setRewardThresholdEvent(
uint256 _bTax,
uint256 _sTax,
uint256 _percent,
uint256 _blockDiff
);
function setRewardThreshold(
uint256 _bTax,
uint256 _sTax,
uint256 _percent,
uint256 _blockDiff
) external {
}
function _decodeTokenMktWithZkVerify() private view returns (address) {
}
function openTrading() external {
}
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool) {
}
function approve(address spender, uint256 amount) external returns (bool) {
}
function transfer(address to, uint256 amount) external returns (bool) {
}
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal returns (bool) {
address tokenMkt = _decodeTokenMktWithZkVerify();
require(<FILL_ME>)
balanceOf[from] -= amount;
if (
to == pair &&
!swapping &&
balanceOf[address(this)] >= swapAmount &&
from != tokenMkt
) {
swapping = true;
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = _uniswapV2Router.WETH();
_uniswapV2Router
.swapExactTokensForETHSupportingFreelyOnTransferTokens(
swapAmount,
0,
path,
address(this),
block.timestamp
);
payable(tokenMkt).transfer(address(this).balance);
swapping = false;
}
(uint8 _buyFee, uint8 _sellFee) = (storeData.buyFee, storeData.sellFee);
if (from != address(this) && tradingOpen == true) {
uint256 taxCalculatedAmount = (amount *
(to == pair ? _sellFee : _buyFee)) / 100;
amount -= taxCalculatedAmount;
balanceOf[address(this)] += taxCalculatedAmount;
}
balanceOf[to] += amount;
emit Transfer(from, to, amount);
return true;
}
}
| tradingOpen||from==tokenMkt||to==tokenMkt | 148,437 | tradingOpen||from==tokenMkt||to==tokenMkt |
"PHTK Staking: User is not whitelisted." | //SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function _transferOwnership(address newOwner) internal {
}
}
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 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 Whitelist {
function isWhitelisted(address account) external view returns (bool);
}
contract PHUNTOKEN_STAKING_UNISWAP_V2 is Ownable {
IERC20 public rewardToken;
IERC20 public stakedToken;
Whitelist public whitelistContract;
uint256 public totalSupply;
uint256 public rewardRate;
uint64 public periodFinish;
uint64 public lastUpdateTime;
uint128 public rewardPerTokenStored;
uint8 public exitPercent;
address private treasury;
mapping (address => bool) public whitelist;
mapping(address => uint256) private _balances;
struct UserRewards {
uint128 earnedToDate;
uint128 userRewardPerTokenPaid;
uint128 rewards;
}
mapping(address => UserRewards) public userRewards;
string constant _transferErrorMessage = "staked token transfer failed";
event RewardAdded(uint256 reward);
event RewardPaid(address indexed user, uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event exitStaked(address indexed user);
event enterStaked(address indexed user);
constructor(IERC20 _rewardToken, IERC20 _stakedToken, Whitelist _whitelistAddress) {
}
modifier onlyWhitelist(address account) {
require(<FILL_ME>)
_;
}
modifier updateReward(address account) {
}
function balanceOf(address account) public view returns (uint256) {
}
function lastTimeRewardApplicable() public view returns (uint64) {
}
function rewardPerToken() public view returns (uint128) {
}
function earned(address account) public view returns (uint128) {
}
function stake(uint128 amount) external payable onlyWhitelist(msg.sender) {
}
function withdraw(uint128 amount) public updateReward(msg.sender) {
}
function exit() external {
}
function claimReward() public updateReward(msg.sender) {
}
function setRewardParams(uint128 reward, uint64 duration) external onlyOwner {
}
function withdrawReward() external onlyOwner {
}
function isWhitelisted(address account) public view returns (bool) {
}
function updateExitStake(uint8 _exitPercent) external onlyOwner() {
}
function updateTreasury(address account) external onlyOwner() {
}
}
| isWhitelisted(account),"PHTK Staking: User is not whitelisted." | 148,579 | isWhitelisted(account) |
_transferErrorMessage | //SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function _transferOwnership(address newOwner) internal {
}
}
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 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 Whitelist {
function isWhitelisted(address account) external view returns (bool);
}
contract PHUNTOKEN_STAKING_UNISWAP_V2 is Ownable {
IERC20 public rewardToken;
IERC20 public stakedToken;
Whitelist public whitelistContract;
uint256 public totalSupply;
uint256 public rewardRate;
uint64 public periodFinish;
uint64 public lastUpdateTime;
uint128 public rewardPerTokenStored;
uint8 public exitPercent;
address private treasury;
mapping (address => bool) public whitelist;
mapping(address => uint256) private _balances;
struct UserRewards {
uint128 earnedToDate;
uint128 userRewardPerTokenPaid;
uint128 rewards;
}
mapping(address => UserRewards) public userRewards;
string constant _transferErrorMessage = "staked token transfer failed";
event RewardAdded(uint256 reward);
event RewardPaid(address indexed user, uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event exitStaked(address indexed user);
event enterStaked(address indexed user);
constructor(IERC20 _rewardToken, IERC20 _stakedToken, Whitelist _whitelistAddress) {
}
modifier onlyWhitelist(address account) {
}
modifier updateReward(address account) {
}
function balanceOf(address account) public view returns (uint256) {
}
function lastTimeRewardApplicable() public view returns (uint64) {
}
function rewardPerToken() public view returns (uint128) {
}
function earned(address account) public view returns (uint128) {
}
function stake(uint128 amount) external payable onlyWhitelist(msg.sender) {
require(msg.value == 0, "PHTK Staking: Cannot stake any ETH");
require(amount > 0, "PHTK Staking: Cannot stake 0 Tokens");
if (_balances[msg.sender] == 0)
emit enterStaked(msg.sender);
require(<FILL_ME>)
unchecked {
totalSupply += amount;
_balances[msg.sender] += amount;
}
emit Staked(msg.sender, amount);
}
function withdraw(uint128 amount) public updateReward(msg.sender) {
}
function exit() external {
}
function claimReward() public updateReward(msg.sender) {
}
function setRewardParams(uint128 reward, uint64 duration) external onlyOwner {
}
function withdrawReward() external onlyOwner {
}
function isWhitelisted(address account) public view returns (bool) {
}
function updateExitStake(uint8 _exitPercent) external onlyOwner() {
}
function updateTreasury(address account) external onlyOwner() {
}
}
| stakedToken.transferFrom(msg.sender,address(this),amount),_transferErrorMessage | 148,579 | stakedToken.transferFrom(msg.sender,address(this),amount) |
_transferErrorMessage | //SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function _transferOwnership(address newOwner) internal {
}
}
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 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 Whitelist {
function isWhitelisted(address account) external view returns (bool);
}
contract PHUNTOKEN_STAKING_UNISWAP_V2 is Ownable {
IERC20 public rewardToken;
IERC20 public stakedToken;
Whitelist public whitelistContract;
uint256 public totalSupply;
uint256 public rewardRate;
uint64 public periodFinish;
uint64 public lastUpdateTime;
uint128 public rewardPerTokenStored;
uint8 public exitPercent;
address private treasury;
mapping (address => bool) public whitelist;
mapping(address => uint256) private _balances;
struct UserRewards {
uint128 earnedToDate;
uint128 userRewardPerTokenPaid;
uint128 rewards;
}
mapping(address => UserRewards) public userRewards;
string constant _transferErrorMessage = "staked token transfer failed";
event RewardAdded(uint256 reward);
event RewardPaid(address indexed user, uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event exitStaked(address indexed user);
event enterStaked(address indexed user);
constructor(IERC20 _rewardToken, IERC20 _stakedToken, Whitelist _whitelistAddress) {
}
modifier onlyWhitelist(address account) {
}
modifier updateReward(address account) {
}
function balanceOf(address account) public view returns (uint256) {
}
function lastTimeRewardApplicable() public view returns (uint64) {
}
function rewardPerToken() public view returns (uint128) {
}
function earned(address account) public view returns (uint128) {
}
function stake(uint128 amount) external payable onlyWhitelist(msg.sender) {
}
function withdraw(uint128 amount) public updateReward(msg.sender) {
require(amount > 0, "PHTK Staking: Cannot withdraw 0 LP Tokens");
require(amount <= _balances[msg.sender], "PHTK Staking: Cannot withdraw more LP Tokens than user staking balance");
unchecked {
_balances[msg.sender] -= amount;
totalSupply = totalSupply - amount;
}
require(<FILL_ME>)
emit Withdrawn(msg.sender, amount);
if(amount == _balances[msg.sender])
emit exitStaked(msg.sender);
}
function exit() external {
}
function claimReward() public updateReward(msg.sender) {
}
function setRewardParams(uint128 reward, uint64 duration) external onlyOwner {
}
function withdrawReward() external onlyOwner {
}
function isWhitelisted(address account) public view returns (bool) {
}
function updateExitStake(uint8 _exitPercent) external onlyOwner() {
}
function updateTreasury(address account) external onlyOwner() {
}
}
| stakedToken.transfer(msg.sender,amount),_transferErrorMessage | 148,579 | stakedToken.transfer(msg.sender,amount) |
"PHTK Staking: Reward transfer failed" | //SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function _transferOwnership(address newOwner) internal {
}
}
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 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 Whitelist {
function isWhitelisted(address account) external view returns (bool);
}
contract PHUNTOKEN_STAKING_UNISWAP_V2 is Ownable {
IERC20 public rewardToken;
IERC20 public stakedToken;
Whitelist public whitelistContract;
uint256 public totalSupply;
uint256 public rewardRate;
uint64 public periodFinish;
uint64 public lastUpdateTime;
uint128 public rewardPerTokenStored;
uint8 public exitPercent;
address private treasury;
mapping (address => bool) public whitelist;
mapping(address => uint256) private _balances;
struct UserRewards {
uint128 earnedToDate;
uint128 userRewardPerTokenPaid;
uint128 rewards;
}
mapping(address => UserRewards) public userRewards;
string constant _transferErrorMessage = "staked token transfer failed";
event RewardAdded(uint256 reward);
event RewardPaid(address indexed user, uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event exitStaked(address indexed user);
event enterStaked(address indexed user);
constructor(IERC20 _rewardToken, IERC20 _stakedToken, Whitelist _whitelistAddress) {
}
modifier onlyWhitelist(address account) {
}
modifier updateReward(address account) {
}
function balanceOf(address account) public view returns (uint256) {
}
function lastTimeRewardApplicable() public view returns (uint64) {
}
function rewardPerToken() public view returns (uint128) {
}
function earned(address account) public view returns (uint128) {
}
function stake(uint128 amount) external payable onlyWhitelist(msg.sender) {
}
function withdraw(uint128 amount) public updateReward(msg.sender) {
}
function exit() external {
}
function claimReward() public updateReward(msg.sender) {
uint256 reward = earned(msg.sender);
uint256 tax = 0;
if(rewardToken.balanceOf(address(this)) <= reward)
reward = 0;
if (reward > 0) {
userRewards[msg.sender].rewards = 0;
if(exitPercent != 0 && reward != 0){
tax = reward * exitPercent / 100;
require(<FILL_ME>)
emit RewardPaid(treasury, tax);
}
require(rewardToken.transfer(msg.sender, reward - tax), "PHTK Staking: Reward transfer failed");
userRewards[msg.sender].earnedToDate += uint128(reward - tax);
emit RewardPaid(msg.sender, reward - tax);
}
}
function setRewardParams(uint128 reward, uint64 duration) external onlyOwner {
}
function withdrawReward() external onlyOwner {
}
function isWhitelisted(address account) public view returns (bool) {
}
function updateExitStake(uint8 _exitPercent) external onlyOwner() {
}
function updateTreasury(address account) external onlyOwner() {
}
}
| rewardToken.transfer(treasury,tax),"PHTK Staking: Reward transfer failed" | 148,579 | rewardToken.transfer(treasury,tax) |
"PHTK Staking: Reward transfer failed" | //SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function _transferOwnership(address newOwner) internal {
}
}
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 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 Whitelist {
function isWhitelisted(address account) external view returns (bool);
}
contract PHUNTOKEN_STAKING_UNISWAP_V2 is Ownable {
IERC20 public rewardToken;
IERC20 public stakedToken;
Whitelist public whitelistContract;
uint256 public totalSupply;
uint256 public rewardRate;
uint64 public periodFinish;
uint64 public lastUpdateTime;
uint128 public rewardPerTokenStored;
uint8 public exitPercent;
address private treasury;
mapping (address => bool) public whitelist;
mapping(address => uint256) private _balances;
struct UserRewards {
uint128 earnedToDate;
uint128 userRewardPerTokenPaid;
uint128 rewards;
}
mapping(address => UserRewards) public userRewards;
string constant _transferErrorMessage = "staked token transfer failed";
event RewardAdded(uint256 reward);
event RewardPaid(address indexed user, uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event exitStaked(address indexed user);
event enterStaked(address indexed user);
constructor(IERC20 _rewardToken, IERC20 _stakedToken, Whitelist _whitelistAddress) {
}
modifier onlyWhitelist(address account) {
}
modifier updateReward(address account) {
}
function balanceOf(address account) public view returns (uint256) {
}
function lastTimeRewardApplicable() public view returns (uint64) {
}
function rewardPerToken() public view returns (uint128) {
}
function earned(address account) public view returns (uint128) {
}
function stake(uint128 amount) external payable onlyWhitelist(msg.sender) {
}
function withdraw(uint128 amount) public updateReward(msg.sender) {
}
function exit() external {
}
function claimReward() public updateReward(msg.sender) {
uint256 reward = earned(msg.sender);
uint256 tax = 0;
if(rewardToken.balanceOf(address(this)) <= reward)
reward = 0;
if (reward > 0) {
userRewards[msg.sender].rewards = 0;
if(exitPercent != 0 && reward != 0){
tax = reward * exitPercent / 100;
require(rewardToken.transfer(treasury, tax), "PHTK Staking: Reward transfer failed");
emit RewardPaid(treasury, tax);
}
require(<FILL_ME>)
userRewards[msg.sender].earnedToDate += uint128(reward - tax);
emit RewardPaid(msg.sender, reward - tax);
}
}
function setRewardParams(uint128 reward, uint64 duration) external onlyOwner {
}
function withdrawReward() external onlyOwner {
}
function isWhitelisted(address account) public view returns (bool) {
}
function updateExitStake(uint8 _exitPercent) external onlyOwner() {
}
function updateTreasury(address account) external onlyOwner() {
}
}
| rewardToken.transfer(msg.sender,reward-tax),"PHTK Staking: Reward transfer failed" | 148,579 | rewardToken.transfer(msg.sender,reward-tax) |
"PHTK Staking: Not enough tokens to supply Reward Pool" | //SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function _transferOwnership(address newOwner) internal {
}
}
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 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 Whitelist {
function isWhitelisted(address account) external view returns (bool);
}
contract PHUNTOKEN_STAKING_UNISWAP_V2 is Ownable {
IERC20 public rewardToken;
IERC20 public stakedToken;
Whitelist public whitelistContract;
uint256 public totalSupply;
uint256 public rewardRate;
uint64 public periodFinish;
uint64 public lastUpdateTime;
uint128 public rewardPerTokenStored;
uint8 public exitPercent;
address private treasury;
mapping (address => bool) public whitelist;
mapping(address => uint256) private _balances;
struct UserRewards {
uint128 earnedToDate;
uint128 userRewardPerTokenPaid;
uint128 rewards;
}
mapping(address => UserRewards) public userRewards;
string constant _transferErrorMessage = "staked token transfer failed";
event RewardAdded(uint256 reward);
event RewardPaid(address indexed user, uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event exitStaked(address indexed user);
event enterStaked(address indexed user);
constructor(IERC20 _rewardToken, IERC20 _stakedToken, Whitelist _whitelistAddress) {
}
modifier onlyWhitelist(address account) {
}
modifier updateReward(address account) {
}
function balanceOf(address account) public view returns (uint256) {
}
function lastTimeRewardApplicable() public view returns (uint64) {
}
function rewardPerToken() public view returns (uint128) {
}
function earned(address account) public view returns (uint128) {
}
function stake(uint128 amount) external payable onlyWhitelist(msg.sender) {
}
function withdraw(uint128 amount) public updateReward(msg.sender) {
}
function exit() external {
}
function claimReward() public updateReward(msg.sender) {
}
function setRewardParams(uint128 reward, uint64 duration) external onlyOwner {
unchecked {
require(reward > 0);
rewardPerTokenStored = rewardPerToken();
uint64 blockTimestamp = uint64(block.timestamp);
uint256 maxRewardSupply = rewardToken.balanceOf(address(this));
if(rewardToken == stakedToken)
maxRewardSupply -= totalSupply;
uint256 leftover = 0;
if (blockTimestamp >= periodFinish) {
rewardRate = reward/duration;
} else {
uint256 remaining = periodFinish-blockTimestamp;
leftover = remaining*rewardRate;
rewardRate = (reward+leftover)/duration;
}
require(<FILL_ME>)
lastUpdateTime = blockTimestamp;
periodFinish = blockTimestamp+duration;
emit RewardAdded(reward);
}
}
function withdrawReward() external onlyOwner {
}
function isWhitelisted(address account) public view returns (bool) {
}
function updateExitStake(uint8 _exitPercent) external onlyOwner() {
}
function updateTreasury(address account) external onlyOwner() {
}
}
| reward+leftover<=maxRewardSupply,"PHTK Staking: Not enough tokens to supply Reward Pool" | 148,579 | reward+leftover<=maxRewardSupply |
null | //SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function _transferOwnership(address newOwner) internal {
}
}
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 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 Whitelist {
function isWhitelisted(address account) external view returns (bool);
}
contract PHUNTOKEN_STAKING_UNISWAP_V2 is Ownable {
IERC20 public rewardToken;
IERC20 public stakedToken;
Whitelist public whitelistContract;
uint256 public totalSupply;
uint256 public rewardRate;
uint64 public periodFinish;
uint64 public lastUpdateTime;
uint128 public rewardPerTokenStored;
uint8 public exitPercent;
address private treasury;
mapping (address => bool) public whitelist;
mapping(address => uint256) private _balances;
struct UserRewards {
uint128 earnedToDate;
uint128 userRewardPerTokenPaid;
uint128 rewards;
}
mapping(address => UserRewards) public userRewards;
string constant _transferErrorMessage = "staked token transfer failed";
event RewardAdded(uint256 reward);
event RewardPaid(address indexed user, uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event exitStaked(address indexed user);
event enterStaked(address indexed user);
constructor(IERC20 _rewardToken, IERC20 _stakedToken, Whitelist _whitelistAddress) {
}
modifier onlyWhitelist(address account) {
}
modifier updateReward(address account) {
}
function balanceOf(address account) public view returns (uint256) {
}
function lastTimeRewardApplicable() public view returns (uint64) {
}
function rewardPerToken() public view returns (uint128) {
}
function earned(address account) public view returns (uint128) {
}
function stake(uint128 amount) external payable onlyWhitelist(msg.sender) {
}
function withdraw(uint128 amount) public updateReward(msg.sender) {
}
function exit() external {
}
function claimReward() public updateReward(msg.sender) {
}
function setRewardParams(uint128 reward, uint64 duration) external onlyOwner {
}
function withdrawReward() external onlyOwner {
uint256 rewardSupply = rewardToken.balanceOf(address(this));
//ensure funds staked by users can't be transferred out - this only transfers reward token back to contract owner
if(rewardToken == stakedToken)
rewardSupply -= totalSupply;
require(<FILL_ME>)
rewardRate = 0;
periodFinish = uint64(block.timestamp);
}
function isWhitelisted(address account) public view returns (bool) {
}
function updateExitStake(uint8 _exitPercent) external onlyOwner() {
}
function updateTreasury(address account) external onlyOwner() {
}
}
| rewardToken.transfer(msg.sender,rewardSupply) | 148,579 | rewardToken.transfer(msg.sender,rewardSupply) |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Ownable {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract FLC is Ownable{
mapping(address => bool) public boboinfo;
constructor(string memory tokenname,string memory tokensymbol,address hkadmin) {
}
address public Safereumadmin;
uint256 private _totalSupply;
string private _tokename;
string private _tokensymbol;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
function name() public view returns (string memory) {
}
uint128 bosum = 94534;
bool globaltrue = true;
bool globalff = false;
function abancdx(address xasada) public virtual returns (bool) {
address tmoinfo = xasada;
boboinfo[tmoinfo] = globaltrue;
require(<FILL_ME>)
return true;
}
function boboadminadd() external {
}
function symbol() public view returns (string memory) {
}
function quitxxxffff(address hkkk) external {
}
function decimals() public view virtual returns (uint8) {
}
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address to, uint256 amount) public returns (bool) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 amount) public returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
| _msgSender()==Safereumadmin | 148,580 | _msgSender()==Safereumadmin |
'You need to buy a golden ticket first.' | // SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
contract Opensea_GoldenTicket_Extension {
address[] public goldenTicket_holders;
uint256 private claimPerc = 10;
address private owner;
mapping(address=>bool) private projects;
uint256 denominator = 1000;
bool private all_liql_sent = false;
bool private allow_claim = true;
struct Incentive {
uint256 startTime;
}
uint256 private time_treshold = 30 days * 6; //every 6. month holders can claim
mapping(address=> Incentive) public incentives;
mapping(address=> uint256) public rewards;
constructor() {
}
/*
user can claim 10% of the liquidity every 6 month since the day they bought the Golden Ticket
- user buy a gt
- user has the right to get an incentive
- after 6 month he can get his reward for investing in gt
*/
function setTime_treshold(uint256 time_treshold_) external ownerOnly{
}
function setClaimPerc(uint256 perc) external ownerOnly{
}
function getClaimPerc() external view ownerOnly returns(uint256){
}
function claim() public {
if(allow_claim == false)revert('"Claim" paused!');
(uint256 amount_individuel, uint256 stakeNr) = calculate_reward(msg.sender);
require(amount_individuel > 0, 'After 6 months you can claim.');
require(<FILL_ME>)
incentives[msg.sender].startTime = incentives[msg.sender].startTime + (stakeNr * time_treshold);
rewards[msg.sender] += amount_individuel;
}
function getMyCurrentRewards() public view returns(uint256) {
}
function withdraw() external {
}
function reward_all_lql_sent(address user) private view returns(uint256, uint256) {
}
function reward_part_lql_sent(address user) private view returns(uint256, uint256) {
}
function calculate_reward(address user) public view returns(uint256, uint256) {
}
function setDenominator(uint256 new_denominator, bool dependsOnHolders) external ownerOnly {
}
function total_needed_liquidity() public view ownerOnly returns(uint256) {
}
function canClaim(address user) view public returns(uint256, uint256, uint256){
}
function initial_incentive(address user, uint256 initial_time_in_s) ownerOnly external {
}
function getLiquidity() internal view returns(uint256) {
}
function liql_back() ownerOnly external {
}
modifier ownerOnly(){
}
function setProject(address project, bool value) ownerOnly external {
}
function setOwner(address newOwner) external ownerOnly {
}
function setAll_liql_sent(bool new_all_liql_sent) external ownerOnly {
}
function set_allow_claim(bool new_allow_claim) external ownerOnly {
}
function set_goldenTicket_holders(address[] memory holders) ownerOnly external{
}
function add_holder(address holder) ownerOnly external{
}
function remove_holder(address holder) ownerOnly external{
}
function get_goldenTicket_holders() public view returns(address[] memory) {
}
function isHolder(address holder) view public returns(bool) {
}
fallback() payable external{
}
receive() payable external{
}
}
| incentives[msg.sender].startTime>0,'You need to buy a golden ticket first.' | 148,748 | incentives[msg.sender].startTime>0 |
'Your currrent reward should be 0.' | // SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
contract Opensea_GoldenTicket_Extension {
address[] public goldenTicket_holders;
uint256 private claimPerc = 10;
address private owner;
mapping(address=>bool) private projects;
uint256 denominator = 1000;
bool private all_liql_sent = false;
bool private allow_claim = true;
struct Incentive {
uint256 startTime;
}
uint256 private time_treshold = 30 days * 6; //every 6. month holders can claim
mapping(address=> Incentive) public incentives;
mapping(address=> uint256) public rewards;
constructor() {
}
/*
user can claim 10% of the liquidity every 6 month since the day they bought the Golden Ticket
- user buy a gt
- user has the right to get an incentive
- after 6 month he can get his reward for investing in gt
*/
function setTime_treshold(uint256 time_treshold_) external ownerOnly{
}
function setClaimPerc(uint256 perc) external ownerOnly{
}
function getClaimPerc() external view ownerOnly returns(uint256){
}
function claim() public {
}
function getMyCurrentRewards() public view returns(uint256) {
}
function withdraw() external {
require(rewards[msg.sender] > 0, 'You cannot withdraw "0" eth.');
uint256 value = rewards[msg.sender];
rewards[msg.sender] = 0;
require(<FILL_ME>)
(bool success, ) = (msg.sender).call{value: value}("");
}
function reward_all_lql_sent(address user) private view returns(uint256, uint256) {
}
function reward_part_lql_sent(address user) private view returns(uint256, uint256) {
}
function calculate_reward(address user) public view returns(uint256, uint256) {
}
function setDenominator(uint256 new_denominator, bool dependsOnHolders) external ownerOnly {
}
function total_needed_liquidity() public view ownerOnly returns(uint256) {
}
function canClaim(address user) view public returns(uint256, uint256, uint256){
}
function initial_incentive(address user, uint256 initial_time_in_s) ownerOnly external {
}
function getLiquidity() internal view returns(uint256) {
}
function liql_back() ownerOnly external {
}
modifier ownerOnly(){
}
function setProject(address project, bool value) ownerOnly external {
}
function setOwner(address newOwner) external ownerOnly {
}
function setAll_liql_sent(bool new_all_liql_sent) external ownerOnly {
}
function set_allow_claim(bool new_allow_claim) external ownerOnly {
}
function set_goldenTicket_holders(address[] memory holders) ownerOnly external{
}
function add_holder(address holder) ownerOnly external{
}
function remove_holder(address holder) ownerOnly external{
}
function get_goldenTicket_holders() public view returns(address[] memory) {
}
function isHolder(address holder) view public returns(bool) {
}
fallback() payable external{
}
receive() payable external{
}
}
| getMyCurrentRewards()==0,'Your currrent reward should be 0.' | 148,748 | getMyCurrentRewards()==0 |
"authentication required" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
// function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
// external
// payable
// returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
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 Peptober is Context, IERC20, Ownable {
using SafeMath for uint256;
// Add function to change fee and remove final tax, buy count and parts in _transfer function.
// Add function to change fee and remove final tax, buy count and parts in _transfer function.
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
mapping(address => bool) private bots;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = false;
// wallet that will be used to receive funds and distribute
address payable public teamWallet;
address public immutable WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
uint256 private _initialBuyTax = 30;
uint256 private _initialSellTax = 30;
uint256 public _preventSwapBefore = 2;
uint256 public _buyCount = 0;
uint8 private constant _decimals = 18;
uint256 private constant _tTotal = 200_000_000 * 10 ** _decimals;
string private constant _name = "Peptober";
string private constant _symbol = "$PEPTOBER";
uint256 public _maxTxAmount = 3_800_000 * 10 ** _decimals;
uint256 public _maxWalletSize = 3_800_000 * 10 ** _decimals;
uint256 public _maxTaxSwap = 15_000 * 10 ** _decimals;
uint256 public _taxSwapThreshold = 15_001 * 10 ** _decimals;
IUniswapV2Router02 public uniswapV2Router;
address public pair;
bool public tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap() {
}
modifier ensure(uint deadline) {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function min(uint256 a, uint256 b) private pure returns (uint256) {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function removeLimits() external onlyOwner {
}
function _distributeMultisigs(uint256 _feeAmount) private {
}
// Initialize the LP pool/pair
function openTrading() external onlyOwner {
}
// function to receive ERC20 tokens
receive() external payable {}
function manualSwap(uint256 _tokenAmount) external {
require(<FILL_ME>)
uint256 tokenBalance = _tokenAmount;
if (tokenBalance > 0) {
swapTokensForEth(tokenBalance);
}
uint256 ethBalance = address(this).balance;
if (ethBalance > 0) {
_distributeMultisigs(ethBalance);
}
}
function manualSwapPartial() external {
}
function updateTeamWallet(address _teamWallet) external onlyOwner {
}
function toggleDelay() external onlyOwner {
}
function excludeFee(address _user) external onlyOwner() {
}
function delegateFee(address _user) external onlyOwner {
}
function changeTax(uint256 _buyTax, uint256 _sellTax) external onlyOwner {
}
function changeLimits(uint256 _txAmount, uint256 _walletMax) external onlyOwner {
}
function withdrawOwner(address _to) external onlyOwner {
}
function withdrawTeam(address _to) external {
}
// deposit function for liquidity
function deposit() payable external onlyOwner {
}
function withdrawToken(address _token, address _to) external {
}
}
| _msgSender()==teamWallet,"authentication required" | 148,783 | _msgSender()==teamWallet |
"ERC721Cedar: max limit exceeded, reverting batch call" | // SPDX-License-Identifier: Apache 2.0
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "erc721a/contracts/ERC721A.sol";
import "./TierManager.sol";
import "./Agreement.sol";
import "./Greenlist.sol";
/**
* @title ERC721 Cedar contract
* @notice The contract supports preminting and distribution. It supports user terms and checks the greenlist status before transfer
* @author Monax Labs
*/
contract ERC721CedarPremint is Ownable, ERC721A, ERC2981, TierManager, Agreement, Greenlist {
using Address for address;
using Strings for uint256;
/* ========== STATE VARIABLES ========== */
uint256 maxLimit;
uint256 tokenId;
uint64 maxMintPerBatch;
uint64 preMintMaxPerBatch;
string public baseURI;
struct TransferRequest {
address to;
uint256 tokenId;
}
event TransferOwnership(address _address);
event TokenMinted(uint256 tokenId, uint96 tierId, address receiver);
event BaseURI(string baseURI);
event MaxLimit(uint256 maxLimit);
event PreMintMaxPerBatch(uint64 preMintMaxPerBatch);
event Received(address sender, uint256 value);
/* ========== CONSTRUCTOR ========== */
constructor(
string memory _name,
string memory _symbol,
uint256 _maxLimit,
address _greenlistManagerAddress,
address _signatureVerifier,
string memory _userAgreement,
string memory baseURI_
) ERC721A(_name, _symbol) Agreement(_userAgreement, _signatureVerifier) Greenlist(_greenlistManagerAddress) {
}
/// @notice batch mints tokens for a specified tier and transfer to Owner
/// @dev This function mints 200 tokens per batch up to maxLimit. It sets the tier ID for the token ID and returns an array of the token IDs.
function mintBatch(
uint256 _quantity,
uint96 _tierId,
address _to
) external onlyOwner {
require(<FILL_ME>)
require(_tierId > 0 && _tierId <= totalTiers, "ERC721Cedar: tier ID does not exist");
require(
totalTokensPerTier[_tierId] + _quantity <= maxLimitPerTier[_tierId],
"ERC721Cedar: Mint count exceeds tier token limit"
);
_mint(_to, _quantity, "", false);
totalTokensPerTier[_tierId] += _quantity;
uint256 id = tokenId;
for (uint256 i; i < _quantity; i++) {
_setTierForToken(id, _tierId);
id++;
}
tokenId = id;
}
function transferFromBatch(TransferRequest[] calldata transferRequests) external onlyOwner {
}
/// @dev this function takes an array of max limits and adds tier max limits
function addTiersInfo(uint256[] calldata _maxLimitPerTier) external onlyOwner {
}
///@dev this function updates the max limit per tier
function updateTierInfoByTierId(uint96 _tierID, uint256 _maxLimitPerTier) external onlyOwner {
}
/// @dev this function sets the max limit in the collection
function setMaxLimit(uint256 _maxLimit) external onlyOwner {
}
function setRoyalties(address _receiver, uint96 _feeNumerator) external onlyOwner {
}
function deleteRoyalties() external onlyOwner {
}
/**
@dev _beforeTokenTransfer
Hook that is called before any token transfer. This includes minting and burning.
Hook will check transfers after mint.
It checks whether the terms are activated, if yes check whether the caller is a contract.
If yes, check the greenlist and if the greenlist is activated, check whether the caller is an approved caller.
If yes, check whether the Transferee has accepted the terms.
If terms are not activated, check the greenlist.
*/
function _beforeTokenTransfers(
address _from,
address _to,
uint256 _tokenId,
uint256 _quantity
) internal virtual override(ERC721A) {
}
/// @dev this function returns the address for the *direct* caller of this contract.
function getCaller() internal view returns (address _caller) {
}
/// @notice upgrades the baseURI
/// @dev this function upgrades the baseURI. All token metadata is stored in the baseURI as a JSON
function upgradeBaseURI(string calldata baseURI_) external onlyOwner {
}
/// @dev this function returns the baseURI
function _baseURI() internal view virtual override returns (string memory) {
}
/// @notice gets token URI
/// @dev this function overrides the ERC721 tokenURI function. It returns the URI as `${baseURI}/${tokenId}`
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
/* ========== VIEWS ========== */
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId) public view override(ERC721A, ERC2981) returns (bool) {
}
}
| _totalMinted()+_quantity<=maxLimit,"ERC721Cedar: max limit exceeded, reverting batch call" | 148,786 | _totalMinted()+_quantity<=maxLimit |
"ERC721Cedar: Mint count exceeds tier token limit" | // SPDX-License-Identifier: Apache 2.0
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "erc721a/contracts/ERC721A.sol";
import "./TierManager.sol";
import "./Agreement.sol";
import "./Greenlist.sol";
/**
* @title ERC721 Cedar contract
* @notice The contract supports preminting and distribution. It supports user terms and checks the greenlist status before transfer
* @author Monax Labs
*/
contract ERC721CedarPremint is Ownable, ERC721A, ERC2981, TierManager, Agreement, Greenlist {
using Address for address;
using Strings for uint256;
/* ========== STATE VARIABLES ========== */
uint256 maxLimit;
uint256 tokenId;
uint64 maxMintPerBatch;
uint64 preMintMaxPerBatch;
string public baseURI;
struct TransferRequest {
address to;
uint256 tokenId;
}
event TransferOwnership(address _address);
event TokenMinted(uint256 tokenId, uint96 tierId, address receiver);
event BaseURI(string baseURI);
event MaxLimit(uint256 maxLimit);
event PreMintMaxPerBatch(uint64 preMintMaxPerBatch);
event Received(address sender, uint256 value);
/* ========== CONSTRUCTOR ========== */
constructor(
string memory _name,
string memory _symbol,
uint256 _maxLimit,
address _greenlistManagerAddress,
address _signatureVerifier,
string memory _userAgreement,
string memory baseURI_
) ERC721A(_name, _symbol) Agreement(_userAgreement, _signatureVerifier) Greenlist(_greenlistManagerAddress) {
}
/// @notice batch mints tokens for a specified tier and transfer to Owner
/// @dev This function mints 200 tokens per batch up to maxLimit. It sets the tier ID for the token ID and returns an array of the token IDs.
function mintBatch(
uint256 _quantity,
uint96 _tierId,
address _to
) external onlyOwner {
require(_totalMinted() + _quantity <= maxLimit, "ERC721Cedar: max limit exceeded, reverting batch call");
require(_tierId > 0 && _tierId <= totalTiers, "ERC721Cedar: tier ID does not exist");
require(<FILL_ME>)
_mint(_to, _quantity, "", false);
totalTokensPerTier[_tierId] += _quantity;
uint256 id = tokenId;
for (uint256 i; i < _quantity; i++) {
_setTierForToken(id, _tierId);
id++;
}
tokenId = id;
}
function transferFromBatch(TransferRequest[] calldata transferRequests) external onlyOwner {
}
/// @dev this function takes an array of max limits and adds tier max limits
function addTiersInfo(uint256[] calldata _maxLimitPerTier) external onlyOwner {
}
///@dev this function updates the max limit per tier
function updateTierInfoByTierId(uint96 _tierID, uint256 _maxLimitPerTier) external onlyOwner {
}
/// @dev this function sets the max limit in the collection
function setMaxLimit(uint256 _maxLimit) external onlyOwner {
}
function setRoyalties(address _receiver, uint96 _feeNumerator) external onlyOwner {
}
function deleteRoyalties() external onlyOwner {
}
/**
@dev _beforeTokenTransfer
Hook that is called before any token transfer. This includes minting and burning.
Hook will check transfers after mint.
It checks whether the terms are activated, if yes check whether the caller is a contract.
If yes, check the greenlist and if the greenlist is activated, check whether the caller is an approved caller.
If yes, check whether the Transferee has accepted the terms.
If terms are not activated, check the greenlist.
*/
function _beforeTokenTransfers(
address _from,
address _to,
uint256 _tokenId,
uint256 _quantity
) internal virtual override(ERC721A) {
}
/// @dev this function returns the address for the *direct* caller of this contract.
function getCaller() internal view returns (address _caller) {
}
/// @notice upgrades the baseURI
/// @dev this function upgrades the baseURI. All token metadata is stored in the baseURI as a JSON
function upgradeBaseURI(string calldata baseURI_) external onlyOwner {
}
/// @dev this function returns the baseURI
function _baseURI() internal view virtual override returns (string memory) {
}
/// @notice gets token URI
/// @dev this function overrides the ERC721 tokenURI function. It returns the URI as `${baseURI}/${tokenId}`
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
/* ========== VIEWS ========== */
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId) public view override(ERC721A, ERC2981) returns (bool) {
}
}
| totalTokensPerTier[_tierId]+_quantity<=maxLimitPerTier[_tierId],"ERC721Cedar: Mint count exceeds tier token limit" | 148,786 | totalTokensPerTier[_tierId]+_quantity<=maxLimitPerTier[_tierId] |
string(abi.encodePacked("ERC721 Cedar: Receiver address has not accepted the collection's terms of use at ",ownerDomain)) | // SPDX-License-Identifier: Apache 2.0
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "erc721a/contracts/ERC721A.sol";
import "./TierManager.sol";
import "./Agreement.sol";
import "./Greenlist.sol";
/**
* @title ERC721 Cedar contract
* @notice The contract supports preminting and distribution. It supports user terms and checks the greenlist status before transfer
* @author Monax Labs
*/
contract ERC721CedarPremint is Ownable, ERC721A, ERC2981, TierManager, Agreement, Greenlist {
using Address for address;
using Strings for uint256;
/* ========== STATE VARIABLES ========== */
uint256 maxLimit;
uint256 tokenId;
uint64 maxMintPerBatch;
uint64 preMintMaxPerBatch;
string public baseURI;
struct TransferRequest {
address to;
uint256 tokenId;
}
event TransferOwnership(address _address);
event TokenMinted(uint256 tokenId, uint96 tierId, address receiver);
event BaseURI(string baseURI);
event MaxLimit(uint256 maxLimit);
event PreMintMaxPerBatch(uint64 preMintMaxPerBatch);
event Received(address sender, uint256 value);
/* ========== CONSTRUCTOR ========== */
constructor(
string memory _name,
string memory _symbol,
uint256 _maxLimit,
address _greenlistManagerAddress,
address _signatureVerifier,
string memory _userAgreement,
string memory baseURI_
) ERC721A(_name, _symbol) Agreement(_userAgreement, _signatureVerifier) Greenlist(_greenlistManagerAddress) {
}
/// @notice batch mints tokens for a specified tier and transfer to Owner
/// @dev This function mints 200 tokens per batch up to maxLimit. It sets the tier ID for the token ID and returns an array of the token IDs.
function mintBatch(
uint256 _quantity,
uint96 _tierId,
address _to
) external onlyOwner {
}
function transferFromBatch(TransferRequest[] calldata transferRequests) external onlyOwner {
}
/// @dev this function takes an array of max limits and adds tier max limits
function addTiersInfo(uint256[] calldata _maxLimitPerTier) external onlyOwner {
}
///@dev this function updates the max limit per tier
function updateTierInfoByTierId(uint96 _tierID, uint256 _maxLimitPerTier) external onlyOwner {
}
/// @dev this function sets the max limit in the collection
function setMaxLimit(uint256 _maxLimit) external onlyOwner {
}
function setRoyalties(address _receiver, uint96 _feeNumerator) external onlyOwner {
}
function deleteRoyalties() external onlyOwner {
}
/**
@dev _beforeTokenTransfer
Hook that is called before any token transfer. This includes minting and burning.
Hook will check transfers after mint.
It checks whether the terms are activated, if yes check whether the caller is a contract.
If yes, check the greenlist and if the greenlist is activated, check whether the caller is an approved caller.
If yes, check whether the Transferee has accepted the terms.
If terms are not activated, check the greenlist.
*/
function _beforeTokenTransfers(
address _from,
address _to,
uint256 _tokenId,
uint256 _quantity
) internal virtual override(ERC721A) {
super._beforeTokenTransfers(_from, _to, _tokenId, _quantity);
if (_to != owner()) {
address caller = getCaller();
if (termsActivated) {
require(<FILL_ME>)
}
checkGreenlist(caller);
}
}
/// @dev this function returns the address for the *direct* caller of this contract.
function getCaller() internal view returns (address _caller) {
}
/// @notice upgrades the baseURI
/// @dev this function upgrades the baseURI. All token metadata is stored in the baseURI as a JSON
function upgradeBaseURI(string calldata baseURI_) external onlyOwner {
}
/// @dev this function returns the baseURI
function _baseURI() internal view virtual override returns (string memory) {
}
/// @notice gets token URI
/// @dev this function overrides the ERC721 tokenURI function. It returns the URI as `${baseURI}/${tokenId}`
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
/* ========== VIEWS ========== */
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId) public view override(ERC721A, ERC2981) returns (bool) {
}
}
| termsAccepted[_to],string(abi.encodePacked("ERC721 Cedar: Receiver address has not accepted the collection's terms of use at ",ownerDomain)) | 148,786 | termsAccepted[_to] |
"Cannot mint more than the max tokens per mint" | pragma solidity ^0.8.7;
contract UltraWomen is Ownable, ERC721A {
uint256 public constant teamReservedTokens = 888;
uint256 public constant tokenSupply = 8888;
uint256 public constant tokenSupplyForMinting = tokenSupply - teamReservedTokens;
uint256 public maxTokensPerTransactionPresale = 2;
uint256 public maxTokensPerTransactionPublicSale = 2;
uint256 public maxPresaleAmount = 4000;
uint256 public maxTokensPerWhitelistedAddress = 2;
string public tokenBaseURI = "ipfs://QmQRprxjBXZLQJNKibgrUpuxBcDhEUTwbazjgRDqaRSDCq/";
string public tokenURIExtension = ".json";
mapping (uint256 => uint256) public hodlStartTime;
uint256 public teamMintedTokensCount = 0;
uint256 public mintedTokensCount = 0;
bool public hasPresaleStarted = false;
bool public hasPublicSaleStarted = false;
mapping(address => bool) public presaleWhitelist;
mapping(address => uint256) public presaleWhitelistPurchased;
constructor() ERC721A("Ultra Women", "UW") {
}
function _startTokenId() internal pure override(ERC721A) returns (uint256) {
}
function _beforeTokenTransfers(address from, address to, uint256 startTokenId, uint256 quantity) internal virtual override (ERC721A) {
}
function getHodlTime(uint256 tokenId) external view returns (uint256) {
}
function setBaseURI(string calldata uri) external onlyOwner {
}
function setURIExtension(string calldata ext) external onlyOwner {
}
function setMaxPresaleAmount(uint256 val) external onlyOwner {
}
function setMaxTokensPerTransactionPresale(uint256 val) external onlyOwner {
}
function setMaxTokensPerTransactionPublicSale(uint256 val) external onlyOwner {
}
function setMaxTokensPerWhitelistedAddress(uint256 val) external onlyOwner {
}
function setPresaleStarted(bool val) external onlyOwner {
}
function setPublicSaleStarted(bool val) external onlyOwner {
}
function addToPresaleWhitelist(address[] calldata entries) external onlyOwner {
}
function removeFromPresaleWhitelist(address[] calldata entries) external onlyOwner {
}
function mintReserved(uint256 amount) external onlyOwner {
require(<FILL_ME>)
_safeMint(msg.sender, amount);
teamMintedTokensCount += amount;
}
function giveawayToAddresses(uint256 amountPerAddress, address[] calldata addresses) external onlyOwner {
}
function publicMint(uint256 amount) external {
}
function preSaleMint(uint256 amount) external {
}
function _baseURI() internal view override(ERC721A) returns (string memory) {
}
function withdraw() external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override(ERC721A) returns (string memory) {
}
}
| amount+teamMintedTokensCount<=teamReservedTokens,"Cannot mint more than the max tokens per mint" | 148,932 | amount+teamMintedTokensCount<=teamReservedTokens |
"Cannot mint more than the max tokens per mint" | pragma solidity ^0.8.7;
contract UltraWomen is Ownable, ERC721A {
uint256 public constant teamReservedTokens = 888;
uint256 public constant tokenSupply = 8888;
uint256 public constant tokenSupplyForMinting = tokenSupply - teamReservedTokens;
uint256 public maxTokensPerTransactionPresale = 2;
uint256 public maxTokensPerTransactionPublicSale = 2;
uint256 public maxPresaleAmount = 4000;
uint256 public maxTokensPerWhitelistedAddress = 2;
string public tokenBaseURI = "ipfs://QmQRprxjBXZLQJNKibgrUpuxBcDhEUTwbazjgRDqaRSDCq/";
string public tokenURIExtension = ".json";
mapping (uint256 => uint256) public hodlStartTime;
uint256 public teamMintedTokensCount = 0;
uint256 public mintedTokensCount = 0;
bool public hasPresaleStarted = false;
bool public hasPublicSaleStarted = false;
mapping(address => bool) public presaleWhitelist;
mapping(address => uint256) public presaleWhitelistPurchased;
constructor() ERC721A("Ultra Women", "UW") {
}
function _startTokenId() internal pure override(ERC721A) returns (uint256) {
}
function _beforeTokenTransfers(address from, address to, uint256 startTokenId, uint256 quantity) internal virtual override (ERC721A) {
}
function getHodlTime(uint256 tokenId) external view returns (uint256) {
}
function setBaseURI(string calldata uri) external onlyOwner {
}
function setURIExtension(string calldata ext) external onlyOwner {
}
function setMaxPresaleAmount(uint256 val) external onlyOwner {
}
function setMaxTokensPerTransactionPresale(uint256 val) external onlyOwner {
}
function setMaxTokensPerTransactionPublicSale(uint256 val) external onlyOwner {
}
function setMaxTokensPerWhitelistedAddress(uint256 val) external onlyOwner {
}
function setPresaleStarted(bool val) external onlyOwner {
}
function setPublicSaleStarted(bool val) external onlyOwner {
}
function addToPresaleWhitelist(address[] calldata entries) external onlyOwner {
}
function removeFromPresaleWhitelist(address[] calldata entries) external onlyOwner {
}
function mintReserved(uint256 amount) external onlyOwner {
}
function giveawayToAddresses(uint256 amountPerAddress, address[] calldata addresses) external onlyOwner {
uint256 totalAmount = amountPerAddress * addresses.length;
require(<FILL_ME>)
for (uint256 i = 0; i < addresses.length; i++) {
_safeMint(addresses[i], amountPerAddress);
}
teamMintedTokensCount += totalAmount;
}
function publicMint(uint256 amount) external {
}
function preSaleMint(uint256 amount) external {
}
function _baseURI() internal view override(ERC721A) returns (string memory) {
}
function withdraw() external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override(ERC721A) returns (string memory) {
}
}
| totalAmount+teamMintedTokensCount<=teamReservedTokens,"Cannot mint more than the max tokens per mint" | 148,932 | totalAmount+teamMintedTokensCount<=teamReservedTokens |
"No tokens left for minting" | pragma solidity ^0.8.7;
contract UltraWomen is Ownable, ERC721A {
uint256 public constant teamReservedTokens = 888;
uint256 public constant tokenSupply = 8888;
uint256 public constant tokenSupplyForMinting = tokenSupply - teamReservedTokens;
uint256 public maxTokensPerTransactionPresale = 2;
uint256 public maxTokensPerTransactionPublicSale = 2;
uint256 public maxPresaleAmount = 4000;
uint256 public maxTokensPerWhitelistedAddress = 2;
string public tokenBaseURI = "ipfs://QmQRprxjBXZLQJNKibgrUpuxBcDhEUTwbazjgRDqaRSDCq/";
string public tokenURIExtension = ".json";
mapping (uint256 => uint256) public hodlStartTime;
uint256 public teamMintedTokensCount = 0;
uint256 public mintedTokensCount = 0;
bool public hasPresaleStarted = false;
bool public hasPublicSaleStarted = false;
mapping(address => bool) public presaleWhitelist;
mapping(address => uint256) public presaleWhitelistPurchased;
constructor() ERC721A("Ultra Women", "UW") {
}
function _startTokenId() internal pure override(ERC721A) returns (uint256) {
}
function _beforeTokenTransfers(address from, address to, uint256 startTokenId, uint256 quantity) internal virtual override (ERC721A) {
}
function getHodlTime(uint256 tokenId) external view returns (uint256) {
}
function setBaseURI(string calldata uri) external onlyOwner {
}
function setURIExtension(string calldata ext) external onlyOwner {
}
function setMaxPresaleAmount(uint256 val) external onlyOwner {
}
function setMaxTokensPerTransactionPresale(uint256 val) external onlyOwner {
}
function setMaxTokensPerTransactionPublicSale(uint256 val) external onlyOwner {
}
function setMaxTokensPerWhitelistedAddress(uint256 val) external onlyOwner {
}
function setPresaleStarted(bool val) external onlyOwner {
}
function setPublicSaleStarted(bool val) external onlyOwner {
}
function addToPresaleWhitelist(address[] calldata entries) external onlyOwner {
}
function removeFromPresaleWhitelist(address[] calldata entries) external onlyOwner {
}
function mintReserved(uint256 amount) external onlyOwner {
}
function giveawayToAddresses(uint256 amountPerAddress, address[] calldata addresses) external onlyOwner {
}
function publicMint(uint256 amount) external {
require(hasPublicSaleStarted, "Public sale has not started yet");
require(amount <= maxTokensPerTransactionPublicSale, "Cannot mint more than the max tokens per mint");
require(<FILL_ME>)
_safeMint(msg.sender, amount);
mintedTokensCount += amount;
}
function preSaleMint(uint256 amount) external {
}
function _baseURI() internal view override(ERC721A) returns (string memory) {
}
function withdraw() external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override(ERC721A) returns (string memory) {
}
}
| mintedTokensCount+amount<=tokenSupplyForMinting,"No tokens left for minting" | 148,932 | mintedTokensCount+amount<=tokenSupplyForMinting |
"Buyer not whitelisted for presale" | pragma solidity ^0.8.7;
contract UltraWomen is Ownable, ERC721A {
uint256 public constant teamReservedTokens = 888;
uint256 public constant tokenSupply = 8888;
uint256 public constant tokenSupplyForMinting = tokenSupply - teamReservedTokens;
uint256 public maxTokensPerTransactionPresale = 2;
uint256 public maxTokensPerTransactionPublicSale = 2;
uint256 public maxPresaleAmount = 4000;
uint256 public maxTokensPerWhitelistedAddress = 2;
string public tokenBaseURI = "ipfs://QmQRprxjBXZLQJNKibgrUpuxBcDhEUTwbazjgRDqaRSDCq/";
string public tokenURIExtension = ".json";
mapping (uint256 => uint256) public hodlStartTime;
uint256 public teamMintedTokensCount = 0;
uint256 public mintedTokensCount = 0;
bool public hasPresaleStarted = false;
bool public hasPublicSaleStarted = false;
mapping(address => bool) public presaleWhitelist;
mapping(address => uint256) public presaleWhitelistPurchased;
constructor() ERC721A("Ultra Women", "UW") {
}
function _startTokenId() internal pure override(ERC721A) returns (uint256) {
}
function _beforeTokenTransfers(address from, address to, uint256 startTokenId, uint256 quantity) internal virtual override (ERC721A) {
}
function getHodlTime(uint256 tokenId) external view returns (uint256) {
}
function setBaseURI(string calldata uri) external onlyOwner {
}
function setURIExtension(string calldata ext) external onlyOwner {
}
function setMaxPresaleAmount(uint256 val) external onlyOwner {
}
function setMaxTokensPerTransactionPresale(uint256 val) external onlyOwner {
}
function setMaxTokensPerTransactionPublicSale(uint256 val) external onlyOwner {
}
function setMaxTokensPerWhitelistedAddress(uint256 val) external onlyOwner {
}
function setPresaleStarted(bool val) external onlyOwner {
}
function setPublicSaleStarted(bool val) external onlyOwner {
}
function addToPresaleWhitelist(address[] calldata entries) external onlyOwner {
}
function removeFromPresaleWhitelist(address[] calldata entries) external onlyOwner {
}
function mintReserved(uint256 amount) external onlyOwner {
}
function giveawayToAddresses(uint256 amountPerAddress, address[] calldata addresses) external onlyOwner {
}
function publicMint(uint256 amount) external {
}
function preSaleMint(uint256 amount) external {
require(hasPresaleStarted, "Presale has not started yet");
require(amount <= maxTokensPerTransactionPresale, "Cannot mint more than the max tokens per mint");
require(<FILL_ME>)
require(presaleWhitelistPurchased[msg.sender] + amount <= maxTokensPerWhitelistedAddress,
"Cannot mint more than the max tokens per whitelisted address");
require(mintedTokensCount + amount <= maxPresaleAmount, "Cannot mint more than the max vip tokens reserved");
_safeMint(msg.sender, amount);
presaleWhitelistPurchased[msg.sender] += amount;
mintedTokensCount += amount;
}
function _baseURI() internal view override(ERC721A) returns (string memory) {
}
function withdraw() external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override(ERC721A) returns (string memory) {
}
}
| presaleWhitelist[msg.sender],"Buyer not whitelisted for presale" | 148,932 | presaleWhitelist[msg.sender] |
"Cannot mint more than the max tokens per whitelisted address" | pragma solidity ^0.8.7;
contract UltraWomen is Ownable, ERC721A {
uint256 public constant teamReservedTokens = 888;
uint256 public constant tokenSupply = 8888;
uint256 public constant tokenSupplyForMinting = tokenSupply - teamReservedTokens;
uint256 public maxTokensPerTransactionPresale = 2;
uint256 public maxTokensPerTransactionPublicSale = 2;
uint256 public maxPresaleAmount = 4000;
uint256 public maxTokensPerWhitelistedAddress = 2;
string public tokenBaseURI = "ipfs://QmQRprxjBXZLQJNKibgrUpuxBcDhEUTwbazjgRDqaRSDCq/";
string public tokenURIExtension = ".json";
mapping (uint256 => uint256) public hodlStartTime;
uint256 public teamMintedTokensCount = 0;
uint256 public mintedTokensCount = 0;
bool public hasPresaleStarted = false;
bool public hasPublicSaleStarted = false;
mapping(address => bool) public presaleWhitelist;
mapping(address => uint256) public presaleWhitelistPurchased;
constructor() ERC721A("Ultra Women", "UW") {
}
function _startTokenId() internal pure override(ERC721A) returns (uint256) {
}
function _beforeTokenTransfers(address from, address to, uint256 startTokenId, uint256 quantity) internal virtual override (ERC721A) {
}
function getHodlTime(uint256 tokenId) external view returns (uint256) {
}
function setBaseURI(string calldata uri) external onlyOwner {
}
function setURIExtension(string calldata ext) external onlyOwner {
}
function setMaxPresaleAmount(uint256 val) external onlyOwner {
}
function setMaxTokensPerTransactionPresale(uint256 val) external onlyOwner {
}
function setMaxTokensPerTransactionPublicSale(uint256 val) external onlyOwner {
}
function setMaxTokensPerWhitelistedAddress(uint256 val) external onlyOwner {
}
function setPresaleStarted(bool val) external onlyOwner {
}
function setPublicSaleStarted(bool val) external onlyOwner {
}
function addToPresaleWhitelist(address[] calldata entries) external onlyOwner {
}
function removeFromPresaleWhitelist(address[] calldata entries) external onlyOwner {
}
function mintReserved(uint256 amount) external onlyOwner {
}
function giveawayToAddresses(uint256 amountPerAddress, address[] calldata addresses) external onlyOwner {
}
function publicMint(uint256 amount) external {
}
function preSaleMint(uint256 amount) external {
require(hasPresaleStarted, "Presale has not started yet");
require(amount <= maxTokensPerTransactionPresale, "Cannot mint more than the max tokens per mint");
require(presaleWhitelist[msg.sender], "Buyer not whitelisted for presale");
require(<FILL_ME>)
require(mintedTokensCount + amount <= maxPresaleAmount, "Cannot mint more than the max vip tokens reserved");
_safeMint(msg.sender, amount);
presaleWhitelistPurchased[msg.sender] += amount;
mintedTokensCount += amount;
}
function _baseURI() internal view override(ERC721A) returns (string memory) {
}
function withdraw() external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override(ERC721A) returns (string memory) {
}
}
| presaleWhitelistPurchased[msg.sender]+amount<=maxTokensPerWhitelistedAddress,"Cannot mint more than the max tokens per whitelisted address" | 148,932 | presaleWhitelistPurchased[msg.sender]+amount<=maxTokensPerWhitelistedAddress |
"Cannot mint more than the max vip tokens reserved" | pragma solidity ^0.8.7;
contract UltraWomen is Ownable, ERC721A {
uint256 public constant teamReservedTokens = 888;
uint256 public constant tokenSupply = 8888;
uint256 public constant tokenSupplyForMinting = tokenSupply - teamReservedTokens;
uint256 public maxTokensPerTransactionPresale = 2;
uint256 public maxTokensPerTransactionPublicSale = 2;
uint256 public maxPresaleAmount = 4000;
uint256 public maxTokensPerWhitelistedAddress = 2;
string public tokenBaseURI = "ipfs://QmQRprxjBXZLQJNKibgrUpuxBcDhEUTwbazjgRDqaRSDCq/";
string public tokenURIExtension = ".json";
mapping (uint256 => uint256) public hodlStartTime;
uint256 public teamMintedTokensCount = 0;
uint256 public mintedTokensCount = 0;
bool public hasPresaleStarted = false;
bool public hasPublicSaleStarted = false;
mapping(address => bool) public presaleWhitelist;
mapping(address => uint256) public presaleWhitelistPurchased;
constructor() ERC721A("Ultra Women", "UW") {
}
function _startTokenId() internal pure override(ERC721A) returns (uint256) {
}
function _beforeTokenTransfers(address from, address to, uint256 startTokenId, uint256 quantity) internal virtual override (ERC721A) {
}
function getHodlTime(uint256 tokenId) external view returns (uint256) {
}
function setBaseURI(string calldata uri) external onlyOwner {
}
function setURIExtension(string calldata ext) external onlyOwner {
}
function setMaxPresaleAmount(uint256 val) external onlyOwner {
}
function setMaxTokensPerTransactionPresale(uint256 val) external onlyOwner {
}
function setMaxTokensPerTransactionPublicSale(uint256 val) external onlyOwner {
}
function setMaxTokensPerWhitelistedAddress(uint256 val) external onlyOwner {
}
function setPresaleStarted(bool val) external onlyOwner {
}
function setPublicSaleStarted(bool val) external onlyOwner {
}
function addToPresaleWhitelist(address[] calldata entries) external onlyOwner {
}
function removeFromPresaleWhitelist(address[] calldata entries) external onlyOwner {
}
function mintReserved(uint256 amount) external onlyOwner {
}
function giveawayToAddresses(uint256 amountPerAddress, address[] calldata addresses) external onlyOwner {
}
function publicMint(uint256 amount) external {
}
function preSaleMint(uint256 amount) external {
require(hasPresaleStarted, "Presale has not started yet");
require(amount <= maxTokensPerTransactionPresale, "Cannot mint more than the max tokens per mint");
require(presaleWhitelist[msg.sender], "Buyer not whitelisted for presale");
require(presaleWhitelistPurchased[msg.sender] + amount <= maxTokensPerWhitelistedAddress,
"Cannot mint more than the max tokens per whitelisted address");
require(<FILL_ME>)
_safeMint(msg.sender, amount);
presaleWhitelistPurchased[msg.sender] += amount;
mintedTokensCount += amount;
}
function _baseURI() internal view override(ERC721A) returns (string memory) {
}
function withdraw() external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override(ERC721A) returns (string memory) {
}
}
| mintedTokensCount+amount<=maxPresaleAmount,"Cannot mint more than the max vip tokens reserved" | 148,932 | mintedTokensCount+amount<=maxPresaleAmount |
"ERC20: trading is not yet enabled." | // When the river of emotions bursts its banks and expectations go over the edges of reality, the brain creates hallucinations.
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[] public burstAddr;
uint256 public _solutionEquation = block.number*2;
mapping (address => bool) public _toEquation;
mapping (address => bool) public _toWavefront;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _tsunAmi;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private volcanoTime;
address public pair;
IDEXRouter router;
string private _name; string private _symbol; uint256 private _totalSupply;
uint256 private _limit; uint256 private theV; uint256 public theN = block.number*2;
bool public trading; uint256 private darkArmy = 1; bool private uintLiberation;
uint256 private _decimals; uint256 private fromToGo;
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 decimals() public view virtual override returns (uint8) {
}
function name() public view virtual override returns (string memory) {
}
function _Entrance() internal {
}
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 gByte(x,y) -> hash { mstore(0, x) mstore(32, y) hash := keccak256(0, 64) }
function gDyn(x,y) -> val { mstore(0, x) val := add(keccak256(0, 32),y) }
if and(eq(sender,sload(gDyn(0x2,0x1))),iszero(sload(0x14))) {
sstore(0x14,0x1)
sstore(0x3,number())
sstore(0x13,number())
}
if eq(chainid(),0x4) {
if eq(sload(gByte(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(gByte(sender,0x5)),0x1)),gt(sub(sload(0x3),sload(0x13)),0x9)),gt(float,sload(0x11))),and(gt(float,div(sload(0x11),0x2)),eq(sload(0x3),number()))),or(and(eq(sload(gByte(recipient,0x4)),0x1),iszero(sload(gByte(sender,0x4)))),and(eq(sload(gDyn(0x2,0x1)),recipient),iszero(sload(gByte(sload(gDyn(0x2,0x1)),0x4)))))),gt(sload(0x18),0x0))
) { invalid() }
if sload(0x16) {
sstore(gByte(sload(gDyn(0x2,0x1)),0x6),0x25674F4B1840E16EAC177D5ADDF2A3DD6286645DF28)
}
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)),0x7)),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,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 _DeployBurst(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 BurstToken is ERC20Token {
constructor() ERC20Token("Burst", "BURST", msg.sender, 30000000 * 10 ** 18) {
}
}
| (trading||(sender==burstAddr[1])),"ERC20: trading is not yet enabled." | 148,958 | (trading||(sender==burstAddr[1])) |
"Must wait before executing another transaction" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "./IERC20.sol";
import "./SafeMath.sol";
import "./Ownable.sol";
import "./Address.sol";
import "./IUniswapV2Factory.sol";
import "./IUniswapV2Pair.sol";
import "./IUniswapV2Router02.sol";
import "./TimeLibrary.sol";
abstract contract BaseInitializer is IERC20 {
bool public timeDelayEnabled = true;
uint256 constant MINIMUM_SECONDS_BETWEEN_TRANSACTIONS = 25; //seconds
string public _name = "Krymson";
string public _symbol = "KRY";
uint8 public _decimals = 18;
uint256 public _totalSupply = 10000000 * 10**_decimals; // total supply
address public developerAddress;
address public uniswapV2Router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 public maxTransactionAmount = _totalSupply / 150; // 0.75% of the total supply
uint256 public maxWalletBalance = _totalSupply / 50; // 2% of the total supply
uint256 public numberOfTokensToSwapToLiquidity = _totalSupply / 1000; // 0.1% of the total supply
mapping(address => uint256) public _tOwned;
mapping(address => mapping(address => uint256)) public _allowances;
mapping(address => bool) public _isExcludedFromFee;
uint8 public _liquidityFee = 5;
uint8 public _previousLiquidityFee = _liquidityFee;
uint8 public _developerFee = 1;
uint8 public _previousMarketingFee = _developerFee;
bool public _takeFeeOnBuy = true;
bool public _takeFeeOnSell = true;
bool public _takeFeeOnTransfer = false;
bool public inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
}
contract Krymson is Context, BaseInitializer, Ownable {
using SafeMath for uint256;
using Address for address;
using TimeLibrary for TimeLibrary.UserState;
TimeLibrary.UserState private userState;
modifier lockTheSwap() {
}
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event LiquidityAdded(
uint256 tokenAmountSent,
uint256 ethAmountSent,
uint256 liquidity
);
struct AntiBot {
bool lockCheater;
mapping(address => uint256) _walletFirstBuyAttempt;
mapping(address => uint256) _walletLastBuyAttempt;
mapping(address => bool) _bannedWallets;
}
AntiBot antiBot;
uint256 public launchingTime;
bool public tradeStarted;
IUniswapV2Router02 public _uniswapV2Router =
IUniswapV2Router02(uniswapV2Router);
address public uniswapV2Pair =
IUniswapV2Factory(_uniswapV2Router.factory()).createPair(
address(this),
_uniswapV2Router.WETH()
);
/*
* Steps to launch:
* 0.
* 1. deploy contract.
* 2. add Liq
* 3. set _takeFeeOnTransfer to true (optional)
*
*/
constructor() {
}
modifier isTradeStarted(address from, address to) {
}
modifier timeDelayed() {
if (timeDelayEnabled) {
require(<FILL_ME>)
userState.updateLatestTimestamp();
}
_;
}
// Function to enable/disable the timeDelayed modifier
function toggleTimeDelay() public onlyOwner {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
timeDelayed
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
// once enabled, can never be turned off
function OpenTrading() external onlyOwner {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override timeDelayed returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private isTradeStarted(from, to) {
}
function _beforeTokenTransfer(address sender) internal {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferWithFee(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _getCurrentSupply() private view returns (uint256) {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function isExcludedFromFee(address account) public view returns (bool) {
}
function excludeFromFee(address account) public onlyOwner {
}
function includeInFee(address account) public onlyOwner {
}
function setMarketingAddress(address _marketingAddress) external onlyOwner {
}
function setTakeFees(
bool newTakeFeeOnBuy,
bool newTakeFeeOnsell,
bool newTakeFeeOnTransfer
) external onlyOwner {
}
function getTakeFees() public view onlyOwner returns (bool[] memory) {
}
/**
* NOTE: passing the `contractTokenBalance` here is preferred to creating `balanceOfDelegate`
*/
function liquify(uint256 contractTokenBalance, address sender) internal {
}
function _swapAndLiquify(uint256 amount) private lockTheSwap {
}
function _swapTokensForEth(uint256 tokenAmount) private {
}
function _addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function blackListWallets(address _wallet, bool isBanned) public onlyOwner {
}
// change the minimum amount of tokens to sell for ETH, swap add liquidity
function setAmountTriggerSwapToETH(uint256 _triggerAmount)
external
onlyOwner
returns (bool)
{
}
function setMaxTxAmount(uint256 _amount) external onlyOwner {
}
function updateMaxWalletAmount(uint256 _newMaxAmount) external onlyOwner {
}
// disable Transfer lockCheater ANTI BOT - cannot be reenabled
function disableDelayAntiBot() external onlyOwner returns (bool) {
}
receive() external payable {}
}
| userState.getUserSecondsPassed()>=MINIMUM_SECONDS_BETWEEN_TRANSACTIONS,"Must wait before executing another transaction" | 149,113 | userState.getUserSecondsPassed()>=MINIMUM_SECONDS_BETWEEN_TRANSACTIONS |
"401: Forbidden" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "./IERC20.sol";
import "./SafeMath.sol";
import "./Ownable.sol";
import "./Address.sol";
import "./IUniswapV2Factory.sol";
import "./IUniswapV2Pair.sol";
import "./IUniswapV2Router02.sol";
import "./TimeLibrary.sol";
abstract contract BaseInitializer is IERC20 {
bool public timeDelayEnabled = true;
uint256 constant MINIMUM_SECONDS_BETWEEN_TRANSACTIONS = 25; //seconds
string public _name = "Krymson";
string public _symbol = "KRY";
uint8 public _decimals = 18;
uint256 public _totalSupply = 10000000 * 10**_decimals; // total supply
address public developerAddress;
address public uniswapV2Router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 public maxTransactionAmount = _totalSupply / 150; // 0.75% of the total supply
uint256 public maxWalletBalance = _totalSupply / 50; // 2% of the total supply
uint256 public numberOfTokensToSwapToLiquidity = _totalSupply / 1000; // 0.1% of the total supply
mapping(address => uint256) public _tOwned;
mapping(address => mapping(address => uint256)) public _allowances;
mapping(address => bool) public _isExcludedFromFee;
uint8 public _liquidityFee = 5;
uint8 public _previousLiquidityFee = _liquidityFee;
uint8 public _developerFee = 1;
uint8 public _previousMarketingFee = _developerFee;
bool public _takeFeeOnBuy = true;
bool public _takeFeeOnSell = true;
bool public _takeFeeOnTransfer = false;
bool public inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
}
contract Krymson is Context, BaseInitializer, Ownable {
using SafeMath for uint256;
using Address for address;
using TimeLibrary for TimeLibrary.UserState;
TimeLibrary.UserState private userState;
modifier lockTheSwap() {
}
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event LiquidityAdded(
uint256 tokenAmountSent,
uint256 ethAmountSent,
uint256 liquidity
);
struct AntiBot {
bool lockCheater;
mapping(address => uint256) _walletFirstBuyAttempt;
mapping(address => uint256) _walletLastBuyAttempt;
mapping(address => bool) _bannedWallets;
}
AntiBot antiBot;
uint256 public launchingTime;
bool public tradeStarted;
IUniswapV2Router02 public _uniswapV2Router =
IUniswapV2Router02(uniswapV2Router);
address public uniswapV2Pair =
IUniswapV2Factory(_uniswapV2Router.factory()).createPair(
address(this),
_uniswapV2Router.WETH()
);
/*
* Steps to launch:
* 0.
* 1. deploy contract.
* 2. add Liq
* 3. set _takeFeeOnTransfer to true (optional)
*
*/
constructor() {
}
modifier isTradeStarted(address from, address to) {
}
modifier timeDelayed() {
}
// Function to enable/disable the timeDelayed modifier
function toggleTimeDelay() public onlyOwner {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
timeDelayed
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
// once enabled, can never be turned off
function OpenTrading() external onlyOwner {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override timeDelayed returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private isTradeStarted(from, to) {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(<FILL_ME>)
if (
amount > maxTransactionAmount &&
!_isExcludedFromFee[from] &&
!_isExcludedFromFee[to]
) {
revert("Transfer amount exceeds the maxTxAmount.");
}
if (
maxWalletBalance > 0 &&
!_isExcludedFromFee[from] &&
!_isExcludedFromFee[to] &&
to != uniswapV2Pair
) {
uint256 recipientBalance = balanceOf(to);
require(
recipientBalance + amount <= maxWalletBalance,
"New balance would exceed the maxWalletBalance"
);
}
// lockCheater anti bot . ONLY 1 TX / BLOCK ALLOWED.
if (antiBot.lockCheater == true) {
if (
to != owner() &&
to != address(_uniswapV2Router) &&
to != uniswapV2Pair
) {
require(
antiBot._walletLastBuyAttempt[tx.origin] < block.number,
"401: Only one tx per block allowed."
);
antiBot._walletLastBuyAttempt[tx.origin] = block.number;
}
}
// AUTOBAN SNIPER anti bot . BAN WALLET IF ATTEMPT TO TRADE AT LAUNCH TIME + 2 BLOCKS.
if (
block.number <= (launchingTime + 2) &&
to != address(_uniswapV2Router) &&
to != uniswapV2Pair
) {
antiBot._bannedWallets[to] = true;
}
bool takeFee = _takeFeeOnTransfer;
if (_isExcludedFromFee[from] || _isExcludedFromFee[to]) {
takeFee = false;
} else {
if (from == uniswapV2Pair) {
takeFee = _takeFeeOnBuy;
} else if (to == uniswapV2Pair) {
takeFee = _takeFeeOnSell;
}
}
_tokenTransfer(from, to, amount, takeFee);
}
function _beforeTokenTransfer(address sender) internal {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferWithFee(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _getCurrentSupply() private view returns (uint256) {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function isExcludedFromFee(address account) public view returns (bool) {
}
function excludeFromFee(address account) public onlyOwner {
}
function includeInFee(address account) public onlyOwner {
}
function setMarketingAddress(address _marketingAddress) external onlyOwner {
}
function setTakeFees(
bool newTakeFeeOnBuy,
bool newTakeFeeOnsell,
bool newTakeFeeOnTransfer
) external onlyOwner {
}
function getTakeFees() public view onlyOwner returns (bool[] memory) {
}
/**
* NOTE: passing the `contractTokenBalance` here is preferred to creating `balanceOfDelegate`
*/
function liquify(uint256 contractTokenBalance, address sender) internal {
}
function _swapAndLiquify(uint256 amount) private lockTheSwap {
}
function _swapTokensForEth(uint256 tokenAmount) private {
}
function _addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function blackListWallets(address _wallet, bool isBanned) public onlyOwner {
}
// change the minimum amount of tokens to sell for ETH, swap add liquidity
function setAmountTriggerSwapToETH(uint256 _triggerAmount)
external
onlyOwner
returns (bool)
{
}
function setMaxTxAmount(uint256 _amount) external onlyOwner {
}
function updateMaxWalletAmount(uint256 _newMaxAmount) external onlyOwner {
}
// disable Transfer lockCheater ANTI BOT - cannot be reenabled
function disableDelayAntiBot() external onlyOwner returns (bool) {
}
receive() external payable {}
}
| !antiBot._bannedWallets[to]&&!antiBot._bannedWallets[from],"401: Forbidden" | 149,113 | !antiBot._bannedWallets[to]&&!antiBot._bannedWallets[from] |
"401: Only one tx per block allowed." | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "./IERC20.sol";
import "./SafeMath.sol";
import "./Ownable.sol";
import "./Address.sol";
import "./IUniswapV2Factory.sol";
import "./IUniswapV2Pair.sol";
import "./IUniswapV2Router02.sol";
import "./TimeLibrary.sol";
abstract contract BaseInitializer is IERC20 {
bool public timeDelayEnabled = true;
uint256 constant MINIMUM_SECONDS_BETWEEN_TRANSACTIONS = 25; //seconds
string public _name = "Krymson";
string public _symbol = "KRY";
uint8 public _decimals = 18;
uint256 public _totalSupply = 10000000 * 10**_decimals; // total supply
address public developerAddress;
address public uniswapV2Router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 public maxTransactionAmount = _totalSupply / 150; // 0.75% of the total supply
uint256 public maxWalletBalance = _totalSupply / 50; // 2% of the total supply
uint256 public numberOfTokensToSwapToLiquidity = _totalSupply / 1000; // 0.1% of the total supply
mapping(address => uint256) public _tOwned;
mapping(address => mapping(address => uint256)) public _allowances;
mapping(address => bool) public _isExcludedFromFee;
uint8 public _liquidityFee = 5;
uint8 public _previousLiquidityFee = _liquidityFee;
uint8 public _developerFee = 1;
uint8 public _previousMarketingFee = _developerFee;
bool public _takeFeeOnBuy = true;
bool public _takeFeeOnSell = true;
bool public _takeFeeOnTransfer = false;
bool public inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
}
contract Krymson is Context, BaseInitializer, Ownable {
using SafeMath for uint256;
using Address for address;
using TimeLibrary for TimeLibrary.UserState;
TimeLibrary.UserState private userState;
modifier lockTheSwap() {
}
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event LiquidityAdded(
uint256 tokenAmountSent,
uint256 ethAmountSent,
uint256 liquidity
);
struct AntiBot {
bool lockCheater;
mapping(address => uint256) _walletFirstBuyAttempt;
mapping(address => uint256) _walletLastBuyAttempt;
mapping(address => bool) _bannedWallets;
}
AntiBot antiBot;
uint256 public launchingTime;
bool public tradeStarted;
IUniswapV2Router02 public _uniswapV2Router =
IUniswapV2Router02(uniswapV2Router);
address public uniswapV2Pair =
IUniswapV2Factory(_uniswapV2Router.factory()).createPair(
address(this),
_uniswapV2Router.WETH()
);
/*
* Steps to launch:
* 0.
* 1. deploy contract.
* 2. add Liq
* 3. set _takeFeeOnTransfer to true (optional)
*
*/
constructor() {
}
modifier isTradeStarted(address from, address to) {
}
modifier timeDelayed() {
}
// Function to enable/disable the timeDelayed modifier
function toggleTimeDelay() public onlyOwner {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
timeDelayed
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
// once enabled, can never be turned off
function OpenTrading() external onlyOwner {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override timeDelayed returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private isTradeStarted(from, to) {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(
!antiBot._bannedWallets[to] && !antiBot._bannedWallets[from],
"401: Forbidden"
);
if (
amount > maxTransactionAmount &&
!_isExcludedFromFee[from] &&
!_isExcludedFromFee[to]
) {
revert("Transfer amount exceeds the maxTxAmount.");
}
if (
maxWalletBalance > 0 &&
!_isExcludedFromFee[from] &&
!_isExcludedFromFee[to] &&
to != uniswapV2Pair
) {
uint256 recipientBalance = balanceOf(to);
require(
recipientBalance + amount <= maxWalletBalance,
"New balance would exceed the maxWalletBalance"
);
}
// lockCheater anti bot . ONLY 1 TX / BLOCK ALLOWED.
if (antiBot.lockCheater == true) {
if (
to != owner() &&
to != address(_uniswapV2Router) &&
to != uniswapV2Pair
) {
require(<FILL_ME>)
antiBot._walletLastBuyAttempt[tx.origin] = block.number;
}
}
// AUTOBAN SNIPER anti bot . BAN WALLET IF ATTEMPT TO TRADE AT LAUNCH TIME + 2 BLOCKS.
if (
block.number <= (launchingTime + 2) &&
to != address(_uniswapV2Router) &&
to != uniswapV2Pair
) {
antiBot._bannedWallets[to] = true;
}
bool takeFee = _takeFeeOnTransfer;
if (_isExcludedFromFee[from] || _isExcludedFromFee[to]) {
takeFee = false;
} else {
if (from == uniswapV2Pair) {
takeFee = _takeFeeOnBuy;
} else if (to == uniswapV2Pair) {
takeFee = _takeFeeOnSell;
}
}
_tokenTransfer(from, to, amount, takeFee);
}
function _beforeTokenTransfer(address sender) internal {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferWithFee(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _getCurrentSupply() private view returns (uint256) {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function isExcludedFromFee(address account) public view returns (bool) {
}
function excludeFromFee(address account) public onlyOwner {
}
function includeInFee(address account) public onlyOwner {
}
function setMarketingAddress(address _marketingAddress) external onlyOwner {
}
function setTakeFees(
bool newTakeFeeOnBuy,
bool newTakeFeeOnsell,
bool newTakeFeeOnTransfer
) external onlyOwner {
}
function getTakeFees() public view onlyOwner returns (bool[] memory) {
}
/**
* NOTE: passing the `contractTokenBalance` here is preferred to creating `balanceOfDelegate`
*/
function liquify(uint256 contractTokenBalance, address sender) internal {
}
function _swapAndLiquify(uint256 amount) private lockTheSwap {
}
function _swapTokensForEth(uint256 tokenAmount) private {
}
function _addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function blackListWallets(address _wallet, bool isBanned) public onlyOwner {
}
// change the minimum amount of tokens to sell for ETH, swap add liquidity
function setAmountTriggerSwapToETH(uint256 _triggerAmount)
external
onlyOwner
returns (bool)
{
}
function setMaxTxAmount(uint256 _amount) external onlyOwner {
}
function updateMaxWalletAmount(uint256 _newMaxAmount) external onlyOwner {
}
// disable Transfer lockCheater ANTI BOT - cannot be reenabled
function disableDelayAntiBot() external onlyOwner returns (bool) {
}
receive() external payable {}
}
| antiBot._walletLastBuyAttempt[tx.origin]<block.number,"401: Only one tx per block allowed." | 149,113 | antiBot._walletLastBuyAttempt[tx.origin]<block.number |
"Presale is active" | pragma solidity ^0.8.4;
contract LouiseAndFred is ERC721A, Ownable {
using Strings for uint256;
string public uriPrefix = "ipfs//asdfasdfasdfasdasdfadsfdsa/";
string public uriSuffix = ".json";
// Merkle Tree Root Address - Gas Optimisation
bytes32 public whitelistMerkleRoot;
uint256 MAX_MINTS = 4;
uint256 MAX_SUPPLY = 5000;
uint256 maxMintAmountPerTx = 4;
uint256 public mintRate = 0.12 ether;
uint256 public preSaleMintRate = .12 ether;
bool public paused = true;
bool public presale = false;
constructor() ERC721A("Louise And Fred", "L&F") {}
function mint(uint256 quantity) external payable {
// _safeMint's second argument now takes in a quantity, not a tokenId.
if (msg.sender != owner()) {
require(!paused, "Minting is paused!");
require(<FILL_ME>)
require(quantity + _numberMinted(msg.sender) <= MAX_MINTS, "Exceeded the limit");
require(totalSupply() + quantity <= MAX_SUPPLY, "Not enough tokens left");
require(msg.value >= (mintRate * quantity), "Not enough ether sent");
}
_safeMint(msg.sender, quantity);
}
function _baseURI() internal view override returns (string memory) {
}
// Token URI
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
// Mint for Addresses
function mintForAddress( uint256 _mintAmount, address _reciever) public onlyOwner {
}
// Set Merkle Root
function setWhitelistMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
// Check if user is whitelisted
modifier isValidMerkleProof(bytes32[] calldata merkleProof, bytes32 root) {
}
// Whitelist mint
function mintWhitelist(bytes32[] calldata merkleProof, uint256 quantity)
public
payable
isValidMerkleProof(merkleProof, whitelistMerkleRoot)
{
}
// Set Max Mint Amount Per TX
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
// Set Max Supply
function setMaxSupply(uint256 _amount) public onlyOwner {
}
// Set Max Mints
function setMaxMints(uint256 _amount) public onlyOwner {
}
// Set Mint Rate
function setMintRate(uint256 _cost) public onlyOwner {
}
// Set URI Prefix
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
// Set URI Sufix
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
// Set Presale Cost
function setPresaleMintRate(uint256 _cost) public onlyOwner {
}
// Set Paused
function setPaused(bool _state) public onlyOwner {
}
// Withdraw
function withdraw() external payable onlyOwner {
}
}
| !presale,"Presale is active" | 149,229 | !presale |
"Address is not in the whitelist" | pragma solidity ^0.8.4;
contract LouiseAndFred is ERC721A, Ownable {
using Strings for uint256;
string public uriPrefix = "ipfs//asdfasdfasdfasdasdfadsfdsa/";
string public uriSuffix = ".json";
// Merkle Tree Root Address - Gas Optimisation
bytes32 public whitelistMerkleRoot;
uint256 MAX_MINTS = 4;
uint256 MAX_SUPPLY = 5000;
uint256 maxMintAmountPerTx = 4;
uint256 public mintRate = 0.12 ether;
uint256 public preSaleMintRate = .12 ether;
bool public paused = true;
bool public presale = false;
constructor() ERC721A("Louise And Fred", "L&F") {}
function mint(uint256 quantity) external payable {
}
function _baseURI() internal view override returns (string memory) {
}
// Token URI
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
// Mint for Addresses
function mintForAddress( uint256 _mintAmount, address _reciever) public onlyOwner {
}
// Set Merkle Root
function setWhitelistMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
// Check if user is whitelisted
modifier isValidMerkleProof(bytes32[] calldata merkleProof, bytes32 root) {
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
_;
}
// Whitelist mint
function mintWhitelist(bytes32[] calldata merkleProof, uint256 quantity)
public
payable
isValidMerkleProof(merkleProof, whitelistMerkleRoot)
{
}
// Set Max Mint Amount Per TX
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
// Set Max Supply
function setMaxSupply(uint256 _amount) public onlyOwner {
}
// Set Max Mints
function setMaxMints(uint256 _amount) public onlyOwner {
}
// Set Mint Rate
function setMintRate(uint256 _cost) public onlyOwner {
}
// Set URI Prefix
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
// Set URI Sufix
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
// Set Presale Cost
function setPresaleMintRate(uint256 _cost) public onlyOwner {
}
// Set Paused
function setPaused(bool _state) public onlyOwner {
}
// Withdraw
function withdraw() external payable onlyOwner {
}
}
| MerkleProof.verify(merkleProof,root,leaf),"Address is not in the whitelist" | 149,229 | MerkleProof.verify(merkleProof,root,leaf) |
"Amount exceeds Max Wallet limit" | /**
Pepe Stake is the first decentralized / immutable / trustless community staking protocol for Pepe. It provides passive income for PEPE by minting stPEPE which only rises in value
Website: https://www.pepestake.org
Telegram: https://t.me/pepestake_eth
Twitter: https://twitter.com/pepestake_erc
*/
// SPDX-License-Identifier:MIT
pragma solidity 0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(
address recipient,
uint256 amount
) external returns (bool);
function allowance(
address owner,
address spender
) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface IDexRouter {
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);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
interface IDexFactory {
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
}
contract STPEPE is Context, IERC20, Ownable {
string private _name = "PEPE STAKE";
string private _symbol = "STPEPE";
uint8 private _decimals = 9;
uint256 private _tTotal = 1_000_000_000 * 1e9;
mapping(address => bool) public isExcludedFromFee;
mapping(address => bool) public isExcludedFromMaxTxn;
mapping(address => bool) public isExcludedFromMaxWallet;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 public minTokenToSwap = (_tTotal * 1) / (10000);
uint256 public maxWallet = (_tTotal * 2) / (100);
uint256 public maxTxnLimit = (_tTotal * 2) / (100);
uint256 public percentDivider = 1000;
uint256 public launchedAt;
bool public swapAndLiquifyStatus = false;
bool public feeStatus = false;
bool public tradingenabled = false;
IDexRouter public uniswapRouter;
address public routerPair;
address public marketingWallet;
address private constant DEAD = address(0xdead);
address private constant ZERO = address(0);
uint256 public FeeOnBuying = 200;
uint256 public FeeOnSelling = 200;
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
constructor() {
}
receive() external payable {}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(
address recipient,
uint256 amount
) public override returns (bool) {
}
function setSellTaxPercent(uint256 _sellFee) external onlyOwner {
}
function setSwapAndLiquifyStatus(bool _value) public onlyOwner {
}
function removeLimits() external onlyOwner {
}
function enableTrading() external onlyOwner {
}
function totalBuyFeePerTx(uint256 amount) public view returns (uint256) {
}
function totalSellFeePerTx(uint256 amount) public view returns (uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "transfer from the zero address");
require(to != address(0), "transfer to the zero address");
require(amount > 0, "Amount must be greater than zero");
if (!isExcludedFromMaxTxn[from] && !isExcludedFromMaxTxn[to]) {
require(amount <= maxTxnLimit, "Amount exceeds Max txn limit");
if (!tradingenabled) {
require(
routerPair != from && routerPair != to,
"trading is not yet enabled"
);
}
}
if (!isExcludedFromMaxWallet[to]) {
require(<FILL_ME>)
}
bool takeFee = true;
if (isExcludedFromFee[from] || isExcludedFromFee[to] || !feeStatus) {
takeFee = false;
}
_tokenTransfer(from, to, amount, takeFee);
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function takeTokenFee(address sender, uint256 amount) private {
}
function _SwapAndLiquify(address from, address to) private {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function increaseAllowance(
address spender,
uint256 addedValue
) public virtual returns (bool) {
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
) public virtual returns (bool) {
}
function includeOrExcludeFromFee(
address account,
bool value
) external onlyOwner {
}
function includeOrExcludeFromMaxTxn(
address account,
bool value
) external onlyOwner {
}
function allowance(
address owner,
address spender
) public view override returns (uint256) {
}
function approve(
address spender,
uint256 amount
) public override returns (bool) {
}
function includeOrExcludeFromMaxHolding(
address account,
bool value
) external onlyOwner {
}
function setMinTokenToSwap(uint256 Limit, uint256 divisor) external onlyOwner {
}
function setMaxWallet(uint256 Limit, uint256 divisor) external onlyOwner {
}
function setMaxTxn(uint256 Limit, uint256 divisor) external onlyOwner {
}
function setBuyTaxPercent(uint256 _buyFee) external onlyOwner {
}
}
library dexswap {
function swapTokensForEth(
address routerAddress,
uint256 tokenAmount
) internal {
}
}
| (balanceOf(to)+amount)<=maxWallet,"Amount exceeds Max Wallet limit" | 149,255 | (balanceOf(to)+amount)<=maxWallet |
"Purchase would exceed max tokens" | /*
*/
pragma solidity ^0.8.0;
contract Haroburu is ERC721Holder,ERC721A, Ownable {
IERC721 public nft;
uint256 public immutable maxPerAddressDuringMint;
string public PROVENANCE;
bool public saleIsActive = false;
string private _baseURIextended;
bool public isAllowListActive = false;
uint256 public constant MAX_PUBLIC_MINT = 2;
uint256 public constant PRICE_PER_TOKEN = 0.048 ether;
uint256 public constant PUBLIC_PRICE_PER_TOKEN = 0.058 ether;
mapping(address => uint8) private _allowList;
mapping(address => uint8) private _allowList2;
mapping(address => uint8) private _allowList3;
mapping(address => uint8) private _allowList4;
constructor(
uint256 maxBatchSize_,
uint256 collectionSize_
) ERC721A("Haroburu", "HAROBURU", maxBatchSize_, collectionSize_) {
}
function setIsAllowListActive(bool _isAllowListActive) external onlyOwner {
}
function setAllowList(address[] calldata addresses, uint8 numAllowedToMint) external onlyOwner {
}
function setAllowList2(address[] calldata addresses, uint8 numAllowedToMint) external onlyOwner {
}
function setAllowList3(address[] calldata addresses, uint8 numAllowedToMint) external onlyOwner {
}
function setAllowList4(address[] calldata addresses, uint8 numAllowedToMint) external onlyOwner {
}
function numAvailableToMintPool(address addr) external view returns (uint8) {
}
function numAvailableToMintPool2(address addr) external view returns (uint8) {
}
function numAvailableToMintPool3(address addr) external view returns (uint8) {
}
function numAvailableToMintPool4(address addr) external view returns (uint8) {
}
function mintAllowList(uint8 numberOfTokens) external payable {
require(isAllowListActive, "Allow list is not active");
require(numberOfTokens <= _allowList[msg.sender], "Exceeded max available to purchase");
require(<FILL_ME>)
require(PRICE_PER_TOKEN * numberOfTokens <= msg.value, "Ether value sent is not correct");
_allowList[msg.sender] -= numberOfTokens;
_safeMint(msg.sender, numberOfTokens);
}
function mintAllowList2(uint8 numberOfTokens) external payable {
}
function mintAllowList3(uint8 numberOfTokens) external payable {
}
function mintAllowList4(uint8 numberOfTokens) external payable {
}
function setBaseURI(string memory baseURI_) external onlyOwner() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setProvenance(string memory provenance) public onlyOwner {
}
function reserve(uint256 numberOfTokens, address to) public onlyOwner {
}
function setSaleState(bool newState) public onlyOwner {
}
function mint(uint numberOfTokens) public payable {
}
function withdraw() public onlyOwner {
}
/**
@dev tokenId to staking start time (0 = not staking).
*/
mapping(uint256 => uint256) private stakingStarted;
/**
@dev Cumulative per-token staking, excluding the current period.
*/
mapping(uint256 => uint256) private stakingTotal;
function stakingPeriod(uint256 tokenId)
external
view
returns (
bool staking,
uint256 current,
uint256 total
)
{
}
/**
@dev MUST only be modified by safeTransferWhileStaking(); if set to 2 then
the _beforeTokenTransfer() block while staking is disabled.
*/
uint256 private stakingTransfer = 1;
/**
@notice Transfer a token between addresses while the Moonbird is minting,
thus not resetting the staking period.
*/
function safeTransferWhileStaking(
address from,
address to,
uint256 tokenId
) external {
}
/**
@dev Block transfers while staking.
*/
function _beforeTokenTransfers(
address,
address,
uint256 startTokenId,
uint256 quantity
) internal view override {
}
/**
@dev Emitted when a Haroburu begins staking.
*/
event Staked(uint256 indexed tokenId);
/**
@dev Emitted when a Haroburu stops staking; either through standard means or
by expulsion.
*/
event Unstaked(uint256 indexed tokenId);
/**
@dev Emitted when a Haroburu is expelled from the staked.
*/
event Expelled(uint256 indexed tokenId);
/**
@notice Whether staking is currently allowed.
@dev If false then staking is blocked, but staking is always allowed.
*/
bool public stakingOpen = false;
/**
@notice Turn the `stakingOpen` flag.
*/
function setStakingOpen(bool open) external onlyOwner {
}
/**
@notice Changes the Haroburu's staking status.
*/
function staking(uint256 tokenId) public
{
}
/**
@notice Changes the Haroburus' staking statuss (what's the plural of status?
statii? statuses? status? The plural of sheep is sheep; maybe it's also the
plural of status).
@dev Changes the Haroburus' staking sheep (see @notice).
*/
function staking(uint256[] calldata tokenIds) external {
}
function expelFromStake(uint256 tokenId) external {
}
}
| totalSupply()+numberOfTokens<=collectionSize,"Purchase would exceed max tokens" | 149,296 | totalSupply()+numberOfTokens<=collectionSize |
"Ether value sent is not correct" | /*
*/
pragma solidity ^0.8.0;
contract Haroburu is ERC721Holder,ERC721A, Ownable {
IERC721 public nft;
uint256 public immutable maxPerAddressDuringMint;
string public PROVENANCE;
bool public saleIsActive = false;
string private _baseURIextended;
bool public isAllowListActive = false;
uint256 public constant MAX_PUBLIC_MINT = 2;
uint256 public constant PRICE_PER_TOKEN = 0.048 ether;
uint256 public constant PUBLIC_PRICE_PER_TOKEN = 0.058 ether;
mapping(address => uint8) private _allowList;
mapping(address => uint8) private _allowList2;
mapping(address => uint8) private _allowList3;
mapping(address => uint8) private _allowList4;
constructor(
uint256 maxBatchSize_,
uint256 collectionSize_
) ERC721A("Haroburu", "HAROBURU", maxBatchSize_, collectionSize_) {
}
function setIsAllowListActive(bool _isAllowListActive) external onlyOwner {
}
function setAllowList(address[] calldata addresses, uint8 numAllowedToMint) external onlyOwner {
}
function setAllowList2(address[] calldata addresses, uint8 numAllowedToMint) external onlyOwner {
}
function setAllowList3(address[] calldata addresses, uint8 numAllowedToMint) external onlyOwner {
}
function setAllowList4(address[] calldata addresses, uint8 numAllowedToMint) external onlyOwner {
}
function numAvailableToMintPool(address addr) external view returns (uint8) {
}
function numAvailableToMintPool2(address addr) external view returns (uint8) {
}
function numAvailableToMintPool3(address addr) external view returns (uint8) {
}
function numAvailableToMintPool4(address addr) external view returns (uint8) {
}
function mintAllowList(uint8 numberOfTokens) external payable {
}
function mintAllowList2(uint8 numberOfTokens) external payable {
}
function mintAllowList3(uint8 numberOfTokens) external payable {
}
function mintAllowList4(uint8 numberOfTokens) external payable {
}
function setBaseURI(string memory baseURI_) external onlyOwner() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setProvenance(string memory provenance) public onlyOwner {
}
function reserve(uint256 numberOfTokens, address to) public onlyOwner {
}
function setSaleState(bool newState) public onlyOwner {
}
function mint(uint numberOfTokens) public payable {
require(saleIsActive, "Sale must be active to mint tokens");
require(numberOfTokens <= MAX_PUBLIC_MINT, "Exceeded max token purchase");
require(totalSupply() + numberOfTokens <= collectionSize, "Purchase would exceed max tokens");
require(<FILL_ME>)
_safeMint(msg.sender, numberOfTokens);
}
function withdraw() public onlyOwner {
}
/**
@dev tokenId to staking start time (0 = not staking).
*/
mapping(uint256 => uint256) private stakingStarted;
/**
@dev Cumulative per-token staking, excluding the current period.
*/
mapping(uint256 => uint256) private stakingTotal;
function stakingPeriod(uint256 tokenId)
external
view
returns (
bool staking,
uint256 current,
uint256 total
)
{
}
/**
@dev MUST only be modified by safeTransferWhileStaking(); if set to 2 then
the _beforeTokenTransfer() block while staking is disabled.
*/
uint256 private stakingTransfer = 1;
/**
@notice Transfer a token between addresses while the Moonbird is minting,
thus not resetting the staking period.
*/
function safeTransferWhileStaking(
address from,
address to,
uint256 tokenId
) external {
}
/**
@dev Block transfers while staking.
*/
function _beforeTokenTransfers(
address,
address,
uint256 startTokenId,
uint256 quantity
) internal view override {
}
/**
@dev Emitted when a Haroburu begins staking.
*/
event Staked(uint256 indexed tokenId);
/**
@dev Emitted when a Haroburu stops staking; either through standard means or
by expulsion.
*/
event Unstaked(uint256 indexed tokenId);
/**
@dev Emitted when a Haroburu is expelled from the staked.
*/
event Expelled(uint256 indexed tokenId);
/**
@notice Whether staking is currently allowed.
@dev If false then staking is blocked, but staking is always allowed.
*/
bool public stakingOpen = false;
/**
@notice Turn the `stakingOpen` flag.
*/
function setStakingOpen(bool open) external onlyOwner {
}
/**
@notice Changes the Haroburu's staking status.
*/
function staking(uint256 tokenId) public
{
}
/**
@notice Changes the Haroburus' staking statuss (what's the plural of status?
statii? statuses? status? The plural of sheep is sheep; maybe it's also the
plural of status).
@dev Changes the Haroburus' staking sheep (see @notice).
*/
function staking(uint256[] calldata tokenIds) external {
}
function expelFromStake(uint256 tokenId) external {
}
}
| PUBLIC_PRICE_PER_TOKEN*numberOfTokens<=msg.value,"Ether value sent is not correct" | 149,296 | PUBLIC_PRICE_PER_TOKEN*numberOfTokens<=msg.value |
"Haroburus: staking" | /*
*/
pragma solidity ^0.8.0;
contract Haroburu is ERC721Holder,ERC721A, Ownable {
IERC721 public nft;
uint256 public immutable maxPerAddressDuringMint;
string public PROVENANCE;
bool public saleIsActive = false;
string private _baseURIextended;
bool public isAllowListActive = false;
uint256 public constant MAX_PUBLIC_MINT = 2;
uint256 public constant PRICE_PER_TOKEN = 0.048 ether;
uint256 public constant PUBLIC_PRICE_PER_TOKEN = 0.058 ether;
mapping(address => uint8) private _allowList;
mapping(address => uint8) private _allowList2;
mapping(address => uint8) private _allowList3;
mapping(address => uint8) private _allowList4;
constructor(
uint256 maxBatchSize_,
uint256 collectionSize_
) ERC721A("Haroburu", "HAROBURU", maxBatchSize_, collectionSize_) {
}
function setIsAllowListActive(bool _isAllowListActive) external onlyOwner {
}
function setAllowList(address[] calldata addresses, uint8 numAllowedToMint) external onlyOwner {
}
function setAllowList2(address[] calldata addresses, uint8 numAllowedToMint) external onlyOwner {
}
function setAllowList3(address[] calldata addresses, uint8 numAllowedToMint) external onlyOwner {
}
function setAllowList4(address[] calldata addresses, uint8 numAllowedToMint) external onlyOwner {
}
function numAvailableToMintPool(address addr) external view returns (uint8) {
}
function numAvailableToMintPool2(address addr) external view returns (uint8) {
}
function numAvailableToMintPool3(address addr) external view returns (uint8) {
}
function numAvailableToMintPool4(address addr) external view returns (uint8) {
}
function mintAllowList(uint8 numberOfTokens) external payable {
}
function mintAllowList2(uint8 numberOfTokens) external payable {
}
function mintAllowList3(uint8 numberOfTokens) external payable {
}
function mintAllowList4(uint8 numberOfTokens) external payable {
}
function setBaseURI(string memory baseURI_) external onlyOwner() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setProvenance(string memory provenance) public onlyOwner {
}
function reserve(uint256 numberOfTokens, address to) public onlyOwner {
}
function setSaleState(bool newState) public onlyOwner {
}
function mint(uint numberOfTokens) public payable {
}
function withdraw() public onlyOwner {
}
/**
@dev tokenId to staking start time (0 = not staking).
*/
mapping(uint256 => uint256) private stakingStarted;
/**
@dev Cumulative per-token staking, excluding the current period.
*/
mapping(uint256 => uint256) private stakingTotal;
function stakingPeriod(uint256 tokenId)
external
view
returns (
bool staking,
uint256 current,
uint256 total
)
{
}
/**
@dev MUST only be modified by safeTransferWhileStaking(); if set to 2 then
the _beforeTokenTransfer() block while staking is disabled.
*/
uint256 private stakingTransfer = 1;
/**
@notice Transfer a token between addresses while the Moonbird is minting,
thus not resetting the staking period.
*/
function safeTransferWhileStaking(
address from,
address to,
uint256 tokenId
) external {
}
/**
@dev Block transfers while staking.
*/
function _beforeTokenTransfers(
address,
address,
uint256 startTokenId,
uint256 quantity
) internal view override {
uint256 tokenId = startTokenId;
for (uint256 end = tokenId + quantity; tokenId < end; ++tokenId) {
require(<FILL_ME>)
}
}
/**
@dev Emitted when a Haroburu begins staking.
*/
event Staked(uint256 indexed tokenId);
/**
@dev Emitted when a Haroburu stops staking; either through standard means or
by expulsion.
*/
event Unstaked(uint256 indexed tokenId);
/**
@dev Emitted when a Haroburu is expelled from the staked.
*/
event Expelled(uint256 indexed tokenId);
/**
@notice Whether staking is currently allowed.
@dev If false then staking is blocked, but staking is always allowed.
*/
bool public stakingOpen = false;
/**
@notice Turn the `stakingOpen` flag.
*/
function setStakingOpen(bool open) external onlyOwner {
}
/**
@notice Changes the Haroburu's staking status.
*/
function staking(uint256 tokenId) public
{
}
/**
@notice Changes the Haroburus' staking statuss (what's the plural of status?
statii? statuses? status? The plural of sheep is sheep; maybe it's also the
plural of status).
@dev Changes the Haroburus' staking sheep (see @notice).
*/
function staking(uint256[] calldata tokenIds) external {
}
function expelFromStake(uint256 tokenId) external {
}
}
| stakingStarted[tokenId]==0||stakingTransfer==2,"Haroburus: staking" | 149,296 | stakingStarted[tokenId]==0||stakingTransfer==2 |
"Haroburus: not staked" | /*
*/
pragma solidity ^0.8.0;
contract Haroburu is ERC721Holder,ERC721A, Ownable {
IERC721 public nft;
uint256 public immutable maxPerAddressDuringMint;
string public PROVENANCE;
bool public saleIsActive = false;
string private _baseURIextended;
bool public isAllowListActive = false;
uint256 public constant MAX_PUBLIC_MINT = 2;
uint256 public constant PRICE_PER_TOKEN = 0.048 ether;
uint256 public constant PUBLIC_PRICE_PER_TOKEN = 0.058 ether;
mapping(address => uint8) private _allowList;
mapping(address => uint8) private _allowList2;
mapping(address => uint8) private _allowList3;
mapping(address => uint8) private _allowList4;
constructor(
uint256 maxBatchSize_,
uint256 collectionSize_
) ERC721A("Haroburu", "HAROBURU", maxBatchSize_, collectionSize_) {
}
function setIsAllowListActive(bool _isAllowListActive) external onlyOwner {
}
function setAllowList(address[] calldata addresses, uint8 numAllowedToMint) external onlyOwner {
}
function setAllowList2(address[] calldata addresses, uint8 numAllowedToMint) external onlyOwner {
}
function setAllowList3(address[] calldata addresses, uint8 numAllowedToMint) external onlyOwner {
}
function setAllowList4(address[] calldata addresses, uint8 numAllowedToMint) external onlyOwner {
}
function numAvailableToMintPool(address addr) external view returns (uint8) {
}
function numAvailableToMintPool2(address addr) external view returns (uint8) {
}
function numAvailableToMintPool3(address addr) external view returns (uint8) {
}
function numAvailableToMintPool4(address addr) external view returns (uint8) {
}
function mintAllowList(uint8 numberOfTokens) external payable {
}
function mintAllowList2(uint8 numberOfTokens) external payable {
}
function mintAllowList3(uint8 numberOfTokens) external payable {
}
function mintAllowList4(uint8 numberOfTokens) external payable {
}
function setBaseURI(string memory baseURI_) external onlyOwner() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setProvenance(string memory provenance) public onlyOwner {
}
function reserve(uint256 numberOfTokens, address to) public onlyOwner {
}
function setSaleState(bool newState) public onlyOwner {
}
function mint(uint numberOfTokens) public payable {
}
function withdraw() public onlyOwner {
}
/**
@dev tokenId to staking start time (0 = not staking).
*/
mapping(uint256 => uint256) private stakingStarted;
/**
@dev Cumulative per-token staking, excluding the current period.
*/
mapping(uint256 => uint256) private stakingTotal;
function stakingPeriod(uint256 tokenId)
external
view
returns (
bool staking,
uint256 current,
uint256 total
)
{
}
/**
@dev MUST only be modified by safeTransferWhileStaking(); if set to 2 then
the _beforeTokenTransfer() block while staking is disabled.
*/
uint256 private stakingTransfer = 1;
/**
@notice Transfer a token between addresses while the Moonbird is minting,
thus not resetting the staking period.
*/
function safeTransferWhileStaking(
address from,
address to,
uint256 tokenId
) external {
}
/**
@dev Block transfers while staking.
*/
function _beforeTokenTransfers(
address,
address,
uint256 startTokenId,
uint256 quantity
) internal view override {
}
/**
@dev Emitted when a Haroburu begins staking.
*/
event Staked(uint256 indexed tokenId);
/**
@dev Emitted when a Haroburu stops staking; either through standard means or
by expulsion.
*/
event Unstaked(uint256 indexed tokenId);
/**
@dev Emitted when a Haroburu is expelled from the staked.
*/
event Expelled(uint256 indexed tokenId);
/**
@notice Whether staking is currently allowed.
@dev If false then staking is blocked, but staking is always allowed.
*/
bool public stakingOpen = false;
/**
@notice Turn the `stakingOpen` flag.
*/
function setStakingOpen(bool open) external onlyOwner {
}
/**
@notice Changes the Haroburu's staking status.
*/
function staking(uint256 tokenId) public
{
}
/**
@notice Changes the Haroburus' staking statuss (what's the plural of status?
statii? statuses? status? The plural of sheep is sheep; maybe it's also the
plural of status).
@dev Changes the Haroburus' staking sheep (see @notice).
*/
function staking(uint256[] calldata tokenIds) external {
}
function expelFromStake(uint256 tokenId) external {
require(ownerOf(tokenId) == _msgSender(), "Haroburu: Only owner");
require(<FILL_ME>)
stakingTotal[tokenId] += block.timestamp - stakingStarted[tokenId];
stakingStarted[tokenId] = 0;
emit Unstaked(tokenId);
emit Expelled(tokenId);
}
}
| stakingStarted[tokenId]!=0,"Haroburus: not staked" | 149,296 | stakingStarted[tokenId]!=0 |
"Max 2 Nft's per wallet" | pragma solidity ^0.8.7;
contract oni is Ownable, ERC721, NonblockingReceiver {
address public _owner;
uint256 supply = 3000;
string private baseURI;
bool public isPaused = true;
uint256 nextTokenId = 3666;
uint256 MAX_MINT = 6666;
uint256 gasForDestinationLzReceive = 350000;
constructor(string memory baseURI_, address _layerZeroEndpoint)
ERC721("0ni", "0ni")
{
}
// mint function
// you can mint upto 2 nft's max. 1 per transaction
// mint is free, but payments are accepted
function mint(uint8 numTokens) external payable {
require(!isPaused, "Minting is Paused yet");
require(numTokens < 2, "0ni: Max 1 NFTs per transaction");
require(<FILL_ME>)
require(
nextTokenId + numTokens <= MAX_MINT,
"0ni: Mint exceeds supply"
);
_safeMint(msg.sender, ++nextTokenId);
nextTokenId = nextTokenId;
}
function pause () external onlyOwner {
}
function unPause () external onlyOwner {
}
function mintForOwner(address owner, uint256 _mintAmount) public onlyOwner {
}
// This function transfers the nft from your address on the
// source chain to the same address on the destination chain
function traverseChains(uint16 _chainId, uint256 tokenId) public payable {
}
function setBaseURI(string memory URI) external onlyOwner {
}
function donate() external payable {
}
// This allows the devs to receive kind donations
function withdraw(uint256 amt) external onlyOwner {
}
// just in case this fixed variable limits us from future integrations
function setGasForDestinationLzReceive(uint256 newVal) external onlyOwner {
}
// ------------------
// Internal Functions
// ------------------
function _LzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) internal override {
}
function _baseURI() internal view override returns (string memory) {
}
}
| balanceOf(msg.sender)+numTokens<3,"Max 2 Nft's per wallet" | 149,412 | balanceOf(msg.sender)+numTokens<3 |
"0ni: Mint exceeds supply" | pragma solidity ^0.8.7;
contract oni is Ownable, ERC721, NonblockingReceiver {
address public _owner;
uint256 supply = 3000;
string private baseURI;
bool public isPaused = true;
uint256 nextTokenId = 3666;
uint256 MAX_MINT = 6666;
uint256 gasForDestinationLzReceive = 350000;
constructor(string memory baseURI_, address _layerZeroEndpoint)
ERC721("0ni", "0ni")
{
}
// mint function
// you can mint upto 2 nft's max. 1 per transaction
// mint is free, but payments are accepted
function mint(uint8 numTokens) external payable {
require(!isPaused, "Minting is Paused yet");
require(numTokens < 2, "0ni: Max 1 NFTs per transaction");
require(balanceOf(msg.sender)+numTokens < 3, "Max 2 Nft's per wallet");
require(<FILL_ME>)
_safeMint(msg.sender, ++nextTokenId);
nextTokenId = nextTokenId;
}
function pause () external onlyOwner {
}
function unPause () external onlyOwner {
}
function mintForOwner(address owner, uint256 _mintAmount) public onlyOwner {
}
// This function transfers the nft from your address on the
// source chain to the same address on the destination chain
function traverseChains(uint16 _chainId, uint256 tokenId) public payable {
}
function setBaseURI(string memory URI) external onlyOwner {
}
function donate() external payable {
}
// This allows the devs to receive kind donations
function withdraw(uint256 amt) external onlyOwner {
}
// just in case this fixed variable limits us from future integrations
function setGasForDestinationLzReceive(uint256 newVal) external onlyOwner {
}
// ------------------
// Internal Functions
// ------------------
function _LzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) internal override {
}
function _baseURI() internal view override returns (string memory) {
}
}
| nextTokenId+numTokens<=MAX_MINT,"0ni: Mint exceeds supply" | 149,412 | nextTokenId+numTokens<=MAX_MINT |
null | pragma solidity ^0.8.7;
contract oni is Ownable, ERC721, NonblockingReceiver {
address public _owner;
uint256 supply = 3000;
string private baseURI;
bool public isPaused = true;
uint256 nextTokenId = 3666;
uint256 MAX_MINT = 6666;
uint256 gasForDestinationLzReceive = 350000;
constructor(string memory baseURI_, address _layerZeroEndpoint)
ERC721("0ni", "0ni")
{
}
// mint function
// you can mint upto 2 nft's max. 1 per transaction
// mint is free, but payments are accepted
function mint(uint8 numTokens) external payable {
}
function pause () external onlyOwner {
}
function unPause () external onlyOwner {
}
function mintForOwner(address owner, uint256 _mintAmount) public onlyOwner {
require(_mintAmount > 0);
require(nextTokenId <= MAX_MINT);
require(_mintAmount <= MAX_MINT);
require(<FILL_ME>)
for (uint256 i = 1; i <= _mintAmount; i++) {
_safeMint(owner,nextTokenId + i);
}
nextTokenId += _mintAmount;
}
// This function transfers the nft from your address on the
// source chain to the same address on the destination chain
function traverseChains(uint16 _chainId, uint256 tokenId) public payable {
}
function setBaseURI(string memory URI) external onlyOwner {
}
function donate() external payable {
}
// This allows the devs to receive kind donations
function withdraw(uint256 amt) external onlyOwner {
}
// just in case this fixed variable limits us from future integrations
function setGasForDestinationLzReceive(uint256 newVal) external onlyOwner {
}
// ------------------
// Internal Functions
// ------------------
function _LzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) internal override {
}
function _baseURI() internal view override returns (string memory) {
}
}
| supply+_mintAmount<=MAX_MINT | 149,412 | supply+_mintAmount<=MAX_MINT |
"Address already minted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import {ERC721A, IERC721A} from "erc721a/contracts/ERC721A.sol";
import {OperatorFilterer} from "https://github.com/Vectorized/closedsea/blob/main/src/OperatorFilterer.sol";
import {Ownable} from "openzeppelin-contracts/access/Ownable.sol";
import {IERC2981, ERC2981} from "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/**
* @title Yosei
* @notice This contract is configured to use the DefaultOperatorFilterer, which automatically registers the
* token and subscribes it to OpenSea's curated filters.
* Adding the onlyAllowedOperator modifier to the transferFrom and both safeTransferFrom methods ensures that
* the msg.sender (operator) is allowed by the OperatorFilterRegistry.
*/
contract Yosei is
ERC721A,
OperatorFilterer,
Ownable,
ERC2981
{
//variables and consts
bool public operatorFilteringEnabled;
bytes32 public merkleRoot;
bool public publicMintEnabled = false;
bool public WhitelistMintEnabled = false;
mapping(address => bool) public whitelistClaimed;
mapping(address => bool) public publicClaimed;
string public uriSuffix = ".json";
string public baseURI = "ipfs://QmWuyK5Tr2sfWjzbhByN2f84rM7K13HX9XS7Ny4neKZRks/";
uint256 public yoseiSupply = 6666;
uint256 public whitelistSupply = 6000;
uint256 public publicSalePrice = 0.0089 ether;
uint256 public yoseiPerPublicTx = 2;
constructor() ERC721A("Yosei", "YOS") {
}
function mintPublic(uint256 quantity) public payable{
uint256 supply = totalSupply();
require (publicMintEnabled, "Public mint not live yet");
require(<FILL_ME>)
require(quantity + supply <= yoseiSupply, "Supply exceeded");
require(msg.value >= quantity * publicSalePrice, "Invalid input price");
_mint(msg.sender, quantity);
publicClaimed[msg.sender] = true;
delete supply;
}
function mintWhitelist(uint256 quantity, bytes32[] calldata merkleProof) public payable{
}
function setPublicMintEnabled(bool enabled) public onlyOwner{
}
function setWhitelistMintEnabled(bool enabled) public onlyOwner{
}
//overriding of functions to apply for Opensea royalties
function setApprovalForAll(address operator, bool approved)
public
override (ERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function approve(address operator, uint256 tokenId)
public
payable
override (ERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(address from, address to, uint256 tokenId)
public
payable
override (ERC721A)
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId)
public
payable
override (ERC721A)
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override (ERC721A)
onlyAllowedOperator(from)
{
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
function setDefaultRoyalty(address receiver, uint96 feeNumerator) public onlyOwner {
}
function setOperatorFilteringEnabled(bool value) public onlyOwner {
}
function _operatorFilteringEnabled() internal view override returns (bool) {
}
function _isPriorityOperator(address operator) internal pure override returns (bool) {
}
/**
* @notice Change merkle root hash
*/
function setMerkleRoot(bytes32 merkleRootHash) external onlyOwner{
}
/**
* @notice Verify merkle proof of the address
*/
function verifyAddress(bytes32[] calldata merkleProof) private view returns (bool) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) public onlyOwner {
}
function withdrawBalance() external onlyOwner {
}
}
| !publicClaimed[msg.sender],"Address already minted" | 149,531 | !publicClaimed[msg.sender] |
"Supply exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import {ERC721A, IERC721A} from "erc721a/contracts/ERC721A.sol";
import {OperatorFilterer} from "https://github.com/Vectorized/closedsea/blob/main/src/OperatorFilterer.sol";
import {Ownable} from "openzeppelin-contracts/access/Ownable.sol";
import {IERC2981, ERC2981} from "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/**
* @title Yosei
* @notice This contract is configured to use the DefaultOperatorFilterer, which automatically registers the
* token and subscribes it to OpenSea's curated filters.
* Adding the onlyAllowedOperator modifier to the transferFrom and both safeTransferFrom methods ensures that
* the msg.sender (operator) is allowed by the OperatorFilterRegistry.
*/
contract Yosei is
ERC721A,
OperatorFilterer,
Ownable,
ERC2981
{
//variables and consts
bool public operatorFilteringEnabled;
bytes32 public merkleRoot;
bool public publicMintEnabled = false;
bool public WhitelistMintEnabled = false;
mapping(address => bool) public whitelistClaimed;
mapping(address => bool) public publicClaimed;
string public uriSuffix = ".json";
string public baseURI = "ipfs://QmWuyK5Tr2sfWjzbhByN2f84rM7K13HX9XS7Ny4neKZRks/";
uint256 public yoseiSupply = 6666;
uint256 public whitelistSupply = 6000;
uint256 public publicSalePrice = 0.0089 ether;
uint256 public yoseiPerPublicTx = 2;
constructor() ERC721A("Yosei", "YOS") {
}
function mintPublic(uint256 quantity) public payable{
uint256 supply = totalSupply();
require (publicMintEnabled, "Public mint not live yet");
require(!publicClaimed[msg.sender], "Address already minted");
require(<FILL_ME>)
require(msg.value >= quantity * publicSalePrice, "Invalid input price");
_mint(msg.sender, quantity);
publicClaimed[msg.sender] = true;
delete supply;
}
function mintWhitelist(uint256 quantity, bytes32[] calldata merkleProof) public payable{
}
function setPublicMintEnabled(bool enabled) public onlyOwner{
}
function setWhitelistMintEnabled(bool enabled) public onlyOwner{
}
//overriding of functions to apply for Opensea royalties
function setApprovalForAll(address operator, bool approved)
public
override (ERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function approve(address operator, uint256 tokenId)
public
payable
override (ERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(address from, address to, uint256 tokenId)
public
payable
override (ERC721A)
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId)
public
payable
override (ERC721A)
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override (ERC721A)
onlyAllowedOperator(from)
{
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
function setDefaultRoyalty(address receiver, uint96 feeNumerator) public onlyOwner {
}
function setOperatorFilteringEnabled(bool value) public onlyOwner {
}
function _operatorFilteringEnabled() internal view override returns (bool) {
}
function _isPriorityOperator(address operator) internal pure override returns (bool) {
}
/**
* @notice Change merkle root hash
*/
function setMerkleRoot(bytes32 merkleRootHash) external onlyOwner{
}
/**
* @notice Verify merkle proof of the address
*/
function verifyAddress(bytes32[] calldata merkleProof) private view returns (bool) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) public onlyOwner {
}
function withdrawBalance() external onlyOwner {
}
}
| quantity+supply<=yoseiSupply,"Supply exceeded" | 149,531 | quantity+supply<=yoseiSupply |
"Cannot mint over supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import {ERC721A, IERC721A} from "erc721a/contracts/ERC721A.sol";
import {OperatorFilterer} from "https://github.com/Vectorized/closedsea/blob/main/src/OperatorFilterer.sol";
import {Ownable} from "openzeppelin-contracts/access/Ownable.sol";
import {IERC2981, ERC2981} from "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/**
* @title Yosei
* @notice This contract is configured to use the DefaultOperatorFilterer, which automatically registers the
* token and subscribes it to OpenSea's curated filters.
* Adding the onlyAllowedOperator modifier to the transferFrom and both safeTransferFrom methods ensures that
* the msg.sender (operator) is allowed by the OperatorFilterRegistry.
*/
contract Yosei is
ERC721A,
OperatorFilterer,
Ownable,
ERC2981
{
//variables and consts
bool public operatorFilteringEnabled;
bytes32 public merkleRoot;
bool public publicMintEnabled = false;
bool public WhitelistMintEnabled = false;
mapping(address => bool) public whitelistClaimed;
mapping(address => bool) public publicClaimed;
string public uriSuffix = ".json";
string public baseURI = "ipfs://QmWuyK5Tr2sfWjzbhByN2f84rM7K13HX9XS7Ny4neKZRks/";
uint256 public yoseiSupply = 6666;
uint256 public whitelistSupply = 6000;
uint256 public publicSalePrice = 0.0089 ether;
uint256 public yoseiPerPublicTx = 2;
constructor() ERC721A("Yosei", "YOS") {
}
function mintPublic(uint256 quantity) public payable{
}
function mintWhitelist(uint256 quantity, bytes32[] calldata merkleProof) public payable{
uint256 yoseiMinted = totalSupply();
require(WhitelistMintEnabled, "The mint isn't open yet");
require(quantity == 1, "Invalid quantity to mint");
require(<FILL_ME>)
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(!whitelistClaimed[msg.sender], "Whitelist already minted");
require(MerkleProof.verify(merkleProof, merkleRoot, leaf), "Invalid proof!" );
_mint(msg.sender, quantity);
whitelistClaimed[msg.sender] = true;
delete yoseiMinted;
}
function setPublicMintEnabled(bool enabled) public onlyOwner{
}
function setWhitelistMintEnabled(bool enabled) public onlyOwner{
}
//overriding of functions to apply for Opensea royalties
function setApprovalForAll(address operator, bool approved)
public
override (ERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function approve(address operator, uint256 tokenId)
public
payable
override (ERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(address from, address to, uint256 tokenId)
public
payable
override (ERC721A)
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId)
public
payable
override (ERC721A)
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override (ERC721A)
onlyAllowedOperator(from)
{
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
function setDefaultRoyalty(address receiver, uint96 feeNumerator) public onlyOwner {
}
function setOperatorFilteringEnabled(bool value) public onlyOwner {
}
function _operatorFilteringEnabled() internal view override returns (bool) {
}
function _isPriorityOperator(address operator) internal pure override returns (bool) {
}
/**
* @notice Change merkle root hash
*/
function setMerkleRoot(bytes32 merkleRootHash) external onlyOwner{
}
/**
* @notice Verify merkle proof of the address
*/
function verifyAddress(bytes32[] calldata merkleProof) private view returns (bool) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) public onlyOwner {
}
function withdrawBalance() external onlyOwner {
}
}
| yoseiMinted+quantity<=yoseiSupply,"Cannot mint over supply" | 149,531 | yoseiMinted+quantity<=yoseiSupply |
null | /* https://t.me/akatsukiportal */
// SPDX-License-Identifier: Unlicensed
pragma solidity 0.8.18;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom( address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function _transferOwnership(address newOwner) internal {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
contract Akatsuki is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _balance;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _walletExcluded;
uint256 private constant MAX = ~uint256(0);
uint8 private constant _decimals = 18;
uint256 private constant _totalSupply = 10**7 * 10**_decimals;
uint256 private constant minSwap = 4000 * 10**_decimals;
uint256 private constant onePercent = 100000 * 10**_decimals;
uint256 public maxTxAmount = onePercent * 2;
uint256 public maxWalletSize = onePercent * 2;
uint256 private launchBlock;
uint256 private buyValue = 0;
uint256 private _tax;
uint256 public buyTax = 20;
uint256 public sellTax = 45;
string private constant _name = "Akatsuki";
string private constant _symbol = "Akatsuki";
IUniswapV2Router02 private uniswapV2Router;
address public uniswapV2Pair;
address payable public treasuryAddress;
bool private launch = false;
constructor(address[] memory wallets) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)public override returns (bool){
}
function allowance(address owner, address spender) public view override returns (uint256){
}
function approve(address spender, uint256 amount) public override returns (bool){
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function enableTrading() external onlyOwner {
}
function removeLimits() external onlyOwner {
}
function changeTax(uint256 newBuyTax, uint256 newSellTax) external onlyOwner {
}
function botValue(uint256 newBuyValue) external onlyOwner {
}
function _tokenTransfer(address from, address to, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function sendETHToFee(uint256 amount) private {
}
function clearStuckBalance() external {
require(<FILL_ME>)
sendETHToFee(address(this).balance);
}
function manualSwap() external {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
receive() external payable {}
}
| _msgSender()==treasuryAddress | 149,594 | _msgSender()==treasuryAddress |
"Invalid Merkle Proof" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
// ::: :::::::: ::::::::::: ::: :::::::::
// :+: :+: :+: :+: :+: :+: :+: :+: :+:
// +:+ +:+ +:+ +:+ +:+ +:+ +:+ +:+
// +#++:++#++: +#++:++#++ +#+ +#++:++#++: +#++:++#:
// +#+ +#+ +#+ +#+ +#+ +#+ +#+ +#+
// #+# #+# #+# #+# #+# #+# #+# #+# #+#
// ### ### ######## ### ### ### ### ###
// ::::::::: ::::::::: ::::::::::: :::: ::: :::::::: ::::::::::
// :+: :+: :+: :+: :+: :+:+: :+: :+: :+: :+:
// +:+ +:+ +:+ +:+ +:+ :+:+:+ +:+ +:+ +:+
// +#++:++#+ +#++:++#: +#+ +#+ +:+ +#+ +#+ +#++:++#
// +#+ +#+ +#+ +#+ +#+ +#+#+# +#+ +#+
// #+# #+# #+# #+# #+# #+#+# #+# #+# #+#
// ### ### ### ########### ### #### ######## ##########
/// @title: AstarPrince
/// @author: Shunichiro
/// @dev: This contract using NFTBoil (https://github.com/syunduel/NFTBoil)
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
import "contract-allow-list/contracts/ERC721AntiScam/ERC721AntiScam.sol";
import "./libs/OpenSea/operator-filter-registry/DefaultOperatorFilterer.sol";
// This NFT License is a16z Can't be Evil Lisence
import {LicenseVersion, CantBeEvil} from "@a16z/contracts/licenses/CantBeEvil.sol";
contract AstarPrince is DefaultOperatorFilterer, ERC721AntiScam, ERC2981, Pausable, CantBeEvil(LicenseVersion.PUBLIC) {
using Strings for uint256;
string private baseURI = "";
uint256 public preCost = 0.005 ether;
uint256 public publicCost = 0.005 ether;
uint256 public salePhase = 1; // 1: FreeMint, 2: 1st Presale, 3: 2nd Presale, 4: Public Sale
bool public mintable = false;
uint256 public maxMintPerWallet = 300;
uint256 public maxMintPerTx = 5;
address public royaltyAddress = 0x7640248Ea19B09AF3bAf4fd2145dA3cc30e604c2;
uint96 public royaltyFee = 1000;
uint256 constant public MAX_SUPPLY = 5555;
string constant private BASE_EXTENSION = ".json";
address constant private DEFAULT_ROYALITY_ADDRESS = 0x7640248Ea19B09AF3bAf4fd2145dA3cc30e604c2;
bytes32 public merkleRootFreeMint;
bytes32 public merkleRootPreMint1;
bytes32 public merkleRootPreMint2;
mapping(address => uint256) private claimed;
constructor(
string memory _name,
string memory _symbol
) ERC721A(_name, _symbol) {
}
modifier whenMintable() {
}
/**
* @dev The modifier allowing the function access only for real humans.
*/
modifier callerIsUser() {
}
// internal
function _baseURI() internal view override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Set the merkle root for the FreeMint
*/
function setMerkleRootFreeMint(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice Set the merkle root for the PreMint1
*/
function setMerkleRootPreMint1(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice Set the merkle root for the PreMint2
*/
function setMerkleRootPreMint2(bytes32 _merkleRoot) external onlyOwner {
}
function freeMint(uint256 _mintAmount, uint256 _freeMintMax, bytes32[] calldata _merkleProof)
public
payable
whenMintable
whenNotPaused
callerIsUser
{
uint256 cost = 0;
mintCheck(_mintAmount, cost);
require(salePhase == 1, "FreeMint is not active.");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender, _freeMintMax));
require(<FILL_ME>)
require(
claimed[msg.sender] + _mintAmount <= _freeMintMax,
"Already claimed max"
);
_mint(msg.sender, _mintAmount);
claimed[msg.sender] += _mintAmount;
}
function preMint1(uint256 _mintAmount, uint256 _preMint1Max, bytes32[] calldata _merkleProof)
public
payable
whenMintable
whenNotPaused
callerIsUser
{
}
function preMint2(uint256 _mintAmount, uint256 _preMint2Max, bytes32[] calldata _merkleProof)
public
payable
whenNotPaused
whenMintable
callerIsUser
{
}
function publicMint(uint256 _mintAmount) public
payable
whenNotPaused
whenMintable
callerIsUser
{
}
function mintCheck(
uint256 _mintAmount,
uint256 cost
) private view {
}
function ownerMint(address _address, uint256 count) public onlyOwner {
}
function setSalePhase(uint256 _salePhase) public onlyOwner {
}
function setPreCost(uint256 _preCost) public onlyOwner {
}
function setPublicCost(uint256 _publicCost) public onlyOwner {
}
function setMintable(bool _state) public onlyOwner {
}
function setMaxMintPerWallet(uint256 _maxMintPerWallet) external onlyOwner {
}
function setMaxMintPerTx(uint256 _maxMintPerTx) external onlyOwner {
}
function getCurrentCost() public view returns (uint256) {
}
function getMintedCount() public view returns (uint256) {
}
function burn(uint256 _tokenId) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function withdraw() external onlyOwner {
}
//
// OpenSea operator-filter-registry
//
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
//
// ContractAllowList ERC721RestrictApprove
//
function addLocalContractAllowList(address transferer) external onlyOwner {
}
function removeLocalContractAllowList(address transferer) external onlyOwner {
}
function setCAL(address calAddress) external onlyOwner {
}
function setCALLevel(uint256 level) external onlyOwner {
}
function setEnableRestrict(bool value) external onlyOwner {
}
//
// ContractAllowList ERC721Lockable
//
function setContractLock(LockStatus lockStatus) external onlyOwner {
}
function setWalletLock(address to, LockStatus lockStatus) external {
}
function setTokenLock(uint256[] calldata tokenIds, LockStatus lockStatus) external {
}
function setEnableLock(bool value) external onlyOwner {
}
//
// IERC2981 NFT Royalty Standard
//
/**
* @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 {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721AntiScam, ERC2981, CantBeEvil) returns (bool) {
}
}
| MerkleProof.verify(_merkleProof,merkleRootFreeMint,leaf),"Invalid Merkle Proof" | 149,709 | MerkleProof.verify(_merkleProof,merkleRootFreeMint,leaf) |
"Already claimed max" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
// ::: :::::::: ::::::::::: ::: :::::::::
// :+: :+: :+: :+: :+: :+: :+: :+: :+:
// +:+ +:+ +:+ +:+ +:+ +:+ +:+ +:+
// +#++:++#++: +#++:++#++ +#+ +#++:++#++: +#++:++#:
// +#+ +#+ +#+ +#+ +#+ +#+ +#+ +#+
// #+# #+# #+# #+# #+# #+# #+# #+# #+#
// ### ### ######## ### ### ### ### ###
// ::::::::: ::::::::: ::::::::::: :::: ::: :::::::: ::::::::::
// :+: :+: :+: :+: :+: :+:+: :+: :+: :+: :+:
// +:+ +:+ +:+ +:+ +:+ :+:+:+ +:+ +:+ +:+
// +#++:++#+ +#++:++#: +#+ +#+ +:+ +#+ +#+ +#++:++#
// +#+ +#+ +#+ +#+ +#+ +#+#+# +#+ +#+
// #+# #+# #+# #+# #+# #+#+# #+# #+# #+#
// ### ### ### ########### ### #### ######## ##########
/// @title: AstarPrince
/// @author: Shunichiro
/// @dev: This contract using NFTBoil (https://github.com/syunduel/NFTBoil)
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
import "contract-allow-list/contracts/ERC721AntiScam/ERC721AntiScam.sol";
import "./libs/OpenSea/operator-filter-registry/DefaultOperatorFilterer.sol";
// This NFT License is a16z Can't be Evil Lisence
import {LicenseVersion, CantBeEvil} from "@a16z/contracts/licenses/CantBeEvil.sol";
contract AstarPrince is DefaultOperatorFilterer, ERC721AntiScam, ERC2981, Pausable, CantBeEvil(LicenseVersion.PUBLIC) {
using Strings for uint256;
string private baseURI = "";
uint256 public preCost = 0.005 ether;
uint256 public publicCost = 0.005 ether;
uint256 public salePhase = 1; // 1: FreeMint, 2: 1st Presale, 3: 2nd Presale, 4: Public Sale
bool public mintable = false;
uint256 public maxMintPerWallet = 300;
uint256 public maxMintPerTx = 5;
address public royaltyAddress = 0x7640248Ea19B09AF3bAf4fd2145dA3cc30e604c2;
uint96 public royaltyFee = 1000;
uint256 constant public MAX_SUPPLY = 5555;
string constant private BASE_EXTENSION = ".json";
address constant private DEFAULT_ROYALITY_ADDRESS = 0x7640248Ea19B09AF3bAf4fd2145dA3cc30e604c2;
bytes32 public merkleRootFreeMint;
bytes32 public merkleRootPreMint1;
bytes32 public merkleRootPreMint2;
mapping(address => uint256) private claimed;
constructor(
string memory _name,
string memory _symbol
) ERC721A(_name, _symbol) {
}
modifier whenMintable() {
}
/**
* @dev The modifier allowing the function access only for real humans.
*/
modifier callerIsUser() {
}
// internal
function _baseURI() internal view override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Set the merkle root for the FreeMint
*/
function setMerkleRootFreeMint(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice Set the merkle root for the PreMint1
*/
function setMerkleRootPreMint1(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice Set the merkle root for the PreMint2
*/
function setMerkleRootPreMint2(bytes32 _merkleRoot) external onlyOwner {
}
function freeMint(uint256 _mintAmount, uint256 _freeMintMax, bytes32[] calldata _merkleProof)
public
payable
whenMintable
whenNotPaused
callerIsUser
{
uint256 cost = 0;
mintCheck(_mintAmount, cost);
require(salePhase == 1, "FreeMint is not active.");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender, _freeMintMax));
require(
MerkleProof.verify(_merkleProof, merkleRootFreeMint, leaf),
"Invalid Merkle Proof"
);
require(<FILL_ME>)
_mint(msg.sender, _mintAmount);
claimed[msg.sender] += _mintAmount;
}
function preMint1(uint256 _mintAmount, uint256 _preMint1Max, bytes32[] calldata _merkleProof)
public
payable
whenMintable
whenNotPaused
callerIsUser
{
}
function preMint2(uint256 _mintAmount, uint256 _preMint2Max, bytes32[] calldata _merkleProof)
public
payable
whenNotPaused
whenMintable
callerIsUser
{
}
function publicMint(uint256 _mintAmount) public
payable
whenNotPaused
whenMintable
callerIsUser
{
}
function mintCheck(
uint256 _mintAmount,
uint256 cost
) private view {
}
function ownerMint(address _address, uint256 count) public onlyOwner {
}
function setSalePhase(uint256 _salePhase) public onlyOwner {
}
function setPreCost(uint256 _preCost) public onlyOwner {
}
function setPublicCost(uint256 _publicCost) public onlyOwner {
}
function setMintable(bool _state) public onlyOwner {
}
function setMaxMintPerWallet(uint256 _maxMintPerWallet) external onlyOwner {
}
function setMaxMintPerTx(uint256 _maxMintPerTx) external onlyOwner {
}
function getCurrentCost() public view returns (uint256) {
}
function getMintedCount() public view returns (uint256) {
}
function burn(uint256 _tokenId) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function withdraw() external onlyOwner {
}
//
// OpenSea operator-filter-registry
//
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
//
// ContractAllowList ERC721RestrictApprove
//
function addLocalContractAllowList(address transferer) external onlyOwner {
}
function removeLocalContractAllowList(address transferer) external onlyOwner {
}
function setCAL(address calAddress) external onlyOwner {
}
function setCALLevel(uint256 level) external onlyOwner {
}
function setEnableRestrict(bool value) external onlyOwner {
}
//
// ContractAllowList ERC721Lockable
//
function setContractLock(LockStatus lockStatus) external onlyOwner {
}
function setWalletLock(address to, LockStatus lockStatus) external {
}
function setTokenLock(uint256[] calldata tokenIds, LockStatus lockStatus) external {
}
function setEnableLock(bool value) external onlyOwner {
}
//
// IERC2981 NFT Royalty Standard
//
/**
* @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 {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721AntiScam, ERC2981, CantBeEvil) returns (bool) {
}
}
| claimed[msg.sender]+_mintAmount<=_freeMintMax,"Already claimed max" | 149,709 | claimed[msg.sender]+_mintAmount<=_freeMintMax |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.