comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Auction address already set" | //SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "../nft/INft.sol";
import "./IAuction.sol";
import "./IHub.sol";
import "../registry/Registry.sol";
contract AuctionHub is Ownable, IHub {
using SafeMath for uint256;
/**
* Needed information about an auction request
*/
struct LotRequest {
address owner; // Owner of token
uint256 tokenID; // ID of the token
uint256 auctionID; // ID of the auction
LotStatus status; // Status of the auction
}
// Enum for the state of an auction
enum AuctionStatus { INACTIVE, ACTIVE, PAUSED }
/**
* Needed information around an auction
*/
struct Auctions {
AuctionStatus status; // If the auction type is valid for requests
string auctionName; // Name of the auction
address auctionContract; // Address of auction implementation
bool onlyPrimarySales; // If the auction can only do primary sales
}
// Scaling factor for splits. Allows for more decimal precision on percentages
uint256 constant internal SPLIT_SCALING_FACTOR = 10000;
// Lot ID to lot request
mapping(uint256 => LotRequest) internal lotRequests_;
// Auction types
mapping(uint256 => Auctions) internal auctions_;
// Address to auction ID
mapping(address => uint256) internal auctionAddress_;
// A mapping to keep track of token IDs to if it is not the first sale
mapping(uint256 => bool) internal isSecondarySale_;
// Interface for NFT contract
INft internal nftInstance_;
// Storage for the registry instance
Registry internal registryInstance_;
// Auction counter
uint256 internal auctionCounter_;
// Lot ID counters for auctions
uint256 internal lotCounter_;
// First sale splits
// Split to creator
uint256 internal creatorSplitFirstSale_;
// Split for system
uint256 internal systemSplitFirstSale_;
// Secondary sale splits
// Split to creator
uint256 internal creatorSplitSecondary_;
// Split to seller
uint256 internal sellerSplitSecondary_;
// Split to system
uint256 internal systemSplitSecondary_;
// -----------------------------------------------------------------------
// EVENTS
// -----------------------------------------------------------------------
event AuctionRegistered(
address owner,
uint256 indexed auctionID,
string auctionName,
address auctionContract
);
event AuctionUpdated(
address owner,
uint256 indexed auctionID,
address oldAuctionContract,
address newAuctionContract
);
event AuctionRemoved(
address owner,
uint256 indexed auctionID
);
event LotStatusChange(
uint256 indexed lotID,
uint256 indexed auctionID,
address indexed auction,
LotStatus status
);
event FirstSaleSplitUpdated(
uint256 oldCreatorSplit,
uint256 newCreatorSplit,
uint256 oldSystemSplit,
uint256 newSystemSplit
);
event SecondarySalesSplitUpdated(
uint256 oldCreatorSplit,
uint256 newCreatorSplit,
uint256 oldSellerSplit,
uint256 newSellerSplit,
uint256 oldSystemSplit,
uint256 newSystemSplit
);
event LotRequested(
address indexed requester,
uint256 indexed tokenID,
uint256 indexed lotID
);
// -----------------------------------------------------------------------
// MODIFIERS
// -----------------------------------------------------------------------
modifier onlyAuction() {
}
modifier onlyTokenOwner(uint256 _lotID) {
}
modifier onlyRegistry() {
}
// -----------------------------------------------------------------------
// CONSTRUCTOR
// -----------------------------------------------------------------------
constructor(
address _registry,
uint256 _primaryCreatorSplit,
uint256 _primarySystemSplit,
uint256 _secondaryCreatorSplit,
uint256 _secondarySellerSplit,
uint256 _secondarySystemSplit
)
Ownable()
{
}
// -----------------------------------------------------------------------
// NON-MODIFYING FUNCTIONS (VIEW)
// -----------------------------------------------------------------------
function getLotInformation(
uint256 _lotID
)
external
view
override
returns(
address owner,
uint256 tokenID,
uint256 auctionID,
LotStatus status
)
{
}
function getAuctionInformation(
uint256 _auctionID
)
external
view
override
returns(
bool active,
string memory auctionName,
address auctionContract,
bool onlyPrimarySales
)
{
}
function getAuctionID(
address _auction
)
external
view
override
returns(uint256)
{
}
function isAuctionActive(uint256 _auctionID) external view override returns(bool) {
}
function getAuctionCount() external view override returns(uint256) {
}
function isAuctionHubImplementation() external view override returns(bool) {
}
function isFirstSale(uint256 _tokenID) external view override returns(bool) {
}
function getFirstSaleSplit()
external
view
override
returns(
uint256 creatorSplit,
uint256 systemSplit
)
{
}
function getSecondarySaleSplits()
external
view
override
returns(
uint256 creatorSplit,
uint256 sellerSplit,
uint256 systemSplit
)
{
}
function getScalingFactor() external view override returns(uint256) {
}
// -----------------------------------------------------------------------
// PUBLIC STATE MODIFYING FUNCTIONS
// -----------------------------------------------------------------------
function requestAuctionLot(
uint256 _auctionType,
uint256 _tokenID
)
external
override
returns(uint256 lotID)
{
}
function init() external override onlyRegistry() returns(bool) {
}
// -----------------------------------------------------------------------
// ONLY AUCTIONS STATE MODIFYING FUNCTIONS
// -----------------------------------------------------------------------
function firstSaleCompleted(uint256 _tokenID) external override onlyAuction() {
}
function lotCreated(
uint256 _auctionID,
uint256 _lotID
)
external
override
onlyAuction()
{
}
function lotAuctionStarted(
uint256 _auctionID,
uint256 _lotID
)
external
override
onlyAuction()
{
}
function lotAuctionCompleted(
uint256 _auctionID,
uint256 _lotID
)
external
override
onlyAuction()
{
}
function lotAuctionCompletedAndClaimed(
uint256 _auctionID,
uint256 _lotID
)
external
override
onlyAuction()
{
}
function cancelLot(
uint256 _auctionID,
uint256 _lotID
)
external
override
onlyTokenOwner(_lotID)
{
}
// -----------------------------------------------------------------------
// ONLY OWNER STATE MODIFYING FUNCTIONS
// -----------------------------------------------------------------------
/**
* @param _newCreatorSplit The new split for the creator on primary sales.
* Scaled for more precision. 20% would be entered as 2000
* @param _newSystemSplit The new split for the system on primary sales.
* Scaled for more precision. 20% would be entered as 2000
* @notice Will revert if the sum of the two new splits does not equal
* 10000 (the scaled resolution)
*/
function updateFirstSaleSplit(
uint256 _newCreatorSplit,
uint256 _newSystemSplit
)
external
onlyOwner()
{
}
/**
* @param _newCreatorSplit The new split for the creator on secondary sales.
* Scaled for more precision. 20% would be entered as 2000
* @param _newSellerSplit The new split to the seller on secondary sales.
Scaled for more precision. 20% would be entered as 2000
* @param _newSystemSplit The new split for the system on secondary sales.
* Scaled for more precision. 20% would be entered as 2000
* @notice Will revert if the sum of the three new splits does not equal
* 10000 (the scaled resolution)
*/
function updateSecondarySalesSplit(
uint256 _newCreatorSplit,
uint256 _newSellerSplit,
uint256 _newSystemSplit
)
external
onlyOwner()
{
}
function registerAuction(
string memory _name,
address _auctionInstance,
bool _onlyPrimarySales
)
external
onlyOwner()
returns(uint256 auctionID)
{
}
/**
* @param _auctionID The ID of the auction to be paused.
* @notice This function allows the owner to pause the auction type. While
* the auction is paused no new lots can be created, but old lots
* can still complete.
*/
function pauseAuction(uint256 _auctionID) external onlyOwner() {
}
function updateAuctionInstance(
uint256 _auctionID,
address _newImplementation
)
external
onlyOwner()
{
require(
auctions_[_auctionID].status == AuctionStatus.PAUSED,
"Auction must be paused before update"
);
require(<FILL_ME>)
IAuction newAuction = IAuction(_newImplementation);
require(
newAuction.isActive() == false,
"Auction has been activated"
);
newAuction.init(_auctionID);
address oldAuctionContract = auctions_[_auctionID].auctionContract;
auctionAddress_[oldAuctionContract] = 0;
auctions_[_auctionID].auctionContract = _newImplementation;
auctionAddress_[_newImplementation] = _auctionID;
emit AuctionUpdated(
msg.sender,
_auctionID,
oldAuctionContract,
_newImplementation
);
}
function removeAuction(
uint256 _auctionID
)
external
onlyOwner()
{
}
// -----------------------------------------------------------------------
// INTERNAL MODIFYING FUNCTIONS
// -----------------------------------------------------------------------
function _updateSecondarySalesSplit(
uint256 _newCreatorSplit,
uint256 _newSellerSplit,
uint256 _newSystemSplit
)
internal
{
}
function _updateFirstSaleSplit(
uint256 _newCreatorSplit,
uint256 _newSystemSplit
)
internal
{
}
}
| auctions_[_auctionID].auctionContract!=_newImplementation,"Auction address already set" | 350,668 | auctions_[_auctionID].auctionContract!=_newImplementation |
"Auction has been activated" | //SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "../nft/INft.sol";
import "./IAuction.sol";
import "./IHub.sol";
import "../registry/Registry.sol";
contract AuctionHub is Ownable, IHub {
using SafeMath for uint256;
/**
* Needed information about an auction request
*/
struct LotRequest {
address owner; // Owner of token
uint256 tokenID; // ID of the token
uint256 auctionID; // ID of the auction
LotStatus status; // Status of the auction
}
// Enum for the state of an auction
enum AuctionStatus { INACTIVE, ACTIVE, PAUSED }
/**
* Needed information around an auction
*/
struct Auctions {
AuctionStatus status; // If the auction type is valid for requests
string auctionName; // Name of the auction
address auctionContract; // Address of auction implementation
bool onlyPrimarySales; // If the auction can only do primary sales
}
// Scaling factor for splits. Allows for more decimal precision on percentages
uint256 constant internal SPLIT_SCALING_FACTOR = 10000;
// Lot ID to lot request
mapping(uint256 => LotRequest) internal lotRequests_;
// Auction types
mapping(uint256 => Auctions) internal auctions_;
// Address to auction ID
mapping(address => uint256) internal auctionAddress_;
// A mapping to keep track of token IDs to if it is not the first sale
mapping(uint256 => bool) internal isSecondarySale_;
// Interface for NFT contract
INft internal nftInstance_;
// Storage for the registry instance
Registry internal registryInstance_;
// Auction counter
uint256 internal auctionCounter_;
// Lot ID counters for auctions
uint256 internal lotCounter_;
// First sale splits
// Split to creator
uint256 internal creatorSplitFirstSale_;
// Split for system
uint256 internal systemSplitFirstSale_;
// Secondary sale splits
// Split to creator
uint256 internal creatorSplitSecondary_;
// Split to seller
uint256 internal sellerSplitSecondary_;
// Split to system
uint256 internal systemSplitSecondary_;
// -----------------------------------------------------------------------
// EVENTS
// -----------------------------------------------------------------------
event AuctionRegistered(
address owner,
uint256 indexed auctionID,
string auctionName,
address auctionContract
);
event AuctionUpdated(
address owner,
uint256 indexed auctionID,
address oldAuctionContract,
address newAuctionContract
);
event AuctionRemoved(
address owner,
uint256 indexed auctionID
);
event LotStatusChange(
uint256 indexed lotID,
uint256 indexed auctionID,
address indexed auction,
LotStatus status
);
event FirstSaleSplitUpdated(
uint256 oldCreatorSplit,
uint256 newCreatorSplit,
uint256 oldSystemSplit,
uint256 newSystemSplit
);
event SecondarySalesSplitUpdated(
uint256 oldCreatorSplit,
uint256 newCreatorSplit,
uint256 oldSellerSplit,
uint256 newSellerSplit,
uint256 oldSystemSplit,
uint256 newSystemSplit
);
event LotRequested(
address indexed requester,
uint256 indexed tokenID,
uint256 indexed lotID
);
// -----------------------------------------------------------------------
// MODIFIERS
// -----------------------------------------------------------------------
modifier onlyAuction() {
}
modifier onlyTokenOwner(uint256 _lotID) {
}
modifier onlyRegistry() {
}
// -----------------------------------------------------------------------
// CONSTRUCTOR
// -----------------------------------------------------------------------
constructor(
address _registry,
uint256 _primaryCreatorSplit,
uint256 _primarySystemSplit,
uint256 _secondaryCreatorSplit,
uint256 _secondarySellerSplit,
uint256 _secondarySystemSplit
)
Ownable()
{
}
// -----------------------------------------------------------------------
// NON-MODIFYING FUNCTIONS (VIEW)
// -----------------------------------------------------------------------
function getLotInformation(
uint256 _lotID
)
external
view
override
returns(
address owner,
uint256 tokenID,
uint256 auctionID,
LotStatus status
)
{
}
function getAuctionInformation(
uint256 _auctionID
)
external
view
override
returns(
bool active,
string memory auctionName,
address auctionContract,
bool onlyPrimarySales
)
{
}
function getAuctionID(
address _auction
)
external
view
override
returns(uint256)
{
}
function isAuctionActive(uint256 _auctionID) external view override returns(bool) {
}
function getAuctionCount() external view override returns(uint256) {
}
function isAuctionHubImplementation() external view override returns(bool) {
}
function isFirstSale(uint256 _tokenID) external view override returns(bool) {
}
function getFirstSaleSplit()
external
view
override
returns(
uint256 creatorSplit,
uint256 systemSplit
)
{
}
function getSecondarySaleSplits()
external
view
override
returns(
uint256 creatorSplit,
uint256 sellerSplit,
uint256 systemSplit
)
{
}
function getScalingFactor() external view override returns(uint256) {
}
// -----------------------------------------------------------------------
// PUBLIC STATE MODIFYING FUNCTIONS
// -----------------------------------------------------------------------
function requestAuctionLot(
uint256 _auctionType,
uint256 _tokenID
)
external
override
returns(uint256 lotID)
{
}
function init() external override onlyRegistry() returns(bool) {
}
// -----------------------------------------------------------------------
// ONLY AUCTIONS STATE MODIFYING FUNCTIONS
// -----------------------------------------------------------------------
function firstSaleCompleted(uint256 _tokenID) external override onlyAuction() {
}
function lotCreated(
uint256 _auctionID,
uint256 _lotID
)
external
override
onlyAuction()
{
}
function lotAuctionStarted(
uint256 _auctionID,
uint256 _lotID
)
external
override
onlyAuction()
{
}
function lotAuctionCompleted(
uint256 _auctionID,
uint256 _lotID
)
external
override
onlyAuction()
{
}
function lotAuctionCompletedAndClaimed(
uint256 _auctionID,
uint256 _lotID
)
external
override
onlyAuction()
{
}
function cancelLot(
uint256 _auctionID,
uint256 _lotID
)
external
override
onlyTokenOwner(_lotID)
{
}
// -----------------------------------------------------------------------
// ONLY OWNER STATE MODIFYING FUNCTIONS
// -----------------------------------------------------------------------
/**
* @param _newCreatorSplit The new split for the creator on primary sales.
* Scaled for more precision. 20% would be entered as 2000
* @param _newSystemSplit The new split for the system on primary sales.
* Scaled for more precision. 20% would be entered as 2000
* @notice Will revert if the sum of the two new splits does not equal
* 10000 (the scaled resolution)
*/
function updateFirstSaleSplit(
uint256 _newCreatorSplit,
uint256 _newSystemSplit
)
external
onlyOwner()
{
}
/**
* @param _newCreatorSplit The new split for the creator on secondary sales.
* Scaled for more precision. 20% would be entered as 2000
* @param _newSellerSplit The new split to the seller on secondary sales.
Scaled for more precision. 20% would be entered as 2000
* @param _newSystemSplit The new split for the system on secondary sales.
* Scaled for more precision. 20% would be entered as 2000
* @notice Will revert if the sum of the three new splits does not equal
* 10000 (the scaled resolution)
*/
function updateSecondarySalesSplit(
uint256 _newCreatorSplit,
uint256 _newSellerSplit,
uint256 _newSystemSplit
)
external
onlyOwner()
{
}
function registerAuction(
string memory _name,
address _auctionInstance,
bool _onlyPrimarySales
)
external
onlyOwner()
returns(uint256 auctionID)
{
}
/**
* @param _auctionID The ID of the auction to be paused.
* @notice This function allows the owner to pause the auction type. While
* the auction is paused no new lots can be created, but old lots
* can still complete.
*/
function pauseAuction(uint256 _auctionID) external onlyOwner() {
}
function updateAuctionInstance(
uint256 _auctionID,
address _newImplementation
)
external
onlyOwner()
{
require(
auctions_[_auctionID].status == AuctionStatus.PAUSED,
"Auction must be paused before update"
);
require(
auctions_[_auctionID].auctionContract != _newImplementation,
"Auction address already set"
);
IAuction newAuction = IAuction(_newImplementation);
require(<FILL_ME>)
newAuction.init(_auctionID);
address oldAuctionContract = auctions_[_auctionID].auctionContract;
auctionAddress_[oldAuctionContract] = 0;
auctions_[_auctionID].auctionContract = _newImplementation;
auctionAddress_[_newImplementation] = _auctionID;
emit AuctionUpdated(
msg.sender,
_auctionID,
oldAuctionContract,
_newImplementation
);
}
function removeAuction(
uint256 _auctionID
)
external
onlyOwner()
{
}
// -----------------------------------------------------------------------
// INTERNAL MODIFYING FUNCTIONS
// -----------------------------------------------------------------------
function _updateSecondarySalesSplit(
uint256 _newCreatorSplit,
uint256 _newSellerSplit,
uint256 _newSystemSplit
)
internal
{
}
function _updateFirstSaleSplit(
uint256 _newCreatorSplit,
uint256 _newSystemSplit
)
internal
{
}
}
| newAuction.isActive()==false,"Auction has been activated" | 350,668 | newAuction.isActive()==false |
"ERC20PresetMinterPauser: must have firestarter role to pause" | pragma solidity ^0.6.0;
/**
, ,, ,
| || | ,/ _____ \.
\_||_/ ||_/ \_||
|| \_| . . |_/
|| | L |
,|| |`==='|
|>| ___`> -<'___
|>|\ / \
\>| \ / , . . |
|| \/ /| . | . | |
||\ ` / | ___|___ | | (
(( || `--' | _______ | | )) (
( )\|| ( )\ | - --- - | -| ( ( \ ))
(\/ || ))/ ( | -- - -- | | )) ) \((
( ()||((( ())| | |( (( () ))
Hellfire!
*/
contract Hellfire is ERC20Burnable, AccessControl
{
address payable teamAddress;
uint256 private _minimumSupply = 6 * (10 ** 18);
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
bool private _burnEnabled;
bytes32 public constant FIRESTARTER_ROLE = keccak256("FIRESTARTER_ROLE");
constructor () public payable ERC20("Hellfire", "HELL") {
}
function transfer(address to, uint256 amount) virtual override public returns (bool) {
}
function transferFrom(address from, address to, uint256 amount) virtual override public returns (bool) {
}
function _partialBurn(uint256 amount) internal returns (uint256) {
}
function startBurn() public virtual {
require(<FILL_ME>)
_burnEnabled = true;
}
function _calculateBurnAmount(uint256 amount) internal view returns (uint256) {
}
}
| hasRole(FIRESTARTER_ROLE,_msgSender()),"ERC20PresetMinterPauser: must have firestarter role to pause" | 350,688 | hasRole(FIRESTARTER_ROLE,_msgSender()) |
null | pragma solidity ^0.4.24;
import "./Ownable.sol";
/**
* @title Lockable
* @dev lock up token transfer during duration. This helps lock up private and pre-sale investor cannot sell token certain period.
* @author Geunil(Brian) Lee
*/
contract Lockable is Ownable {
/**
* @dev hold lock up address and duration
*/
mapping(address => uint256) public lockedUp;
uint public nowTime;
constructor () public {
}
/**
* @dev lock up by pass when duration is passed or not exist on lockedUp mapping.
*/
modifier whenNotLockedUp() {
require(<FILL_ME>)
_;
}
/**
* @dev lock up status
* @return true - no lock up. false - locked up
*/
function nolockedUp(address sender) public view returns (bool){
}
/**
* @dev add lock up investor to mapping
* @param _investor lock up address
* @param _duration lock up period. unit is days
*/
function addLockUp(address _investor, uint _duration ) onlyOwner public {
}
/**
* @dev remove lock up address from mapping
* @param _investor lock up address to be removed from mapping
*/
function removeLockUp(address _investor ) onlyOwner public {
}
}
| lockedUp[msg.sender]<now||lockedUp[msg.sender]==0 | 350,696 | lockedUp[msg.sender]<now||lockedUp[msg.sender]==0 |
null | pragma solidity ^0.4.24;
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
* based on https://https://github.com/OpenZeppelin/zeppelin-solidity. modified to have multiple ownership.
* @author Geunil(Brian) Lee
*/
contract Ownable {
/**
* Ownership can be owned by multiple owner. Useful when have multiple contract to communicate each other
**/
mapping (address => bool) public owner;
event OwnershipAdded(address newOwner);
event OwnershipRemoved(address noOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor () public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(<FILL_ME>)
_;
}
/**
* @dev Add ownership
* @param _newOwner add address to the ownership
*/
function addOwnership(address _newOwner) public onlyOwner {
}
/**
* @dev Remove ownership
* @param _ownership remove ownership
*/
function removeOwner(address _ownership) public onlyOwner{
}
}
| owner[msg.sender]==true | 350,697 | owner[msg.sender]==true |
"Exceeds Max Public Supply" | pragma solidity ^0.8.7;
contract SKULLAPEGANG is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
using Strings for uint256;
//Counters
Counters.Counter internal _count;
Counters.Counter internal _publicCount;
string public baseURI;
string public baseExtension = ".json";
uint256 public cost = 0.04 ether;
uint256 public whitelistCost = 0.00 ether;
uint256 public maxSupply = 8488;
uint256 public maxWhitelistSupply = 400;
uint256 public maxMintAmount = 10;
uint256 public nftPerAddressLimit = 1;
bool public paused = false;
bool public onlyWhitelisted = true;
mapping(address => uint256) public addressMintedBalance;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI
) ERC721(_name, _symbol) {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public sale
function mint(uint256 _mintAmount) public payable {
// total nft minted count
uint256 supply = totalSupply();
//if owner is not
if (msg.sender != owner()) {
//if pause is enable throw error
require(!paused, "The contract is paused");
//if whitelist is enable throw error
require(!onlyWhitelisted, "You can't mint Pre-sale enable");
//address mint count
uint256 trackMintedCount = addressMintedBalance[msg.sender];
//mint count should be greater than 0
require(_mintAmount > 0, "Need to mint at least 1 NFT");
//per transaction limit
require(_mintAmount <= maxMintAmount, "Max mint amount per session exceeded");
//max supply limit
require(<FILL_ME>)
//addresss quota limit
require((trackMintedCount + _mintAmount) <= maxMintAmount,"Your quota exceeded for per address ");
//mint cost
require(msg.value >= cost * _mintAmount, "Insuffient funds");
}
for (uint256 i = 1; i <= _mintAmount; i++) {
addressMintedBalance[msg.sender]++;
_safeMint(msg.sender, supply + i);
_publicCount.increment();
}
}
//pre-sale
function mintWhitelist( uint256 _mintAmount) public payable {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function totalWhitelistSupply() public view returns (uint256) {
}
function totalPublicSupply() public view returns (uint256) {
}
function remainingWhitelistSupply() public view returns (uint256) {
}
function remainingPublicSupply() public view returns (uint256) {
}
function setNftPerAddressLimit(uint256 _limit) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setwhitelistCost(uint256 _newWhitelistCost) public onlyOwner {
}
function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
}
function setmaxSupply(uint256 _newmaxSupply) public onlyOwner {
}
function setmaxWhitelistSupply(uint256 _newmaxWhitelistSupply) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function setOnlyWhitelisted(bool _state) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| _publicCount.current()+_mintAmount<=maxSupply,"Exceeds Max Public Supply" | 350,765 | _publicCount.current()+_mintAmount<=maxSupply |
"Your quota exceeded for per address " | pragma solidity ^0.8.7;
contract SKULLAPEGANG is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
using Strings for uint256;
//Counters
Counters.Counter internal _count;
Counters.Counter internal _publicCount;
string public baseURI;
string public baseExtension = ".json";
uint256 public cost = 0.04 ether;
uint256 public whitelistCost = 0.00 ether;
uint256 public maxSupply = 8488;
uint256 public maxWhitelistSupply = 400;
uint256 public maxMintAmount = 10;
uint256 public nftPerAddressLimit = 1;
bool public paused = false;
bool public onlyWhitelisted = true;
mapping(address => uint256) public addressMintedBalance;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI
) ERC721(_name, _symbol) {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public sale
function mint(uint256 _mintAmount) public payable {
// total nft minted count
uint256 supply = totalSupply();
//if owner is not
if (msg.sender != owner()) {
//if pause is enable throw error
require(!paused, "The contract is paused");
//if whitelist is enable throw error
require(!onlyWhitelisted, "You can't mint Pre-sale enable");
//address mint count
uint256 trackMintedCount = addressMintedBalance[msg.sender];
//mint count should be greater than 0
require(_mintAmount > 0, "Need to mint at least 1 NFT");
//per transaction limit
require(_mintAmount <= maxMintAmount, "Max mint amount per session exceeded");
//max supply limit
require(_publicCount.current() + _mintAmount <= maxSupply, "Exceeds Max Public Supply");
//addresss quota limit
require(<FILL_ME>)
//mint cost
require(msg.value >= cost * _mintAmount, "Insuffient funds");
}
for (uint256 i = 1; i <= _mintAmount; i++) {
addressMintedBalance[msg.sender]++;
_safeMint(msg.sender, supply + i);
_publicCount.increment();
}
}
//pre-sale
function mintWhitelist( uint256 _mintAmount) public payable {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function totalWhitelistSupply() public view returns (uint256) {
}
function totalPublicSupply() public view returns (uint256) {
}
function remainingWhitelistSupply() public view returns (uint256) {
}
function remainingPublicSupply() public view returns (uint256) {
}
function setNftPerAddressLimit(uint256 _limit) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setwhitelistCost(uint256 _newWhitelistCost) public onlyOwner {
}
function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
}
function setmaxSupply(uint256 _newmaxSupply) public onlyOwner {
}
function setmaxWhitelistSupply(uint256 _newmaxWhitelistSupply) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function setOnlyWhitelisted(bool _state) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| (trackMintedCount+_mintAmount)<=maxMintAmount,"Your quota exceeded for per address " | 350,765 | (trackMintedCount+_mintAmount)<=maxMintAmount |
"Exceeds Max Whitelist Supply" | pragma solidity ^0.8.7;
contract SKULLAPEGANG is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
using Strings for uint256;
//Counters
Counters.Counter internal _count;
Counters.Counter internal _publicCount;
string public baseURI;
string public baseExtension = ".json";
uint256 public cost = 0.04 ether;
uint256 public whitelistCost = 0.00 ether;
uint256 public maxSupply = 8488;
uint256 public maxWhitelistSupply = 400;
uint256 public maxMintAmount = 10;
uint256 public nftPerAddressLimit = 1;
bool public paused = false;
bool public onlyWhitelisted = true;
mapping(address => uint256) public addressMintedBalance;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI
) ERC721(_name, _symbol) {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public sale
function mint(uint256 _mintAmount) public payable {
}
//pre-sale
function mintWhitelist( uint256 _mintAmount) public payable {
uint256 supply = totalSupply();
if (msg.sender != owner()) {
if(onlyWhitelisted == true) {
require(!paused, "The contract is paused");
require(_mintAmount > 0, "Need to mint at least 1 NFT");
uint256 ownerMintedCount = addressMintedBalance[msg.sender];
require(<FILL_ME>)
require(ownerMintedCount + _mintAmount <= nftPerAddressLimit, "Max NFT per address exceeded");
require(msg.value >= whitelistCost * _mintAmount, "Insuffient funds");
}
}
for (uint256 i = 1; i <= _mintAmount; i++) {
addressMintedBalance[msg.sender]++;
_safeMint(msg.sender, supply + i);
_count.increment();
}
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function totalWhitelistSupply() public view returns (uint256) {
}
function totalPublicSupply() public view returns (uint256) {
}
function remainingWhitelistSupply() public view returns (uint256) {
}
function remainingPublicSupply() public view returns (uint256) {
}
function setNftPerAddressLimit(uint256 _limit) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setwhitelistCost(uint256 _newWhitelistCost) public onlyOwner {
}
function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
}
function setmaxSupply(uint256 _newmaxSupply) public onlyOwner {
}
function setmaxWhitelistSupply(uint256 _newmaxWhitelistSupply) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function setOnlyWhitelisted(bool _state) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| _count.current()+_mintAmount<=maxWhitelistSupply,"Exceeds Max Whitelist Supply" | 350,765 | _count.current()+_mintAmount<=maxWhitelistSupply |
"Supply exceeded with provided amount." | pragma solidity ^0.8.0;
contract StonedApeSaturnClub is ERC721Enumerable, Ownable {
using Strings for uint256;
address public _t1 = 0xd230f390AbB50470fa265a022d673c6147BDc396;
address public _t2 = 0xbc15b4665633eC65925040fAb61D0fC1C4eeFAaB;
address public _t3 = 0x5F55Cd7A509fdA9F0beB9309A49a689EB8C122EE;
address public _t4 = 0x5F55Cd7A509fdA9F0beB9309A49a689EB8C122EE;
address public _t5 = 0x9CED6C82326c7Dbc222dd17B6573E69cfE3983f2;
address public _t6 = 0x630A035Be662260Db9Fe33cD58aFD71f7e8F4fa3;
address public _t7 = 0x335B108025D6F6cAf4f98357baaa6Dfde715406C;
address public _t8 = 0x872b7b86BA6F64E724CfB8788410cB3042F564FA;
bool public _active = false;
string public _baseTokenURI;
uint256 public _gifts = 145;
uint256 public _price = 0.024 ether;
uint256 public _supply = 6969;
constructor(string memory baseURI) ERC721("Stoned Ape Saturn Club", "SASC") {
}
function setActive(bool active) public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setPrice(uint256 price) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function gift(address _to, uint256 _amount) external onlyOwner {
}
function mint(uint256 _amount) public payable {
uint256 supply = totalSupply();
require( _active, "Sale is not active.");
require( _amount < 10, "Provided amount exceeds mint limit.");
require( msg.value >= _price * _amount, "Insufficient ether provided.");
require(<FILL_ME>)
for(uint256 i; i < _amount; i++){
_safeMint( msg.sender, supply + i );
}
}
function withdraw() public payable onlyOwner {
}
}
| supply+_amount<=_supply-_gifts,"Supply exceeded with provided amount." | 350,801 | supply+_amount<=_supply-_gifts |
null | pragma solidity ^0.8.0;
contract StonedApeSaturnClub is ERC721Enumerable, Ownable {
using Strings for uint256;
address public _t1 = 0xd230f390AbB50470fa265a022d673c6147BDc396;
address public _t2 = 0xbc15b4665633eC65925040fAb61D0fC1C4eeFAaB;
address public _t3 = 0x5F55Cd7A509fdA9F0beB9309A49a689EB8C122EE;
address public _t4 = 0x5F55Cd7A509fdA9F0beB9309A49a689EB8C122EE;
address public _t5 = 0x9CED6C82326c7Dbc222dd17B6573E69cfE3983f2;
address public _t6 = 0x630A035Be662260Db9Fe33cD58aFD71f7e8F4fa3;
address public _t7 = 0x335B108025D6F6cAf4f98357baaa6Dfde715406C;
address public _t8 = 0x872b7b86BA6F64E724CfB8788410cB3042F564FA;
bool public _active = false;
string public _baseTokenURI;
uint256 public _gifts = 145;
uint256 public _price = 0.024 ether;
uint256 public _supply = 6969;
constructor(string memory baseURI) ERC721("Stoned Ape Saturn Club", "SASC") {
}
function setActive(bool active) public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setPrice(uint256 price) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function gift(address _to, uint256 _amount) external onlyOwner {
}
function mint(uint256 _amount) public payable {
}
function withdraw() public payable onlyOwner {
uint256 _p1 = address(this).balance / 10;
uint256 _p2 = address(this).balance * 2 / 25;
uint256 _p3 = address(this).balance * 2 / 25;
uint256 _p4 = address(this).balance * 11 / 100;
uint256 _p5 = address(this).balance * 11 / 100;
uint256 _p6 = address(this).balance * 11 / 100;
uint256 _p7 = address(this).balance * 11 / 100;
uint256 _p8 = address(this).balance * 3 / 10;
require(<FILL_ME>)
require(payable(_t2).send(_p2));
require(payable(_t3).send(_p3));
require(payable(_t4).send(_p4));
require(payable(_t5).send(_p5));
require(payable(_t6).send(_p6));
require(payable(_t7).send(_p7));
require(payable(_t8).send(_p8));
}
}
| payable(_t1).send(_p1) | 350,801 | payable(_t1).send(_p1) |
null | pragma solidity ^0.8.0;
contract StonedApeSaturnClub is ERC721Enumerable, Ownable {
using Strings for uint256;
address public _t1 = 0xd230f390AbB50470fa265a022d673c6147BDc396;
address public _t2 = 0xbc15b4665633eC65925040fAb61D0fC1C4eeFAaB;
address public _t3 = 0x5F55Cd7A509fdA9F0beB9309A49a689EB8C122EE;
address public _t4 = 0x5F55Cd7A509fdA9F0beB9309A49a689EB8C122EE;
address public _t5 = 0x9CED6C82326c7Dbc222dd17B6573E69cfE3983f2;
address public _t6 = 0x630A035Be662260Db9Fe33cD58aFD71f7e8F4fa3;
address public _t7 = 0x335B108025D6F6cAf4f98357baaa6Dfde715406C;
address public _t8 = 0x872b7b86BA6F64E724CfB8788410cB3042F564FA;
bool public _active = false;
string public _baseTokenURI;
uint256 public _gifts = 145;
uint256 public _price = 0.024 ether;
uint256 public _supply = 6969;
constructor(string memory baseURI) ERC721("Stoned Ape Saturn Club", "SASC") {
}
function setActive(bool active) public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setPrice(uint256 price) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function gift(address _to, uint256 _amount) external onlyOwner {
}
function mint(uint256 _amount) public payable {
}
function withdraw() public payable onlyOwner {
uint256 _p1 = address(this).balance / 10;
uint256 _p2 = address(this).balance * 2 / 25;
uint256 _p3 = address(this).balance * 2 / 25;
uint256 _p4 = address(this).balance * 11 / 100;
uint256 _p5 = address(this).balance * 11 / 100;
uint256 _p6 = address(this).balance * 11 / 100;
uint256 _p7 = address(this).balance * 11 / 100;
uint256 _p8 = address(this).balance * 3 / 10;
require(payable(_t1).send(_p1));
require(<FILL_ME>)
require(payable(_t3).send(_p3));
require(payable(_t4).send(_p4));
require(payable(_t5).send(_p5));
require(payable(_t6).send(_p6));
require(payable(_t7).send(_p7));
require(payable(_t8).send(_p8));
}
}
| payable(_t2).send(_p2) | 350,801 | payable(_t2).send(_p2) |
null | pragma solidity ^0.8.0;
contract StonedApeSaturnClub is ERC721Enumerable, Ownable {
using Strings for uint256;
address public _t1 = 0xd230f390AbB50470fa265a022d673c6147BDc396;
address public _t2 = 0xbc15b4665633eC65925040fAb61D0fC1C4eeFAaB;
address public _t3 = 0x5F55Cd7A509fdA9F0beB9309A49a689EB8C122EE;
address public _t4 = 0x5F55Cd7A509fdA9F0beB9309A49a689EB8C122EE;
address public _t5 = 0x9CED6C82326c7Dbc222dd17B6573E69cfE3983f2;
address public _t6 = 0x630A035Be662260Db9Fe33cD58aFD71f7e8F4fa3;
address public _t7 = 0x335B108025D6F6cAf4f98357baaa6Dfde715406C;
address public _t8 = 0x872b7b86BA6F64E724CfB8788410cB3042F564FA;
bool public _active = false;
string public _baseTokenURI;
uint256 public _gifts = 145;
uint256 public _price = 0.024 ether;
uint256 public _supply = 6969;
constructor(string memory baseURI) ERC721("Stoned Ape Saturn Club", "SASC") {
}
function setActive(bool active) public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setPrice(uint256 price) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function gift(address _to, uint256 _amount) external onlyOwner {
}
function mint(uint256 _amount) public payable {
}
function withdraw() public payable onlyOwner {
uint256 _p1 = address(this).balance / 10;
uint256 _p2 = address(this).balance * 2 / 25;
uint256 _p3 = address(this).balance * 2 / 25;
uint256 _p4 = address(this).balance * 11 / 100;
uint256 _p5 = address(this).balance * 11 / 100;
uint256 _p6 = address(this).balance * 11 / 100;
uint256 _p7 = address(this).balance * 11 / 100;
uint256 _p8 = address(this).balance * 3 / 10;
require(payable(_t1).send(_p1));
require(payable(_t2).send(_p2));
require(<FILL_ME>)
require(payable(_t4).send(_p4));
require(payable(_t5).send(_p5));
require(payable(_t6).send(_p6));
require(payable(_t7).send(_p7));
require(payable(_t8).send(_p8));
}
}
| payable(_t3).send(_p3) | 350,801 | payable(_t3).send(_p3) |
null | pragma solidity ^0.8.0;
contract StonedApeSaturnClub is ERC721Enumerable, Ownable {
using Strings for uint256;
address public _t1 = 0xd230f390AbB50470fa265a022d673c6147BDc396;
address public _t2 = 0xbc15b4665633eC65925040fAb61D0fC1C4eeFAaB;
address public _t3 = 0x5F55Cd7A509fdA9F0beB9309A49a689EB8C122EE;
address public _t4 = 0x5F55Cd7A509fdA9F0beB9309A49a689EB8C122EE;
address public _t5 = 0x9CED6C82326c7Dbc222dd17B6573E69cfE3983f2;
address public _t6 = 0x630A035Be662260Db9Fe33cD58aFD71f7e8F4fa3;
address public _t7 = 0x335B108025D6F6cAf4f98357baaa6Dfde715406C;
address public _t8 = 0x872b7b86BA6F64E724CfB8788410cB3042F564FA;
bool public _active = false;
string public _baseTokenURI;
uint256 public _gifts = 145;
uint256 public _price = 0.024 ether;
uint256 public _supply = 6969;
constructor(string memory baseURI) ERC721("Stoned Ape Saturn Club", "SASC") {
}
function setActive(bool active) public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setPrice(uint256 price) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function gift(address _to, uint256 _amount) external onlyOwner {
}
function mint(uint256 _amount) public payable {
}
function withdraw() public payable onlyOwner {
uint256 _p1 = address(this).balance / 10;
uint256 _p2 = address(this).balance * 2 / 25;
uint256 _p3 = address(this).balance * 2 / 25;
uint256 _p4 = address(this).balance * 11 / 100;
uint256 _p5 = address(this).balance * 11 / 100;
uint256 _p6 = address(this).balance * 11 / 100;
uint256 _p7 = address(this).balance * 11 / 100;
uint256 _p8 = address(this).balance * 3 / 10;
require(payable(_t1).send(_p1));
require(payable(_t2).send(_p2));
require(payable(_t3).send(_p3));
require(<FILL_ME>)
require(payable(_t5).send(_p5));
require(payable(_t6).send(_p6));
require(payable(_t7).send(_p7));
require(payable(_t8).send(_p8));
}
}
| payable(_t4).send(_p4) | 350,801 | payable(_t4).send(_p4) |
null | pragma solidity ^0.8.0;
contract StonedApeSaturnClub is ERC721Enumerable, Ownable {
using Strings for uint256;
address public _t1 = 0xd230f390AbB50470fa265a022d673c6147BDc396;
address public _t2 = 0xbc15b4665633eC65925040fAb61D0fC1C4eeFAaB;
address public _t3 = 0x5F55Cd7A509fdA9F0beB9309A49a689EB8C122EE;
address public _t4 = 0x5F55Cd7A509fdA9F0beB9309A49a689EB8C122EE;
address public _t5 = 0x9CED6C82326c7Dbc222dd17B6573E69cfE3983f2;
address public _t6 = 0x630A035Be662260Db9Fe33cD58aFD71f7e8F4fa3;
address public _t7 = 0x335B108025D6F6cAf4f98357baaa6Dfde715406C;
address public _t8 = 0x872b7b86BA6F64E724CfB8788410cB3042F564FA;
bool public _active = false;
string public _baseTokenURI;
uint256 public _gifts = 145;
uint256 public _price = 0.024 ether;
uint256 public _supply = 6969;
constructor(string memory baseURI) ERC721("Stoned Ape Saturn Club", "SASC") {
}
function setActive(bool active) public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setPrice(uint256 price) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function gift(address _to, uint256 _amount) external onlyOwner {
}
function mint(uint256 _amount) public payable {
}
function withdraw() public payable onlyOwner {
uint256 _p1 = address(this).balance / 10;
uint256 _p2 = address(this).balance * 2 / 25;
uint256 _p3 = address(this).balance * 2 / 25;
uint256 _p4 = address(this).balance * 11 / 100;
uint256 _p5 = address(this).balance * 11 / 100;
uint256 _p6 = address(this).balance * 11 / 100;
uint256 _p7 = address(this).balance * 11 / 100;
uint256 _p8 = address(this).balance * 3 / 10;
require(payable(_t1).send(_p1));
require(payable(_t2).send(_p2));
require(payable(_t3).send(_p3));
require(payable(_t4).send(_p4));
require(<FILL_ME>)
require(payable(_t6).send(_p6));
require(payable(_t7).send(_p7));
require(payable(_t8).send(_p8));
}
}
| payable(_t5).send(_p5) | 350,801 | payable(_t5).send(_p5) |
null | pragma solidity ^0.8.0;
contract StonedApeSaturnClub is ERC721Enumerable, Ownable {
using Strings for uint256;
address public _t1 = 0xd230f390AbB50470fa265a022d673c6147BDc396;
address public _t2 = 0xbc15b4665633eC65925040fAb61D0fC1C4eeFAaB;
address public _t3 = 0x5F55Cd7A509fdA9F0beB9309A49a689EB8C122EE;
address public _t4 = 0x5F55Cd7A509fdA9F0beB9309A49a689EB8C122EE;
address public _t5 = 0x9CED6C82326c7Dbc222dd17B6573E69cfE3983f2;
address public _t6 = 0x630A035Be662260Db9Fe33cD58aFD71f7e8F4fa3;
address public _t7 = 0x335B108025D6F6cAf4f98357baaa6Dfde715406C;
address public _t8 = 0x872b7b86BA6F64E724CfB8788410cB3042F564FA;
bool public _active = false;
string public _baseTokenURI;
uint256 public _gifts = 145;
uint256 public _price = 0.024 ether;
uint256 public _supply = 6969;
constructor(string memory baseURI) ERC721("Stoned Ape Saturn Club", "SASC") {
}
function setActive(bool active) public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setPrice(uint256 price) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function gift(address _to, uint256 _amount) external onlyOwner {
}
function mint(uint256 _amount) public payable {
}
function withdraw() public payable onlyOwner {
uint256 _p1 = address(this).balance / 10;
uint256 _p2 = address(this).balance * 2 / 25;
uint256 _p3 = address(this).balance * 2 / 25;
uint256 _p4 = address(this).balance * 11 / 100;
uint256 _p5 = address(this).balance * 11 / 100;
uint256 _p6 = address(this).balance * 11 / 100;
uint256 _p7 = address(this).balance * 11 / 100;
uint256 _p8 = address(this).balance * 3 / 10;
require(payable(_t1).send(_p1));
require(payable(_t2).send(_p2));
require(payable(_t3).send(_p3));
require(payable(_t4).send(_p4));
require(payable(_t5).send(_p5));
require(<FILL_ME>)
require(payable(_t7).send(_p7));
require(payable(_t8).send(_p8));
}
}
| payable(_t6).send(_p6) | 350,801 | payable(_t6).send(_p6) |
null | pragma solidity ^0.8.0;
contract StonedApeSaturnClub is ERC721Enumerable, Ownable {
using Strings for uint256;
address public _t1 = 0xd230f390AbB50470fa265a022d673c6147BDc396;
address public _t2 = 0xbc15b4665633eC65925040fAb61D0fC1C4eeFAaB;
address public _t3 = 0x5F55Cd7A509fdA9F0beB9309A49a689EB8C122EE;
address public _t4 = 0x5F55Cd7A509fdA9F0beB9309A49a689EB8C122EE;
address public _t5 = 0x9CED6C82326c7Dbc222dd17B6573E69cfE3983f2;
address public _t6 = 0x630A035Be662260Db9Fe33cD58aFD71f7e8F4fa3;
address public _t7 = 0x335B108025D6F6cAf4f98357baaa6Dfde715406C;
address public _t8 = 0x872b7b86BA6F64E724CfB8788410cB3042F564FA;
bool public _active = false;
string public _baseTokenURI;
uint256 public _gifts = 145;
uint256 public _price = 0.024 ether;
uint256 public _supply = 6969;
constructor(string memory baseURI) ERC721("Stoned Ape Saturn Club", "SASC") {
}
function setActive(bool active) public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setPrice(uint256 price) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function gift(address _to, uint256 _amount) external onlyOwner {
}
function mint(uint256 _amount) public payable {
}
function withdraw() public payable onlyOwner {
uint256 _p1 = address(this).balance / 10;
uint256 _p2 = address(this).balance * 2 / 25;
uint256 _p3 = address(this).balance * 2 / 25;
uint256 _p4 = address(this).balance * 11 / 100;
uint256 _p5 = address(this).balance * 11 / 100;
uint256 _p6 = address(this).balance * 11 / 100;
uint256 _p7 = address(this).balance * 11 / 100;
uint256 _p8 = address(this).balance * 3 / 10;
require(payable(_t1).send(_p1));
require(payable(_t2).send(_p2));
require(payable(_t3).send(_p3));
require(payable(_t4).send(_p4));
require(payable(_t5).send(_p5));
require(payable(_t6).send(_p6));
require(<FILL_ME>)
require(payable(_t8).send(_p8));
}
}
| payable(_t7).send(_p7) | 350,801 | payable(_t7).send(_p7) |
null | pragma solidity ^0.8.0;
contract StonedApeSaturnClub is ERC721Enumerable, Ownable {
using Strings for uint256;
address public _t1 = 0xd230f390AbB50470fa265a022d673c6147BDc396;
address public _t2 = 0xbc15b4665633eC65925040fAb61D0fC1C4eeFAaB;
address public _t3 = 0x5F55Cd7A509fdA9F0beB9309A49a689EB8C122EE;
address public _t4 = 0x5F55Cd7A509fdA9F0beB9309A49a689EB8C122EE;
address public _t5 = 0x9CED6C82326c7Dbc222dd17B6573E69cfE3983f2;
address public _t6 = 0x630A035Be662260Db9Fe33cD58aFD71f7e8F4fa3;
address public _t7 = 0x335B108025D6F6cAf4f98357baaa6Dfde715406C;
address public _t8 = 0x872b7b86BA6F64E724CfB8788410cB3042F564FA;
bool public _active = false;
string public _baseTokenURI;
uint256 public _gifts = 145;
uint256 public _price = 0.024 ether;
uint256 public _supply = 6969;
constructor(string memory baseURI) ERC721("Stoned Ape Saturn Club", "SASC") {
}
function setActive(bool active) public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setPrice(uint256 price) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function gift(address _to, uint256 _amount) external onlyOwner {
}
function mint(uint256 _amount) public payable {
}
function withdraw() public payable onlyOwner {
uint256 _p1 = address(this).balance / 10;
uint256 _p2 = address(this).balance * 2 / 25;
uint256 _p3 = address(this).balance * 2 / 25;
uint256 _p4 = address(this).balance * 11 / 100;
uint256 _p5 = address(this).balance * 11 / 100;
uint256 _p6 = address(this).balance * 11 / 100;
uint256 _p7 = address(this).balance * 11 / 100;
uint256 _p8 = address(this).balance * 3 / 10;
require(payable(_t1).send(_p1));
require(payable(_t2).send(_p2));
require(payable(_t3).send(_p3));
require(payable(_t4).send(_p4));
require(payable(_t5).send(_p5));
require(payable(_t6).send(_p6));
require(payable(_t7).send(_p7));
require(<FILL_ME>)
}
}
| payable(_t8).send(_p8) | 350,801 | payable(_t8).send(_p8) |
"PRESALE: Only registered customers can mint!" | // SPDX-License-Identifier: MIT
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/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./ERC721Pausable.sol";
contract Nippleverse is ERC721Enumerable, Ownable, ERC721Burnable, ERC721Pausable {
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
bool public SALE_OPEN = false;
uint256 private constant PRICE = 69 * 10**15; // 0.069ETH Per Nipple
uint256 private constant PRICE_PRESALE = 5 * 10**16; // 0.05ETH Per Nipple
uint256 private constant PRICE_PREMINT = 0; // Free Per Nipple
uint256 private constant MAX_ELEMENTS = 4444; // 4444 Nipples for Entire Collection.
uint256 private constant MAX_ELEMENTS_PRESALE = 444; // 444 Nipples for Pre Sale.
uint256 private constant MAX_ELEMENTS_PREMINT = 30; // 30 Nipples for GiveAway.
uint256 private constant MAX_MINT = 20; // Upper Limit per Mint is 20
uint256 private constant MAX_MINT_PRESALE = 5; // Upper Limit per Mint is 5
uint256 private constant MAX_MINT_PREMINT = 28; // Upper Limit per Mint is 28
uint256 private _price;
uint256 private _maxElements;
uint256 private _maxMint;
mapping(uint256 => bool) private _isOccupiedId;
uint256[] private _occupiedList;
mapping(address => bool) public _whitelist;
bool private _isPresale;
string private baseTokenURI;
event NippleverseCreated(address to, uint256 indexed id);
modifier saleIsOpen {
}
constructor (string memory baseURI) ERC721("Nippleverse", "NIP") {
}
function mint(address payable _to, uint256[] memory _ids) public payable saleIsOpen {
uint256 total = _totalSupply();
if (_isPresale == true) {
require(<FILL_ME>)
}
require(total + _ids.length <= _maxElements, "MINT: Current count exceeds maximum element count.");
require(total <= _maxElements, "MINT: Please go to the Opensea to buy NippleVerse.");
require(_ids.length <= _maxMint, "MINT: Current count exceeds maximum mint count.");
if (_to != owner()) {
require(msg.value >= price(_ids.length), "MINT: Current value is below the sales price of NippleVerse");
}
for (uint256 i = 0; i < _ids.length; i++) {
require(_isOccupiedId[_ids[i]] == false, "MINT: Those ids already have been used for other customers");
}
for (uint256 i = 0; i < _ids.length; i++) {
_mintAnElement(_to, _ids[i]);
}
}
function _mintAnElement(address payable _to, uint256 _id) private {
}
function startPreSale() public onlyOwner {
}
function startPublicSale() public onlyOwner {
}
function flipSaleState() public onlyOwner {
}
function addToWhitelist(address attender) public onlyOwner {
}
function removeFromWhitelist(address attender) public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function price(uint256 _count) public view returns (uint256) {
}
function _totalSupply() internal view returns (uint) {
}
function occupiedList() public view returns (uint256[] memory) {
}
function maxMint() public view returns (uint256) {
}
function maxSales() public view returns (uint256) {
}
function maxSupply() public pure returns (uint256) {
}
function raised() public view returns (uint256) {
}
function getTokenIdsOfWallet(address _owner) external view returns (uint256[] memory) {
}
function withdrawAll() public payable onlyOwner {
}
function _widthdraw(address _address, uint256 _amount) private {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721, ERC721Enumerable, ERC721Pausable) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC721Enumerable) returns (bool) {
}
}
| _whitelist[_to]==true,"PRESALE: Only registered customers can mint!" | 350,919 | _whitelist[_to]==true |
"MINT: Current count exceeds maximum element count." | // SPDX-License-Identifier: MIT
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/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./ERC721Pausable.sol";
contract Nippleverse is ERC721Enumerable, Ownable, ERC721Burnable, ERC721Pausable {
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
bool public SALE_OPEN = false;
uint256 private constant PRICE = 69 * 10**15; // 0.069ETH Per Nipple
uint256 private constant PRICE_PRESALE = 5 * 10**16; // 0.05ETH Per Nipple
uint256 private constant PRICE_PREMINT = 0; // Free Per Nipple
uint256 private constant MAX_ELEMENTS = 4444; // 4444 Nipples for Entire Collection.
uint256 private constant MAX_ELEMENTS_PRESALE = 444; // 444 Nipples for Pre Sale.
uint256 private constant MAX_ELEMENTS_PREMINT = 30; // 30 Nipples for GiveAway.
uint256 private constant MAX_MINT = 20; // Upper Limit per Mint is 20
uint256 private constant MAX_MINT_PRESALE = 5; // Upper Limit per Mint is 5
uint256 private constant MAX_MINT_PREMINT = 28; // Upper Limit per Mint is 28
uint256 private _price;
uint256 private _maxElements;
uint256 private _maxMint;
mapping(uint256 => bool) private _isOccupiedId;
uint256[] private _occupiedList;
mapping(address => bool) public _whitelist;
bool private _isPresale;
string private baseTokenURI;
event NippleverseCreated(address to, uint256 indexed id);
modifier saleIsOpen {
}
constructor (string memory baseURI) ERC721("Nippleverse", "NIP") {
}
function mint(address payable _to, uint256[] memory _ids) public payable saleIsOpen {
uint256 total = _totalSupply();
if (_isPresale == true) {
require(_whitelist[_to] == true, "PRESALE: Only registered customers can mint!");
}
require(<FILL_ME>)
require(total <= _maxElements, "MINT: Please go to the Opensea to buy NippleVerse.");
require(_ids.length <= _maxMint, "MINT: Current count exceeds maximum mint count.");
if (_to != owner()) {
require(msg.value >= price(_ids.length), "MINT: Current value is below the sales price of NippleVerse");
}
for (uint256 i = 0; i < _ids.length; i++) {
require(_isOccupiedId[_ids[i]] == false, "MINT: Those ids already have been used for other customers");
}
for (uint256 i = 0; i < _ids.length; i++) {
_mintAnElement(_to, _ids[i]);
}
}
function _mintAnElement(address payable _to, uint256 _id) private {
}
function startPreSale() public onlyOwner {
}
function startPublicSale() public onlyOwner {
}
function flipSaleState() public onlyOwner {
}
function addToWhitelist(address attender) public onlyOwner {
}
function removeFromWhitelist(address attender) public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function price(uint256 _count) public view returns (uint256) {
}
function _totalSupply() internal view returns (uint) {
}
function occupiedList() public view returns (uint256[] memory) {
}
function maxMint() public view returns (uint256) {
}
function maxSales() public view returns (uint256) {
}
function maxSupply() public pure returns (uint256) {
}
function raised() public view returns (uint256) {
}
function getTokenIdsOfWallet(address _owner) external view returns (uint256[] memory) {
}
function withdrawAll() public payable onlyOwner {
}
function _widthdraw(address _address, uint256 _amount) private {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721, ERC721Enumerable, ERC721Pausable) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC721Enumerable) returns (bool) {
}
}
| total+_ids.length<=_maxElements,"MINT: Current count exceeds maximum element count." | 350,919 | total+_ids.length<=_maxElements |
"MINT: Those ids already have been used for other customers" | // SPDX-License-Identifier: MIT
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/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./ERC721Pausable.sol";
contract Nippleverse is ERC721Enumerable, Ownable, ERC721Burnable, ERC721Pausable {
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
bool public SALE_OPEN = false;
uint256 private constant PRICE = 69 * 10**15; // 0.069ETH Per Nipple
uint256 private constant PRICE_PRESALE = 5 * 10**16; // 0.05ETH Per Nipple
uint256 private constant PRICE_PREMINT = 0; // Free Per Nipple
uint256 private constant MAX_ELEMENTS = 4444; // 4444 Nipples for Entire Collection.
uint256 private constant MAX_ELEMENTS_PRESALE = 444; // 444 Nipples for Pre Sale.
uint256 private constant MAX_ELEMENTS_PREMINT = 30; // 30 Nipples for GiveAway.
uint256 private constant MAX_MINT = 20; // Upper Limit per Mint is 20
uint256 private constant MAX_MINT_PRESALE = 5; // Upper Limit per Mint is 5
uint256 private constant MAX_MINT_PREMINT = 28; // Upper Limit per Mint is 28
uint256 private _price;
uint256 private _maxElements;
uint256 private _maxMint;
mapping(uint256 => bool) private _isOccupiedId;
uint256[] private _occupiedList;
mapping(address => bool) public _whitelist;
bool private _isPresale;
string private baseTokenURI;
event NippleverseCreated(address to, uint256 indexed id);
modifier saleIsOpen {
}
constructor (string memory baseURI) ERC721("Nippleverse", "NIP") {
}
function mint(address payable _to, uint256[] memory _ids) public payable saleIsOpen {
uint256 total = _totalSupply();
if (_isPresale == true) {
require(_whitelist[_to] == true, "PRESALE: Only registered customers can mint!");
}
require(total + _ids.length <= _maxElements, "MINT: Current count exceeds maximum element count.");
require(total <= _maxElements, "MINT: Please go to the Opensea to buy NippleVerse.");
require(_ids.length <= _maxMint, "MINT: Current count exceeds maximum mint count.");
if (_to != owner()) {
require(msg.value >= price(_ids.length), "MINT: Current value is below the sales price of NippleVerse");
}
for (uint256 i = 0; i < _ids.length; i++) {
require(<FILL_ME>)
}
for (uint256 i = 0; i < _ids.length; i++) {
_mintAnElement(_to, _ids[i]);
}
}
function _mintAnElement(address payable _to, uint256 _id) private {
}
function startPreSale() public onlyOwner {
}
function startPublicSale() public onlyOwner {
}
function flipSaleState() public onlyOwner {
}
function addToWhitelist(address attender) public onlyOwner {
}
function removeFromWhitelist(address attender) public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function price(uint256 _count) public view returns (uint256) {
}
function _totalSupply() internal view returns (uint) {
}
function occupiedList() public view returns (uint256[] memory) {
}
function maxMint() public view returns (uint256) {
}
function maxSales() public view returns (uint256) {
}
function maxSupply() public pure returns (uint256) {
}
function raised() public view returns (uint256) {
}
function getTokenIdsOfWallet(address _owner) external view returns (uint256[] memory) {
}
function withdrawAll() public payable onlyOwner {
}
function _widthdraw(address _address, uint256 _amount) private {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721, ERC721Enumerable, ERC721Pausable) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC721Enumerable) returns (bool) {
}
}
| _isOccupiedId[_ids[i]]==false,"MINT: Those ids already have been used for other customers" | 350,919 | _isOccupiedId[_ids[i]]==false |
"UnicVester: Already initialized token" | pragma solidity 0.6.12;
contract UnicVester is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IUnicSwapV2Factory public factory;
address public bar;
address public unic;
address public weth;
uint256 public vestingDuration;
mapping(address => Schedule) public vestings;
mapping(address => bool) public initialized;
struct Schedule {
uint256 amount;
uint256 start;
uint256 end;
}
constructor(IUnicSwapV2Factory _factory, address _bar, address _unic, address _weth) public {
}
// Initializes vesting schedule for new uToken
function initialize(address token) onlyOwner public {
require(<FILL_ME>)
vestings[token] = Schedule(
{
amount: IERC20(token).balanceOf(address(this)),
start: getBlockTimestamp(),
end: getBlockTimestamp().add(vestingDuration)
}
);
}
// Set protocol's vesting schedule for future uTokens
function setSchedule(uint256 _vestingDuration) onlyOwner public {
}
function swap(address token) onlyOwner public {
}
// Converts token passed as an argument to WETH
function _toWETH(address token, uint amountIn) internal returns (uint256) {
}
// Converts WETH to Unic
function _toUNIC(uint256 amountIn) internal {
}
// Wrapper for safeTransfer
function _safeTransfer(address token, address to, uint256 amount) internal {
}
function getBlockTimestamp() internal view returns (uint) {
}
}
| !initialized[token],"UnicVester: Already initialized token" | 351,018 | !initialized[token] |
"MOON: Account is less than the qty limit" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/****************************************
* @author: tos_nft *
* @team: TheOtherSide *
****************************************
* TOS-ERC721 provides low-gas *
* mints + transfers *
****************************************/
import './Delegated.sol';
import './ERC721EnumerableT.sol';
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract TheOtherSide is ERC721EnumerableT, Delegated, ReentrancyGuard {
using Strings for uint;
/**
* @dev Data structure of Moon
*/
struct Moon {
address owner;
bool celestialType;
}
/**
* @notice Keep track of each user and their info
*/
struct Staker {
mapping(address => uint256[]) stakedTokens;
mapping(address => uint256) timeStaked;
uint256 amountStaked;
}
// @notice mapping of a staker to its current properties
mapping(address => Staker) public stakers;
// Mapping from token ID to owner address
mapping(uint256 => address) public originalStakeOwner;
// @notice event emitted when a user has staked a token
event Staked(address owner, uint256 tokenId);
// @notice event emitted when a user has unstaked a token
event Unstaked(address owner, uint256 tokenId);
bool public revealed = false;
string public notRevealedUri = "ipfs://QmXZGWhQp3CQc3svnDhUuf4yTtoQBuqumHeC33jmEG69Dd/hidden.json";
uint public MAX_SUPPLY = 8888;
uint public PRICE = 0.15 ether;
uint public MAX_QTY = 2;
Moon[] public moons;
bool public isWhitelistActive = false;
bool public isMintActive = false;
mapping(address => uint) public accessList;
bool public isStakeActive = false;
mapping(address => uint) private _balances;
string private _tokenURIPrefix;
string private _tokenURISuffix = ".json";
constructor()
ERC721T("The Other Side", "TOS"){
}
/**
* @dev Returns the number of tokens in ``owners``'s account.
*/
function balanceOf(address account) public view override returns (uint) {
}
/**
* @dev Returns the bool of tokens if``owner``'s account contains the tokenIds.
*/
function isOwnerOf( address account, uint[] calldata tokenIds ) external view override returns( bool ){
}
/**
* @dev Returns the owner of the `tokenId` token.
*
*/
function ownerOf( uint tokenId ) public override view returns( address owner_ ){
}
/**
* @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
* Use along with {totalSupply} to enumerate all tokens.
*/
function tokenByIndex(uint index) external view override returns (uint) {
}
/**
* @dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
*/
function tokenOfOwnerByIndex(address owner, uint index) public view override returns (uint tokenId) {
}
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint tokenId) external view override returns (string memory) {
}
/**
* @dev Returns the total amount of tokens stored by the contract.
*/
function totalSupply() public view override returns( uint totalSupply_ ){
}
/**
* @dev Returns the list of tokenIds stored by the owner's account.
*/
function walletOfOwner( address account ) external view override returns( uint[] memory ){
}
/**
* @dev Owner sets the Staking contract address.
*/
function setRevealState(bool reveal_) external onlyDelegates {
}
/**
* @dev Owner sets the Staking contract address.
*/
function setUnrevealURI(string calldata notRevealUri_) external onlyDelegates {
}
/**
* @dev mints token based on the number of qty specified.
*/
function mint( uint quantity ) external payable nonReentrant {
require(isMintActive == true,"MOON: Minting needs to be enabled.");
require( msg.value >= PRICE * quantity, "MOON: Ether sent is not correct" );
//If whitelist is active, people in WL can mint
//based on the allowable qty limit set by owner/delegates.
if( isWhitelistActive ){
require(<FILL_ME>)
accessList[ msg.sender ] -= quantity;
} else {
//For public, MAX_QTY limit will be applied.
//MAX_QTY is determined by the owner/delegates
require(quantity <= MAX_QTY, "MOON:Quantity must be less than or equal MAX_QTY");
}
uint supply = totalSupply();
require( supply + quantity <= MAX_SUPPLY, "MOON: Mint/order exceeds supply" );
for(uint i; i < quantity; ++i){
_mint( msg.sender, supply++ );
}
}
/**
* @dev Returns the balance amount of the Contract address.
*/
function getBalanceofContract() external view returns (uint256) {
}
/**
* @dev Withdraws an amount from the contract balance.
*/
function withdraw(uint256 amount_) public onlyOwner {
}
/**
* @dev Allows team to mint the token without restriction.
*/
function team_mint(uint[] calldata quantity, address[] calldata recipient) external onlyDelegates{
}
/**
* @dev Owner/Delegate sets the Whitelist active flag.
*/
function setWhitelistAddress(address[] calldata accounts, uint allowed) external onlyDelegates{
}
/**
* @dev Owner/Delegate sets the Minting flag.
*/
function setMintingActive(bool mintActive_) external onlyDelegates {
}
/**
* @dev Owner/Delegate sets the Whitelist active flag.
*/
function setWhitelistActive(bool isWhitelistActive_) external onlyDelegates{
}
/**
* @dev Owner/Delegates sets the BaseURI of IPFS.
*/
function setBaseURI(string calldata prefix, string calldata suffix) external onlyDelegates{
}
/**
* @dev Owner/Delegate sets the Max supply of the token.
*/
function setMaxSupply(uint maxSupply) external onlyDelegates{
}
/**
* @dev Owner/Delegate sets the Max. qty
*/
function setMaxQty(uint maxQty) external onlyDelegates{
}
/**
* @dev Owner/Delegate sets the minting price.
*/
function setPrice(uint price) external onlyDelegates{
}
/**
* @dev increment and decrement balances based on address from and to.
*/
function _beforeTokenTransfer(address from, address to) internal {
}
/**
* @dev returns bool if the tokenId exist.
*/
function _exists(uint tokenId) internal view override returns (bool) {
}
/**
* @dev mints token based address and tokenId
*/
function _mint(address to, uint tokenId) internal {
}
/**
* @dev update the moon type.
*/
function updateMoontype(bool moonType, uint[] calldata tokenIds ) external onlyDelegates {
}
/**
* @dev returns the moontypes based on the tokenIds.
*/
function getMoonType(uint[] calldata tokenIds) external view returns(bool[] memory moonTypes) {
}
/**
* @dev transfer tokenId to other address.
*/
function _transfer(address from, address to, uint tokenId) internal override {
}
/**
* @dev Get the tokens staked by a user
*/
function getStakedTokens(address _user) public view returns (uint256[] memory tokenIds) {
}
/**
* @dev Stake the NFT based on array of tokenIds
*/
function stake( uint[] calldata tokenIds ) external {
}
/**
* @dev For internal access to stake the NFT based tokenId
*/
function _stake( address _user, uint256 _tokenId ) internal {
}
/**
* @dev Unstake the token based on array of tokenIds
*/
function unStake( uint[] calldata tokenIds ) external {
}
/**
* @dev For internal access to unstake the NFT based tokenId
*/
function _unstake( address _user, uint256 _tokenId) internal {
}
/**
* @dev Owner/Delegate sets the Whitelist active flag.
*/
function setStakeActive( bool isActive_ ) external onlyDelegates {
}
/**
* @notice remove given elements from array
* @dev usable only if _array contains unique elements only
*/
function _removeElement(address _user, uint256 _element) internal {
}
}
| accessList[msg.sender]>=quantity,"MOON: Account is less than the qty limit" | 351,028 | accessList[msg.sender]>=quantity |
"Address: insufficient balance" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/****************************************
* @author: tos_nft *
* @team: TheOtherSide *
****************************************
* TOS-ERC721 provides low-gas *
* mints + transfers *
****************************************/
import './Delegated.sol';
import './ERC721EnumerableT.sol';
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract TheOtherSide is ERC721EnumerableT, Delegated, ReentrancyGuard {
using Strings for uint;
/**
* @dev Data structure of Moon
*/
struct Moon {
address owner;
bool celestialType;
}
/**
* @notice Keep track of each user and their info
*/
struct Staker {
mapping(address => uint256[]) stakedTokens;
mapping(address => uint256) timeStaked;
uint256 amountStaked;
}
// @notice mapping of a staker to its current properties
mapping(address => Staker) public stakers;
// Mapping from token ID to owner address
mapping(uint256 => address) public originalStakeOwner;
// @notice event emitted when a user has staked a token
event Staked(address owner, uint256 tokenId);
// @notice event emitted when a user has unstaked a token
event Unstaked(address owner, uint256 tokenId);
bool public revealed = false;
string public notRevealedUri = "ipfs://QmXZGWhQp3CQc3svnDhUuf4yTtoQBuqumHeC33jmEG69Dd/hidden.json";
uint public MAX_SUPPLY = 8888;
uint public PRICE = 0.15 ether;
uint public MAX_QTY = 2;
Moon[] public moons;
bool public isWhitelistActive = false;
bool public isMintActive = false;
mapping(address => uint) public accessList;
bool public isStakeActive = false;
mapping(address => uint) private _balances;
string private _tokenURIPrefix;
string private _tokenURISuffix = ".json";
constructor()
ERC721T("The Other Side", "TOS"){
}
/**
* @dev Returns the number of tokens in ``owners``'s account.
*/
function balanceOf(address account) public view override returns (uint) {
}
/**
* @dev Returns the bool of tokens if``owner``'s account contains the tokenIds.
*/
function isOwnerOf( address account, uint[] calldata tokenIds ) external view override returns( bool ){
}
/**
* @dev Returns the owner of the `tokenId` token.
*
*/
function ownerOf( uint tokenId ) public override view returns( address owner_ ){
}
/**
* @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
* Use along with {totalSupply} to enumerate all tokens.
*/
function tokenByIndex(uint index) external view override returns (uint) {
}
/**
* @dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
*/
function tokenOfOwnerByIndex(address owner, uint index) public view override returns (uint tokenId) {
}
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint tokenId) external view override returns (string memory) {
}
/**
* @dev Returns the total amount of tokens stored by the contract.
*/
function totalSupply() public view override returns( uint totalSupply_ ){
}
/**
* @dev Returns the list of tokenIds stored by the owner's account.
*/
function walletOfOwner( address account ) external view override returns( uint[] memory ){
}
/**
* @dev Owner sets the Staking contract address.
*/
function setRevealState(bool reveal_) external onlyDelegates {
}
/**
* @dev Owner sets the Staking contract address.
*/
function setUnrevealURI(string calldata notRevealUri_) external onlyDelegates {
}
/**
* @dev mints token based on the number of qty specified.
*/
function mint( uint quantity ) external payable nonReentrant {
}
/**
* @dev Returns the balance amount of the Contract address.
*/
function getBalanceofContract() external view returns (uint256) {
}
/**
* @dev Withdraws an amount from the contract balance.
*/
function withdraw(uint256 amount_) public onlyOwner {
require(<FILL_ME>)
// This will payout the owner 100% of the contract balance.
// Do not remove this otherwise you will not be able to withdraw the funds.
// =============================================================================
(bool os, ) = payable(owner()).call{value: amount_}("");
require(os);
// =============================================================================
}
/**
* @dev Allows team to mint the token without restriction.
*/
function team_mint(uint[] calldata quantity, address[] calldata recipient) external onlyDelegates{
}
/**
* @dev Owner/Delegate sets the Whitelist active flag.
*/
function setWhitelistAddress(address[] calldata accounts, uint allowed) external onlyDelegates{
}
/**
* @dev Owner/Delegate sets the Minting flag.
*/
function setMintingActive(bool mintActive_) external onlyDelegates {
}
/**
* @dev Owner/Delegate sets the Whitelist active flag.
*/
function setWhitelistActive(bool isWhitelistActive_) external onlyDelegates{
}
/**
* @dev Owner/Delegates sets the BaseURI of IPFS.
*/
function setBaseURI(string calldata prefix, string calldata suffix) external onlyDelegates{
}
/**
* @dev Owner/Delegate sets the Max supply of the token.
*/
function setMaxSupply(uint maxSupply) external onlyDelegates{
}
/**
* @dev Owner/Delegate sets the Max. qty
*/
function setMaxQty(uint maxQty) external onlyDelegates{
}
/**
* @dev Owner/Delegate sets the minting price.
*/
function setPrice(uint price) external onlyDelegates{
}
/**
* @dev increment and decrement balances based on address from and to.
*/
function _beforeTokenTransfer(address from, address to) internal {
}
/**
* @dev returns bool if the tokenId exist.
*/
function _exists(uint tokenId) internal view override returns (bool) {
}
/**
* @dev mints token based address and tokenId
*/
function _mint(address to, uint tokenId) internal {
}
/**
* @dev update the moon type.
*/
function updateMoontype(bool moonType, uint[] calldata tokenIds ) external onlyDelegates {
}
/**
* @dev returns the moontypes based on the tokenIds.
*/
function getMoonType(uint[] calldata tokenIds) external view returns(bool[] memory moonTypes) {
}
/**
* @dev transfer tokenId to other address.
*/
function _transfer(address from, address to, uint tokenId) internal override {
}
/**
* @dev Get the tokens staked by a user
*/
function getStakedTokens(address _user) public view returns (uint256[] memory tokenIds) {
}
/**
* @dev Stake the NFT based on array of tokenIds
*/
function stake( uint[] calldata tokenIds ) external {
}
/**
* @dev For internal access to stake the NFT based tokenId
*/
function _stake( address _user, uint256 _tokenId ) internal {
}
/**
* @dev Unstake the token based on array of tokenIds
*/
function unStake( uint[] calldata tokenIds ) external {
}
/**
* @dev For internal access to unstake the NFT based tokenId
*/
function _unstake( address _user, uint256 _tokenId) internal {
}
/**
* @dev Owner/Delegate sets the Whitelist active flag.
*/
function setStakeActive( bool isActive_ ) external onlyDelegates {
}
/**
* @notice remove given elements from array
* @dev usable only if _array contains unique elements only
*/
function _removeElement(address _user, uint256 _element) internal {
}
}
| address(this).balance>=amount_,"Address: insufficient balance" | 351,028 | address(this).balance>=amount_ |
"MOON: Mint/order exceeds supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/****************************************
* @author: tos_nft *
* @team: TheOtherSide *
****************************************
* TOS-ERC721 provides low-gas *
* mints + transfers *
****************************************/
import './Delegated.sol';
import './ERC721EnumerableT.sol';
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract TheOtherSide is ERC721EnumerableT, Delegated, ReentrancyGuard {
using Strings for uint;
/**
* @dev Data structure of Moon
*/
struct Moon {
address owner;
bool celestialType;
}
/**
* @notice Keep track of each user and their info
*/
struct Staker {
mapping(address => uint256[]) stakedTokens;
mapping(address => uint256) timeStaked;
uint256 amountStaked;
}
// @notice mapping of a staker to its current properties
mapping(address => Staker) public stakers;
// Mapping from token ID to owner address
mapping(uint256 => address) public originalStakeOwner;
// @notice event emitted when a user has staked a token
event Staked(address owner, uint256 tokenId);
// @notice event emitted when a user has unstaked a token
event Unstaked(address owner, uint256 tokenId);
bool public revealed = false;
string public notRevealedUri = "ipfs://QmXZGWhQp3CQc3svnDhUuf4yTtoQBuqumHeC33jmEG69Dd/hidden.json";
uint public MAX_SUPPLY = 8888;
uint public PRICE = 0.15 ether;
uint public MAX_QTY = 2;
Moon[] public moons;
bool public isWhitelistActive = false;
bool public isMintActive = false;
mapping(address => uint) public accessList;
bool public isStakeActive = false;
mapping(address => uint) private _balances;
string private _tokenURIPrefix;
string private _tokenURISuffix = ".json";
constructor()
ERC721T("The Other Side", "TOS"){
}
/**
* @dev Returns the number of tokens in ``owners``'s account.
*/
function balanceOf(address account) public view override returns (uint) {
}
/**
* @dev Returns the bool of tokens if``owner``'s account contains the tokenIds.
*/
function isOwnerOf( address account, uint[] calldata tokenIds ) external view override returns( bool ){
}
/**
* @dev Returns the owner of the `tokenId` token.
*
*/
function ownerOf( uint tokenId ) public override view returns( address owner_ ){
}
/**
* @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
* Use along with {totalSupply} to enumerate all tokens.
*/
function tokenByIndex(uint index) external view override returns (uint) {
}
/**
* @dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
*/
function tokenOfOwnerByIndex(address owner, uint index) public view override returns (uint tokenId) {
}
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint tokenId) external view override returns (string memory) {
}
/**
* @dev Returns the total amount of tokens stored by the contract.
*/
function totalSupply() public view override returns( uint totalSupply_ ){
}
/**
* @dev Returns the list of tokenIds stored by the owner's account.
*/
function walletOfOwner( address account ) external view override returns( uint[] memory ){
}
/**
* @dev Owner sets the Staking contract address.
*/
function setRevealState(bool reveal_) external onlyDelegates {
}
/**
* @dev Owner sets the Staking contract address.
*/
function setUnrevealURI(string calldata notRevealUri_) external onlyDelegates {
}
/**
* @dev mints token based on the number of qty specified.
*/
function mint( uint quantity ) external payable nonReentrant {
}
/**
* @dev Returns the balance amount of the Contract address.
*/
function getBalanceofContract() external view returns (uint256) {
}
/**
* @dev Withdraws an amount from the contract balance.
*/
function withdraw(uint256 amount_) public onlyOwner {
}
/**
* @dev Allows team to mint the token without restriction.
*/
function team_mint(uint[] calldata quantity, address[] calldata recipient) external onlyDelegates{
require(quantity.length == recipient.length, "MOON: Must provide equal quantities and recipients" );
uint totalQuantity;
uint supply = totalSupply();
for(uint i; i < quantity.length; ++i){
totalQuantity += quantity[i];
}
require(<FILL_ME>)
for(uint i; i < recipient.length; ++i){
for(uint j; j < quantity[i]; ++j){
uint tokenId = supply++;
_mint( recipient[i], tokenId);
}
}
}
/**
* @dev Owner/Delegate sets the Whitelist active flag.
*/
function setWhitelistAddress(address[] calldata accounts, uint allowed) external onlyDelegates{
}
/**
* @dev Owner/Delegate sets the Minting flag.
*/
function setMintingActive(bool mintActive_) external onlyDelegates {
}
/**
* @dev Owner/Delegate sets the Whitelist active flag.
*/
function setWhitelistActive(bool isWhitelistActive_) external onlyDelegates{
}
/**
* @dev Owner/Delegates sets the BaseURI of IPFS.
*/
function setBaseURI(string calldata prefix, string calldata suffix) external onlyDelegates{
}
/**
* @dev Owner/Delegate sets the Max supply of the token.
*/
function setMaxSupply(uint maxSupply) external onlyDelegates{
}
/**
* @dev Owner/Delegate sets the Max. qty
*/
function setMaxQty(uint maxQty) external onlyDelegates{
}
/**
* @dev Owner/Delegate sets the minting price.
*/
function setPrice(uint price) external onlyDelegates{
}
/**
* @dev increment and decrement balances based on address from and to.
*/
function _beforeTokenTransfer(address from, address to) internal {
}
/**
* @dev returns bool if the tokenId exist.
*/
function _exists(uint tokenId) internal view override returns (bool) {
}
/**
* @dev mints token based address and tokenId
*/
function _mint(address to, uint tokenId) internal {
}
/**
* @dev update the moon type.
*/
function updateMoontype(bool moonType, uint[] calldata tokenIds ) external onlyDelegates {
}
/**
* @dev returns the moontypes based on the tokenIds.
*/
function getMoonType(uint[] calldata tokenIds) external view returns(bool[] memory moonTypes) {
}
/**
* @dev transfer tokenId to other address.
*/
function _transfer(address from, address to, uint tokenId) internal override {
}
/**
* @dev Get the tokens staked by a user
*/
function getStakedTokens(address _user) public view returns (uint256[] memory tokenIds) {
}
/**
* @dev Stake the NFT based on array of tokenIds
*/
function stake( uint[] calldata tokenIds ) external {
}
/**
* @dev For internal access to stake the NFT based tokenId
*/
function _stake( address _user, uint256 _tokenId ) internal {
}
/**
* @dev Unstake the token based on array of tokenIds
*/
function unStake( uint[] calldata tokenIds ) external {
}
/**
* @dev For internal access to unstake the NFT based tokenId
*/
function _unstake( address _user, uint256 _tokenId) internal {
}
/**
* @dev Owner/Delegate sets the Whitelist active flag.
*/
function setStakeActive( bool isActive_ ) external onlyDelegates {
}
/**
* @notice remove given elements from array
* @dev usable only if _array contains unique elements only
*/
function _removeElement(address _user, uint256 _element) internal {
}
}
| supply+totalQuantity<MAX_SUPPLY,"MOON: Mint/order exceeds supply" | 351,028 | supply+totalQuantity<MAX_SUPPLY |
"MOON: transfer of token that is not owned" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/****************************************
* @author: tos_nft *
* @team: TheOtherSide *
****************************************
* TOS-ERC721 provides low-gas *
* mints + transfers *
****************************************/
import './Delegated.sol';
import './ERC721EnumerableT.sol';
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract TheOtherSide is ERC721EnumerableT, Delegated, ReentrancyGuard {
using Strings for uint;
/**
* @dev Data structure of Moon
*/
struct Moon {
address owner;
bool celestialType;
}
/**
* @notice Keep track of each user and their info
*/
struct Staker {
mapping(address => uint256[]) stakedTokens;
mapping(address => uint256) timeStaked;
uint256 amountStaked;
}
// @notice mapping of a staker to its current properties
mapping(address => Staker) public stakers;
// Mapping from token ID to owner address
mapping(uint256 => address) public originalStakeOwner;
// @notice event emitted when a user has staked a token
event Staked(address owner, uint256 tokenId);
// @notice event emitted when a user has unstaked a token
event Unstaked(address owner, uint256 tokenId);
bool public revealed = false;
string public notRevealedUri = "ipfs://QmXZGWhQp3CQc3svnDhUuf4yTtoQBuqumHeC33jmEG69Dd/hidden.json";
uint public MAX_SUPPLY = 8888;
uint public PRICE = 0.15 ether;
uint public MAX_QTY = 2;
Moon[] public moons;
bool public isWhitelistActive = false;
bool public isMintActive = false;
mapping(address => uint) public accessList;
bool public isStakeActive = false;
mapping(address => uint) private _balances;
string private _tokenURIPrefix;
string private _tokenURISuffix = ".json";
constructor()
ERC721T("The Other Side", "TOS"){
}
/**
* @dev Returns the number of tokens in ``owners``'s account.
*/
function balanceOf(address account) public view override returns (uint) {
}
/**
* @dev Returns the bool of tokens if``owner``'s account contains the tokenIds.
*/
function isOwnerOf( address account, uint[] calldata tokenIds ) external view override returns( bool ){
}
/**
* @dev Returns the owner of the `tokenId` token.
*
*/
function ownerOf( uint tokenId ) public override view returns( address owner_ ){
}
/**
* @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
* Use along with {totalSupply} to enumerate all tokens.
*/
function tokenByIndex(uint index) external view override returns (uint) {
}
/**
* @dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
*/
function tokenOfOwnerByIndex(address owner, uint index) public view override returns (uint tokenId) {
}
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint tokenId) external view override returns (string memory) {
}
/**
* @dev Returns the total amount of tokens stored by the contract.
*/
function totalSupply() public view override returns( uint totalSupply_ ){
}
/**
* @dev Returns the list of tokenIds stored by the owner's account.
*/
function walletOfOwner( address account ) external view override returns( uint[] memory ){
}
/**
* @dev Owner sets the Staking contract address.
*/
function setRevealState(bool reveal_) external onlyDelegates {
}
/**
* @dev Owner sets the Staking contract address.
*/
function setUnrevealURI(string calldata notRevealUri_) external onlyDelegates {
}
/**
* @dev mints token based on the number of qty specified.
*/
function mint( uint quantity ) external payable nonReentrant {
}
/**
* @dev Returns the balance amount of the Contract address.
*/
function getBalanceofContract() external view returns (uint256) {
}
/**
* @dev Withdraws an amount from the contract balance.
*/
function withdraw(uint256 amount_) public onlyOwner {
}
/**
* @dev Allows team to mint the token without restriction.
*/
function team_mint(uint[] calldata quantity, address[] calldata recipient) external onlyDelegates{
}
/**
* @dev Owner/Delegate sets the Whitelist active flag.
*/
function setWhitelistAddress(address[] calldata accounts, uint allowed) external onlyDelegates{
}
/**
* @dev Owner/Delegate sets the Minting flag.
*/
function setMintingActive(bool mintActive_) external onlyDelegates {
}
/**
* @dev Owner/Delegate sets the Whitelist active flag.
*/
function setWhitelistActive(bool isWhitelistActive_) external onlyDelegates{
}
/**
* @dev Owner/Delegates sets the BaseURI of IPFS.
*/
function setBaseURI(string calldata prefix, string calldata suffix) external onlyDelegates{
}
/**
* @dev Owner/Delegate sets the Max supply of the token.
*/
function setMaxSupply(uint maxSupply) external onlyDelegates{
}
/**
* @dev Owner/Delegate sets the Max. qty
*/
function setMaxQty(uint maxQty) external onlyDelegates{
}
/**
* @dev Owner/Delegate sets the minting price.
*/
function setPrice(uint price) external onlyDelegates{
}
/**
* @dev increment and decrement balances based on address from and to.
*/
function _beforeTokenTransfer(address from, address to) internal {
}
/**
* @dev returns bool if the tokenId exist.
*/
function _exists(uint tokenId) internal view override returns (bool) {
}
/**
* @dev mints token based address and tokenId
*/
function _mint(address to, uint tokenId) internal {
}
/**
* @dev update the moon type.
*/
function updateMoontype(bool moonType, uint[] calldata tokenIds ) external onlyDelegates {
}
/**
* @dev returns the moontypes based on the tokenIds.
*/
function getMoonType(uint[] calldata tokenIds) external view returns(bool[] memory moonTypes) {
}
/**
* @dev transfer tokenId to other address.
*/
function _transfer(address from, address to, uint tokenId) internal override {
require(<FILL_ME>)
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_beforeTokenTransfer(from, to);
moons[tokenId].owner = to;
emit Transfer(from, to, tokenId);
}
/**
* @dev Get the tokens staked by a user
*/
function getStakedTokens(address _user) public view returns (uint256[] memory tokenIds) {
}
/**
* @dev Stake the NFT based on array of tokenIds
*/
function stake( uint[] calldata tokenIds ) external {
}
/**
* @dev For internal access to stake the NFT based tokenId
*/
function _stake( address _user, uint256 _tokenId ) internal {
}
/**
* @dev Unstake the token based on array of tokenIds
*/
function unStake( uint[] calldata tokenIds ) external {
}
/**
* @dev For internal access to unstake the NFT based tokenId
*/
function _unstake( address _user, uint256 _tokenId) internal {
}
/**
* @dev Owner/Delegate sets the Whitelist active flag.
*/
function setStakeActive( bool isActive_ ) external onlyDelegates {
}
/**
* @notice remove given elements from array
* @dev usable only if _array contains unique elements only
*/
function _removeElement(address _user, uint256 _element) internal {
}
}
| moons[tokenId].owner==from,"MOON: transfer of token that is not owned" | 351,028 | moons[tokenId].owner==from |
"MOON._unstake: Sender must have staked tokenID" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/****************************************
* @author: tos_nft *
* @team: TheOtherSide *
****************************************
* TOS-ERC721 provides low-gas *
* mints + transfers *
****************************************/
import './Delegated.sol';
import './ERC721EnumerableT.sol';
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract TheOtherSide is ERC721EnumerableT, Delegated, ReentrancyGuard {
using Strings for uint;
/**
* @dev Data structure of Moon
*/
struct Moon {
address owner;
bool celestialType;
}
/**
* @notice Keep track of each user and their info
*/
struct Staker {
mapping(address => uint256[]) stakedTokens;
mapping(address => uint256) timeStaked;
uint256 amountStaked;
}
// @notice mapping of a staker to its current properties
mapping(address => Staker) public stakers;
// Mapping from token ID to owner address
mapping(uint256 => address) public originalStakeOwner;
// @notice event emitted when a user has staked a token
event Staked(address owner, uint256 tokenId);
// @notice event emitted when a user has unstaked a token
event Unstaked(address owner, uint256 tokenId);
bool public revealed = false;
string public notRevealedUri = "ipfs://QmXZGWhQp3CQc3svnDhUuf4yTtoQBuqumHeC33jmEG69Dd/hidden.json";
uint public MAX_SUPPLY = 8888;
uint public PRICE = 0.15 ether;
uint public MAX_QTY = 2;
Moon[] public moons;
bool public isWhitelistActive = false;
bool public isMintActive = false;
mapping(address => uint) public accessList;
bool public isStakeActive = false;
mapping(address => uint) private _balances;
string private _tokenURIPrefix;
string private _tokenURISuffix = ".json";
constructor()
ERC721T("The Other Side", "TOS"){
}
/**
* @dev Returns the number of tokens in ``owners``'s account.
*/
function balanceOf(address account) public view override returns (uint) {
}
/**
* @dev Returns the bool of tokens if``owner``'s account contains the tokenIds.
*/
function isOwnerOf( address account, uint[] calldata tokenIds ) external view override returns( bool ){
}
/**
* @dev Returns the owner of the `tokenId` token.
*
*/
function ownerOf( uint tokenId ) public override view returns( address owner_ ){
}
/**
* @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
* Use along with {totalSupply} to enumerate all tokens.
*/
function tokenByIndex(uint index) external view override returns (uint) {
}
/**
* @dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
*/
function tokenOfOwnerByIndex(address owner, uint index) public view override returns (uint tokenId) {
}
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint tokenId) external view override returns (string memory) {
}
/**
* @dev Returns the total amount of tokens stored by the contract.
*/
function totalSupply() public view override returns( uint totalSupply_ ){
}
/**
* @dev Returns the list of tokenIds stored by the owner's account.
*/
function walletOfOwner( address account ) external view override returns( uint[] memory ){
}
/**
* @dev Owner sets the Staking contract address.
*/
function setRevealState(bool reveal_) external onlyDelegates {
}
/**
* @dev Owner sets the Staking contract address.
*/
function setUnrevealURI(string calldata notRevealUri_) external onlyDelegates {
}
/**
* @dev mints token based on the number of qty specified.
*/
function mint( uint quantity ) external payable nonReentrant {
}
/**
* @dev Returns the balance amount of the Contract address.
*/
function getBalanceofContract() external view returns (uint256) {
}
/**
* @dev Withdraws an amount from the contract balance.
*/
function withdraw(uint256 amount_) public onlyOwner {
}
/**
* @dev Allows team to mint the token without restriction.
*/
function team_mint(uint[] calldata quantity, address[] calldata recipient) external onlyDelegates{
}
/**
* @dev Owner/Delegate sets the Whitelist active flag.
*/
function setWhitelistAddress(address[] calldata accounts, uint allowed) external onlyDelegates{
}
/**
* @dev Owner/Delegate sets the Minting flag.
*/
function setMintingActive(bool mintActive_) external onlyDelegates {
}
/**
* @dev Owner/Delegate sets the Whitelist active flag.
*/
function setWhitelistActive(bool isWhitelistActive_) external onlyDelegates{
}
/**
* @dev Owner/Delegates sets the BaseURI of IPFS.
*/
function setBaseURI(string calldata prefix, string calldata suffix) external onlyDelegates{
}
/**
* @dev Owner/Delegate sets the Max supply of the token.
*/
function setMaxSupply(uint maxSupply) external onlyDelegates{
}
/**
* @dev Owner/Delegate sets the Max. qty
*/
function setMaxQty(uint maxQty) external onlyDelegates{
}
/**
* @dev Owner/Delegate sets the minting price.
*/
function setPrice(uint price) external onlyDelegates{
}
/**
* @dev increment and decrement balances based on address from and to.
*/
function _beforeTokenTransfer(address from, address to) internal {
}
/**
* @dev returns bool if the tokenId exist.
*/
function _exists(uint tokenId) internal view override returns (bool) {
}
/**
* @dev mints token based address and tokenId
*/
function _mint(address to, uint tokenId) internal {
}
/**
* @dev update the moon type.
*/
function updateMoontype(bool moonType, uint[] calldata tokenIds ) external onlyDelegates {
}
/**
* @dev returns the moontypes based on the tokenIds.
*/
function getMoonType(uint[] calldata tokenIds) external view returns(bool[] memory moonTypes) {
}
/**
* @dev transfer tokenId to other address.
*/
function _transfer(address from, address to, uint tokenId) internal override {
}
/**
* @dev Get the tokens staked by a user
*/
function getStakedTokens(address _user) public view returns (uint256[] memory tokenIds) {
}
/**
* @dev Stake the NFT based on array of tokenIds
*/
function stake( uint[] calldata tokenIds ) external {
}
/**
* @dev For internal access to stake the NFT based tokenId
*/
function _stake( address _user, uint256 _tokenId ) internal {
}
/**
* @dev Unstake the token based on array of tokenIds
*/
function unStake( uint[] calldata tokenIds ) external {
require( isStakeActive, "MOON: Staking is not active" );
//Check if TokenIds exist
for( uint i; i < tokenIds.length; ++i ){
require(<FILL_ME>)
_unstake(msg.sender,tokenIds[i]);
}
}
/**
* @dev For internal access to unstake the NFT based tokenId
*/
function _unstake( address _user, uint256 _tokenId) internal {
}
/**
* @dev Owner/Delegate sets the Whitelist active flag.
*/
function setStakeActive( bool isActive_ ) external onlyDelegates {
}
/**
* @notice remove given elements from array
* @dev usable only if _array contains unique elements only
*/
function _removeElement(address _user, uint256 _element) internal {
}
}
| originalStakeOwner[tokenIds[i]]==msg.sender,"MOON._unstake: Sender must have staked tokenID" | 351,028 | originalStakeOwner[tokenIds[i]]==msg.sender |
"Exceeds maximum token supply." | pragma solidity >=0.8.0 <0.9.0;
//SPDX-License-Identifier: MIT
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
// rare ghost club X nervous.eth
//
// ██████ █████ ██████ ███████ ██████ ██ ██ ██████ ███████ ████████ ██████ ██ ██ ██ ██████
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
// ██████ ███████ ██████ █████ ██ ███ ███████ ██ ██ ███████ ██ ██ ██ ██ ██ ██████
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
// ██ ██ ██ ██ ██ ██ ███████ ██████ ██ ██ ██████ ███████ ██ ██████ ███████ ██████ ██████
//
//
// ██ ██
// ██ ██
// ███
// ██ ██
// ██ ██
//
//
// ███ ██ ███████ ██████ ██ ██ ██████ ██ ██ ███████
// ████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
// ██ ██ ██ █████ ██████ ██ ██ ██ ██ ██ ██ ███████
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
// ██ ████ ███████ ██ ██ ████ ██████ ██████ ███████
//
// work with us: nervous.net // [email protected]
contract NervousNFT is ERC721, ERC721Enumerable, PaymentSplitter, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
uint256 public MAX_TOKENS = 100000;
uint256 public tokenPrice = 80000000000000000;
bool public hasSaleStarted = false;
string public baseURI;
uint256 public MAX_GIFTS = 30000;
uint256 public numberOfGifts;
uint256 public MAX_VIP_MINTS = 3;
bool public hasVIPSaleStarted = true;
address public bouncer;
mapping(address => uint256) private VIPListMints;
string public constant R =
"We are Nervous. Are you? Let us help you with your next NFT Project -> [email protected]";
constructor(
string memory name,
string memory symbol,
string memory _initBaseURI,
uint256 _maxTokens,
uint256 _price,
uint256 _maxGifts,
address[] memory payees,
uint256[] memory shares
) ERC721(name, symbol) PaymentSplitter(payees, shares) {
}
function calculatePrice() public view returns (uint256) {
}
function startSale() public onlyOwner {
}
function pauseSale() public onlyOwner {
}
function mint(uint256 numTokens) public payable {
require(hasSaleStarted == true, "Sale hasn't started");
require(<FILL_ME>)
require(
numTokens > 0 && numTokens <= 10,
"Machine can dispense a minimum of 1, maximum of 10 tokens"
);
require(
msg.value >= SafeMath.mul(calculatePrice(), numTokens),
"Amount of Ether sent is not correct."
);
for (uint256 i = 0; i < numTokens; i++) {
_safeMint(msg.sender, _tokenIds.current());
_tokenIds.increment();
}
}
/* VIP Handling */
function startVIPSale() public onlyOwner {
}
function pauseVIPSale() public onlyOwner {
}
function setBouncer(address _bouncer) public onlyOwner {
}
function mintVIP(uint8 numTokens, bytes memory signature) public payable {
}
/* Magic */
function magicGift(address[] calldata receivers) external onlyOwner {
}
function magicMint(uint256 numTokens) external onlyOwner {
}
/* URIs */
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) 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)
{
}
}
| _tokenIds.current()+numTokens<=MAX_TOKENS,"Exceeds maximum token supply." | 351,035 | _tokenIds.current()+numTokens<=MAX_TOKENS |
"Address not on VIP List." | pragma solidity >=0.8.0 <0.9.0;
//SPDX-License-Identifier: MIT
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
// rare ghost club X nervous.eth
//
// ██████ █████ ██████ ███████ ██████ ██ ██ ██████ ███████ ████████ ██████ ██ ██ ██ ██████
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
// ██████ ███████ ██████ █████ ██ ███ ███████ ██ ██ ███████ ██ ██ ██ ██ ██ ██████
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
// ██ ██ ██ ██ ██ ██ ███████ ██████ ██ ██ ██████ ███████ ██ ██████ ███████ ██████ ██████
//
//
// ██ ██
// ██ ██
// ███
// ██ ██
// ██ ██
//
//
// ███ ██ ███████ ██████ ██ ██ ██████ ██ ██ ███████
// ████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
// ██ ██ ██ █████ ██████ ██ ██ ██ ██ ██ ██ ███████
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
// ██ ████ ███████ ██ ██ ████ ██████ ██████ ███████
//
// work with us: nervous.net // [email protected]
contract NervousNFT is ERC721, ERC721Enumerable, PaymentSplitter, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
uint256 public MAX_TOKENS = 100000;
uint256 public tokenPrice = 80000000000000000;
bool public hasSaleStarted = false;
string public baseURI;
uint256 public MAX_GIFTS = 30000;
uint256 public numberOfGifts;
uint256 public MAX_VIP_MINTS = 3;
bool public hasVIPSaleStarted = true;
address public bouncer;
mapping(address => uint256) private VIPListMints;
string public constant R =
"We are Nervous. Are you? Let us help you with your next NFT Project -> [email protected]";
constructor(
string memory name,
string memory symbol,
string memory _initBaseURI,
uint256 _maxTokens,
uint256 _price,
uint256 _maxGifts,
address[] memory payees,
uint256[] memory shares
) ERC721(name, symbol) PaymentSplitter(payees, shares) {
}
function calculatePrice() public view returns (uint256) {
}
function startSale() public onlyOwner {
}
function pauseSale() public onlyOwner {
}
function mint(uint256 numTokens) public payable {
}
/* VIP Handling */
function startVIPSale() public onlyOwner {
}
function pauseVIPSale() public onlyOwner {
}
function setBouncer(address _bouncer) public onlyOwner {
}
function mintVIP(uint8 numTokens, bytes memory signature) public payable {
bytes32 messageHash = keccak256(abi.encodePacked(msg.sender));
bytes32 ethMessageHash = ECDSA.toEthSignedMessageHash(messageHash);
require(hasVIPSaleStarted == true, "Sale hasn't started");
require(<FILL_ME>)
require(
numTokens > 0 && numTokens <= 10,
"Machine can dispense a minimum of 1, maximum of 10 tokens"
);
require(
VIPListMints[msg.sender] + numTokens <= MAX_VIP_MINTS,
"Exceeds maximum VIP Mints."
);
require(
_tokenIds.current() + numTokens <= MAX_TOKENS,
"Exceeds maximum token supply."
);
require(
msg.value >= (calculatePrice() * numTokens),
"Amount of Ether sent is not correct."
);
for (uint256 i = 0; i < numTokens; i++) {
_mint(msg.sender, _tokenIds.current());
_tokenIds.increment();
VIPListMints[msg.sender] = VIPListMints[msg.sender] + 1;
}
}
/* Magic */
function magicGift(address[] calldata receivers) external onlyOwner {
}
function magicMint(uint256 numTokens) external onlyOwner {
}
/* URIs */
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) 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)
{
}
}
| SignatureChecker.isValidSignatureNow(bouncer,ethMessageHash,signature),"Address not on VIP List." | 351,035 | SignatureChecker.isValidSignatureNow(bouncer,ethMessageHash,signature) |
"Exceeds maximum VIP Mints." | pragma solidity >=0.8.0 <0.9.0;
//SPDX-License-Identifier: MIT
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
// rare ghost club X nervous.eth
//
// ██████ █████ ██████ ███████ ██████ ██ ██ ██████ ███████ ████████ ██████ ██ ██ ██ ██████
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
// ██████ ███████ ██████ █████ ██ ███ ███████ ██ ██ ███████ ██ ██ ██ ██ ██ ██████
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
// ██ ██ ██ ██ ██ ██ ███████ ██████ ██ ██ ██████ ███████ ██ ██████ ███████ ██████ ██████
//
//
// ██ ██
// ██ ██
// ███
// ██ ██
// ██ ██
//
//
// ███ ██ ███████ ██████ ██ ██ ██████ ██ ██ ███████
// ████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
// ██ ██ ██ █████ ██████ ██ ██ ██ ██ ██ ██ ███████
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
// ██ ████ ███████ ██ ██ ████ ██████ ██████ ███████
//
// work with us: nervous.net // [email protected]
contract NervousNFT is ERC721, ERC721Enumerable, PaymentSplitter, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
uint256 public MAX_TOKENS = 100000;
uint256 public tokenPrice = 80000000000000000;
bool public hasSaleStarted = false;
string public baseURI;
uint256 public MAX_GIFTS = 30000;
uint256 public numberOfGifts;
uint256 public MAX_VIP_MINTS = 3;
bool public hasVIPSaleStarted = true;
address public bouncer;
mapping(address => uint256) private VIPListMints;
string public constant R =
"We are Nervous. Are you? Let us help you with your next NFT Project -> [email protected]";
constructor(
string memory name,
string memory symbol,
string memory _initBaseURI,
uint256 _maxTokens,
uint256 _price,
uint256 _maxGifts,
address[] memory payees,
uint256[] memory shares
) ERC721(name, symbol) PaymentSplitter(payees, shares) {
}
function calculatePrice() public view returns (uint256) {
}
function startSale() public onlyOwner {
}
function pauseSale() public onlyOwner {
}
function mint(uint256 numTokens) public payable {
}
/* VIP Handling */
function startVIPSale() public onlyOwner {
}
function pauseVIPSale() public onlyOwner {
}
function setBouncer(address _bouncer) public onlyOwner {
}
function mintVIP(uint8 numTokens, bytes memory signature) public payable {
bytes32 messageHash = keccak256(abi.encodePacked(msg.sender));
bytes32 ethMessageHash = ECDSA.toEthSignedMessageHash(messageHash);
require(hasVIPSaleStarted == true, "Sale hasn't started");
require(
SignatureChecker.isValidSignatureNow(
bouncer,
ethMessageHash,
signature
),
"Address not on VIP List."
);
require(
numTokens > 0 && numTokens <= 10,
"Machine can dispense a minimum of 1, maximum of 10 tokens"
);
require(<FILL_ME>)
require(
_tokenIds.current() + numTokens <= MAX_TOKENS,
"Exceeds maximum token supply."
);
require(
msg.value >= (calculatePrice() * numTokens),
"Amount of Ether sent is not correct."
);
for (uint256 i = 0; i < numTokens; i++) {
_mint(msg.sender, _tokenIds.current());
_tokenIds.increment();
VIPListMints[msg.sender] = VIPListMints[msg.sender] + 1;
}
}
/* Magic */
function magicGift(address[] calldata receivers) external onlyOwner {
}
function magicMint(uint256 numTokens) external onlyOwner {
}
/* URIs */
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) 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)
{
}
}
| VIPListMints[msg.sender]+numTokens<=MAX_VIP_MINTS,"Exceeds maximum VIP Mints." | 351,035 | VIPListMints[msg.sender]+numTokens<=MAX_VIP_MINTS |
"Amount of Ether sent is not correct." | pragma solidity >=0.8.0 <0.9.0;
//SPDX-License-Identifier: MIT
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
// rare ghost club X nervous.eth
//
// ██████ █████ ██████ ███████ ██████ ██ ██ ██████ ███████ ████████ ██████ ██ ██ ██ ██████
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
// ██████ ███████ ██████ █████ ██ ███ ███████ ██ ██ ███████ ██ ██ ██ ██ ██ ██████
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
// ██ ██ ██ ██ ██ ██ ███████ ██████ ██ ██ ██████ ███████ ██ ██████ ███████ ██████ ██████
//
//
// ██ ██
// ██ ██
// ███
// ██ ██
// ██ ██
//
//
// ███ ██ ███████ ██████ ██ ██ ██████ ██ ██ ███████
// ████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
// ██ ██ ██ █████ ██████ ██ ██ ██ ██ ██ ██ ███████
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
// ██ ████ ███████ ██ ██ ████ ██████ ██████ ███████
//
// work with us: nervous.net // [email protected]
contract NervousNFT is ERC721, ERC721Enumerable, PaymentSplitter, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
uint256 public MAX_TOKENS = 100000;
uint256 public tokenPrice = 80000000000000000;
bool public hasSaleStarted = false;
string public baseURI;
uint256 public MAX_GIFTS = 30000;
uint256 public numberOfGifts;
uint256 public MAX_VIP_MINTS = 3;
bool public hasVIPSaleStarted = true;
address public bouncer;
mapping(address => uint256) private VIPListMints;
string public constant R =
"We are Nervous. Are you? Let us help you with your next NFT Project -> [email protected]";
constructor(
string memory name,
string memory symbol,
string memory _initBaseURI,
uint256 _maxTokens,
uint256 _price,
uint256 _maxGifts,
address[] memory payees,
uint256[] memory shares
) ERC721(name, symbol) PaymentSplitter(payees, shares) {
}
function calculatePrice() public view returns (uint256) {
}
function startSale() public onlyOwner {
}
function pauseSale() public onlyOwner {
}
function mint(uint256 numTokens) public payable {
}
/* VIP Handling */
function startVIPSale() public onlyOwner {
}
function pauseVIPSale() public onlyOwner {
}
function setBouncer(address _bouncer) public onlyOwner {
}
function mintVIP(uint8 numTokens, bytes memory signature) public payable {
bytes32 messageHash = keccak256(abi.encodePacked(msg.sender));
bytes32 ethMessageHash = ECDSA.toEthSignedMessageHash(messageHash);
require(hasVIPSaleStarted == true, "Sale hasn't started");
require(
SignatureChecker.isValidSignatureNow(
bouncer,
ethMessageHash,
signature
),
"Address not on VIP List."
);
require(
numTokens > 0 && numTokens <= 10,
"Machine can dispense a minimum of 1, maximum of 10 tokens"
);
require(
VIPListMints[msg.sender] + numTokens <= MAX_VIP_MINTS,
"Exceeds maximum VIP Mints."
);
require(
_tokenIds.current() + numTokens <= MAX_TOKENS,
"Exceeds maximum token supply."
);
require(<FILL_ME>)
for (uint256 i = 0; i < numTokens; i++) {
_mint(msg.sender, _tokenIds.current());
_tokenIds.increment();
VIPListMints[msg.sender] = VIPListMints[msg.sender] + 1;
}
}
/* Magic */
function magicGift(address[] calldata receivers) external onlyOwner {
}
function magicMint(uint256 numTokens) external onlyOwner {
}
/* URIs */
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) 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)
{
}
}
| msg.value>=(calculatePrice()*numTokens),"Amount of Ether sent is not correct." | 351,035 | msg.value>=(calculatePrice()*numTokens) |
"Exceeds maximum token supply" | pragma solidity >=0.8.0 <0.9.0;
//SPDX-License-Identifier: MIT
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
// rare ghost club X nervous.eth
//
// ██████ █████ ██████ ███████ ██████ ██ ██ ██████ ███████ ████████ ██████ ██ ██ ██ ██████
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
// ██████ ███████ ██████ █████ ██ ███ ███████ ██ ██ ███████ ██ ██ ██ ██ ██ ██████
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
// ██ ██ ██ ██ ██ ██ ███████ ██████ ██ ██ ██████ ███████ ██ ██████ ███████ ██████ ██████
//
//
// ██ ██
// ██ ██
// ███
// ██ ██
// ██ ██
//
//
// ███ ██ ███████ ██████ ██ ██ ██████ ██ ██ ███████
// ████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
// ██ ██ ██ █████ ██████ ██ ██ ██ ██ ██ ██ ███████
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
// ██ ████ ███████ ██ ██ ████ ██████ ██████ ███████
//
// work with us: nervous.net // [email protected]
contract NervousNFT is ERC721, ERC721Enumerable, PaymentSplitter, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
uint256 public MAX_TOKENS = 100000;
uint256 public tokenPrice = 80000000000000000;
bool public hasSaleStarted = false;
string public baseURI;
uint256 public MAX_GIFTS = 30000;
uint256 public numberOfGifts;
uint256 public MAX_VIP_MINTS = 3;
bool public hasVIPSaleStarted = true;
address public bouncer;
mapping(address => uint256) private VIPListMints;
string public constant R =
"We are Nervous. Are you? Let us help you with your next NFT Project -> [email protected]";
constructor(
string memory name,
string memory symbol,
string memory _initBaseURI,
uint256 _maxTokens,
uint256 _price,
uint256 _maxGifts,
address[] memory payees,
uint256[] memory shares
) ERC721(name, symbol) PaymentSplitter(payees, shares) {
}
function calculatePrice() public view returns (uint256) {
}
function startSale() public onlyOwner {
}
function pauseSale() public onlyOwner {
}
function mint(uint256 numTokens) public payable {
}
/* VIP Handling */
function startVIPSale() public onlyOwner {
}
function pauseVIPSale() public onlyOwner {
}
function setBouncer(address _bouncer) public onlyOwner {
}
function mintVIP(uint8 numTokens, bytes memory signature) public payable {
}
/* Magic */
function magicGift(address[] calldata receivers) external onlyOwner {
require(<FILL_ME>)
require(
numberOfGifts + receivers.length <= MAX_GIFTS,
"Exceeds maximum allowed gifts"
);
for (uint256 i = 0; i < receivers.length; i++) {
numberOfGifts++;
_safeMint(receivers[i], _tokenIds.current());
_tokenIds.increment();
}
}
function magicMint(uint256 numTokens) external onlyOwner {
}
/* URIs */
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) 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)
{
}
}
| _tokenIds.current()+receivers.length<=MAX_TOKENS,"Exceeds maximum token supply" | 351,035 | _tokenIds.current()+receivers.length<=MAX_TOKENS |
"Exceeds maximum allowed gifts" | pragma solidity >=0.8.0 <0.9.0;
//SPDX-License-Identifier: MIT
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
// rare ghost club X nervous.eth
//
// ██████ █████ ██████ ███████ ██████ ██ ██ ██████ ███████ ████████ ██████ ██ ██ ██ ██████
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
// ██████ ███████ ██████ █████ ██ ███ ███████ ██ ██ ███████ ██ ██ ██ ██ ██ ██████
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
// ██ ██ ██ ██ ██ ██ ███████ ██████ ██ ██ ██████ ███████ ██ ██████ ███████ ██████ ██████
//
//
// ██ ██
// ██ ██
// ███
// ██ ██
// ██ ██
//
//
// ███ ██ ███████ ██████ ██ ██ ██████ ██ ██ ███████
// ████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
// ██ ██ ██ █████ ██████ ██ ██ ██ ██ ██ ██ ███████
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
// ██ ████ ███████ ██ ██ ████ ██████ ██████ ███████
//
// work with us: nervous.net // [email protected]
contract NervousNFT is ERC721, ERC721Enumerable, PaymentSplitter, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
uint256 public MAX_TOKENS = 100000;
uint256 public tokenPrice = 80000000000000000;
bool public hasSaleStarted = false;
string public baseURI;
uint256 public MAX_GIFTS = 30000;
uint256 public numberOfGifts;
uint256 public MAX_VIP_MINTS = 3;
bool public hasVIPSaleStarted = true;
address public bouncer;
mapping(address => uint256) private VIPListMints;
string public constant R =
"We are Nervous. Are you? Let us help you with your next NFT Project -> [email protected]";
constructor(
string memory name,
string memory symbol,
string memory _initBaseURI,
uint256 _maxTokens,
uint256 _price,
uint256 _maxGifts,
address[] memory payees,
uint256[] memory shares
) ERC721(name, symbol) PaymentSplitter(payees, shares) {
}
function calculatePrice() public view returns (uint256) {
}
function startSale() public onlyOwner {
}
function pauseSale() public onlyOwner {
}
function mint(uint256 numTokens) public payable {
}
/* VIP Handling */
function startVIPSale() public onlyOwner {
}
function pauseVIPSale() public onlyOwner {
}
function setBouncer(address _bouncer) public onlyOwner {
}
function mintVIP(uint8 numTokens, bytes memory signature) public payable {
}
/* Magic */
function magicGift(address[] calldata receivers) external onlyOwner {
require(
_tokenIds.current() + receivers.length <= MAX_TOKENS,
"Exceeds maximum token supply"
);
require(<FILL_ME>)
for (uint256 i = 0; i < receivers.length; i++) {
numberOfGifts++;
_safeMint(receivers[i], _tokenIds.current());
_tokenIds.increment();
}
}
function magicMint(uint256 numTokens) external onlyOwner {
}
/* URIs */
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) 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)
{
}
}
| numberOfGifts+receivers.length<=MAX_GIFTS,"Exceeds maximum allowed gifts" | 351,035 | numberOfGifts+receivers.length<=MAX_GIFTS |
"ERC721: transfer from incorrect owner" | // SPDX-License-Identifier: MIT
// Adapted from OpenZeppelin Contracts v4.5.0 (token/ERC721/ERC721.sol)
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
/**
* @dev Optimized implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata extension, but not including the Enumerable extension
*
* @author ponky
* @notice This contract is optimized specifically for the Humanoids use case, do not use as a template
*
*/
contract ERC721NOIDS is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
uint256 internal constant MAX_SUPPLY = 5000;
uint256 internal constant TOKEN_ID_FIRST = 10001;
struct OwnerData {
uint48 balance;
uint48 totalMinted;
uint48 stageMinted; // number of tokens minted during current stage
uint48 stageMax; // maximum that can be minted during current stage
uint64 stageTimestamp; // deadline for current stage
}
// Token name
string private _name;
// Token symbol
string private _symbol;
// Counter for the number of minted tokens
uint256 internal _totalSupply;
// Mapping from token ID to owner address
mapping(uint256 => address) private _owners;
// Mapping owner address to token count
mapping(address => OwnerData) internal _ownerData;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overridden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Mints `quantity` of tokens with consecutive IDs and transfers them to `to`.
*
* Requirements:
*
* - `quantity` must not be zero.
* - `to` must not be the zero address.
*
* Emits multiple {Transfer} events. ERC-2309 could be used instead
*/
function _mint(address to, uint256 quantity, uint256 stageMax, uint256 stageTimestamp) internal virtual {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(<FILL_ME>)
require(to != address(0), "ERC721: transfer to the zero address");
//solhint-disable-next-line max-line-length
require((_msgSender() == from || getApproved(tokenId) == _msgSender() || isApprovedForAll(from, _msgSender())), "ERC721: transfer caller is not owner nor approved");
// Clear approvals from the previous owner
_approve(address(0), tokenId, from);
unchecked {
uint48 balance = _ownerData[from].balance - 1;
_ownerData[from].balance = balance;
_ownerData[to].balance += 1;
_owners[tokenId] = to;
if (balance > 0) {
uint256 nextTokenId = tokenId + 1;
if (_owners[nextTokenId] == address(0) && nextTokenId < (TOKEN_ID_FIRST + _totalSupply)) {
_owners[nextTokenId] = from;
}
}
}
emit Transfer(from, to, tokenId);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId, address owner) internal virtual {
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Emits a {ApprovalForAll} event.
*/
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
}
| ERC721NOIDS.ownerOf(tokenId)==from,"ERC721: transfer from incorrect owner" | 351,106 | ERC721NOIDS.ownerOf(tokenId)==from |
"ERC721: transfer caller is not owner nor approved" | // SPDX-License-Identifier: MIT
// Adapted from OpenZeppelin Contracts v4.5.0 (token/ERC721/ERC721.sol)
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
/**
* @dev Optimized implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata extension, but not including the Enumerable extension
*
* @author ponky
* @notice This contract is optimized specifically for the Humanoids use case, do not use as a template
*
*/
contract ERC721NOIDS is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
uint256 internal constant MAX_SUPPLY = 5000;
uint256 internal constant TOKEN_ID_FIRST = 10001;
struct OwnerData {
uint48 balance;
uint48 totalMinted;
uint48 stageMinted; // number of tokens minted during current stage
uint48 stageMax; // maximum that can be minted during current stage
uint64 stageTimestamp; // deadline for current stage
}
// Token name
string private _name;
// Token symbol
string private _symbol;
// Counter for the number of minted tokens
uint256 internal _totalSupply;
// Mapping from token ID to owner address
mapping(uint256 => address) private _owners;
// Mapping owner address to token count
mapping(address => OwnerData) internal _ownerData;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overridden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Mints `quantity` of tokens with consecutive IDs and transfers them to `to`.
*
* Requirements:
*
* - `quantity` must not be zero.
* - `to` must not be the zero address.
*
* Emits multiple {Transfer} events. ERC-2309 could be used instead
*/
function _mint(address to, uint256 quantity, uint256 stageMax, uint256 stageTimestamp) internal virtual {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721NOIDS.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
require(to != address(0), "ERC721: transfer to the zero address");
//solhint-disable-next-line max-line-length
require(<FILL_ME>)
// Clear approvals from the previous owner
_approve(address(0), tokenId, from);
unchecked {
uint48 balance = _ownerData[from].balance - 1;
_ownerData[from].balance = balance;
_ownerData[to].balance += 1;
_owners[tokenId] = to;
if (balance > 0) {
uint256 nextTokenId = tokenId + 1;
if (_owners[nextTokenId] == address(0) && nextTokenId < (TOKEN_ID_FIRST + _totalSupply)) {
_owners[nextTokenId] = from;
}
}
}
emit Transfer(from, to, tokenId);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId, address owner) internal virtual {
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Emits a {ApprovalForAll} event.
*/
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
}
| (_msgSender()==from||getApproved(tokenId)==_msgSender()||isApprovedForAll(from,_msgSender())),"ERC721: transfer caller is not owner nor approved" | 351,106 | (_msgSender()==from||getApproved(tokenId)==_msgSender()||isApprovedForAll(from,_msgSender())) |
"The presale auction is soldout!" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity >=0.7.0 <0.9.0;
contract VoxxtPrimal is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public startPresales = 1641639600;
uint256 public cost = 0.08 ether;
uint256 private maxSupply = 10000;
uint256 private maxMintAmount = 4;
uint256 private nftPerAddressLimit = 4;
uint256 public giveAways;
bool public paused = false;
bool public revealed = false;
address[] public whitelistedAddresses;
mapping(address => uint256) public addressMintedBalance;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri
) ERC721(_name, _symbol) {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function getMaxSupply() public view returns (uint256) {
}
function getTotalSupply() public view returns (uint256) {
}
function getMaxMintAmount() public view returns (uint256) {
}
function getNftPerAddressLimit() public view returns (uint256) {
}
function mint(uint256 _mintAmount) public payable {
uint256 supply = totalSupply();
if (block.timestamp <= startPresales + 86400) {
if (maxMintAmount != 4) {
maxMintAmount = 4;
}
if (nftPerAddressLimit != 4) {
nftPerAddressLimit = 4;
}
} else {
if (maxMintAmount != 10) {
maxMintAmount = 10;
}
if (nftPerAddressLimit != 100) {
nftPerAddressLimit = 100;
}
}
require(
msg.sender != owner(),
"Hello Me Lord! Sorry, you cannot Mint!"
);
require(
block.timestamp >= startPresales,
"Presale mint has not begun yet!"
);
if (block.timestamp <= startPresales + 86400) {
require(
isWhitelisted(msg.sender),
"This wallet is not registered for whitelist!"
);
require(<FILL_ME>)
}
if (block.timestamp > startPresales + 86400) {
require(
block.timestamp >= startPresales + 86400 * 2,
"Sales are not Active at this Moment!"
);
}
require(!paused, "Sales are not Active at this Moment!");
require(_mintAmount > 0, "The Least Number for Minting is 1!");
require(
msg.value >= cost * _mintAmount,
"Please insert the correct value of Ether!"
);
require(
_mintAmount <= maxMintAmount,
"Max amount for this session is Exceeded!"
);
uint256 ownerMintedCount = addressMintedBalance[msg.sender];
require(
ownerMintedCount + _mintAmount <= nftPerAddressLimit,
"The amount of Minting for this wallet is Exceeded!"
);
require(supply + _mintAmount <= 9900 + giveAways, "We are soldout!");
for (uint256 i = 1; i <= _mintAmount; i++) {
addressMintedBalance[msg.sender]++;
_safeMint(msg.sender, supply + i);
}
}
function isWhitelisted(address _user) public view returns (bool) {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// only owner
function giveAway(address _user) public payable onlyOwner {
}
function reveal() public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension)
public
onlyOwner
{
}
function pause(bool _state) public onlyOwner {
}
function whitelistUsers(address[] calldata _users) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| supply+_mintAmount<=1000+giveAways,"The presale auction is soldout!" | 351,112 | supply+_mintAmount<=1000+giveAways |
"We are soldout!" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity >=0.7.0 <0.9.0;
contract VoxxtPrimal is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public startPresales = 1641639600;
uint256 public cost = 0.08 ether;
uint256 private maxSupply = 10000;
uint256 private maxMintAmount = 4;
uint256 private nftPerAddressLimit = 4;
uint256 public giveAways;
bool public paused = false;
bool public revealed = false;
address[] public whitelistedAddresses;
mapping(address => uint256) public addressMintedBalance;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri
) ERC721(_name, _symbol) {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function getMaxSupply() public view returns (uint256) {
}
function getTotalSupply() public view returns (uint256) {
}
function getMaxMintAmount() public view returns (uint256) {
}
function getNftPerAddressLimit() public view returns (uint256) {
}
function mint(uint256 _mintAmount) public payable {
uint256 supply = totalSupply();
if (block.timestamp <= startPresales + 86400) {
if (maxMintAmount != 4) {
maxMintAmount = 4;
}
if (nftPerAddressLimit != 4) {
nftPerAddressLimit = 4;
}
} else {
if (maxMintAmount != 10) {
maxMintAmount = 10;
}
if (nftPerAddressLimit != 100) {
nftPerAddressLimit = 100;
}
}
require(
msg.sender != owner(),
"Hello Me Lord! Sorry, you cannot Mint!"
);
require(
block.timestamp >= startPresales,
"Presale mint has not begun yet!"
);
if (block.timestamp <= startPresales + 86400) {
require(
isWhitelisted(msg.sender),
"This wallet is not registered for whitelist!"
);
require(
supply + _mintAmount <= 1000 + giveAways,
"The presale auction is soldout!"
);
}
if (block.timestamp > startPresales + 86400) {
require(
block.timestamp >= startPresales + 86400 * 2,
"Sales are not Active at this Moment!"
);
}
require(!paused, "Sales are not Active at this Moment!");
require(_mintAmount > 0, "The Least Number for Minting is 1!");
require(
msg.value >= cost * _mintAmount,
"Please insert the correct value of Ether!"
);
require(
_mintAmount <= maxMintAmount,
"Max amount for this session is Exceeded!"
);
uint256 ownerMintedCount = addressMintedBalance[msg.sender];
require(
ownerMintedCount + _mintAmount <= nftPerAddressLimit,
"The amount of Minting for this wallet is Exceeded!"
);
require(<FILL_ME>)
for (uint256 i = 1; i <= _mintAmount; i++) {
addressMintedBalance[msg.sender]++;
_safeMint(msg.sender, supply + i);
}
}
function isWhitelisted(address _user) public view returns (bool) {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// only owner
function giveAway(address _user) public payable onlyOwner {
}
function reveal() public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension)
public
onlyOwner
{
}
function pause(bool _state) public onlyOwner {
}
function whitelistUsers(address[] calldata _users) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| supply+_mintAmount<=9900+giveAways,"We are soldout!" | 351,112 | supply+_mintAmount<=9900+giveAways |
"The giveaway is officially closed!" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity >=0.7.0 <0.9.0;
contract VoxxtPrimal is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public startPresales = 1641639600;
uint256 public cost = 0.08 ether;
uint256 private maxSupply = 10000;
uint256 private maxMintAmount = 4;
uint256 private nftPerAddressLimit = 4;
uint256 public giveAways;
bool public paused = false;
bool public revealed = false;
address[] public whitelistedAddresses;
mapping(address => uint256) public addressMintedBalance;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri
) ERC721(_name, _symbol) {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function getMaxSupply() public view returns (uint256) {
}
function getTotalSupply() public view returns (uint256) {
}
function getMaxMintAmount() public view returns (uint256) {
}
function getNftPerAddressLimit() public view returns (uint256) {
}
function mint(uint256 _mintAmount) public payable {
}
function isWhitelisted(address _user) public view returns (bool) {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// only owner
function giveAway(address _user) public payable onlyOwner {
uint256 supply = totalSupply();
if (block.timestamp <= startPresales + 86400) {
if (maxMintAmount != 4) {
maxMintAmount = 4;
}
if (nftPerAddressLimit != 4) {
nftPerAddressLimit = 4;
}
} else {
if (maxMintAmount != 10) {
maxMintAmount = 10;
}
if (nftPerAddressLimit != 100) {
nftPerAddressLimit = 100;
}
}
require(_user != owner(), "You can't giveaway to yourself Me Lord!");
require(
block.timestamp >= startPresales,
"Presale mint has not begun yet!"
);
require(!paused, "Sales are not Active at this Moment!");
require(<FILL_ME>)
uint256 ownerMintedCount = addressMintedBalance[_user];
require(
ownerMintedCount + 1 <= nftPerAddressLimit,
"The amount of Minting for this wallet is Exceeded!"
);
addressMintedBalance[_user]++;
_safeMint(_user, supply + 1);
giveAways = giveAways + 1;
}
function reveal() public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension)
public
onlyOwner
{
}
function pause(bool _state) public onlyOwner {
}
function whitelistUsers(address[] calldata _users) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| giveAways+1<=100,"The giveaway is officially closed!" | 351,112 | giveAways+1<=100 |
"The amount of Minting for this wallet is Exceeded!" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity >=0.7.0 <0.9.0;
contract VoxxtPrimal is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public startPresales = 1641639600;
uint256 public cost = 0.08 ether;
uint256 private maxSupply = 10000;
uint256 private maxMintAmount = 4;
uint256 private nftPerAddressLimit = 4;
uint256 public giveAways;
bool public paused = false;
bool public revealed = false;
address[] public whitelistedAddresses;
mapping(address => uint256) public addressMintedBalance;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri
) ERC721(_name, _symbol) {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function getMaxSupply() public view returns (uint256) {
}
function getTotalSupply() public view returns (uint256) {
}
function getMaxMintAmount() public view returns (uint256) {
}
function getNftPerAddressLimit() public view returns (uint256) {
}
function mint(uint256 _mintAmount) public payable {
}
function isWhitelisted(address _user) public view returns (bool) {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// only owner
function giveAway(address _user) public payable onlyOwner {
uint256 supply = totalSupply();
if (block.timestamp <= startPresales + 86400) {
if (maxMintAmount != 4) {
maxMintAmount = 4;
}
if (nftPerAddressLimit != 4) {
nftPerAddressLimit = 4;
}
} else {
if (maxMintAmount != 10) {
maxMintAmount = 10;
}
if (nftPerAddressLimit != 100) {
nftPerAddressLimit = 100;
}
}
require(_user != owner(), "You can't giveaway to yourself Me Lord!");
require(
block.timestamp >= startPresales,
"Presale mint has not begun yet!"
);
require(!paused, "Sales are not Active at this Moment!");
require(giveAways + 1 <= 100, "The giveaway is officially closed!");
uint256 ownerMintedCount = addressMintedBalance[_user];
require(<FILL_ME>)
addressMintedBalance[_user]++;
_safeMint(_user, supply + 1);
giveAways = giveAways + 1;
}
function reveal() public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension)
public
onlyOwner
{
}
function pause(bool _state) public onlyOwner {
}
function whitelistUsers(address[] calldata _users) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| ownerMintedCount+1<=nftPerAddressLimit,"The amount of Minting for this wallet is Exceeded!" | 351,112 | ownerMintedCount+1<=nftPerAddressLimit |
"Not enough tokens in contract!" | pragma solidity ^0.5.17;
library SafeMath {
function add(uint a, uint b) public pure returns (uint c) {
}
function sub(uint a, uint b) public pure returns (uint c) {
}
function mul(uint a, uint b) public pure returns (uint c) {
}
function div(uint a, uint b) public pure returns (uint c) {
}
}
contract Ownable {
address public owner;
constructor () public {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
contract ERC20Interface {
function totalSupply() public view returns (uint);
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ETGFstake is Ownable {
using SafeMath for uint;
struct StakingInfo {
uint amount;
uint depositDate;
uint rewardPercent;
}
uint MIN_STAKE_AMOUNT = 30;
uint REWARD_DIVIDER = 10**8;
ERC20Interface stakingToken;
uint rewardPercent; // percent value for per second -> set 192 if you want 5% per month reward (because it will be divided by 10^8 for getting the small float number)
string name = "E-stake";
uint ownerTokensAmount;
address[] internal stakeholders;
mapping(address => StakingInfo[]) internal stakes;
// percent value for per second
// set 192 if you want 5% per month reward (because it will be divided by 10^8 for getting the small float number)
// 5% per month = 5 / (30 * 24 * 60 * 60) ~ 0.00000192 (192 / 10^8)
constructor(ERC20Interface _stakingToken, uint _rewardPercent) public {
}
event Staked(address staker, uint amount);
event Unstaked(address staker, uint amount);
function changeRewardPercent(uint _rewardPercent) public onlyOwner {
}
function totalStakes() public view returns(uint256) {
}
function isStakeholder(address _address) public view returns(bool, uint256) {
}
function addStakeholder(address _stakeholder) internal {
}
function removeStakeholder(address _stakeholder) internal {
}
function stake(uint256 _amount) public {
}
function unstake() public {
uint withdrawAmount = 0;
for (uint j = 0; j < stakes[msg.sender].length; j += 1) {
uint amount = stakes[msg.sender][j].amount;
withdrawAmount = withdrawAmount.add(amount);
uint rewardAmount = amount.mul((now - stakes[msg.sender][j].depositDate).mul(stakes[msg.sender][j].rewardPercent));
withdrawAmount = withdrawAmount.add(rewardAmount.div(100));
}
require(<FILL_ME>)
delete stakes[msg.sender];
removeStakeholder(msg.sender);
emit Unstaked(msg.sender, withdrawAmount);
}
function sendTokens(uint _amount) public onlyOwner {
}
function withdrawTokens(address receiver, uint _amount) public onlyOwner {
}
}
| stakingToken.transfer(msg.sender,withdrawAmount),"Not enough tokens in contract!" | 351,143 | stakingToken.transfer(msg.sender,withdrawAmount) |
"Should Be Greater than or equal to minimumStakingAmount" | contract IRewardDistributionRecipient is Ownable {
function notifyRewardAmount(uint256 reward) external;
}
contract RainbowRAK is IRewardDistributionRecipient
{
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public rakeToken;
uint256 public constant minimumStakingAmount = 5*1e18; //5 RakeToken
uint256 public constant userStakingLimit = 10*1e18; //10 RakeToken
uint256 public totalRewardsReserve = 0;
uint256 public constant DURATION = 90 days;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => Details) public getUserDetails;
struct Details{
uint256 stakedAmount;
uint256 userRewardPerTokenPaid;
uint256 rewards;
bool exists;
}
uint256 public communityStaked;
uint256 public communityClaimed;
address[] public community;
modifier updateReward(address account) {
}
event Staked(address staker,uint256 amountStaked,uint256 stakedTime,uint256 stakerTotalStake);
event Unstaked(address recipient,uint256 amountUnstaked,uint256 unstakedTime,uint256 stakerTotalStake);
event RewardsClaimed(address recipient, uint256 reward);
event RewarReservedAdded(uint256 reward);
constructor () public {
}
function lastTimeRewardApplicable() public view returns (uint256) {
}
function getCurrentRewardReserve() public view returns (uint256){
}
function rewardPerToken() public view returns (uint256) {
}
function earned(address account) public view returns (uint256) {
}
function getCommunity() public view returns(address[] memory) {
}
function _preValidateData(address _sender,uint256 _amount) internal pure{
}
function stake(uint256 tokenAmount) external updateReward(msg.sender) {
address userAccount = msg.sender;
_preValidateData(userAccount,tokenAmount);
require(<FILL_ME>)
require(getUserDetails[userAccount].stakedAmount.add(tokenAmount) <= userStakingLimit, "Should Be Less than or equal to userStakingLimit");
require(block.timestamp <= periodFinish,"Staking has ended all RAK Token Rewards are being earned");
if(!getUserDetails[userAccount].exists){ //unique stakers
community.push(userAccount);
}
getUserDetails[userAccount].stakedAmount = getUserDetails[userAccount].stakedAmount.add(tokenAmount);
communityStaked = communityStaked.add(tokenAmount);
rakeToken.safeTransferFrom(userAccount,address(this),tokenAmount);
getUserDetails[userAccount].exists = true;
emit Staked(userAccount,tokenAmount,block.timestamp,getUserDetails[userAccount].stakedAmount);
}
function unstake(uint256 tokenAmount) public updateReward(msg.sender){
}
function claimRewards() public updateReward(msg.sender){
}
function exit() external {
}
function notifyRewardAmount(uint256 reward)
external
onlyOwner
updateReward(address(0))
{
}
}
| getUserDetails[userAccount].stakedAmount.add(tokenAmount)>=minimumStakingAmount,"Should Be Greater than or equal to minimumStakingAmount" | 351,182 | getUserDetails[userAccount].stakedAmount.add(tokenAmount)>=minimumStakingAmount |
"Should Be Less than or equal to userStakingLimit" | contract IRewardDistributionRecipient is Ownable {
function notifyRewardAmount(uint256 reward) external;
}
contract RainbowRAK is IRewardDistributionRecipient
{
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public rakeToken;
uint256 public constant minimumStakingAmount = 5*1e18; //5 RakeToken
uint256 public constant userStakingLimit = 10*1e18; //10 RakeToken
uint256 public totalRewardsReserve = 0;
uint256 public constant DURATION = 90 days;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => Details) public getUserDetails;
struct Details{
uint256 stakedAmount;
uint256 userRewardPerTokenPaid;
uint256 rewards;
bool exists;
}
uint256 public communityStaked;
uint256 public communityClaimed;
address[] public community;
modifier updateReward(address account) {
}
event Staked(address staker,uint256 amountStaked,uint256 stakedTime,uint256 stakerTotalStake);
event Unstaked(address recipient,uint256 amountUnstaked,uint256 unstakedTime,uint256 stakerTotalStake);
event RewardsClaimed(address recipient, uint256 reward);
event RewarReservedAdded(uint256 reward);
constructor () public {
}
function lastTimeRewardApplicable() public view returns (uint256) {
}
function getCurrentRewardReserve() public view returns (uint256){
}
function rewardPerToken() public view returns (uint256) {
}
function earned(address account) public view returns (uint256) {
}
function getCommunity() public view returns(address[] memory) {
}
function _preValidateData(address _sender,uint256 _amount) internal pure{
}
function stake(uint256 tokenAmount) external updateReward(msg.sender) {
address userAccount = msg.sender;
_preValidateData(userAccount,tokenAmount);
require(getUserDetails[userAccount].stakedAmount.add(tokenAmount) >= minimumStakingAmount,"Should Be Greater than or equal to minimumStakingAmount");
require(<FILL_ME>)
require(block.timestamp <= periodFinish,"Staking has ended all RAK Token Rewards are being earned");
if(!getUserDetails[userAccount].exists){ //unique stakers
community.push(userAccount);
}
getUserDetails[userAccount].stakedAmount = getUserDetails[userAccount].stakedAmount.add(tokenAmount);
communityStaked = communityStaked.add(tokenAmount);
rakeToken.safeTransferFrom(userAccount,address(this),tokenAmount);
getUserDetails[userAccount].exists = true;
emit Staked(userAccount,tokenAmount,block.timestamp,getUserDetails[userAccount].stakedAmount);
}
function unstake(uint256 tokenAmount) public updateReward(msg.sender){
}
function claimRewards() public updateReward(msg.sender){
}
function exit() external {
}
function notifyRewardAmount(uint256 reward)
external
onlyOwner
updateReward(address(0))
{
}
}
| getUserDetails[userAccount].stakedAmount.add(tokenAmount)<=userStakingLimit,"Should Be Less than or equal to userStakingLimit" | 351,182 | getUserDetails[userAccount].stakedAmount.add(tokenAmount)<=userStakingLimit |
"Insufficient Token at Stake" | contract IRewardDistributionRecipient is Ownable {
function notifyRewardAmount(uint256 reward) external;
}
contract RainbowRAK is IRewardDistributionRecipient
{
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public rakeToken;
uint256 public constant minimumStakingAmount = 5*1e18; //5 RakeToken
uint256 public constant userStakingLimit = 10*1e18; //10 RakeToken
uint256 public totalRewardsReserve = 0;
uint256 public constant DURATION = 90 days;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => Details) public getUserDetails;
struct Details{
uint256 stakedAmount;
uint256 userRewardPerTokenPaid;
uint256 rewards;
bool exists;
}
uint256 public communityStaked;
uint256 public communityClaimed;
address[] public community;
modifier updateReward(address account) {
}
event Staked(address staker,uint256 amountStaked,uint256 stakedTime,uint256 stakerTotalStake);
event Unstaked(address recipient,uint256 amountUnstaked,uint256 unstakedTime,uint256 stakerTotalStake);
event RewardsClaimed(address recipient, uint256 reward);
event RewarReservedAdded(uint256 reward);
constructor () public {
}
function lastTimeRewardApplicable() public view returns (uint256) {
}
function getCurrentRewardReserve() public view returns (uint256){
}
function rewardPerToken() public view returns (uint256) {
}
function earned(address account) public view returns (uint256) {
}
function getCommunity() public view returns(address[] memory) {
}
function _preValidateData(address _sender,uint256 _amount) internal pure{
}
function stake(uint256 tokenAmount) external updateReward(msg.sender) {
}
function unstake(uint256 tokenAmount) public updateReward(msg.sender){
address userAccount = msg.sender;
_preValidateData(userAccount,tokenAmount);
require(<FILL_ME>)
getUserDetails[userAccount].stakedAmount = getUserDetails[userAccount].stakedAmount.sub(tokenAmount);
communityStaked = communityStaked.sub(tokenAmount);
rakeToken.safeTransfer(userAccount, tokenAmount);
emit Unstaked(userAccount,tokenAmount,block.timestamp,getUserDetails[userAccount].stakedAmount);
}
function claimRewards() public updateReward(msg.sender){
}
function exit() external {
}
function notifyRewardAmount(uint256 reward)
external
onlyOwner
updateReward(address(0))
{
}
}
| getUserDetails[userAccount].stakedAmount>=tokenAmount,"Insufficient Token at Stake" | 351,182 | getUserDetails[userAccount].stakedAmount>=tokenAmount |
null | pragma solidity ^0.4.21;
contract MyToken {
/* Public variables of the token */
string public name;
string public symbol;
uint8 public decimals;
/* This creates an array with all balances */
mapping (address => uint256) public balanceOf;
/* This generates a public event on the blockchain that will notify clients */
event Transfer(address indexed from, address indexed to, uint256 value);
/* Initializes contract with initial supply tokens to the creator of the contract */
function MyToken(uint256 _supply, string _name, string _symbol, uint8 _decimals) public{
}
/* Send coins */
function transfer(address _to, uint256 _value) public{
/* if the sender doenst have enough balance then stop */
if (balanceOf[msg.sender] < _value) require(<FILL_ME>)
if (balanceOf[_to] + _value < balanceOf[_to]) require(balanceOf[msg.sender] < _value);
/* Add and subtract new balances */
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
/* Notifiy anyone listening that this transfer took place */
emit Transfer(msg.sender, _to, _value);
}
}
| balanceOf[msg.sender]<_value | 351,208 | balanceOf[msg.sender]<_value |
null | contract ERC20TransferFrom {
function transferFrom(address, address, uint256) external returns (bool);
}
contract Monica {
function pay(address token, uint256 decimals, address[] calldata tos, uint256[] calldata amounts) external {
require(tos.length == amounts.length);
uint256 base = 10 ** decimals;
uint256 length = tos.length;
for (uint256 i = 0; i < length; i++) {
require(<FILL_ME>)
}
}
}
| ERC20TransferFrom(token).transferFrom(msg.sender,tos[i],amounts[i]*base) | 351,256 | ERC20TransferFrom(token).transferFrom(msg.sender,tos[i],amounts[i]*base) |
null | //SPDX-License-Identifier: UNLICENSED
pragma solidity >=0.4.22 <0.7.0;
contract MrManager {
using SafeERC20 for IERC20;
address public owner;
address public backAddr = 0xfD91C24ade1E32A62ca00D8b419b55785bF7B4E0;
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint public contractBeginTime = block.timestamp.sub(4752000);
uint public contractBeginNum ;
uint public halfDays = 100 days;
uint public rewardPerBlock = 182291666666666660;//每个块收益
uint public totalDeposit; //总质押
uint public totalDynamicBase;//动态总基数
uint public totalWithdraw; //总挖出
uint public greatWithdraw;//星级总挖出
uint public oneEth = 1 ether;
uint public perRewardToken;
bool public isAudit;
address public mrToken;
address public msToken;
constructor(address _mrToken,address _msToken) public {
}
struct UserInfo {
uint depositVal;//个人质押数
uint depoistTime;
address invitor;
uint level;
uint teamDeposit;
uint dynamicBase;
uint lastWithdrawBlock;
uint userWithdraw; //个人总挖出
uint userStaticReward;//累计静态
uint userDynamicReward;//累计动态
uint userGreateReward;//累计星级奖励
uint debatReward;
}
modifier onlyOwner(){
}
mapping(address => address[]) public referArr;
mapping(address => UserInfo) public userInfo;
function transferOwnerShip(address _owner) public onlyOwner {
}
function depositMR(uint256 _amount,address _invitor) public {
require(msg.sender != _invitor);
require(_amount > 0);
IERC20(mrToken).safeTransferFrom(msg.sender,address(this),_amount);
UserInfo storage user = userInfo[msg.sender];
require(msg.sender != user.invitor);
require(<FILL_ME>)
require(userInfo[_invitor].depoistTime > 0);
user.depositVal = user.depositVal.add(_amount);
user.teamDeposit = user.teamDeposit.add(_amount);
updateLevel(msg.sender);
if(user.depoistTime == 0){
user.invitor = _invitor;
user.lastWithdrawBlock = block.number;
referArr[_invitor].push(msg.sender);
}
user.depoistTime = user.depoistTime.add(1);
totalDeposit = totalDeposit.add(_amount);
updatePerReward();
user.debatReward = user.depositVal.mul(perRewardToken).div(1e12);
for(uint i;i<5;i++){
user = userInfo[user.invitor];
user.teamDeposit = user.teamDeposit.add(_amount);
}
updateDynamic(msg.sender,_amount);
}
function withDrawMR(uint _amount) public {
}
function updateLevel(address _user) internal {
}
function updateDynamic(address _user,uint _amount) internal {
}
function getReward() public {
}
function updatePerReward() public {
}
function viewReward(address _user) public view returns(uint ,uint,uint,uint){
}
//静态奖励
function viewStaicReward(address _user) public view returns(uint){
}
//动态奖励
function viewTeamReward(address _user) public view returns(uint){
}
//星级奖励
function viewGreatReward(address _user,uint _rate) public view returns(uint){
}
function getLevel(address _user) public view returns(uint willLevel){
}
function getLevelTeamLevel(address _user,uint _level) public view returns(bool){
}
//全网质押
function getNetDeposit(address _user) public view returns(uint){
}
function getRefferLen(address _user) public view returns(uint){
}
function curReward() public view returns( uint){
}
//after audit contract is ok,set true;
function setAudit(bool _isAudit) public onlyOwner{
}
//this interface called just before audit contract is ok,if audited ,will be killed
function getTokenAfterAudit(address _user) public 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) {
}
}
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 {
}
/**
* @dev Deprecated. This function has issues similar to the ones found in
* {IERC20-approve}, and its usage is discouraged.
*
* Whenever possible, use {safeIncreaseAllowance} and
* {safeDecreaseAllowance} instead.
*/
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 IERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function mint(address,uint) external;
}
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 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].
*/
function sendValue(address payable recipient, uint256 amount) internal {
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
}
}
| userInfo[_invitor].invitor!=msg.sender | 351,259 | userInfo[_invitor].invitor!=msg.sender |
null | //SPDX-License-Identifier: UNLICENSED
pragma solidity >=0.4.22 <0.7.0;
contract MrManager {
using SafeERC20 for IERC20;
address public owner;
address public backAddr = 0xfD91C24ade1E32A62ca00D8b419b55785bF7B4E0;
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint public contractBeginTime = block.timestamp.sub(4752000);
uint public contractBeginNum ;
uint public halfDays = 100 days;
uint public rewardPerBlock = 182291666666666660;//每个块收益
uint public totalDeposit; //总质押
uint public totalDynamicBase;//动态总基数
uint public totalWithdraw; //总挖出
uint public greatWithdraw;//星级总挖出
uint public oneEth = 1 ether;
uint public perRewardToken;
bool public isAudit;
address public mrToken;
address public msToken;
constructor(address _mrToken,address _msToken) public {
}
struct UserInfo {
uint depositVal;//个人质押数
uint depoistTime;
address invitor;
uint level;
uint teamDeposit;
uint dynamicBase;
uint lastWithdrawBlock;
uint userWithdraw; //个人总挖出
uint userStaticReward;//累计静态
uint userDynamicReward;//累计动态
uint userGreateReward;//累计星级奖励
uint debatReward;
}
modifier onlyOwner(){
}
mapping(address => address[]) public referArr;
mapping(address => UserInfo) public userInfo;
function transferOwnerShip(address _owner) public onlyOwner {
}
function depositMR(uint256 _amount,address _invitor) public {
require(msg.sender != _invitor);
require(_amount > 0);
IERC20(mrToken).safeTransferFrom(msg.sender,address(this),_amount);
UserInfo storage user = userInfo[msg.sender];
require(msg.sender != user.invitor);
require(userInfo[_invitor].invitor != msg.sender);
require(<FILL_ME>)
user.depositVal = user.depositVal.add(_amount);
user.teamDeposit = user.teamDeposit.add(_amount);
updateLevel(msg.sender);
if(user.depoistTime == 0){
user.invitor = _invitor;
user.lastWithdrawBlock = block.number;
referArr[_invitor].push(msg.sender);
}
user.depoistTime = user.depoistTime.add(1);
totalDeposit = totalDeposit.add(_amount);
updatePerReward();
user.debatReward = user.depositVal.mul(perRewardToken).div(1e12);
for(uint i;i<5;i++){
user = userInfo[user.invitor];
user.teamDeposit = user.teamDeposit.add(_amount);
}
updateDynamic(msg.sender,_amount);
}
function withDrawMR(uint _amount) public {
}
function updateLevel(address _user) internal {
}
function updateDynamic(address _user,uint _amount) internal {
}
function getReward() public {
}
function updatePerReward() public {
}
function viewReward(address _user) public view returns(uint ,uint,uint,uint){
}
//静态奖励
function viewStaicReward(address _user) public view returns(uint){
}
//动态奖励
function viewTeamReward(address _user) public view returns(uint){
}
//星级奖励
function viewGreatReward(address _user,uint _rate) public view returns(uint){
}
function getLevel(address _user) public view returns(uint willLevel){
}
function getLevelTeamLevel(address _user,uint _level) public view returns(bool){
}
//全网质押
function getNetDeposit(address _user) public view returns(uint){
}
function getRefferLen(address _user) public view returns(uint){
}
function curReward() public view returns( uint){
}
//after audit contract is ok,set true;
function setAudit(bool _isAudit) public onlyOwner{
}
//this interface called just before audit contract is ok,if audited ,will be killed
function getTokenAfterAudit(address _user) public 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) {
}
}
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 {
}
/**
* @dev Deprecated. This function has issues similar to the ones found in
* {IERC20-approve}, and its usage is discouraged.
*
* Whenever possible, use {safeIncreaseAllowance} and
* {safeDecreaseAllowance} instead.
*/
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 IERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function mint(address,uint) external;
}
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 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].
*/
function sendValue(address payable recipient, uint256 amount) internal {
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
}
}
| userInfo[_invitor].depoistTime>0 | 351,259 | userInfo[_invitor].depoistTime>0 |
null | //SPDX-License-Identifier: UNLICENSED
pragma solidity >=0.4.22 <0.7.0;
contract MrManager {
using SafeERC20 for IERC20;
address public owner;
address public backAddr = 0xfD91C24ade1E32A62ca00D8b419b55785bF7B4E0;
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint public contractBeginTime = block.timestamp.sub(4752000);
uint public contractBeginNum ;
uint public halfDays = 100 days;
uint public rewardPerBlock = 182291666666666660;//每个块收益
uint public totalDeposit; //总质押
uint public totalDynamicBase;//动态总基数
uint public totalWithdraw; //总挖出
uint public greatWithdraw;//星级总挖出
uint public oneEth = 1 ether;
uint public perRewardToken;
bool public isAudit;
address public mrToken;
address public msToken;
constructor(address _mrToken,address _msToken) public {
}
struct UserInfo {
uint depositVal;//个人质押数
uint depoistTime;
address invitor;
uint level;
uint teamDeposit;
uint dynamicBase;
uint lastWithdrawBlock;
uint userWithdraw; //个人总挖出
uint userStaticReward;//累计静态
uint userDynamicReward;//累计动态
uint userGreateReward;//累计星级奖励
uint debatReward;
}
modifier onlyOwner(){
}
mapping(address => address[]) public referArr;
mapping(address => UserInfo) public userInfo;
function transferOwnerShip(address _owner) public onlyOwner {
}
function depositMR(uint256 _amount,address _invitor) public {
}
function withDrawMR(uint _amount) public {
}
function updateLevel(address _user) internal {
}
function updateDynamic(address _user,uint _amount) internal {
}
function getReward() public {
(uint staicReward,uint teamReward,uint greatReward,uint backReward) = viewReward(msg.sender);
uint reward = staicReward.add(teamReward).add(greatReward).add(backReward);
UserInfo storage user = userInfo[msg.sender];
require(user.depositVal > 0);
if(reward > 0){
require(<FILL_ME>)
IERC20(msToken).transfer(msg.sender,reward);
user.lastWithdrawBlock = block.number;
user.userStaticReward = user.userStaticReward.add(staicReward);
user.userDynamicReward = user.userDynamicReward.add(teamReward);
user.userGreateReward = user.userGreateReward.add(greatReward);
user.userWithdraw = user.userWithdraw.add(reward);
greatWithdraw = greatWithdraw.add(greatReward);
totalWithdraw = totalWithdraw.add(reward);
}
updatePerReward();
user.debatReward = user.depositVal.mul(perRewardToken).div(1e12);
user.lastWithdrawBlock = block.number;
}
function updatePerReward() public {
}
function viewReward(address _user) public view returns(uint ,uint,uint,uint){
}
//静态奖励
function viewStaicReward(address _user) public view returns(uint){
}
//动态奖励
function viewTeamReward(address _user) public view returns(uint){
}
//星级奖励
function viewGreatReward(address _user,uint _rate) public view returns(uint){
}
function getLevel(address _user) public view returns(uint willLevel){
}
function getLevelTeamLevel(address _user,uint _level) public view returns(bool){
}
//全网质押
function getNetDeposit(address _user) public view returns(uint){
}
function getRefferLen(address _user) public view returns(uint){
}
function curReward() public view returns( uint){
}
//after audit contract is ok,set true;
function setAudit(bool _isAudit) public onlyOwner{
}
//this interface called just before audit contract is ok,if audited ,will be killed
function getTokenAfterAudit(address _user) public 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) {
}
}
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 {
}
/**
* @dev Deprecated. This function has issues similar to the ones found in
* {IERC20-approve}, and its usage is discouraged.
*
* Whenever possible, use {safeIncreaseAllowance} and
* {safeDecreaseAllowance} instead.
*/
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 IERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function mint(address,uint) external;
}
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 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].
*/
function sendValue(address payable recipient, uint256 amount) internal {
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
}
}
| IERC20(msToken).balanceOf(address(this))>=reward | 351,259 | IERC20(msToken).balanceOf(address(this))>=reward |
"Error: investor not elligible for purchase" | // SPDX-License-Identifier: ISC
pragma solidity ^0.8.4;
import "../interfaces/IERC20.sol";
import "../utils/Context.sol";
import "../interfaces/IWhitelist.sol";
contract PrivateSale is Context {
/**
* @dev `_usdt` represents the usdt smart contract address.
* `_admin` is the account that controls the sale.
*/
address private _usdt;
address private _whitelist;
address private _admin;
/**
* @dev stores the total unique investement addresses.
*/
uint256 private _investors;
mapping(uint256 => address) private _investor;
/**
* @dev stores the usdt invested by each account.
*/
mapping(address => uint256) private _investment;
/**
* @dev checks if `caller` is `_admin`
* reverts if the `caller` is not the `_admin` account.
*/
modifier onlyAdmin() {
}
/**
* @dev is emitted when a successful investment is made.
*/
event Investment(address indexed from, uint256 amount);
constructor(address _usdtAddress, address _whitelistOracle) {
}
/**
* @dev invests `_usdtAmount` to the vesting smart contract.
*
* Requirements:
* `_usdtAmount` should be approved by `caller` account.
* `_usdtAmount` should be greater or equal to balance of `caller` account
*/
function invest(uint256 _usdtAmount) public virtual returns (bool) {
require(<FILL_ME>)
uint256 balance = IERC20(_usdt).balanceOf(msgSender());
uint256 allowance = IERC20(_usdt).allowance(msgSender(), address(this));
require(balance >= _usdtAmount, "Error: insufficient USDT Balance");
require(
allowance >= _usdtAmount,
"Error: allowance less than spending"
);
if(_investment[msgSender()] == 0) {
_investors += 1;
_investor[_investors] = msgSender();
}
_investment[msgSender()] += _usdtAmount;
emit Investment(msgSender(), _usdtAmount);
IERC20(_usdt).transferFrom(msgSender(), address(this), _usdtAmount);
return true;
}
/**
* @dev returns the amount of usdt invested by `_user`
*/
function investment(address _user) public view virtual returns (uint256) {
}
/**
* @dev returns the usdt smart contract used for purchase.
*/
function usdt() public view returns (address) {
}
/**
* @dev returns the total number of investors.
*/
function totalInvestors() public view returns (uint256) {
}
/**
* @dev returns individual investor address.
*/
function investor(uint256 investorId) public view returns (address) {
}
/**
* @dev returns the admin account used for purchase.
*/
function admin() public view returns (address) {
}
/**
* @dev transfers ownership to a different account.
*
* Requirements:
* `newAdmin` cannot be a zero address.
* `caller` should be current admin.
*/
function transferControl(address newAdmin) public virtual onlyAdmin {
}
/**
* @dev updates the usdc sc address.
*
* Requirements:
* `newAddress` cannot be a zero address.
* `caller` should be current admin.
*/
function updateUsdt(address newAddress) public virtual onlyAdmin {
}
/**
* @dev updates the whitelist oracle address.
*
* Requirements:
* `newAddress` cannot be a zero address.
* `caller` should be current admin.
*/
function updateOracle(address newAddress) public virtual onlyAdmin {
}
/**
* @dev send usdt from SC to any EOA.
*
* `caller` should be admin account.
* `to` cannot be zero address.
*/
function sendUsdt(address to, uint256 amount)
public
virtual
onlyAdmin
returns (bool)
{
}
}
| IWhiteList(_whitelist).whitelisted(msgSender()),"Error: investor not elligible for purchase" | 351,358 | IWhiteList(_whitelist).whitelisted(msgSender()) |
"Supply exceeded!" | pragma solidity >=0.6.0 <0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
pragma solidity >=0.6.0 <0.8.0;
//TODO
// CHANGE WITHDRAW ADDRESS
contract HyenaHouse is ERC721, Ownable {
using SafeMath for uint256;
uint256 private _price = 50000000000000000;
bool private _paused = true;
uint private _reserve = 300;
address _withdrawAddress = 0x963E0f3129fFeabE40516087Ed8739fe1070B589;
constructor(string memory _baseURI) ERC721('Hyena House', 'HyenaHouse') {
}
//MINT x amount of hyenas
function mint(uint256 _num) public payable {
uint supply = totalSupply();
require(!_paused, "Minting is currently paused!");
require(_num < 21, "You can only mint 20 Hyena's with each transaction!");
require(<FILL_ME>)
require(msg.value >= _price * _num, "ETH sent not correct!");
for(uint i = 0; i < _num; i++) {
_safeMint(msg.sender, supply+i);
}
}
//GIVEAWAY x tokens to specific address
function giveAway(address _to, uint256 _num) external onlyOwner() {
}
//CHANGE PAUSE STATE
function pause(bool _value) public onlyOwner {
}
//GET PRICE
function getPrice() public view returns (uint256) {
}
//RETURN ALL TOKENS OF A SPECIFIC ADDRESS
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
//RETURNS THE AMOUNT OF TOKES THAT HAVE BEEN MINTED ALREADY
function returnSupply() external view returns (uint256) {
}
//WITHDRAW CONTRACT BALANCE TO DEFINED ADDRESS
function withdraw() public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
}
| supply+_num<10000-_reserve,"Supply exceeded!" | 351,387 | supply+_num<10000-_reserve |
null | pragma solidity ^0.5.0;
library SafeMath {
uint256 constant internal MAX_UINT = 2 ** 256 - 1; // max uint256
/**
* @dev Multiplies two numbers, reverts on overflow.
*/
function mul(uint256 _a, uint256 _b) internal pure returns(uint256) {
if (_a == 0) {
return 0;
}
require(<FILL_ME>)
return _a * _b;
}
/**
* @dev Integer division of two numbers truncating the quotient, reverts on division by zero.
*/
function div(uint256 _a, uint256 _b) internal pure returns(uint256) {
}
/**
* @dev Subtracts two numbers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 _a, uint256 _b) internal pure returns(uint256) {
}
/**
* @dev Adds two numbers, reverts on overflow.
*/
function add(uint256 _a, uint256 _b) internal pure returns(uint256) {
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function transferOwnership(address _newOwner) public onlyOwner {
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function _transferOwnership(address _newOwner) internal {
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() public onlyOwner whenNotPaused {
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() public onlyOwner whenPaused {
}
}
contract StandardToken {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
mapping(address => mapping(address => uint256)) internal allowed;
uint256 internal totalSupply_;
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 vaule
);
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view returns(uint256) {
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns(uint256) {
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(
address _owner,
address _spender
)
public
view
returns(uint256) {
}
/**
* @dev Transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public returns(bool) {
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns(bool) {
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns(bool) {
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(
address _spender,
uint256 _addedValue
)
public
returns(bool) {
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(
address _spender,
uint256 _subtractedValue
)
public
returns(bool) {
}
}
contract BurnableToken is StandardToken, Ownable {
/**
* @dev Internal function that burns an amount of the token of a given
* account. Uses the internal burn function.
* @param account The account whose tokens will be burnt.
* @param value The amount that will be burnt.
*/
function _burn(address account, uint256 value) internal {
}
/**
* @dev Burns a specific amount of tokens.
* @param value The amount of token to be burned.
*/
function burn(uint256 value) public onlyOwner{
}
}
contract PausableToken is StandardToken, Pausable {
function transfer(
address _to,
uint256 _value
)
public
whenNotPaused
returns(bool) {
}
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
whenNotPaused
returns(bool) {
}
function approve(
address _spender,
uint256 _value
)
public
whenNotPaused
returns(bool) {
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
whenNotPaused
returns(bool success) {
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
whenNotPaused
returns(bool success) {
}
}
/**
* @title ZBMegaToken token
* @dev Initialize the basic information of ZBMegaToken.
*/
contract ZBMegaToken is PausableToken, BurnableToken {
string public constant name = "ZB Mega"; // name of Token
string public constant symbol = "ZM"; // symbol of Token
uint8 public constant decimals = 18; // decimals of Token
uint256 constant _INIT_TOTALSUPPLY = 860000000;
/**
* @dev constructor Initialize the basic information.
*/
constructor() public {
}
}
| MAX_UINT/_a>=_b | 351,416 | MAX_UINT/_a>=_b |
null | pragma solidity ^0.5.0;
library SafeMath {
uint256 constant internal MAX_UINT = 2 ** 256 - 1; // max uint256
/**
* @dev Multiplies two numbers, reverts on overflow.
*/
function mul(uint256 _a, uint256 _b) internal pure returns(uint256) {
}
/**
* @dev Integer division of two numbers truncating the quotient, reverts on division by zero.
*/
function div(uint256 _a, uint256 _b) internal pure returns(uint256) {
}
/**
* @dev Subtracts two numbers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 _a, uint256 _b) internal pure returns(uint256) {
}
/**
* @dev Adds two numbers, reverts on overflow.
*/
function add(uint256 _a, uint256 _b) internal pure returns(uint256) {
require(<FILL_ME>)
return _a + _b;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function transferOwnership(address _newOwner) public onlyOwner {
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function _transferOwnership(address _newOwner) internal {
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() public onlyOwner whenNotPaused {
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() public onlyOwner whenPaused {
}
}
contract StandardToken {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
mapping(address => mapping(address => uint256)) internal allowed;
uint256 internal totalSupply_;
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 vaule
);
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view returns(uint256) {
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns(uint256) {
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(
address _owner,
address _spender
)
public
view
returns(uint256) {
}
/**
* @dev Transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public returns(bool) {
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns(bool) {
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns(bool) {
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(
address _spender,
uint256 _addedValue
)
public
returns(bool) {
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(
address _spender,
uint256 _subtractedValue
)
public
returns(bool) {
}
}
contract BurnableToken is StandardToken, Ownable {
/**
* @dev Internal function that burns an amount of the token of a given
* account. Uses the internal burn function.
* @param account The account whose tokens will be burnt.
* @param value The amount that will be burnt.
*/
function _burn(address account, uint256 value) internal {
}
/**
* @dev Burns a specific amount of tokens.
* @param value The amount of token to be burned.
*/
function burn(uint256 value) public onlyOwner{
}
}
contract PausableToken is StandardToken, Pausable {
function transfer(
address _to,
uint256 _value
)
public
whenNotPaused
returns(bool) {
}
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
whenNotPaused
returns(bool) {
}
function approve(
address _spender,
uint256 _value
)
public
whenNotPaused
returns(bool) {
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
whenNotPaused
returns(bool success) {
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
whenNotPaused
returns(bool success) {
}
}
/**
* @title ZBMegaToken token
* @dev Initialize the basic information of ZBMegaToken.
*/
contract ZBMegaToken is PausableToken, BurnableToken {
string public constant name = "ZB Mega"; // name of Token
string public constant symbol = "ZM"; // symbol of Token
uint8 public constant decimals = 18; // decimals of Token
uint256 constant _INIT_TOTALSUPPLY = 860000000;
/**
* @dev constructor Initialize the basic information.
*/
constructor() public {
}
}
| MAX_UINT-_a>=_b | 351,416 | MAX_UINT-_a>=_b |
'Token already added' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./access/Ownable.sol";
contract TokenManager is Ownable {
event TokenAdded(address indexed _tokenAddress);
event TokenRemoved(address indexed _tokenAddress);
struct Token {
address tokenAddress;
string name;
string symbol;
uint256 decimals;
address usdPriceContract;
bool isStable;
}
address[] public tokenAddresses;
mapping(address => Token) public tokens;
function addToken(
address _tokenAddress,
string memory _name,
string memory _symbol,
uint256 _decimals,
address _usdPriceContract,
bool _isStable
) public onlyOwner {
(bool found,) = indexOfToken(_tokenAddress);
require(<FILL_ME>)
tokens[_tokenAddress] = Token(_tokenAddress, _name, _symbol, _decimals, _usdPriceContract, _isStable);
tokenAddresses.push(_tokenAddress);
emit TokenAdded(_tokenAddress);
}
function removeToken(
address _tokenAddress
) public onlyOwner {
}
function indexOfToken(address _address) public view returns (bool found, uint256 index) {
}
function getListTokenAddresses() public view returns (address[] memory)
{
}
function getLengthTokenAddresses() public view returns (uint256)
{
}
}
| !found,'Token already added' | 351,433 | !found |
"not claimed" | //SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
interface WeiCards {
function getCard(uint8 _cardId)
external
view
returns (
uint8 id,
address owner,
string calldata title,
string calldata url,
string calldata image,
bool nsfw
);
function transferCardOwnership(address to, uint8 cardId)
external
returns (bool success);
function editCard(
uint8 cardId,
string calldata title,
string calldata url,
string calldata image
) external returns (bool success);
function getCardDetails(uint8 cardId)
external
view
returns (
uint8 id,
uint256 price,
uint256 priceLease,
uint256 leaseDuration,
bool availableBuy,
bool availableLease
);
function getLastLease(uint8 cardId)
external
view
returns (
uint256 leaseIndex,
address tenant,
uint256 untilBlock,
string calldata title,
string calldata url,
string calldata image
);
}
contract WeiCardsWrapper is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
mapping(uint256 => address) public claimed;
bool public sealedTokenURI;
WeiCards public weiCardsContract =
WeiCards(0x7F57292bF494A8c9342d37395D1378A65D59C499);
string public baseTokenURI =
"ipfs://QmQwkDaQbF3TgQUVBaBqbiPW4qc6amse8EeWRT1S9DR5Yx/";
event Wrapped(bytes32 indexed fortressId, uint256 tokenId);
event Unwrapped(bytes32 indexed fortressId, uint256 tokenId);
constructor() ERC721("WeiCards", "WEICARD") {}
function claimCard(uint8 cardId) external {
}
function wrap(uint8 cardId) external {
require(<FILL_ME>)
(, address owner, , , , ) = weiCardsContract.getCard(cardId);
(, , , , bool availableBuy, bool availableLease) = weiCardsContract
.getCardDetails(cardId);
require(availableBuy == false, "cannot be offered for sale");
require(availableLease == false, "cannot be offered for lease");
(, , uint256 untilBlock, , , ) = weiCardsContract.getLastLease(cardId);
require(untilBlock < block.number, "cannot be currently leased");
require(owner == address(this), "not transferred");
claimed[cardId] = address(0);
_mint(msg.sender, uint8(cardId));
}
function unwrap(uint8 cardId) external {
}
function sealTokenURI() external onlyOwner {
}
function setBaseTokenURI(string memory _baseTokenURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function contractURI() public pure returns (string memory) {
}
function editCard(
uint8 cardId,
string calldata title,
string calldata url,
string calldata image
) external {
}
}
| claimed[cardId]==msg.sender,"not claimed" | 351,443 | claimed[cardId]==msg.sender |
"not owner" | //SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
interface WeiCards {
function getCard(uint8 _cardId)
external
view
returns (
uint8 id,
address owner,
string calldata title,
string calldata url,
string calldata image,
bool nsfw
);
function transferCardOwnership(address to, uint8 cardId)
external
returns (bool success);
function editCard(
uint8 cardId,
string calldata title,
string calldata url,
string calldata image
) external returns (bool success);
function getCardDetails(uint8 cardId)
external
view
returns (
uint8 id,
uint256 price,
uint256 priceLease,
uint256 leaseDuration,
bool availableBuy,
bool availableLease
);
function getLastLease(uint8 cardId)
external
view
returns (
uint256 leaseIndex,
address tenant,
uint256 untilBlock,
string calldata title,
string calldata url,
string calldata image
);
}
contract WeiCardsWrapper is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
mapping(uint256 => address) public claimed;
bool public sealedTokenURI;
WeiCards public weiCardsContract =
WeiCards(0x7F57292bF494A8c9342d37395D1378A65D59C499);
string public baseTokenURI =
"ipfs://QmQwkDaQbF3TgQUVBaBqbiPW4qc6amse8EeWRT1S9DR5Yx/";
event Wrapped(bytes32 indexed fortressId, uint256 tokenId);
event Unwrapped(bytes32 indexed fortressId, uint256 tokenId);
constructor() ERC721("WeiCards", "WEICARD") {}
function claimCard(uint8 cardId) external {
}
function wrap(uint8 cardId) external {
}
function unwrap(uint8 cardId) external {
require(<FILL_ME>)
_burn(cardId);
weiCardsContract.transferCardOwnership(msg.sender, cardId);
}
function sealTokenURI() external onlyOwner {
}
function setBaseTokenURI(string memory _baseTokenURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function contractURI() public pure returns (string memory) {
}
function editCard(
uint8 cardId,
string calldata title,
string calldata url,
string calldata image
) external {
}
}
| ownerOf(cardId)==msg.sender,"not owner" | 351,443 | ownerOf(cardId)==msg.sender |
"user is not whitelisted" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity >=0.7.0 <0.9.0;
contract PPAC is ERC721Enumerable, Ownable {
using Strings for uint256;
string baseURI;
string public baseExtension = ".json";
uint256 public cost = 0.05 ether;
uint256 public maxSupply = 1000;
uint256 public maxMintAmount = 100;
bool public paused = false;
bool public revealed = false;
string public notRevealedUri;
bool public onlyWhitelisted = true;
bytes32 merkleRoot;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri
) ERC721(_name, _symbol) {
}
function setMerkleRoot(bytes32 root) external onlyOwner {
}
function getMerkleRoot() external view returns (bytes32) {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function mint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable {
uint256 supply = totalSupply();
require(!paused);
require(_mintAmount > 0);
require(_mintAmount <= maxMintAmount);
require(supply + _mintAmount <= maxSupply);
if (msg.sender != owner()) {
if(onlyWhitelisted == true) {
require(<FILL_ME>)
}
require(msg.value >= cost * _mintAmount);
}
for (uint256 i = 1; i <= _mintAmount; i++) {
_safeMint(msg.sender, supply + i);
}
}
function isWhitelisted(bytes32[] calldata _merkleProof, address _user) public view returns (bool) {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
//only owner
function reveal() public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setMaxSupply(uint256 _newSupply) public onlyOwner {
}
function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function setOnlyWhitelisted(bool _state) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| isWhitelisted(_merkleProof,msg.sender),"user is not whitelisted" | 351,517 | isWhitelisted(_merkleProof,msg.sender) |
"Ether value sent is not correct" | // SPDX-License-Identifier: MIT
/*
_______ ___ ___ _______ __ _ _______ __ __ __ _ ___ _ _______ __ __ ___ __ _ _______ _______
| _ || | | | | || | | | | || | | || | | || | | | | || | | || | | | | || || |
| |_| || | | | | ___|| |_| | | _ || | | || |_| || |_| | |_ _|| |_| || | | |_| || ___|| _____|
| || | | | | |___ | | | |_| || |_| || || _| | | | || | | || | __ | |_____
| || |___ | | | ___|| _ | | ___|| || _ || |_ | | | || | | _ || || ||_____ |
| _ || || | | |___ | | | | | | | || | | || _ | | | | _ || | | | | || |_| | _____| |
|__| |__||_______||___| |_______||_| |__| |___| |_______||_| |__||___| |_| |___| |__| |__||___| |_| |__||_______||_______|
These aren't ordinary aliens...
8,888 Alien Punk Things
First 1500 are free, then 0.01 ETH
Alien Punk Things are 8,888 unique and randomly generated NFTs.
Traits are inspired by many NFTs including Cryptopunks, Alien Frens, Thingdoms, Cryptoadz, mfers, and more...
Benefits to holding an NFT include discounted minting price on our next evolution project, eligibility for NFT givaways.
Come join our welcoming community and Discord!
*/
pragma solidity ^0.8.0;
import "./lib/ERC721EnumerableLite.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
contract AlienPunkThings is ERC721EnumerableLite, Ownable, PaymentSplitter {
using Strings for uint256;
uint public _price = 0.015 ether;
uint public _max = 8888;
uint public _txnLimit = 20;
bool public _saleIsActive = false;
uint public _totalFree = 1500;
uint public _freeLimit = 3;
uint public _freeMinted = 0;
mapping(address => uint) public _freeTracker;
string private _tokenBaseURI;
address[] private addressList = [
0x0beAF25a1De14FAF9DB5BA0bad13B70267e3D01e,
0xBc3B2d37c5B32686b0804a7d6A317E15173d10A7,
0xe0478e355CAb72D60c31b9c73c2656826BC016F7
];
uint[] private shareList = [
45,
45,
10
];
constructor()
ERC721B("AlienPunkThings", "APT")
PaymentSplitter(addressList, shareList) {
}
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function flipSaleState() public onlyOwner {
}
function mint(uint total) public payable {
require(_saleIsActive, "Sale is not active");
require(total > 0, "Number to mint must be greater than 0");
require(total <= _txnLimit, "Over transaction limit");
require(<FILL_ME>)
uint256 supply = _owners.length;
require(supply + total <= _max, "Purchase would exceed max supply");
for(uint i = 0; i < total; i++) {
_safeMint(msg.sender, supply++);
}
}
function calcMintingFee(uint total) internal returns(uint cost) {
}
function freeMintsRemaining(address addr) public view returns(uint remaining) {
}
}
| calcMintingFee(total)<=msg.value,"Ether value sent is not correct" | 351,618 | calcMintingFee(total)<=msg.value |
"Purchase would exceed max supply" | // SPDX-License-Identifier: MIT
/*
_______ ___ ___ _______ __ _ _______ __ __ __ _ ___ _ _______ __ __ ___ __ _ _______ _______
| _ || | | | | || | | | | || | | || | | || | | | | || | | || | | | | || || |
| |_| || | | | | ___|| |_| | | _ || | | || |_| || |_| | |_ _|| |_| || | | |_| || ___|| _____|
| || | | | | |___ | | | |_| || |_| || || _| | | | || | | || | __ | |_____
| || |___ | | | ___|| _ | | ___|| || _ || |_ | | | || | | _ || || ||_____ |
| _ || || | | |___ | | | | | | | || | | || _ | | | | _ || | | | | || |_| | _____| |
|__| |__||_______||___| |_______||_| |__| |___| |_______||_| |__||___| |_| |___| |__| |__||___| |_| |__||_______||_______|
These aren't ordinary aliens...
8,888 Alien Punk Things
First 1500 are free, then 0.01 ETH
Alien Punk Things are 8,888 unique and randomly generated NFTs.
Traits are inspired by many NFTs including Cryptopunks, Alien Frens, Thingdoms, Cryptoadz, mfers, and more...
Benefits to holding an NFT include discounted minting price on our next evolution project, eligibility for NFT givaways.
Come join our welcoming community and Discord!
*/
pragma solidity ^0.8.0;
import "./lib/ERC721EnumerableLite.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
contract AlienPunkThings is ERC721EnumerableLite, Ownable, PaymentSplitter {
using Strings for uint256;
uint public _price = 0.015 ether;
uint public _max = 8888;
uint public _txnLimit = 20;
bool public _saleIsActive = false;
uint public _totalFree = 1500;
uint public _freeLimit = 3;
uint public _freeMinted = 0;
mapping(address => uint) public _freeTracker;
string private _tokenBaseURI;
address[] private addressList = [
0x0beAF25a1De14FAF9DB5BA0bad13B70267e3D01e,
0xBc3B2d37c5B32686b0804a7d6A317E15173d10A7,
0xe0478e355CAb72D60c31b9c73c2656826BC016F7
];
uint[] private shareList = [
45,
45,
10
];
constructor()
ERC721B("AlienPunkThings", "APT")
PaymentSplitter(addressList, shareList) {
}
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function flipSaleState() public onlyOwner {
}
function mint(uint total) public payable {
require(_saleIsActive, "Sale is not active");
require(total > 0, "Number to mint must be greater than 0");
require(total <= _txnLimit, "Over transaction limit");
require(calcMintingFee(total) <= msg.value, "Ether value sent is not correct");
uint256 supply = _owners.length;
require(<FILL_ME>)
for(uint i = 0; i < total; i++) {
_safeMint(msg.sender, supply++);
}
}
function calcMintingFee(uint total) internal returns(uint cost) {
}
function freeMintsRemaining(address addr) public view returns(uint remaining) {
}
}
| supply+total<=_max,"Purchase would exceed max supply" | 351,618 | supply+total<=_max |
"No more free mints available" | // SPDX-License-Identifier: MIT
/*
_______ ___ ___ _______ __ _ _______ __ __ __ _ ___ _ _______ __ __ ___ __ _ _______ _______
| _ || | | | | || | | | | || | | || | | || | | | | || | | || | | | | || || |
| |_| || | | | | ___|| |_| | | _ || | | || |_| || |_| | |_ _|| |_| || | | |_| || ___|| _____|
| || | | | | |___ | | | |_| || |_| || || _| | | | || | | || | __ | |_____
| || |___ | | | ___|| _ | | ___|| || _ || |_ | | | || | | _ || || ||_____ |
| _ || || | | |___ | | | | | | | || | | || _ | | | | _ || | | | | || |_| | _____| |
|__| |__||_______||___| |_______||_| |__| |___| |_______||_| |__||___| |_| |___| |__| |__||___| |_| |__||_______||_______|
These aren't ordinary aliens...
8,888 Alien Punk Things
First 1500 are free, then 0.01 ETH
Alien Punk Things are 8,888 unique and randomly generated NFTs.
Traits are inspired by many NFTs including Cryptopunks, Alien Frens, Thingdoms, Cryptoadz, mfers, and more...
Benefits to holding an NFT include discounted minting price on our next evolution project, eligibility for NFT givaways.
Come join our welcoming community and Discord!
*/
pragma solidity ^0.8.0;
import "./lib/ERC721EnumerableLite.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
contract AlienPunkThings is ERC721EnumerableLite, Ownable, PaymentSplitter {
using Strings for uint256;
uint public _price = 0.015 ether;
uint public _max = 8888;
uint public _txnLimit = 20;
bool public _saleIsActive = false;
uint public _totalFree = 1500;
uint public _freeLimit = 3;
uint public _freeMinted = 0;
mapping(address => uint) public _freeTracker;
string private _tokenBaseURI;
address[] private addressList = [
0x0beAF25a1De14FAF9DB5BA0bad13B70267e3D01e,
0xBc3B2d37c5B32686b0804a7d6A317E15173d10A7,
0xe0478e355CAb72D60c31b9c73c2656826BC016F7
];
uint[] private shareList = [
45,
45,
10
];
constructor()
ERC721B("AlienPunkThings", "APT")
PaymentSplitter(addressList, shareList) {
}
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function flipSaleState() public onlyOwner {
}
function mint(uint total) public payable {
}
function calcMintingFee(uint total) internal returns(uint cost) {
uint freeMints = 0;
if(_freeMinted < _totalFree && _freeTracker[msg.sender] < _freeLimit) {
freeMints = Math.min(_freeLimit, total);
freeMints = Math.min(freeMints, _freeLimit - _freeTracker[msg.sender]);
require(<FILL_ME>)
_freeTracker[msg.sender] += freeMints;
_freeMinted += freeMints;
}
return (total - freeMints) * _price;
}
function freeMintsRemaining(address addr) public view returns(uint remaining) {
}
}
| _freeMinted+freeMints<=_totalFree,"No more free mints available" | 351,618 | _freeMinted+freeMints<=_totalFree |
null | pragma solidity ^0.4.23;
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
/**
* @dev Allows the current owner to relinquish control of the contract.
*/
function renounceOwnership() public onlyOwner {
}
}
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Subtracts 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 c) {
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() onlyOwner whenNotPaused public {
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() onlyOwner whenPaused public {
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public returns (bool) {
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256) {
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(
address _spender,
uint _addedValue
)
public
returns (bool)
{
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
returns (bool)
{
}
}
contract PausableToken is StandardToken, Pausable {
function transfer(
address _to,
uint256 _value
)
public
whenNotPaused
returns (bool)
{
}
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
whenNotPaused
returns (bool)
{
}
function approve(
address _spender,
uint256 _value
)
public
whenNotPaused
returns (bool)
{
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
whenNotPaused
returns (bool success)
{
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
whenNotPaused
returns (bool success)
{
}
}
contract Spider is PausableToken{
string public name; //fancy name: eg Simon Bucks
uint8 public decimals; //How many decimals to show.
string public symbol; //An identifier: eg SBX
uint256 public exchangeRate; //0.1 eth
bool public sellPaused = false;
constructor(
uint256 _initialAmount
) public {
}
function setExchangeRate(uint256 x) public onlyOwner {
}
modifier whenSellNotPaused() {
require(<FILL_ME>)
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenSellPaused() {
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function sellpause() onlyOwner whenSellNotPaused public {
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unsellpause() onlyOwner whenSellPaused public {
}
function () payable whenSellNotPaused whenNotPaused public {
}
function withdrawAll () onlyOwner() public {
}
function withdrawAmount (uint256 _amount) onlyOwner() public {
}
}
| !sellPaused | 351,667 | !sellPaused |
"Transfer failed" | pragma solidity ^0.4.23;
contract BasicSecurityToken is ERC2980, Ownable, Issuable, DetailedERC20, MintableToken, BurnableToken, Frozenlist, Whitelist {
constructor(string memory name, string memory symbol, bool enableWhitelist)
Ownable()
DetailedERC20(name, symbol, 0)
Whitelist(enableWhitelist)
public {
}
//Modifiers
modifier onlyOwner() {
}
//Public functions (place the view and pure functions last)
function mint(address account, uint256 amount) public onlyOwner onlyIfNotFrozen(account) onlyIfWhitelisted(account) returns (bool) {
}
function burn(uint256 amount) public onlyIfNotFrozen(msg.sender) {
}
function burnFrom(address account, uint256 amount) public onlyIfNotFrozen(account) {
}
function transfer(address recipient, uint256 amount) public onlyIfNotFrozen(msg.sender) onlyIfNotFrozen(recipient) onlyIfWhitelisted(recipient) returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public onlyIfNotFrozen(sender) onlyIfNotFrozen(recipient) onlyIfWhitelisted(recipient) returns (bool) {
require(<FILL_ME>)
return true;
}
function reassign(address from, address to) public onlyIssuer {
}
function revoke(address from) public onlyIssuer {
}
//Internal functions
function _transfer(address _from, address _to, uint256 _value) public returns (bool) {
}
//Private functions
}
| super.transferFrom(sender,recipient,amount),"Transfer failed" | 351,706 | super.transferFrom(sender,recipient,amount) |
null | pragma solidity ^0.4.23;
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) {
}
}
interface tokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public;
}
contract KYRIOSToken {
using SafeMath for uint256;
string public name = "KYRIOS Token";
string public symbol = "KRS";
uint8 public decimals = 18;
uint256 public totalSupply = 2000000000 ether;
uint256 public totalAirDrop = totalSupply * 10 / 100;
uint256 public eachAirDropAmount = 25000 ether;
bool public airdropFinished = false;
mapping (address => bool) public airDropBlacklist;
mapping (address => bool) public transferBlacklist;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function KYRIOSToken() public {
}
modifier canAirDrop() {
require(<FILL_ME>)
_;
}
modifier onlyWhitelist() {
}
function airDrop(address _to, uint256 _amount) canAirDrop private returns (bool) {
}
function inspire(address _to, uint256 _amount) private returns (bool) {
}
function getAirDropTokens() payable canAirDrop onlyWhitelist public {
}
function getInspireTokens(address _from, address _to,uint256 _amount) payable public{
}
function () external payable {
}
function _transfer(address _from, address _to, uint _value) internal {
}
function transfer(address _to, uint256 _value) public {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
function approve(address _spender, uint256 _value) public returns (bool success) {
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
}
function burn(uint256 _value) public returns (bool success) {
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
}
}
| !airdropFinished | 351,783 | !airdropFinished |
null | pragma solidity ^0.4.23;
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) {
}
}
interface tokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public;
}
contract KYRIOSToken {
using SafeMath for uint256;
string public name = "KYRIOS Token";
string public symbol = "KRS";
uint8 public decimals = 18;
uint256 public totalSupply = 2000000000 ether;
uint256 public totalAirDrop = totalSupply * 10 / 100;
uint256 public eachAirDropAmount = 25000 ether;
bool public airdropFinished = false;
mapping (address => bool) public airDropBlacklist;
mapping (address => bool) public transferBlacklist;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function KYRIOSToken() public {
}
modifier canAirDrop() {
}
modifier onlyWhitelist() {
require(<FILL_ME>)
_;
}
function airDrop(address _to, uint256 _amount) canAirDrop private returns (bool) {
}
function inspire(address _to, uint256 _amount) private returns (bool) {
}
function getAirDropTokens() payable canAirDrop onlyWhitelist public {
}
function getInspireTokens(address _from, address _to,uint256 _amount) payable public{
}
function () external payable {
}
function _transfer(address _from, address _to, uint _value) internal {
}
function transfer(address _to, uint256 _value) public {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
function approve(address _spender, uint256 _value) public returns (bool success) {
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
}
function burn(uint256 _value) public returns (bool success) {
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
}
}
| airDropBlacklist[msg.sender]==false | 351,783 | airDropBlacklist[msg.sender]==false |
null | pragma solidity ^0.4.18;
//>> Reference to https://github.com/OpenZeppelin/zeppelin-solidity
/**
* @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) {
}
}
//<< Reference to https://github.com/OpenZeppelin/zeppelin-solidity
contract Coin {
function sell(address _to, uint256 _value, string _note) public returns (bool);
}
/**
* @title MultiOwnable
*/
contract MultiOwnable {
address public root;
mapping (address => address) public owners; // owner => parent of owner
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function MultiOwnable() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(<FILL_ME>)
_;
}
/**
* @dev Adding new owners
*/
function newOwner(address _owner) onlyOwner public returns (bool) {
}
/**
* @dev Deleting owners
*/
function deleteOwner(address _owner) onlyOwner public returns (bool) {
}
}
/**
* @title KStarCoinSale
* @author Tae Kim
* @notice This contract is for crowdfunding of KStarCoin.
*/
contract KStarCoinSale is MultiOwnable {
using SafeMath for uint256;
eICOLevel public level;
uint256 public rate;
uint256 public minWei;
function checkValidLevel(eICOLevel _level) public pure returns (bool) {
}
modifier onSale() {
}
enum eICOLevel { C_ICO_PRESALE, C_ICO_ONSALE, C_ICO_END }
Coin public coin;
address public wallet;
// Constructure
function KStarCoinSale(Coin _coin, address _wallet) public {
}
// Update variables related to crowdfunding
function updateICOVars(eICOLevel _level, uint _rate, uint _minWei) onlyOwner public returns (bool) {
}
function () external payable {
}
function buyCoin(address beneficiary) onSale public payable {
}
function getCoinAmount(uint256 weiAmount) internal view returns(uint256) {
}
// send ether to the fund collection wallet
function forwardFunds() internal {
}
event ICOVarsChange(eICOLevel level, uint256 rate, uint256 minWei);
}
| owners[msg.sender]!=0 | 351,830 | owners[msg.sender]!=0 |
null | pragma solidity ^0.4.18;
//>> Reference to https://github.com/OpenZeppelin/zeppelin-solidity
/**
* @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) {
}
}
//<< Reference to https://github.com/OpenZeppelin/zeppelin-solidity
contract Coin {
function sell(address _to, uint256 _value, string _note) public returns (bool);
}
/**
* @title MultiOwnable
*/
contract MultiOwnable {
address public root;
mapping (address => address) public owners; // owner => parent of owner
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function MultiOwnable() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Adding new owners
*/
function newOwner(address _owner) onlyOwner public returns (bool) {
}
/**
* @dev Deleting owners
*/
function deleteOwner(address _owner) onlyOwner public returns (bool) {
require(<FILL_ME>)
owners[_owner]= 0;
return true;
}
}
/**
* @title KStarCoinSale
* @author Tae Kim
* @notice This contract is for crowdfunding of KStarCoin.
*/
contract KStarCoinSale is MultiOwnable {
using SafeMath for uint256;
eICOLevel public level;
uint256 public rate;
uint256 public minWei;
function checkValidLevel(eICOLevel _level) public pure returns (bool) {
}
modifier onSale() {
}
enum eICOLevel { C_ICO_PRESALE, C_ICO_ONSALE, C_ICO_END }
Coin public coin;
address public wallet;
// Constructure
function KStarCoinSale(Coin _coin, address _wallet) public {
}
// Update variables related to crowdfunding
function updateICOVars(eICOLevel _level, uint _rate, uint _minWei) onlyOwner public returns (bool) {
}
function () external payable {
}
function buyCoin(address beneficiary) onSale public payable {
}
function getCoinAmount(uint256 weiAmount) internal view returns(uint256) {
}
// send ether to the fund collection wallet
function forwardFunds() internal {
}
event ICOVarsChange(eICOLevel level, uint256 rate, uint256 minWei);
}
| owners[_owner]==msg.sender||(owners[_owner]!=0&&msg.sender==root) | 351,830 | owners[_owner]==msg.sender||(owners[_owner]!=0&&msg.sender==root) |
null | pragma solidity ^0.4.18;
//>> Reference to https://github.com/OpenZeppelin/zeppelin-solidity
/**
* @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) {
}
}
//<< Reference to https://github.com/OpenZeppelin/zeppelin-solidity
contract Coin {
function sell(address _to, uint256 _value, string _note) public returns (bool);
}
/**
* @title MultiOwnable
*/
contract MultiOwnable {
address public root;
mapping (address => address) public owners; // owner => parent of owner
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function MultiOwnable() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Adding new owners
*/
function newOwner(address _owner) onlyOwner public returns (bool) {
}
/**
* @dev Deleting owners
*/
function deleteOwner(address _owner) onlyOwner public returns (bool) {
}
}
/**
* @title KStarCoinSale
* @author Tae Kim
* @notice This contract is for crowdfunding of KStarCoin.
*/
contract KStarCoinSale is MultiOwnable {
using SafeMath for uint256;
eICOLevel public level;
uint256 public rate;
uint256 public minWei;
function checkValidLevel(eICOLevel _level) public pure returns (bool) {
}
modifier onSale() {
}
enum eICOLevel { C_ICO_PRESALE, C_ICO_ONSALE, C_ICO_END }
Coin public coin;
address public wallet;
// Constructure
function KStarCoinSale(Coin _coin, address _wallet) public {
}
// Update variables related to crowdfunding
function updateICOVars(eICOLevel _level, uint _rate, uint _minWei) onlyOwner public returns (bool) {
require(<FILL_ME>)
require(_rate != 0);
require(_minWei >= 1 szabo);
level= _level;
rate= _rate;
minWei= _minWei;
ICOVarsChange(level, rate, minWei);
return true;
}
function () external payable {
}
function buyCoin(address beneficiary) onSale public payable {
}
function getCoinAmount(uint256 weiAmount) internal view returns(uint256) {
}
// send ether to the fund collection wallet
function forwardFunds() internal {
}
event ICOVarsChange(eICOLevel level, uint256 rate, uint256 minWei);
}
| checkValidLevel(_level) | 351,830 | checkValidLevel(_level) |
"Could not transfer Tokens." | pragma solidity ^0.6.12;
// SPDX-License-Identifier: MIT
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 public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) onlyOwner public {
}
}
interface YfDFI {
function balanceOf(address) external returns (uint);
function transferFrom(address, address, uint) external returns (bool);
function transfer(address, uint) external returns (bool);
}
contract YFDFI_LockingFarmingTokens is Ownable {
using SafeMath for uint;
address public constant tokenAddress = 0x4F4F0Ef7978737ce928BFF395529161b44e27ad9;
uint public constant tokensLocked = 5000e18; // 5000 YFD Tokens
uint public constant unlockRate = 5000;
uint public constant lockDuration = 6 days; // Farming Platform Release
uint public lastClaimedTime;
uint public deployTime;
constructor() public {
}
function claim() public onlyOwner {
uint pendingUnlocked = getPendingUnlocked();
uint contractBalance = YfDFI(tokenAddress).balanceOf(address(this));
uint amountToSend = pendingUnlocked;
if (contractBalance < pendingUnlocked) {
amountToSend = contractBalance;
}
require(<FILL_ME>)
lastClaimedTime = now;
}
function getPendingUnlocked() public view returns (uint) {
}
// function to allow admin to claim *other* ERC20 tokens sent to this contract (by mistake)
function transferAnyERC20Tokens(address _tokenAddr, address _to, uint _amount) public onlyOwner {
}
}
| YfDFI(tokenAddress).transfer(owner,amountToSend),"Could not transfer Tokens." | 352,074 | YfDFI(tokenAddress).transfer(owner,amountToSend) |
null | /// @title Store lederboards in the Blockchain
/// @author Marcel Scherello [email protected]
/// @notice Create a custom leaderboard and start counting the scores
/// @dev All function calls are currently implement without side effects
/// @dev v1.1.0
contract BlockScores {
struct Player {
bytes32 playerName;
address playerAddress;
uint score;
uint score_unconfirmed;
uint isActive;
}
struct Board {
bytes32 boardName;
string boardDescription;
uint numPlayers;
address boardOwner;
mapping (uint => Player) players;
}
mapping (bytes32 => Board) boards;
uint public numBoards;
address owner = msg.sender;
uint public balance;
uint public boardCost = 1000000000000000;
uint public playerCost = 1000000000000000;
modifier isOwner {
}
/**
Funding Functions
*/
/// @notice withdraw all funds to contract owner
/// @return true
function withdraw() isOwner public returns(bool) {
}
/// @notice change the costs for using the contract
/// @param costBoard costs for a new board
/// @param costPlayer costs for a new player
/// @return true
function setCosts (uint costBoard, uint costPlayer) isOwner public returns(bool) {
}
/// @notice split the revenue of a new player between boardOwner and contract owner
/// @param boardOwner of the leaderboard
/// @param _amount amount to be split
/// @return true
function split(address boardOwner, uint _amount) internal returns(bool) {
}
/// @notice Event for Withdrawal
event Withdrawal(address indexed _from, uint _value);
/**
Board Functions
*/
/// @notice Add a new leaderboard. Board hash will be created by name and creator
/// @notice a funding is required to create a new leaderboard
/// @param name The name of the leaderboard
/// @param boardDescription A subtitle for the leaderboard
/// @return The hash of the newly created leaderboard
function addNewBoard(bytes32 name, string boardDescription) public payable returns(bytes32 boardHash){
}
/// @notice Simulate the creation of a leaderboard hash
/// @param name The name of the leaderboard
/// @param admin The address of the admin address
/// @return The possible hash of the leaderboard
function createBoardHash(bytes32 name, address admin) pure public returns (bytes32){
}
/// @notice Get the metadata of a leaderboard
/// @param boardHash The hash of the leaderboard
/// @return Leaderboard name, description and number of players
function getBoardByHash(bytes32 boardHash) constant public returns(bytes32,string,uint){
}
/// @notice Overwrite leaderboard name and desctiption as owner only
/// @param boardHash The hash of the leaderboard to be modified
/// @param name The new name of the leaderboard
/// @param boardDescription The new subtitle for the leaderboard
/// @return true
function changeBoardMetadata(bytes32 boardHash, bytes32 name, string boardDescription) public returns(bool) {
require(<FILL_ME>)
boards[boardHash].boardName = name;
boards[boardHash].boardDescription = boardDescription;
}
/// @notice event for newly created leaderboard
event newBoardCreated(bytes32 boardHash);
/**
Player Functions
*/
/// @notice Add a new player to an existing leaderboard
/// @param boardHash The hash of the leaderboard
/// @param playerName The name of the player
/// @return Player ID
function addPlayerToBoard(bytes32 boardHash, bytes32 playerName) public payable returns (bool) {
}
/// @notice Get player data by leaderboard hash and player id/index
/// @param boardHash The hash of the leaderboard
/// @param playerID Index number of the player
/// @return Player name, confirmed score, unconfirmed score
function getPlayerByBoard(bytes32 boardHash, uint8 playerID) constant public returns (bytes32, uint, uint){
}
/// @notice The leaderboard owner can remove a player
/// @param boardHash The hash of the leaderboard
/// @param playerName The name of the player to be removed
/// @return true/false
function removePlayerFromBoard(bytes32 boardHash, bytes32 playerName) public returns (bool){
}
/// @notice Get the player id either by player Name or address
/// @param boardHash The hash of the leaderboard
/// @param playerName The name of the player
/// @param playerAddress The player address
/// @return ID or 999 in case of false
function getPlayerId (bytes32 boardHash, bytes32 playerName, address playerAddress) constant internal returns (uint8) {
}
/**
Score Functions
*/
/// @notice Add a unconfirmed score to leaderboard/player. Overwrites an existing unconfirmed score
/// @param boardHash The hash of the leaderboard
/// @param playerName The name of the player
/// @param score Integer
/// @return true/false
function addBoardScore(bytes32 boardHash, bytes32 playerName, uint score) public returns (bool){
}
/// @notice Confirm an unconfirmed score to leaderboard/player. Adds unconfirmed to existing score. Player can not confirm his own score
/// @param boardHash The hash of the leaderboard
/// @param playerName The name of the player who's score should be confirmed
/// @return true/false
function confirmBoardScore(bytes32 boardHash, bytes32 playerName) public returns (bool){
}
/**
Migration Functions
*/
/// @notice Read board metadata for migration as contract owner only
/// @param boardHash The hash of the leaderboard
/// @return Bord metadata
function migrationGetBoard(bytes32 boardHash) constant isOwner public returns(bytes32,string,uint,address) {
}
/// @notice Write board metadata for migration as contract owner only
/// @param boardHash The hash of the leaderboard to be modified
/// @param name The new name of the leaderboard
/// @param boardDescription The new subtitle for the leaderboard
/// @param boardOwner The address for the boardowner
/// @return true
function migrationSetBoard(bytes32 boardHash, bytes32 name, string boardDescription, uint8 numPlayers, address boardOwner) isOwner public returns(bool) {
}
/// @notice Read player metadata for migration as contract owner
/// @param boardHash The hash of the leaderboard
/// @param playerID Index number of the player
/// @return Player metadata
function migrationGetPlayer(bytes32 boardHash, uint8 playerID) constant isOwner public returns (uint, bytes32, address, uint, uint, uint){
}
/// @notice Write player metadata for migration as contract owner only
/// @param boardHash The hash of the leaderboard
/// @param playerID Player ID
/// @param playerName Player name
/// @param playerAddress Player address
/// @param score Player score
/// @param score_unconfirmed Player unconfirmed score
/// @param isActive Player isActive
/// @return true
function migrationSetPlayer(bytes32 boardHash, uint playerID, bytes32 playerName, address playerAddress, uint score, uint score_unconfirmed, uint isActive) isOwner public returns (bool) {
}
}
| boards[boardHash].boardOwner==msg.sender | 352,138 | boards[boardHash].boardOwner==msg.sender |
null | /// @title Store lederboards in the Blockchain
/// @author Marcel Scherello [email protected]
/// @notice Create a custom leaderboard and start counting the scores
/// @dev All function calls are currently implement without side effects
/// @dev v1.1.0
contract BlockScores {
struct Player {
bytes32 playerName;
address playerAddress;
uint score;
uint score_unconfirmed;
uint isActive;
}
struct Board {
bytes32 boardName;
string boardDescription;
uint numPlayers;
address boardOwner;
mapping (uint => Player) players;
}
mapping (bytes32 => Board) boards;
uint public numBoards;
address owner = msg.sender;
uint public balance;
uint public boardCost = 1000000000000000;
uint public playerCost = 1000000000000000;
modifier isOwner {
}
/**
Funding Functions
*/
/// @notice withdraw all funds to contract owner
/// @return true
function withdraw() isOwner public returns(bool) {
}
/// @notice change the costs for using the contract
/// @param costBoard costs for a new board
/// @param costPlayer costs for a new player
/// @return true
function setCosts (uint costBoard, uint costPlayer) isOwner public returns(bool) {
}
/// @notice split the revenue of a new player between boardOwner and contract owner
/// @param boardOwner of the leaderboard
/// @param _amount amount to be split
/// @return true
function split(address boardOwner, uint _amount) internal returns(bool) {
}
/// @notice Event for Withdrawal
event Withdrawal(address indexed _from, uint _value);
/**
Board Functions
*/
/// @notice Add a new leaderboard. Board hash will be created by name and creator
/// @notice a funding is required to create a new leaderboard
/// @param name The name of the leaderboard
/// @param boardDescription A subtitle for the leaderboard
/// @return The hash of the newly created leaderboard
function addNewBoard(bytes32 name, string boardDescription) public payable returns(bytes32 boardHash){
}
/// @notice Simulate the creation of a leaderboard hash
/// @param name The name of the leaderboard
/// @param admin The address of the admin address
/// @return The possible hash of the leaderboard
function createBoardHash(bytes32 name, address admin) pure public returns (bytes32){
}
/// @notice Get the metadata of a leaderboard
/// @param boardHash The hash of the leaderboard
/// @return Leaderboard name, description and number of players
function getBoardByHash(bytes32 boardHash) constant public returns(bytes32,string,uint){
}
/// @notice Overwrite leaderboard name and desctiption as owner only
/// @param boardHash The hash of the leaderboard to be modified
/// @param name The new name of the leaderboard
/// @param boardDescription The new subtitle for the leaderboard
/// @return true
function changeBoardMetadata(bytes32 boardHash, bytes32 name, string boardDescription) public returns(bool) {
}
/// @notice event for newly created leaderboard
event newBoardCreated(bytes32 boardHash);
/**
Player Functions
*/
/// @notice Add a new player to an existing leaderboard
/// @param boardHash The hash of the leaderboard
/// @param playerName The name of the player
/// @return Player ID
function addPlayerToBoard(bytes32 boardHash, bytes32 playerName) public payable returns (bool) {
}
/// @notice Get player data by leaderboard hash and player id/index
/// @param boardHash The hash of the leaderboard
/// @param playerID Index number of the player
/// @return Player name, confirmed score, unconfirmed score
function getPlayerByBoard(bytes32 boardHash, uint8 playerID) constant public returns (bytes32, uint, uint){
}
/// @notice The leaderboard owner can remove a player
/// @param boardHash The hash of the leaderboard
/// @param playerName The name of the player to be removed
/// @return true/false
function removePlayerFromBoard(bytes32 boardHash, bytes32 playerName) public returns (bool){
}
/// @notice Get the player id either by player Name or address
/// @param boardHash The hash of the leaderboard
/// @param playerName The name of the player
/// @param playerAddress The player address
/// @return ID or 999 in case of false
function getPlayerId (bytes32 boardHash, bytes32 playerName, address playerAddress) constant internal returns (uint8) {
}
/**
Score Functions
*/
/// @notice Add a unconfirmed score to leaderboard/player. Overwrites an existing unconfirmed score
/// @param boardHash The hash of the leaderboard
/// @param playerName The name of the player
/// @param score Integer
/// @return true/false
function addBoardScore(bytes32 boardHash, bytes32 playerName, uint score) public returns (bool){
}
/// @notice Confirm an unconfirmed score to leaderboard/player. Adds unconfirmed to existing score. Player can not confirm his own score
/// @param boardHash The hash of the leaderboard
/// @param playerName The name of the player who's score should be confirmed
/// @return true/false
function confirmBoardScore(bytes32 boardHash, bytes32 playerName) public returns (bool){
uint8 playerID = getPlayerId (boardHash, playerName, 0);
uint8 confirmerID = getPlayerId (boardHash, "", msg.sender);
require(playerID < 255); // player needs to be active
require(confirmerID < 255); // confirmer needs to be active
require(<FILL_ME>) //confirm only other players
boards[boardHash].players[playerID].score += boards[boardHash].players[playerID].score_unconfirmed;
boards[boardHash].players[playerID].score_unconfirmed = 0;
return true;
}
/**
Migration Functions
*/
/// @notice Read board metadata for migration as contract owner only
/// @param boardHash The hash of the leaderboard
/// @return Bord metadata
function migrationGetBoard(bytes32 boardHash) constant isOwner public returns(bytes32,string,uint,address) {
}
/// @notice Write board metadata for migration as contract owner only
/// @param boardHash The hash of the leaderboard to be modified
/// @param name The new name of the leaderboard
/// @param boardDescription The new subtitle for the leaderboard
/// @param boardOwner The address for the boardowner
/// @return true
function migrationSetBoard(bytes32 boardHash, bytes32 name, string boardDescription, uint8 numPlayers, address boardOwner) isOwner public returns(bool) {
}
/// @notice Read player metadata for migration as contract owner
/// @param boardHash The hash of the leaderboard
/// @param playerID Index number of the player
/// @return Player metadata
function migrationGetPlayer(bytes32 boardHash, uint8 playerID) constant isOwner public returns (uint, bytes32, address, uint, uint, uint){
}
/// @notice Write player metadata for migration as contract owner only
/// @param boardHash The hash of the leaderboard
/// @param playerID Player ID
/// @param playerName Player name
/// @param playerAddress Player address
/// @param score Player score
/// @param score_unconfirmed Player unconfirmed score
/// @param isActive Player isActive
/// @return true
function migrationSetPlayer(bytes32 boardHash, uint playerID, bytes32 playerName, address playerAddress, uint score, uint score_unconfirmed, uint isActive) isOwner public returns (bool) {
}
}
| boards[boardHash].players[playerID].playerAddress!=msg.sender | 352,138 | boards[boardHash].players[playerID].playerAddress!=msg.sender |
"No change in strategy balance" | // zsTokens are Stabilize proxy tokens that serve as receipts for deposits into Stabilize strategies
// zsTokens should increase in value if the strategy it uses is profitable
// When someone deposits into the zsToken contract, tokens are minted and when they redeem, tokens are burned
interface StabilizeStrategy {
function rewardTokensCount() external view returns (uint256);
function rewardTokenAddress(uint256) external view returns (address);
function balance() external view returns (uint256);
function pricePerToken() external view returns (uint256);
function enter() external;
function exit() external;
function deposit(address) external;
function withdraw(address, uint256, uint256) external returns (uint256); // Will withdraw to the address specified a percent of total shares
}
pragma solidity ^0.6.6;
contract zsToken is ERC20("Stabilize Strategy UNI ETH/USDT LP Token", "zs-ETHUSDT"), Ownable {
using SafeERC20 for IERC20;
// Variables
uint256 constant divisionFactor = 100000;
// There are no fees to deposit and withdraw from the zs-Tokens
// Token information
IERC20 private _underlyingAsset; // Token of the deposited asset
address private _underlyingPriceAsset; // The stablecoin used by the proxy token for price reference
bool public depositsOpen = true; // Governance can open or close deposits without timelock, cannot block withdrawals
// Strategy information
StabilizeStrategy private currentStrategy; // This will be the contract for the strategy
address private _pendingStrategy;
// Events
event Wrapped(address indexed user, uint256 amount);
event Unwrapped(address indexed user, uint256 amount);
constructor (IERC20 _asset, address _underlyingStable) public {
}
function getCurrentStrategy() external view returns (address) {
}
function getPendingStrategy() external view returns (address) {
}
function underlyingAsset() public view returns (address) {
}
function underlyingLPAsset() public view returns (address) {
}
function pricePerToken() public view returns (uint256) {
}
function valueOfVaultAndStrategy() public view returns (uint256) {
}
// Now handle deposits into the strategy
function deposit(uint256 amount) public {
uint256 total = valueOfVaultAndStrategy(); // Get token equivalent at strategy and here if applicable
require(currentStrategy != StabilizeStrategy(address(0)),"No strategy contract has been selected yet");
require(depositsOpen == true, "Deposits have been suspended, but you can still withdraw");
uint256 _before = _underlyingAsset.balanceOf(address(this));
_underlyingAsset.safeTransferFrom(_msgSender(), address(this), amount); // Transfer token to this address
amount = _underlyingAsset.balanceOf(address(this)).sub(_before); // Some tokens lose amount (transfer fee) upon transfer
require(amount > 0, "Cannot deposit 0");
uint256 _strategyBalance = currentStrategy.balance(); // Will get the balance of the value of the main tokens at the strategy
// Now call the strategy to deposit
_underlyingAsset.safeTransfer(address(currentStrategy), amount); // Transfer again into the strategy
currentStrategy.deposit(_msgSender()); // Activate strategy deposit
require(<FILL_ME>) // Balance should increase
uint256 mintAmount = amount;
if(totalSupply() > 0){
// There is already a balance here, calculate our share
mintAmount = amount.mul(totalSupply()).div(total); // Our share of the total
}
_mint(_msgSender(),mintAmount); // Now mint new zs-token to the depositor
emit Wrapped(_msgSender(), amount);
}
function redeem(uint256 share) public {
}
// Governance functions
// Stop/start all deposits, no timelock required
// --------------------
function stopDeposits() external onlyGovernance {
}
function startDeposits() external onlyGovernance {
}
// A function used in case of strategy failure, possibly due to bug in theplatform our strategy is using, governance can stop using it quick
function emergencyStopStrategy() external onlyGovernance {
}
// --------------------
// Timelock variables
uint256 private _timelockStart; // The start of the timelock to change governance variables
uint256 private _timelockType; // The function that needs to be changed
uint256 constant _timelockDuration = 86400; // Timelock is 24 hours
// Reusable timelock variables
address private _timelock_address;
modifier timelockConditionsMet(uint256 _type) {
}
// Change the owner of the token contract
// --------------------
function startGovernanceChange(address _address) external onlyGovernance {
}
function finishGovernanceChange() external onlyGovernance timelockConditionsMet(1) {
}
// --------------------
// Change the treasury address
// --------------------
function startChangeStrategy(address _address) external onlyGovernance {
}
function finishChangeStrategy() public onlyGovernance timelockConditionsMet(2) {
}
function pushTokensToStrategy() internal {
}
// --------------------
}
| currentStrategy.balance()>_strategyBalance,"No change in strategy balance" | 352,223 | currentStrategy.balance()>_strategyBalance |
"This address is already registered." | pragma solidity ^0.5.0; // solidity 0.5.2
import "./SafeMath.sol";
/**
* @title MultiOwnable
* dev
*/
contract MultiOwnable {
using SafeMath for uint256;
address public root; // 혹시 몰라 준비해둔 superOwner 의 백업. 하드웨어 월렛 주소로 세팅할 예정.
address public superOwner;
mapping (address => bool) public owners;
address[] public ownerList;
// for changeSuperOwnerByDAO
// mapping(address => mapping (address => bool)) public preSuperOwnerMap;
mapping(address => address) public candidateSuperOwnerMap;
event ChangedRoot(address newRoot);
event ChangedSuperOwner(address newSuperOwner);
event AddedNewOwner(address newOwner);
event DeletedOwner(address deletedOwner);
constructor() public {
}
modifier onlyRoot() {
}
modifier onlySuperOwner() {
}
modifier onlyOwner() {
}
/**
* dev root 교체 (root 는 root 와 superOwner 를 교체할 수 있는 권리가 있다.)
* dev 기존 루트가 관리자에서 지워지지 않고, 새 루트가 자동으로 관리자에 등록되지 않음을 유의!
*/
function changeRoot(address newRoot) onlyRoot public returns (bool) {
}
/**
* dev superOwner 교체 (root 는 root 와 superOwner 를 교체할 수 있는 권리가 있다.)
* dev 기존 superOwner 가 관리자에서 지워지지 않고, 새 superOwner 가 자동으로 관리자에 등록되지 않음을 유의!
*/
function changeSuperOwner(address newSuperOwner) onlyRoot public returns (bool) {
}
/**
* dev owner 들의 1/2 초과가 합의하면 superOwner 를 교체할 수 있다.
*/
function changeSuperOwnerByDAO(address newSuperOwner) onlyOwner public returns (bool) {
}
function newOwner(address owner) onlySuperOwner public returns (bool) {
require(owner != address(0), "This address to be set is zero address(0). Check the input address.");
require(<FILL_ME>)
owners[owner] = true;
ownerList.push(owner);
emit AddedNewOwner(owner);
return true;
}
function deleteOwner(address owner) onlySuperOwner public returns (bool) {
}
}
| !owners[owner],"This address is already registered." | 352,309 | !owners[owner] |
"This input address is not a super owner." | pragma solidity ^0.5.0; // solidity 0.5.2
import "./SafeMath.sol";
/**
* @title MultiOwnable
* dev
*/
contract MultiOwnable {
using SafeMath for uint256;
address public root; // 혹시 몰라 준비해둔 superOwner 의 백업. 하드웨어 월렛 주소로 세팅할 예정.
address public superOwner;
mapping (address => bool) public owners;
address[] public ownerList;
// for changeSuperOwnerByDAO
// mapping(address => mapping (address => bool)) public preSuperOwnerMap;
mapping(address => address) public candidateSuperOwnerMap;
event ChangedRoot(address newRoot);
event ChangedSuperOwner(address newSuperOwner);
event AddedNewOwner(address newOwner);
event DeletedOwner(address deletedOwner);
constructor() public {
}
modifier onlyRoot() {
}
modifier onlySuperOwner() {
}
modifier onlyOwner() {
}
/**
* dev root 교체 (root 는 root 와 superOwner 를 교체할 수 있는 권리가 있다.)
* dev 기존 루트가 관리자에서 지워지지 않고, 새 루트가 자동으로 관리자에 등록되지 않음을 유의!
*/
function changeRoot(address newRoot) onlyRoot public returns (bool) {
}
/**
* dev superOwner 교체 (root 는 root 와 superOwner 를 교체할 수 있는 권리가 있다.)
* dev 기존 superOwner 가 관리자에서 지워지지 않고, 새 superOwner 가 자동으로 관리자에 등록되지 않음을 유의!
*/
function changeSuperOwner(address newSuperOwner) onlyRoot public returns (bool) {
}
/**
* dev owner 들의 1/2 초과가 합의하면 superOwner 를 교체할 수 있다.
*/
function changeSuperOwnerByDAO(address newSuperOwner) onlyOwner public returns (bool) {
}
function newOwner(address owner) onlySuperOwner public returns (bool) {
}
function deleteOwner(address owner) onlySuperOwner public returns (bool) {
require(<FILL_ME>)
delete owners[owner];
for (uint256 i = 0; i < ownerList.length; i++) {
if (ownerList[i] == owner) {
ownerList[i] = ownerList[ownerList.length.sub(1)];
ownerList.length = ownerList.length.sub(1);
break;
}
}
emit DeletedOwner(owner);
return true;
}
}
| owners[owner],"This input address is not a super owner." | 352,309 | owners[owner] |
"You need to stake before getting rewards!" | // Rizencoin is a both deflationary and inflationary currency, designed to reward holders & stakers , pump price, and for sound economy.
// Rizen is a community-driven Defi project with unique staking & holding model.
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 add(uint a, uint b) public pure returns (uint c) {
}
function sub(uint a, uint b) public pure returns (uint c) {
}
function mul(uint a, uint b) public pure returns (uint c) {
}
function div(uint a, uint b) public pure returns (uint c) {
}
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function isOwner() public view returns (bool) {
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
}
function name() public view returns(string memory) {
}
function symbol() public view returns(string memory) {
}
function decimals() public view returns(uint8) {
}
}
contract RizenCoin is ERC20Detailed, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 public constant ONE_WEEK = 7 days;
mapping (address => uint256) private _lastWeeklyRewardDate;
// bool _isStakingStarted = false;
// address _stakingContract;
mapping (address => uint256) private _stakes;
mapping (address => uint256) private _stakeRewardsPaid;
uint256 _totalStaked = 0;
uint256 _totalStakingRewardAmount = 0;
uint256 _totalStakingRewardPaid = 0;
string constant tokenName = "Rizen Coin";
string constant tokenSymbol = "RZN";
uint8 constant tokenDecimals = 18;
uint256 _totalSupply = 5000 * (10 ** 18); // 5000
event Staked(address account, uint256 amount);
event Unstaked(address account, uint256 amount);
event RewardWithdrawn(address account, uint256 amount);
constructor() public ERC20Detailed(tokenName, tokenSymbol, tokenDecimals) {
}
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function allowance(address owner, address spender) 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 _transfer(address from, address to, uint256 value) internal {
}
/*
Staking logic and functions
*/
function totalStaked() public view returns (uint256) {
}
function stakesOf(address account) public view returns (uint256) {
}
function stakingRewardAmount() public view returns (uint256) {
}
function rewardsOnPoolOf(address account) public view returns (uint256) {
}
function paidRewardsOf(address account) public view returns (uint256) {
}
function stake(uint256 amount) external {
}
function unstake(uint256 amount) external {
}
function getStakingRewards() external {
require(<FILL_ME>)
require(_totalStakingRewardAmount > _totalStakingRewardPaid, "All the staking rewards paid for now, come back later!");
uint256 rewards = _totalStakingRewardAmount.mul(_stakes[msg.sender]).div(_totalStaked);
require(rewards > _stakeRewardsPaid[msg.sender], "You earned all the rewards!");
uint256 rewardsForWithdraw = rewards.sub(_stakeRewardsPaid[msg.sender]);
_stakeRewardsPaid[msg.sender] = _stakeRewardsPaid[msg.sender].add(rewardsForWithdraw);
_totalStakingRewardPaid = _totalStakingRewardPaid.add(rewardsForWithdraw);
uint256 tax = rewardsForWithdraw.div(100);
_balances[msg.sender] = _balances[msg.sender].add(rewardsForWithdraw.sub(tax));
_burn(address(this), tax);
emit RewardWithdrawn(msg.sender, rewardsForWithdraw);
}
function addRewardTokens(uint256 amount) external onlyOwner {
}
function burn(uint256 amount) external {
}
function _burn(address account, uint256 amount) internal {
}
function _mint(address account, uint256 amount) internal onlyOwner {
}
function getWeeklyReward() external {
}
}
| _stakes[msg.sender]>0,"You need to stake before getting rewards!" | 352,352 | _stakes[msg.sender]>0 |
"Sold Out" | pragma solidity ^0.8.0;
contract MVRSNFT is ERC721, ERC721Enumerable, Ownable, Pausable {
using SafeMath for uint256;
using Strings for uint256;
using SafeERC20 for IERC20;
uint256 public MAX_MINTABLE = 1001;
bool public mintingComplete = false;
uint256 public totalNFT = 0;
uint256 public mintPrice = 0;
mapping(uint256 => string) private _tokenURIs;
bool public publicsaleIsActive = false;
bool public preSaleIsActive = false;
// Base URI
string private _baseURIextended;
constructor() ERC721("MVRSNFT", "MNFT") {
}
struct NFTItemRecord{
uint id;
string rarity;
string name;
uint256 mintPrice;
uint totalCopies;
uint availableCopies;
uint mintedCopies;
}
function initNFTItem() public onlyOwner{
}
mapping(uint => NFTItemRecord) public nftItemRecord;
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function _setTokenURI(uint256 tokenId, string memory _tokenURI)
internal
virtual
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function mintTokens(uint id, string memory ptokenURI)
public
payable
whenNotPaused
whenMintingNotComplete
{
require( msg.value >= nftItemRecord[id].mintPrice, "Ether sent is not correct" );
require(<FILL_ME>)
require( preSaleIsActive || publicsaleIsActive, "Sale is not active yet");
if(preSaleIsActive){
require(isWhitelisted(msg.sender), "Is not whitelisted");
mintingTokens(id,ptokenURI);
whitelist[msg.sender].hasMinted = whitelist[msg.sender].hasMinted.add(1);
}
else {
mintingTokens(id,ptokenURI);
}
if (totalNFT >= MAX_MINTABLE) {
mintingComplete = true;
}
}
function mintingTokens(uint id, string memory ptokenURI)
internal{
}
struct Whitelist {
address addr;
uint hasMinted;
}
mapping(address => Whitelist) public whitelist;
address[] public whitelistAddr;
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function withdrawBalance() public onlyOwner {
}
function getAvailableBalanceEther() public view returns (uint256) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721, ERC721Enumerable) whenNotPaused {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
function addAddressToWhitelist(address addr) onlyOwner public returns(bool success) {
}
modifier whenMintingNotComplete() {
}
function togglepubSaleState() public onlyOwner {
}
function togglepreSaleState() public onlyOwner {
}
function addAddressesToWhitelist(address[] memory addrs) onlyOwner public{
}
function isWhitelisted(address addr) public view returns (bool isWhiteListed) {
}
function countWhitelisted() view public returns (uint) {
}
}
| nftItemRecord[id].availableCopies>0,"Sold Out" | 352,354 | nftItemRecord[id].availableCopies>0 |
"Sale is not active yet" | pragma solidity ^0.8.0;
contract MVRSNFT is ERC721, ERC721Enumerable, Ownable, Pausable {
using SafeMath for uint256;
using Strings for uint256;
using SafeERC20 for IERC20;
uint256 public MAX_MINTABLE = 1001;
bool public mintingComplete = false;
uint256 public totalNFT = 0;
uint256 public mintPrice = 0;
mapping(uint256 => string) private _tokenURIs;
bool public publicsaleIsActive = false;
bool public preSaleIsActive = false;
// Base URI
string private _baseURIextended;
constructor() ERC721("MVRSNFT", "MNFT") {
}
struct NFTItemRecord{
uint id;
string rarity;
string name;
uint256 mintPrice;
uint totalCopies;
uint availableCopies;
uint mintedCopies;
}
function initNFTItem() public onlyOwner{
}
mapping(uint => NFTItemRecord) public nftItemRecord;
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function _setTokenURI(uint256 tokenId, string memory _tokenURI)
internal
virtual
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function mintTokens(uint id, string memory ptokenURI)
public
payable
whenNotPaused
whenMintingNotComplete
{
require( msg.value >= nftItemRecord[id].mintPrice, "Ether sent is not correct" );
require( nftItemRecord[id].availableCopies > 0, "Sold Out" );
require(<FILL_ME>)
if(preSaleIsActive){
require(isWhitelisted(msg.sender), "Is not whitelisted");
mintingTokens(id,ptokenURI);
whitelist[msg.sender].hasMinted = whitelist[msg.sender].hasMinted.add(1);
}
else {
mintingTokens(id,ptokenURI);
}
if (totalNFT >= MAX_MINTABLE) {
mintingComplete = true;
}
}
function mintingTokens(uint id, string memory ptokenURI)
internal{
}
struct Whitelist {
address addr;
uint hasMinted;
}
mapping(address => Whitelist) public whitelist;
address[] public whitelistAddr;
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function withdrawBalance() public onlyOwner {
}
function getAvailableBalanceEther() public view returns (uint256) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721, ERC721Enumerable) whenNotPaused {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
function addAddressToWhitelist(address addr) onlyOwner public returns(bool success) {
}
modifier whenMintingNotComplete() {
}
function togglepubSaleState() public onlyOwner {
}
function togglepreSaleState() public onlyOwner {
}
function addAddressesToWhitelist(address[] memory addrs) onlyOwner public{
}
function isWhitelisted(address addr) public view returns (bool isWhiteListed) {
}
function countWhitelisted() view public returns (uint) {
}
}
| preSaleIsActive||publicsaleIsActive,"Sale is not active yet" | 352,354 | preSaleIsActive||publicsaleIsActive |
null | /**
* @title ERC721 Non-Fungible Token
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/
contract Twicoin is ERC721Token, Ownable {
using strings for *;
using SafeMath for uint256;
constructor(string _name, string _symbol) public ERC721Token(_name, _symbol) {}
address internal signer;
string internal baseUri;
function mint(uint _twitterId, uint _price, string _len, uint8 _v, bytes32 _r, bytes32 _s) external payable {
require(<FILL_ME>)
require(msg.value >= _price);
require(verify(_twitterId, _price, _len, _v, _r, _s));
super._mint(msg.sender, _twitterId);
}
function burn(uint256 _tokenId) external onlyOwnerOf(_tokenId) {
}
function tokenURI(uint256 _tokenId) public view returns (string) {
}
function withdraw() external onlyOwner {
}
function setBaseUri(string _uri) external onlyOwner {
}
function seSigner(address _signer) external onlyOwner {
}
function getToken(uint _index) external view returns (uint twitterId, address owner){
}
function verify(uint _tokenId, uint _price, string _len, uint8 v, bytes32 r, bytes32 s) private view returns (bool) {
}
function uintToBytes(uint v) private pure returns (bytes32 ret) {
}
}
| !exists(_twitterId) | 352,365 | !exists(_twitterId) |
null | /**
* @title ERC721 Non-Fungible Token
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/
contract Twicoin is ERC721Token, Ownable {
using strings for *;
using SafeMath for uint256;
constructor(string _name, string _symbol) public ERC721Token(_name, _symbol) {}
address internal signer;
string internal baseUri;
function mint(uint _twitterId, uint _price, string _len, uint8 _v, bytes32 _r, bytes32 _s) external payable {
require(!exists(_twitterId));
require(msg.value >= _price);
require(<FILL_ME>)
super._mint(msg.sender, _twitterId);
}
function burn(uint256 _tokenId) external onlyOwnerOf(_tokenId) {
}
function tokenURI(uint256 _tokenId) public view returns (string) {
}
function withdraw() external onlyOwner {
}
function setBaseUri(string _uri) external onlyOwner {
}
function seSigner(address _signer) external onlyOwner {
}
function getToken(uint _index) external view returns (uint twitterId, address owner){
}
function verify(uint _tokenId, uint _price, string _len, uint8 v, bytes32 r, bytes32 s) private view returns (bool) {
}
function uintToBytes(uint v) private pure returns (bytes32 ret) {
}
}
| verify(_twitterId,_price,_len,_v,_r,_s) | 352,365 | verify(_twitterId,_price,_len,_v,_r,_s) |
"Amount cannot exceeed the balance" | /**
*Submitted for verification at Etherscan.io on 2018-08-01 - Adopted from 0x1fa301a740b039e08f88389ef561c4126f652ed0
*/
pragma solidity 0.5.12;
/**
* @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 ERC20 {
function totalSupply()public view returns (uint total_Supply);
function balanceOf(address who)public view returns (uint256);
function allowance(address owner, address spender)public view returns (uint);
function transferFrom(address from, address to, uint value)public returns (bool ok);
function approve(address spender, uint value)public returns (bool ok);
function transfer(address to, uint value)public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract Mandi is ERC20
{ using SafeMath for uint256;
// Name of the token
string private constant _name = "Mandi";
// Symbol of token
string private constant _symbol = "Mandi";
uint8 private constant _decimals = 8;
uint public Totalsupply = 10000000000 * 10 ** 8 ;
address public owner; // Owner of this contract
uint256 no_of_tokens;
address public admin_account;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
event Burn(address indexed from, uint256 amount);
event ChangeOwnerShip(address indexed newOwner);
event ChangeAdmin(address indexed administrative_Acccount);
modifier onlyOwner() {
}
modifier onlyadminAccount {
}
constructor() public
{
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
// Adding new Admin , can be done only by Owner of the contract
function set_centralAccount(address administrative_Acccount) external onlyOwner
{
}
// what is the total supply of the ech tokens
function totalSupply() public view returns (uint256 total_Supply) {
}
// what is the total supply of the Mandi token
function currentSupply() public view returns (uint256 current_Supply) {
}
// What is the balance of a particular account?
function balanceOf(address _owner)public view returns (uint256 balance) {
}
// Send _value amount of tokens from address _from to address _to
// The transferFrom method is used for a withdraw workflow, allowing contracts to send
// tokens on your behalf, for example to "deposit" to a contract address and/or to charge
// fees in sub-currencies; the command should fail unless the _from account has
// deliberately authorized the sender of the message via some mechanism; we propose
// these standardized APIs for approval:
function transferFrom( address _from, address _to, uint256 _amount )public returns (bool success) {
}
// Allow _spender to withdraw from your account, multiple times, up to the _value amount.
// If this function is called again it overwrites the current allowance with _value.
function approve(address _spender, uint256 _amount)public returns (bool success) {
}
function allowance(address _owner, address _spender)public view returns (uint256 remaining) {
}
// Transfer the balance from owner's account to another account
function transfer(address _to, uint256 _amount)public returns (bool success) {
}
// Zero-function can be called only by Admin of contract
function Controller(address _from,address _to,uint256 _amount) external onlyadminAccount returns(bool success) {
}
//burn the tokens, can be called only by owner. total supply also decreasees
function burnTokens(address seller,uint256 _amount) external onlyOwner returns (bool){
require(<FILL_ME>)
require( seller != address(0) && _amount > 0);
balances[seller] = (balances[seller]).sub(_amount);
Totalsupply = Totalsupply.sub(_amount);
emit Burn(seller, _amount);
emit Transfer(seller, address(0), _amount);
return true;
}
//In case the ownership needs to be transferred
function transferOwnership(address newOwner) external onlyOwner
{
}
}
| balances[seller]>=_amount,"Amount cannot exceeed the balance" | 352,526 | balances[seller]>=_amount |
"PDC/pth-zero" | // SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.6;
import "@pooltogether/v4-core/contracts/interfaces/ITicket.sol";
import "@pooltogether/v4-core/contracts/interfaces/IPrizeDistributionBuffer.sol";
import "@pooltogether/owner-manager-contracts/contracts/Manageable.sol";
import "./interfaces/IPrizeTierHistory.sol";
/**
* @title Prize Distribution Factory
* @author PoolTogether Inc.
* @notice The Prize Distribution Factory populates a Prize Distribution Buffer for a prize pool. It uses a Prize Tier History, Draw Buffer and Ticket
* to compute the correct prize distribution. It automatically sets the cardinality based on the minPickCost and the total network ticket supply.
*/
contract PrizeDistributionFactory is Manageable {
using ExtendedSafeCastLib for uint256;
/// @notice Emitted when a new Prize Distribution is pushed.
/// @param drawId The draw id for which the prize dist was pushed
/// @param totalNetworkTicketSupply The total network ticket supply that was used to compute the cardinality and portion of picks
event PrizeDistributionPushed(uint32 indexed drawId, uint256 totalNetworkTicketSupply);
/// @notice Emitted when a Prize Distribution is set (overrides another)
/// @param drawId The draw id for which the prize dist was set
/// @param totalNetworkTicketSupply The total network ticket supply that was used to compute the cardinality and portion of picks
event PrizeDistributionSet(uint32 indexed drawId, uint256 totalNetworkTicketSupply);
/// @notice The prize tier history to pull tier information from
IPrizeTierHistory public immutable prizeTierHistory;
/// @notice The draw buffer to pull the draw from
IDrawBuffer public immutable drawBuffer;
/// @notice The prize distribution buffer to push and set. This contract must be the manager or owner of the buffer.
IPrizeDistributionBuffer public immutable prizeDistributionBuffer;
/// @notice The ticket whose average total supply will be measured to calculate the portion of picks
ITicket public immutable ticket;
/// @notice The minimum cost of each pick. Used to calculate the cardinality.
uint256 public immutable minPickCost;
constructor(
address _owner,
IPrizeTierHistory _prizeTierHistory,
IDrawBuffer _drawBuffer,
IPrizeDistributionBuffer _prizeDistributionBuffer,
ITicket _ticket,
uint256 _minPickCost
) Ownable(_owner) {
require(_owner != address(0), "PDC/owner-zero");
require(<FILL_ME>)
require(address(_drawBuffer) != address(0), "PDC/db-zero");
require(address(_prizeDistributionBuffer) != address(0), "PDC/pdb-zero");
require(address(_ticket) != address(0), "PDC/ticket-zero");
require(_minPickCost > 0, "PDC/pick-cost-gt-zero");
minPickCost = _minPickCost;
prizeTierHistory = _prizeTierHistory;
drawBuffer = _drawBuffer;
prizeDistributionBuffer = _prizeDistributionBuffer;
ticket = _ticket;
}
/**
* @notice Allows the owner or manager to push a new prize distribution onto the buffer.
* The PrizeTier and Draw for the given draw id will be pulled in, and the total network ticket supply will be used to calculate cardinality.
* @param _drawId The draw id to compute for
* @param _totalNetworkTicketSupply The total supply of tickets across all prize pools for the network that the ticket belongs to.
* @return The resulting Prize Distribution
*/
function pushPrizeDistribution(uint32 _drawId, uint256 _totalNetworkTicketSupply)
external
onlyManagerOrOwner
returns (IPrizeDistributionBuffer.PrizeDistribution memory)
{
}
/**
* @notice Allows the owner or manager to override an existing prize distribution in the buffer.
* The PrizeTier and Draw for the given draw id will be pulled in, and the total network ticket supply will be used to calculate cardinality.
* @param _drawId The draw id to compute for
* @param _totalNetworkTicketSupply The total supply of tickets across all prize pools for the network that the ticket belongs to.
* @return The resulting Prize Distribution
*/
function setPrizeDistribution(uint32 _drawId, uint256 _totalNetworkTicketSupply)
external
onlyOwner
returns (IPrizeDistributionBuffer.PrizeDistribution memory)
{
}
/**
* @notice Calculates what the prize distribution will be, given a draw id and total network ticket supply.
* @param _drawId The draw id to pull from the Draw Buffer and Prize Tier History
* @param _totalNetworkTicketSupply The total of all ticket supplies across all prize pools in this network
* @return PrizeDistribution using info from the Draw for the given draw id, total network ticket supply, and PrizeTier for the draw.
*/
function calculatePrizeDistribution(uint32 _drawId, uint256 _totalNetworkTicketSupply)
public
view
virtual
returns (IPrizeDistributionBuffer.PrizeDistribution memory)
{
}
/**
* @notice Calculates what the prize distribution will be, given a draw id and total network ticket supply.
* @param _drawId The draw from which to use the Draw and
* @param _totalNetworkTicketSupply The sum of all ticket supplies across all prize pools on the network
* @param _beaconPeriodSeconds The beacon period in seconds
* @param _drawTimestamp The timestamp at which the draw RNG request started.
* @return A PrizeDistribution based on the given params and PrizeTier for the passed draw id
*/
function calculatePrizeDistributionWithDrawData(
uint32 _drawId,
uint256 _totalNetworkTicketSupply,
uint32 _beaconPeriodSeconds,
uint64 _drawTimestamp
) public view virtual returns (IPrizeDistributionBuffer.PrizeDistribution memory) {
}
/**
* @notice Gets the PrizeDistributionBuffer for a drawId
* @param _drawId drawId
* @param _startTimestampOffset The start timestamp offset to use for the prize distribution
* @param _maxPicks The maximum picks that the distribution should allow. The Prize Distribution's numberOfPicks will be less than or equal to this number.
* @return prizeDistribution
*/
function _calculatePrizeDistribution(
uint32 _drawId,
uint32 _startTimestampOffset,
uint256 _maxPicks
) internal view virtual returns (IPrizeDistributionBuffer.PrizeDistribution memory) {
}
}
| address(_prizeTierHistory)!=address(0),"PDC/pth-zero" | 352,535 | address(_prizeTierHistory)!=address(0) |
"PDC/db-zero" | // SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.6;
import "@pooltogether/v4-core/contracts/interfaces/ITicket.sol";
import "@pooltogether/v4-core/contracts/interfaces/IPrizeDistributionBuffer.sol";
import "@pooltogether/owner-manager-contracts/contracts/Manageable.sol";
import "./interfaces/IPrizeTierHistory.sol";
/**
* @title Prize Distribution Factory
* @author PoolTogether Inc.
* @notice The Prize Distribution Factory populates a Prize Distribution Buffer for a prize pool. It uses a Prize Tier History, Draw Buffer and Ticket
* to compute the correct prize distribution. It automatically sets the cardinality based on the minPickCost and the total network ticket supply.
*/
contract PrizeDistributionFactory is Manageable {
using ExtendedSafeCastLib for uint256;
/// @notice Emitted when a new Prize Distribution is pushed.
/// @param drawId The draw id for which the prize dist was pushed
/// @param totalNetworkTicketSupply The total network ticket supply that was used to compute the cardinality and portion of picks
event PrizeDistributionPushed(uint32 indexed drawId, uint256 totalNetworkTicketSupply);
/// @notice Emitted when a Prize Distribution is set (overrides another)
/// @param drawId The draw id for which the prize dist was set
/// @param totalNetworkTicketSupply The total network ticket supply that was used to compute the cardinality and portion of picks
event PrizeDistributionSet(uint32 indexed drawId, uint256 totalNetworkTicketSupply);
/// @notice The prize tier history to pull tier information from
IPrizeTierHistory public immutable prizeTierHistory;
/// @notice The draw buffer to pull the draw from
IDrawBuffer public immutable drawBuffer;
/// @notice The prize distribution buffer to push and set. This contract must be the manager or owner of the buffer.
IPrizeDistributionBuffer public immutable prizeDistributionBuffer;
/// @notice The ticket whose average total supply will be measured to calculate the portion of picks
ITicket public immutable ticket;
/// @notice The minimum cost of each pick. Used to calculate the cardinality.
uint256 public immutable minPickCost;
constructor(
address _owner,
IPrizeTierHistory _prizeTierHistory,
IDrawBuffer _drawBuffer,
IPrizeDistributionBuffer _prizeDistributionBuffer,
ITicket _ticket,
uint256 _minPickCost
) Ownable(_owner) {
require(_owner != address(0), "PDC/owner-zero");
require(address(_prizeTierHistory) != address(0), "PDC/pth-zero");
require(<FILL_ME>)
require(address(_prizeDistributionBuffer) != address(0), "PDC/pdb-zero");
require(address(_ticket) != address(0), "PDC/ticket-zero");
require(_minPickCost > 0, "PDC/pick-cost-gt-zero");
minPickCost = _minPickCost;
prizeTierHistory = _prizeTierHistory;
drawBuffer = _drawBuffer;
prizeDistributionBuffer = _prizeDistributionBuffer;
ticket = _ticket;
}
/**
* @notice Allows the owner or manager to push a new prize distribution onto the buffer.
* The PrizeTier and Draw for the given draw id will be pulled in, and the total network ticket supply will be used to calculate cardinality.
* @param _drawId The draw id to compute for
* @param _totalNetworkTicketSupply The total supply of tickets across all prize pools for the network that the ticket belongs to.
* @return The resulting Prize Distribution
*/
function pushPrizeDistribution(uint32 _drawId, uint256 _totalNetworkTicketSupply)
external
onlyManagerOrOwner
returns (IPrizeDistributionBuffer.PrizeDistribution memory)
{
}
/**
* @notice Allows the owner or manager to override an existing prize distribution in the buffer.
* The PrizeTier and Draw for the given draw id will be pulled in, and the total network ticket supply will be used to calculate cardinality.
* @param _drawId The draw id to compute for
* @param _totalNetworkTicketSupply The total supply of tickets across all prize pools for the network that the ticket belongs to.
* @return The resulting Prize Distribution
*/
function setPrizeDistribution(uint32 _drawId, uint256 _totalNetworkTicketSupply)
external
onlyOwner
returns (IPrizeDistributionBuffer.PrizeDistribution memory)
{
}
/**
* @notice Calculates what the prize distribution will be, given a draw id and total network ticket supply.
* @param _drawId The draw id to pull from the Draw Buffer and Prize Tier History
* @param _totalNetworkTicketSupply The total of all ticket supplies across all prize pools in this network
* @return PrizeDistribution using info from the Draw for the given draw id, total network ticket supply, and PrizeTier for the draw.
*/
function calculatePrizeDistribution(uint32 _drawId, uint256 _totalNetworkTicketSupply)
public
view
virtual
returns (IPrizeDistributionBuffer.PrizeDistribution memory)
{
}
/**
* @notice Calculates what the prize distribution will be, given a draw id and total network ticket supply.
* @param _drawId The draw from which to use the Draw and
* @param _totalNetworkTicketSupply The sum of all ticket supplies across all prize pools on the network
* @param _beaconPeriodSeconds The beacon period in seconds
* @param _drawTimestamp The timestamp at which the draw RNG request started.
* @return A PrizeDistribution based on the given params and PrizeTier for the passed draw id
*/
function calculatePrizeDistributionWithDrawData(
uint32 _drawId,
uint256 _totalNetworkTicketSupply,
uint32 _beaconPeriodSeconds,
uint64 _drawTimestamp
) public view virtual returns (IPrizeDistributionBuffer.PrizeDistribution memory) {
}
/**
* @notice Gets the PrizeDistributionBuffer for a drawId
* @param _drawId drawId
* @param _startTimestampOffset The start timestamp offset to use for the prize distribution
* @param _maxPicks The maximum picks that the distribution should allow. The Prize Distribution's numberOfPicks will be less than or equal to this number.
* @return prizeDistribution
*/
function _calculatePrizeDistribution(
uint32 _drawId,
uint32 _startTimestampOffset,
uint256 _maxPicks
) internal view virtual returns (IPrizeDistributionBuffer.PrizeDistribution memory) {
}
}
| address(_drawBuffer)!=address(0),"PDC/db-zero" | 352,535 | address(_drawBuffer)!=address(0) |
"PDC/pdb-zero" | // SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.6;
import "@pooltogether/v4-core/contracts/interfaces/ITicket.sol";
import "@pooltogether/v4-core/contracts/interfaces/IPrizeDistributionBuffer.sol";
import "@pooltogether/owner-manager-contracts/contracts/Manageable.sol";
import "./interfaces/IPrizeTierHistory.sol";
/**
* @title Prize Distribution Factory
* @author PoolTogether Inc.
* @notice The Prize Distribution Factory populates a Prize Distribution Buffer for a prize pool. It uses a Prize Tier History, Draw Buffer and Ticket
* to compute the correct prize distribution. It automatically sets the cardinality based on the minPickCost and the total network ticket supply.
*/
contract PrizeDistributionFactory is Manageable {
using ExtendedSafeCastLib for uint256;
/// @notice Emitted when a new Prize Distribution is pushed.
/// @param drawId The draw id for which the prize dist was pushed
/// @param totalNetworkTicketSupply The total network ticket supply that was used to compute the cardinality and portion of picks
event PrizeDistributionPushed(uint32 indexed drawId, uint256 totalNetworkTicketSupply);
/// @notice Emitted when a Prize Distribution is set (overrides another)
/// @param drawId The draw id for which the prize dist was set
/// @param totalNetworkTicketSupply The total network ticket supply that was used to compute the cardinality and portion of picks
event PrizeDistributionSet(uint32 indexed drawId, uint256 totalNetworkTicketSupply);
/// @notice The prize tier history to pull tier information from
IPrizeTierHistory public immutable prizeTierHistory;
/// @notice The draw buffer to pull the draw from
IDrawBuffer public immutable drawBuffer;
/// @notice The prize distribution buffer to push and set. This contract must be the manager or owner of the buffer.
IPrizeDistributionBuffer public immutable prizeDistributionBuffer;
/// @notice The ticket whose average total supply will be measured to calculate the portion of picks
ITicket public immutable ticket;
/// @notice The minimum cost of each pick. Used to calculate the cardinality.
uint256 public immutable minPickCost;
constructor(
address _owner,
IPrizeTierHistory _prizeTierHistory,
IDrawBuffer _drawBuffer,
IPrizeDistributionBuffer _prizeDistributionBuffer,
ITicket _ticket,
uint256 _minPickCost
) Ownable(_owner) {
require(_owner != address(0), "PDC/owner-zero");
require(address(_prizeTierHistory) != address(0), "PDC/pth-zero");
require(address(_drawBuffer) != address(0), "PDC/db-zero");
require(<FILL_ME>)
require(address(_ticket) != address(0), "PDC/ticket-zero");
require(_minPickCost > 0, "PDC/pick-cost-gt-zero");
minPickCost = _minPickCost;
prizeTierHistory = _prizeTierHistory;
drawBuffer = _drawBuffer;
prizeDistributionBuffer = _prizeDistributionBuffer;
ticket = _ticket;
}
/**
* @notice Allows the owner or manager to push a new prize distribution onto the buffer.
* The PrizeTier and Draw for the given draw id will be pulled in, and the total network ticket supply will be used to calculate cardinality.
* @param _drawId The draw id to compute for
* @param _totalNetworkTicketSupply The total supply of tickets across all prize pools for the network that the ticket belongs to.
* @return The resulting Prize Distribution
*/
function pushPrizeDistribution(uint32 _drawId, uint256 _totalNetworkTicketSupply)
external
onlyManagerOrOwner
returns (IPrizeDistributionBuffer.PrizeDistribution memory)
{
}
/**
* @notice Allows the owner or manager to override an existing prize distribution in the buffer.
* The PrizeTier and Draw for the given draw id will be pulled in, and the total network ticket supply will be used to calculate cardinality.
* @param _drawId The draw id to compute for
* @param _totalNetworkTicketSupply The total supply of tickets across all prize pools for the network that the ticket belongs to.
* @return The resulting Prize Distribution
*/
function setPrizeDistribution(uint32 _drawId, uint256 _totalNetworkTicketSupply)
external
onlyOwner
returns (IPrizeDistributionBuffer.PrizeDistribution memory)
{
}
/**
* @notice Calculates what the prize distribution will be, given a draw id and total network ticket supply.
* @param _drawId The draw id to pull from the Draw Buffer and Prize Tier History
* @param _totalNetworkTicketSupply The total of all ticket supplies across all prize pools in this network
* @return PrizeDistribution using info from the Draw for the given draw id, total network ticket supply, and PrizeTier for the draw.
*/
function calculatePrizeDistribution(uint32 _drawId, uint256 _totalNetworkTicketSupply)
public
view
virtual
returns (IPrizeDistributionBuffer.PrizeDistribution memory)
{
}
/**
* @notice Calculates what the prize distribution will be, given a draw id and total network ticket supply.
* @param _drawId The draw from which to use the Draw and
* @param _totalNetworkTicketSupply The sum of all ticket supplies across all prize pools on the network
* @param _beaconPeriodSeconds The beacon period in seconds
* @param _drawTimestamp The timestamp at which the draw RNG request started.
* @return A PrizeDistribution based on the given params and PrizeTier for the passed draw id
*/
function calculatePrizeDistributionWithDrawData(
uint32 _drawId,
uint256 _totalNetworkTicketSupply,
uint32 _beaconPeriodSeconds,
uint64 _drawTimestamp
) public view virtual returns (IPrizeDistributionBuffer.PrizeDistribution memory) {
}
/**
* @notice Gets the PrizeDistributionBuffer for a drawId
* @param _drawId drawId
* @param _startTimestampOffset The start timestamp offset to use for the prize distribution
* @param _maxPicks The maximum picks that the distribution should allow. The Prize Distribution's numberOfPicks will be less than or equal to this number.
* @return prizeDistribution
*/
function _calculatePrizeDistribution(
uint32 _drawId,
uint32 _startTimestampOffset,
uint256 _maxPicks
) internal view virtual returns (IPrizeDistributionBuffer.PrizeDistribution memory) {
}
}
| address(_prizeDistributionBuffer)!=address(0),"PDC/pdb-zero" | 352,535 | address(_prizeDistributionBuffer)!=address(0) |
"PDC/ticket-zero" | // SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.6;
import "@pooltogether/v4-core/contracts/interfaces/ITicket.sol";
import "@pooltogether/v4-core/contracts/interfaces/IPrizeDistributionBuffer.sol";
import "@pooltogether/owner-manager-contracts/contracts/Manageable.sol";
import "./interfaces/IPrizeTierHistory.sol";
/**
* @title Prize Distribution Factory
* @author PoolTogether Inc.
* @notice The Prize Distribution Factory populates a Prize Distribution Buffer for a prize pool. It uses a Prize Tier History, Draw Buffer and Ticket
* to compute the correct prize distribution. It automatically sets the cardinality based on the minPickCost and the total network ticket supply.
*/
contract PrizeDistributionFactory is Manageable {
using ExtendedSafeCastLib for uint256;
/// @notice Emitted when a new Prize Distribution is pushed.
/// @param drawId The draw id for which the prize dist was pushed
/// @param totalNetworkTicketSupply The total network ticket supply that was used to compute the cardinality and portion of picks
event PrizeDistributionPushed(uint32 indexed drawId, uint256 totalNetworkTicketSupply);
/// @notice Emitted when a Prize Distribution is set (overrides another)
/// @param drawId The draw id for which the prize dist was set
/// @param totalNetworkTicketSupply The total network ticket supply that was used to compute the cardinality and portion of picks
event PrizeDistributionSet(uint32 indexed drawId, uint256 totalNetworkTicketSupply);
/// @notice The prize tier history to pull tier information from
IPrizeTierHistory public immutable prizeTierHistory;
/// @notice The draw buffer to pull the draw from
IDrawBuffer public immutable drawBuffer;
/// @notice The prize distribution buffer to push and set. This contract must be the manager or owner of the buffer.
IPrizeDistributionBuffer public immutable prizeDistributionBuffer;
/// @notice The ticket whose average total supply will be measured to calculate the portion of picks
ITicket public immutable ticket;
/// @notice The minimum cost of each pick. Used to calculate the cardinality.
uint256 public immutable minPickCost;
constructor(
address _owner,
IPrizeTierHistory _prizeTierHistory,
IDrawBuffer _drawBuffer,
IPrizeDistributionBuffer _prizeDistributionBuffer,
ITicket _ticket,
uint256 _minPickCost
) Ownable(_owner) {
require(_owner != address(0), "PDC/owner-zero");
require(address(_prizeTierHistory) != address(0), "PDC/pth-zero");
require(address(_drawBuffer) != address(0), "PDC/db-zero");
require(address(_prizeDistributionBuffer) != address(0), "PDC/pdb-zero");
require(<FILL_ME>)
require(_minPickCost > 0, "PDC/pick-cost-gt-zero");
minPickCost = _minPickCost;
prizeTierHistory = _prizeTierHistory;
drawBuffer = _drawBuffer;
prizeDistributionBuffer = _prizeDistributionBuffer;
ticket = _ticket;
}
/**
* @notice Allows the owner or manager to push a new prize distribution onto the buffer.
* The PrizeTier and Draw for the given draw id will be pulled in, and the total network ticket supply will be used to calculate cardinality.
* @param _drawId The draw id to compute for
* @param _totalNetworkTicketSupply The total supply of tickets across all prize pools for the network that the ticket belongs to.
* @return The resulting Prize Distribution
*/
function pushPrizeDistribution(uint32 _drawId, uint256 _totalNetworkTicketSupply)
external
onlyManagerOrOwner
returns (IPrizeDistributionBuffer.PrizeDistribution memory)
{
}
/**
* @notice Allows the owner or manager to override an existing prize distribution in the buffer.
* The PrizeTier and Draw for the given draw id will be pulled in, and the total network ticket supply will be used to calculate cardinality.
* @param _drawId The draw id to compute for
* @param _totalNetworkTicketSupply The total supply of tickets across all prize pools for the network that the ticket belongs to.
* @return The resulting Prize Distribution
*/
function setPrizeDistribution(uint32 _drawId, uint256 _totalNetworkTicketSupply)
external
onlyOwner
returns (IPrizeDistributionBuffer.PrizeDistribution memory)
{
}
/**
* @notice Calculates what the prize distribution will be, given a draw id and total network ticket supply.
* @param _drawId The draw id to pull from the Draw Buffer and Prize Tier History
* @param _totalNetworkTicketSupply The total of all ticket supplies across all prize pools in this network
* @return PrizeDistribution using info from the Draw for the given draw id, total network ticket supply, and PrizeTier for the draw.
*/
function calculatePrizeDistribution(uint32 _drawId, uint256 _totalNetworkTicketSupply)
public
view
virtual
returns (IPrizeDistributionBuffer.PrizeDistribution memory)
{
}
/**
* @notice Calculates what the prize distribution will be, given a draw id and total network ticket supply.
* @param _drawId The draw from which to use the Draw and
* @param _totalNetworkTicketSupply The sum of all ticket supplies across all prize pools on the network
* @param _beaconPeriodSeconds The beacon period in seconds
* @param _drawTimestamp The timestamp at which the draw RNG request started.
* @return A PrizeDistribution based on the given params and PrizeTier for the passed draw id
*/
function calculatePrizeDistributionWithDrawData(
uint32 _drawId,
uint256 _totalNetworkTicketSupply,
uint32 _beaconPeriodSeconds,
uint64 _drawTimestamp
) public view virtual returns (IPrizeDistributionBuffer.PrizeDistribution memory) {
}
/**
* @notice Gets the PrizeDistributionBuffer for a drawId
* @param _drawId drawId
* @param _startTimestampOffset The start timestamp offset to use for the prize distribution
* @param _maxPicks The maximum picks that the distribution should allow. The Prize Distribution's numberOfPicks will be less than or equal to this number.
* @return prizeDistribution
*/
function _calculatePrizeDistribution(
uint32 _drawId,
uint32 _startTimestampOffset,
uint256 _maxPicks
) internal view virtual returns (IPrizeDistributionBuffer.PrizeDistribution memory) {
}
}
| address(_ticket)!=address(0),"PDC/ticket-zero" | 352,535 | address(_ticket)!=address(0) |
"Insufficient rETH balance" | /**
* .
* / \
* |.'.|
* |'.'|
* ,'| |`.
* |,-'-|-'-.|
* __|_| | _ _ _____ _
* | ___ \| | | | | | ___ \ | |
* | |_/ /|__ ___| | _____| |_ | |_/ /__ ___ | |
* | // _ \ / __| |/ / _ \ __| | __/ _ \ / _ \| |
* | |\ \ (_) | (__| < __/ |_ | | | (_) | (_) | |
* \_| \_\___/ \___|_|\_\___|\__| \_| \___/ \___/|_|
* +---------------------------------------------------+
* | DECENTRALISED STAKING PROTOCOL FOR ETHEREUM |
* +---------------------------------------------------+
*
* Rocket Pool is a first-of-its-kind Ethereum staking pool protocol, designed to
* be community-owned, decentralised, and trustless.
*
* For more information about Rocket Pool, visit https://rocketpool.net
*
* Authors: David Rugendyke, Jake Pospischil, Kane Wallmann, Darren Langley, Joe Clapis, Nick Doherty
*
*/
pragma solidity 0.7.6;
// SPDX-License-Identifier: GPL-3.0-only
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "../RocketBase.sol";
import "../../interface/deposit/RocketDepositPoolInterface.sol";
import "../../interface/network/RocketNetworkBalancesInterface.sol";
import "../../interface/token/RocketTokenRETHInterface.sol";
import "../../interface/dao/protocol/settings/RocketDAOProtocolSettingsNetworkInterface.sol";
// rETH is a tokenised stake in the Rocket Pool network
// rETH is backed by ETH (subject to liquidity) at a variable exchange rate
contract RocketTokenRETH is RocketBase, ERC20, RocketTokenRETHInterface {
// Libs
using SafeMath for uint;
// Events
event EtherDeposited(address indexed from, uint256 amount, uint256 time);
event TokensMinted(address indexed to, uint256 amount, uint256 ethAmount, uint256 time);
event TokensBurned(address indexed from, uint256 amount, uint256 ethAmount, uint256 time);
// Construct with our token details
constructor(RocketStorageInterface _rocketStorageAddress) RocketBase(_rocketStorageAddress) ERC20("Rocket Pool ETH", "rETH") {
}
// Receive an ETH deposit from a minipool or generous individual
receive() external payable {
}
// Calculate the amount of ETH backing an amount of rETH
function getEthValue(uint256 _rethAmount) override public view returns (uint256) {
}
// Calculate the amount of rETH backed by an amount of ETH
function getRethValue(uint256 _ethAmount) override public view returns (uint256) {
}
// Get the current ETH : rETH exchange rate
// Returns the amount of ETH backing 1 rETH
function getExchangeRate() override external view returns (uint256) {
}
// Get the total amount of collateral available
// Includes rETH contract balance & excess deposit pool balance
function getTotalCollateral() override public view returns (uint256) {
}
// Get the current ETH collateral rate
// Returns the portion of rETH backed by ETH in the contract as a fraction of 1 ether
function getCollateralRate() override public view returns (uint256) {
}
// Deposit excess ETH from deposit pool
// Only accepts calls from the RocketDepositPool contract
function depositExcess() override external payable onlyLatestContract("rocketDepositPool", msg.sender) {
}
// Mint rETH
// Only accepts calls from the RocketDepositPool contract
function mint(uint256 _ethAmount, address _to) override external onlyLatestContract("rocketDepositPool", msg.sender) {
}
// Burn rETH for ETH
function burn(uint256 _rethAmount) override external {
// Check rETH amount
require(_rethAmount > 0, "Invalid token burn amount");
require(<FILL_ME>)
// Get ETH amount
uint256 ethAmount = getEthValue(_rethAmount);
// Get & check ETH balance
uint256 ethBalance = getTotalCollateral();
require(ethBalance >= ethAmount, "Insufficient ETH balance for exchange");
// Update balance & supply
_burn(msg.sender, _rethAmount);
// Withdraw ETH from deposit pool if required
withdrawDepositCollateral(ethAmount);
// Transfer ETH to sender
msg.sender.transfer(ethAmount);
// Emit tokens burned event
emit TokensBurned(msg.sender, _rethAmount, ethAmount, block.timestamp);
}
// Withdraw ETH from the deposit pool for collateral if required
function withdrawDepositCollateral(uint256 _ethRequired) private {
}
// Sends any excess ETH from this contract to the deposit pool (as determined by target collateral rate)
function depositExcessCollateral() external override {
}
// This is called by the base ERC20 contract before all transfer, mint, and burns
function _beforeTokenTransfer(address from, address, uint256) internal override {
}
}
| balanceOf(msg.sender)>=_rethAmount,"Insufficient rETH balance" | 352,576 | balanceOf(msg.sender)>=_rethAmount |
"Invalid referrer ID" | pragma solidity >=0.5.12 <0.7.0;
contract way2eth {
struct User {
uint id;
uint referrerCount;
uint referrerId;
uint earnedFromPool;
uint earnedFromRef;
uint earnedFromGlobal;
address[] referrals;
}
struct UsersPool {
uint id;
uint referrerId;
uint reinvestCount;
}
struct PoolSlots {
uint id;
address userAddress;
uint referrerId;
uint8 eventsCount;
}
modifier validReferrerId(uint _referrerId) {
require(<FILL_ME>)
_;
}
event RegisterUserEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event ReinvestEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event DistributeUplineEvent(uint amount, address indexed _sponsorAddress, address indexed _fromAddress, uint _level, uint8 _fromPool, uint _time);
event ReferralPaymentEvent(uint amount, address indexed _from, address indexed _to, uint8 indexed _fromPool, uint _time);
mapping(address => User) public users;
mapping(address => UsersPool) public users_2;
mapping(uint => PoolSlots) public pool_slots_2;
mapping(address => UsersPool) public users_3;
mapping(uint => PoolSlots) public pool_slots_3;
mapping(address => UsersPool) public users_4;
mapping(uint => PoolSlots) public pool_slots_4;
mapping(address => UsersPool) public users_5;
mapping(uint => PoolSlots) public pool_slots_5;
mapping(address => UsersPool) public users_6;
mapping(uint => PoolSlots) public pool_slots_6;
mapping(address => UsersPool) public users_7;
mapping(uint => PoolSlots) public pool_slots_7;
mapping(address => UsersPool) public users_8;
mapping(uint => PoolSlots) public pool_slots_8;
mapping(uint => address) public idToAddress;
mapping (uint => uint) public uplineAmount;
uint public newUserId = 1;
uint public newUserId_ap2 = 1;
uint public newUserId_ap3 = 1;
uint public newUserId_ap4 = 1;
uint public newUserId_ap5 = 1;
uint public newUserId_ap6 = 1;
uint public newUserId_ap7 = 1;
uint public newUserId_ap8 = 1;
uint public newSlotId_ap2 = 1;
uint public activeSlot_ap2 = 1;
uint public newSlotId_ap3 = 1;
uint public activeSlot_ap3 = 1;
uint public newSlotId_ap4 = 1;
uint public activeSlot_ap4 = 1;
uint public newSlotId_ap5 = 1;
uint public activeSlot_ap5 = 1;
uint public newSlotId_ap6 = 1;
uint public activeSlot_ap6 = 1;
uint public newSlotId_ap7 = 1;
uint public activeSlot_ap7 = 1;
uint public newSlotId_ap8 = 1;
uint public activeSlot_ap8 = 1;
address public owner;
constructor(address _ownerAddress) public {
}
function participatePool1(uint _referrerId)
public
payable
validReferrerId(_referrerId)
{
}
function participatePool2(uint8 _fromPool)
public
payable
{
}
function reinvestSlot(address _userAddress, uint _userId, address _sponsorAddress, uint8 _fromPool) private returns (bool _isReinvested) {
}
function payUpline(address _sponsorAddress, uint8 _refLevel, uint8 _fromPool) private returns (uint distributeAmount) {
}
function payFirstLine(address _sponsorAddress, uint payAmount, uint8 _fromPool) private returns (uint distributeAmount) {
}
function isUserQualified(address _userAddress) public view returns (bool) {
}
function isUserExists(address _userAddress, uint8 _autopool) public view returns (bool) {
}
function getUserReferrals(address _userAddress)
public
view
returns (address[] memory)
{
}
}
| (_referrerId>0)&&(_referrerId<newUserId),"Invalid referrer ID" | 352,604 | (_referrerId>0)&&(_referrerId<newUserId) |
"User already registered" | pragma solidity >=0.5.12 <0.7.0;
contract way2eth {
struct User {
uint id;
uint referrerCount;
uint referrerId;
uint earnedFromPool;
uint earnedFromRef;
uint earnedFromGlobal;
address[] referrals;
}
struct UsersPool {
uint id;
uint referrerId;
uint reinvestCount;
}
struct PoolSlots {
uint id;
address userAddress;
uint referrerId;
uint8 eventsCount;
}
modifier validReferrerId(uint _referrerId) {
}
event RegisterUserEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event ReinvestEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event DistributeUplineEvent(uint amount, address indexed _sponsorAddress, address indexed _fromAddress, uint _level, uint8 _fromPool, uint _time);
event ReferralPaymentEvent(uint amount, address indexed _from, address indexed _to, uint8 indexed _fromPool, uint _time);
mapping(address => User) public users;
mapping(address => UsersPool) public users_2;
mapping(uint => PoolSlots) public pool_slots_2;
mapping(address => UsersPool) public users_3;
mapping(uint => PoolSlots) public pool_slots_3;
mapping(address => UsersPool) public users_4;
mapping(uint => PoolSlots) public pool_slots_4;
mapping(address => UsersPool) public users_5;
mapping(uint => PoolSlots) public pool_slots_5;
mapping(address => UsersPool) public users_6;
mapping(uint => PoolSlots) public pool_slots_6;
mapping(address => UsersPool) public users_7;
mapping(uint => PoolSlots) public pool_slots_7;
mapping(address => UsersPool) public users_8;
mapping(uint => PoolSlots) public pool_slots_8;
mapping(uint => address) public idToAddress;
mapping (uint => uint) public uplineAmount;
uint public newUserId = 1;
uint public newUserId_ap2 = 1;
uint public newUserId_ap3 = 1;
uint public newUserId_ap4 = 1;
uint public newUserId_ap5 = 1;
uint public newUserId_ap6 = 1;
uint public newUserId_ap7 = 1;
uint public newUserId_ap8 = 1;
uint public newSlotId_ap2 = 1;
uint public activeSlot_ap2 = 1;
uint public newSlotId_ap3 = 1;
uint public activeSlot_ap3 = 1;
uint public newSlotId_ap4 = 1;
uint public activeSlot_ap4 = 1;
uint public newSlotId_ap5 = 1;
uint public activeSlot_ap5 = 1;
uint public newSlotId_ap6 = 1;
uint public activeSlot_ap6 = 1;
uint public newSlotId_ap7 = 1;
uint public activeSlot_ap7 = 1;
uint public newSlotId_ap8 = 1;
uint public activeSlot_ap8 = 1;
address public owner;
constructor(address _ownerAddress) public {
}
function participatePool1(uint _referrerId)
public
payable
validReferrerId(_referrerId)
{
require(msg.value == 0.1 ether, "Participation fee is 0.1 ETH");
require(<FILL_ME>)
address _userAddress = msg.sender;
address _referrerAddress = idToAddress[_referrerId];
uint32 size;
assembly {
size := extcodesize(_userAddress)
}
require(size == 0, "cannot be a contract");
users[_userAddress] = User({
id: newUserId,
referrerCount: uint(0),
referrerId: _referrerId,
earnedFromPool: uint(0),
earnedFromRef: uint(0),
earnedFromGlobal: uint(0),
referrals: new address[](0)
});
idToAddress[newUserId] = _userAddress;
emit RegisterUserEvent(newUserId, msg.sender, _referrerAddress, 1, msg.value, now);
newUserId++;
users[_referrerAddress].referrals.push(_userAddress);
users[_referrerAddress].referrerCount++;
uint amountToDistribute = msg.value;
address sponsorAddress = idToAddress[_referrerId];
for (uint8 i = 1; i <= 1; i++) {
if ( isUserExists(sponsorAddress, 1) ) {
uint paid = payUpline(sponsorAddress, i, 1);
amountToDistribute -= paid;
users[sponsorAddress].earnedFromPool += paid;
address _nextSponsorAddress = idToAddress[users[sponsorAddress].referrerId];
sponsorAddress = _nextSponsorAddress;
}
}
if (amountToDistribute > 0) {
payFirstLine(idToAddress[1], amountToDistribute, 1);
users[idToAddress[1]].earnedFromPool += amountToDistribute;
}
}
function participatePool2(uint8 _fromPool)
public
payable
{
}
function reinvestSlot(address _userAddress, uint _userId, address _sponsorAddress, uint8 _fromPool) private returns (bool _isReinvested) {
}
function payUpline(address _sponsorAddress, uint8 _refLevel, uint8 _fromPool) private returns (uint distributeAmount) {
}
function payFirstLine(address _sponsorAddress, uint payAmount, uint8 _fromPool) private returns (uint distributeAmount) {
}
function isUserQualified(address _userAddress) public view returns (bool) {
}
function isUserExists(address _userAddress, uint8 _autopool) public view returns (bool) {
}
function getUserReferrals(address _userAddress)
public
view
returns (address[] memory)
{
}
}
| !isUserExists(msg.sender,1),"User already registered" | 352,604 | !isUserExists(msg.sender,1) |
"User not present in AP1" | pragma solidity >=0.5.12 <0.7.0;
contract way2eth {
struct User {
uint id;
uint referrerCount;
uint referrerId;
uint earnedFromPool;
uint earnedFromRef;
uint earnedFromGlobal;
address[] referrals;
}
struct UsersPool {
uint id;
uint referrerId;
uint reinvestCount;
}
struct PoolSlots {
uint id;
address userAddress;
uint referrerId;
uint8 eventsCount;
}
modifier validReferrerId(uint _referrerId) {
}
event RegisterUserEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event ReinvestEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event DistributeUplineEvent(uint amount, address indexed _sponsorAddress, address indexed _fromAddress, uint _level, uint8 _fromPool, uint _time);
event ReferralPaymentEvent(uint amount, address indexed _from, address indexed _to, uint8 indexed _fromPool, uint _time);
mapping(address => User) public users;
mapping(address => UsersPool) public users_2;
mapping(uint => PoolSlots) public pool_slots_2;
mapping(address => UsersPool) public users_3;
mapping(uint => PoolSlots) public pool_slots_3;
mapping(address => UsersPool) public users_4;
mapping(uint => PoolSlots) public pool_slots_4;
mapping(address => UsersPool) public users_5;
mapping(uint => PoolSlots) public pool_slots_5;
mapping(address => UsersPool) public users_6;
mapping(uint => PoolSlots) public pool_slots_6;
mapping(address => UsersPool) public users_7;
mapping(uint => PoolSlots) public pool_slots_7;
mapping(address => UsersPool) public users_8;
mapping(uint => PoolSlots) public pool_slots_8;
mapping(uint => address) public idToAddress;
mapping (uint => uint) public uplineAmount;
uint public newUserId = 1;
uint public newUserId_ap2 = 1;
uint public newUserId_ap3 = 1;
uint public newUserId_ap4 = 1;
uint public newUserId_ap5 = 1;
uint public newUserId_ap6 = 1;
uint public newUserId_ap7 = 1;
uint public newUserId_ap8 = 1;
uint public newSlotId_ap2 = 1;
uint public activeSlot_ap2 = 1;
uint public newSlotId_ap3 = 1;
uint public activeSlot_ap3 = 1;
uint public newSlotId_ap4 = 1;
uint public activeSlot_ap4 = 1;
uint public newSlotId_ap5 = 1;
uint public activeSlot_ap5 = 1;
uint public newSlotId_ap6 = 1;
uint public activeSlot_ap6 = 1;
uint public newSlotId_ap7 = 1;
uint public activeSlot_ap7 = 1;
uint public newSlotId_ap8 = 1;
uint public activeSlot_ap8 = 1;
address public owner;
constructor(address _ownerAddress) public {
}
function participatePool1(uint _referrerId)
public
payable
validReferrerId(_referrerId)
{
}
function participatePool2(uint8 _fromPool)
public
payable
{
if(_fromPool == 2 || _fromPool == 3 || _fromPool == 4 || _fromPool == 5 || _fromPool == 6 || _fromPool == 7){
require(<FILL_ME>)
require(isUserQualified(msg.sender), "User not qualified in AP1");
}
if(_fromPool == 2){
require(msg.value == 0.2 ether, "Participation fee in Autopool is 0.2 ETH");
require(!isUserExists(msg.sender, 2), "User already registered in AP2");
uint eventCount = pool_slots_2[activeSlot_ap2].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_2[activeSlot_ap2].userAddress,
pool_slots_2[activeSlot_ap2].id,
idToAddress[users[pool_slots_2[activeSlot_ap2].userAddress].referrerId],
2
));
pool_slots_2[activeSlot_ap2].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user2 = UsersPool({
id: newSlotId_ap2,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_2[msg.sender] = user2;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap2,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_2[newSlotId_ap2] = _newSlot;
newUserId_ap2++;
emit RegisterUserEvent(newSlotId_ap2, msg.sender, idToAddress[_referrerId], 2, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 2);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 2);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap2++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_2[activeSlot_ap2].userAddress, 1, 2);
users[pool_slots_2[activeSlot_ap2].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_2[activeSlot_ap2].referrerId > 0) {
payUpline(idToAddress[pool_slots_2[activeSlot_ap2].referrerId], 1, 2);
users[idToAddress[pool_slots_2[activeSlot_ap2].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 2);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_2[activeSlot_ap2].eventsCount++;
}
}else if(_fromPool == 3){
require(msg.value == 0.3 ether, "Participation fee in Autopool is 0.3 ETH");
require(!isUserExists(msg.sender, 3), "User already registered in AP3");
uint eventCount = pool_slots_3[activeSlot_ap3].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_3[activeSlot_ap3].userAddress,
pool_slots_3[activeSlot_ap3].id,
idToAddress[users[pool_slots_3[activeSlot_ap3].userAddress].referrerId],
3
));
pool_slots_3[activeSlot_ap3].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user3 = UsersPool({
id: newSlotId_ap3,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_3[msg.sender] = user3;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap3,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_3[newSlotId_ap3] = _newSlot;
newUserId_ap3++;
emit RegisterUserEvent(newSlotId_ap3, msg.sender, idToAddress[_referrerId], 3, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 3);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 3);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap3++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_3[activeSlot_ap3].userAddress, 1, 3);
users[pool_slots_3[activeSlot_ap3].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_3[activeSlot_ap3].referrerId > 0) {
payUpline(idToAddress[pool_slots_3[activeSlot_ap3].referrerId], 1, 3);
users[idToAddress[pool_slots_3[activeSlot_ap3].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 3);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_3[activeSlot_ap3].eventsCount++;
}
}
else if(_fromPool == 4){
require(msg.value == 0.4 ether, "Participation fee in Autopool is 0.4 ETH");
require(!isUserExists(msg.sender, 4), "User already registered in AP4");
uint eventCount = pool_slots_4[activeSlot_ap4].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_4[activeSlot_ap4].userAddress,
pool_slots_4[activeSlot_ap4].id,
idToAddress[users[pool_slots_4[activeSlot_ap4].userAddress].referrerId],
4
));
pool_slots_4[activeSlot_ap4].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user4 = UsersPool({
id: newSlotId_ap4,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_4[msg.sender] = user4;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap4,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_4[newSlotId_ap4] = _newSlot;
newUserId_ap4++;
emit RegisterUserEvent(newSlotId_ap4, msg.sender, idToAddress[_referrerId], 4, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 4);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 4);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap4++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_4[activeSlot_ap4].userAddress, 1, 4);
users[pool_slots_4[activeSlot_ap4].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_4[activeSlot_ap4].referrerId > 0) {
payUpline(idToAddress[pool_slots_4[activeSlot_ap4].referrerId], 1, 4);
users[idToAddress[pool_slots_4[activeSlot_ap4].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 4);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_4[activeSlot_ap4].eventsCount++;
}
}
else if(_fromPool == 5){
require(msg.value == 0.5 ether, "Participation fee in Autopool is 0.5 ETH");
require(!isUserExists(msg.sender, 5), "User already registered in AP5");
uint eventCount = pool_slots_5[activeSlot_ap5].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_5[activeSlot_ap5].userAddress,
pool_slots_5[activeSlot_ap5].id,
idToAddress[users[pool_slots_5[activeSlot_ap5].userAddress].referrerId],
5
));
pool_slots_5[activeSlot_ap5].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user5 = UsersPool({
id: newSlotId_ap5,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_5[msg.sender] = user5;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap5,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_5[newSlotId_ap5] = _newSlot;
newUserId_ap5++;
emit RegisterUserEvent(newSlotId_ap5, msg.sender, idToAddress[_referrerId], 5, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 5);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 5);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap5++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_5[activeSlot_ap5].userAddress, 1, 5);
users[pool_slots_5[activeSlot_ap5].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_5[activeSlot_ap5].referrerId > 0) {
payUpline(idToAddress[pool_slots_5[activeSlot_ap5].referrerId], 1, 5);
users[idToAddress[pool_slots_5[activeSlot_ap5].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 5);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_5[activeSlot_ap5].eventsCount++;
}
}
else if(_fromPool == 6){
require(msg.value == 0.7 ether, "Participation fee in Autopool is 0.7 ETH");
require(!isUserExists(msg.sender, 6), "User already registered in AP6");
uint eventCount = pool_slots_6[activeSlot_ap6].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_6[activeSlot_ap6].userAddress,
pool_slots_6[activeSlot_ap6].id,
idToAddress[users[pool_slots_6[activeSlot_ap6].userAddress].referrerId],
6
));
pool_slots_6[activeSlot_ap6].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user6 = UsersPool({
id: newSlotId_ap6,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_6[msg.sender] = user6;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap6,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_6[newSlotId_ap6] = _newSlot;
newUserId_ap6++;
emit RegisterUserEvent(newSlotId_ap6, msg.sender, idToAddress[_referrerId], 6, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 6);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 6);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap6++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_6[activeSlot_ap6].userAddress, 1, 6);
users[pool_slots_6[activeSlot_ap6].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_6[activeSlot_ap6].referrerId > 0) {
payUpline(idToAddress[pool_slots_6[activeSlot_ap6].referrerId], 1, 6);
users[idToAddress[pool_slots_6[activeSlot_ap6].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 6);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_6[activeSlot_ap6].eventsCount++;
}
}else{
require(msg.value == 1 ether, "Participation fee in Autopool is 1 ETH");
require(!isUserExists(msg.sender, 7), "User already registered in AP7");
uint eventCount = pool_slots_7[activeSlot_ap7].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_7[activeSlot_ap7].userAddress,
pool_slots_7[activeSlot_ap7].id,
idToAddress[users[pool_slots_7[activeSlot_ap7].userAddress].referrerId],
7
));
pool_slots_7[activeSlot_ap7].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user7 = UsersPool({
id: newSlotId_ap7,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_7[msg.sender] = user7;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap7,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_7[newSlotId_ap7] = _newSlot;
newUserId_ap7++;
emit RegisterUserEvent(newSlotId_ap7, msg.sender, idToAddress[_referrerId], 7, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 7);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 7);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap7++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_7[activeSlot_ap7].userAddress, 1, 7);
users[pool_slots_7[activeSlot_ap7].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_7[activeSlot_ap7].referrerId > 0) {
payUpline(idToAddress[pool_slots_7[activeSlot_ap7].referrerId], 1, 7);
users[idToAddress[pool_slots_7[activeSlot_ap7].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 7);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_7[activeSlot_ap7].eventsCount++;
}
}
}
function reinvestSlot(address _userAddress, uint _userId, address _sponsorAddress, uint8 _fromPool) private returns (bool _isReinvested) {
}
function payUpline(address _sponsorAddress, uint8 _refLevel, uint8 _fromPool) private returns (uint distributeAmount) {
}
function payFirstLine(address _sponsorAddress, uint payAmount, uint8 _fromPool) private returns (uint distributeAmount) {
}
function isUserQualified(address _userAddress) public view returns (bool) {
}
function isUserExists(address _userAddress, uint8 _autopool) public view returns (bool) {
}
function getUserReferrals(address _userAddress)
public
view
returns (address[] memory)
{
}
}
| isUserExists(msg.sender,1),"User not present in AP1" | 352,604 | isUserExists(msg.sender,1) |
"User not qualified in AP1" | pragma solidity >=0.5.12 <0.7.0;
contract way2eth {
struct User {
uint id;
uint referrerCount;
uint referrerId;
uint earnedFromPool;
uint earnedFromRef;
uint earnedFromGlobal;
address[] referrals;
}
struct UsersPool {
uint id;
uint referrerId;
uint reinvestCount;
}
struct PoolSlots {
uint id;
address userAddress;
uint referrerId;
uint8 eventsCount;
}
modifier validReferrerId(uint _referrerId) {
}
event RegisterUserEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event ReinvestEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event DistributeUplineEvent(uint amount, address indexed _sponsorAddress, address indexed _fromAddress, uint _level, uint8 _fromPool, uint _time);
event ReferralPaymentEvent(uint amount, address indexed _from, address indexed _to, uint8 indexed _fromPool, uint _time);
mapping(address => User) public users;
mapping(address => UsersPool) public users_2;
mapping(uint => PoolSlots) public pool_slots_2;
mapping(address => UsersPool) public users_3;
mapping(uint => PoolSlots) public pool_slots_3;
mapping(address => UsersPool) public users_4;
mapping(uint => PoolSlots) public pool_slots_4;
mapping(address => UsersPool) public users_5;
mapping(uint => PoolSlots) public pool_slots_5;
mapping(address => UsersPool) public users_6;
mapping(uint => PoolSlots) public pool_slots_6;
mapping(address => UsersPool) public users_7;
mapping(uint => PoolSlots) public pool_slots_7;
mapping(address => UsersPool) public users_8;
mapping(uint => PoolSlots) public pool_slots_8;
mapping(uint => address) public idToAddress;
mapping (uint => uint) public uplineAmount;
uint public newUserId = 1;
uint public newUserId_ap2 = 1;
uint public newUserId_ap3 = 1;
uint public newUserId_ap4 = 1;
uint public newUserId_ap5 = 1;
uint public newUserId_ap6 = 1;
uint public newUserId_ap7 = 1;
uint public newUserId_ap8 = 1;
uint public newSlotId_ap2 = 1;
uint public activeSlot_ap2 = 1;
uint public newSlotId_ap3 = 1;
uint public activeSlot_ap3 = 1;
uint public newSlotId_ap4 = 1;
uint public activeSlot_ap4 = 1;
uint public newSlotId_ap5 = 1;
uint public activeSlot_ap5 = 1;
uint public newSlotId_ap6 = 1;
uint public activeSlot_ap6 = 1;
uint public newSlotId_ap7 = 1;
uint public activeSlot_ap7 = 1;
uint public newSlotId_ap8 = 1;
uint public activeSlot_ap8 = 1;
address public owner;
constructor(address _ownerAddress) public {
}
function participatePool1(uint _referrerId)
public
payable
validReferrerId(_referrerId)
{
}
function participatePool2(uint8 _fromPool)
public
payable
{
if(_fromPool == 2 || _fromPool == 3 || _fromPool == 4 || _fromPool == 5 || _fromPool == 6 || _fromPool == 7){
require(isUserExists(msg.sender, 1), "User not present in AP1");
require(<FILL_ME>)
}
if(_fromPool == 2){
require(msg.value == 0.2 ether, "Participation fee in Autopool is 0.2 ETH");
require(!isUserExists(msg.sender, 2), "User already registered in AP2");
uint eventCount = pool_slots_2[activeSlot_ap2].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_2[activeSlot_ap2].userAddress,
pool_slots_2[activeSlot_ap2].id,
idToAddress[users[pool_slots_2[activeSlot_ap2].userAddress].referrerId],
2
));
pool_slots_2[activeSlot_ap2].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user2 = UsersPool({
id: newSlotId_ap2,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_2[msg.sender] = user2;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap2,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_2[newSlotId_ap2] = _newSlot;
newUserId_ap2++;
emit RegisterUserEvent(newSlotId_ap2, msg.sender, idToAddress[_referrerId], 2, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 2);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 2);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap2++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_2[activeSlot_ap2].userAddress, 1, 2);
users[pool_slots_2[activeSlot_ap2].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_2[activeSlot_ap2].referrerId > 0) {
payUpline(idToAddress[pool_slots_2[activeSlot_ap2].referrerId], 1, 2);
users[idToAddress[pool_slots_2[activeSlot_ap2].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 2);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_2[activeSlot_ap2].eventsCount++;
}
}else if(_fromPool == 3){
require(msg.value == 0.3 ether, "Participation fee in Autopool is 0.3 ETH");
require(!isUserExists(msg.sender, 3), "User already registered in AP3");
uint eventCount = pool_slots_3[activeSlot_ap3].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_3[activeSlot_ap3].userAddress,
pool_slots_3[activeSlot_ap3].id,
idToAddress[users[pool_slots_3[activeSlot_ap3].userAddress].referrerId],
3
));
pool_slots_3[activeSlot_ap3].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user3 = UsersPool({
id: newSlotId_ap3,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_3[msg.sender] = user3;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap3,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_3[newSlotId_ap3] = _newSlot;
newUserId_ap3++;
emit RegisterUserEvent(newSlotId_ap3, msg.sender, idToAddress[_referrerId], 3, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 3);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 3);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap3++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_3[activeSlot_ap3].userAddress, 1, 3);
users[pool_slots_3[activeSlot_ap3].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_3[activeSlot_ap3].referrerId > 0) {
payUpline(idToAddress[pool_slots_3[activeSlot_ap3].referrerId], 1, 3);
users[idToAddress[pool_slots_3[activeSlot_ap3].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 3);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_3[activeSlot_ap3].eventsCount++;
}
}
else if(_fromPool == 4){
require(msg.value == 0.4 ether, "Participation fee in Autopool is 0.4 ETH");
require(!isUserExists(msg.sender, 4), "User already registered in AP4");
uint eventCount = pool_slots_4[activeSlot_ap4].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_4[activeSlot_ap4].userAddress,
pool_slots_4[activeSlot_ap4].id,
idToAddress[users[pool_slots_4[activeSlot_ap4].userAddress].referrerId],
4
));
pool_slots_4[activeSlot_ap4].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user4 = UsersPool({
id: newSlotId_ap4,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_4[msg.sender] = user4;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap4,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_4[newSlotId_ap4] = _newSlot;
newUserId_ap4++;
emit RegisterUserEvent(newSlotId_ap4, msg.sender, idToAddress[_referrerId], 4, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 4);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 4);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap4++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_4[activeSlot_ap4].userAddress, 1, 4);
users[pool_slots_4[activeSlot_ap4].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_4[activeSlot_ap4].referrerId > 0) {
payUpline(idToAddress[pool_slots_4[activeSlot_ap4].referrerId], 1, 4);
users[idToAddress[pool_slots_4[activeSlot_ap4].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 4);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_4[activeSlot_ap4].eventsCount++;
}
}
else if(_fromPool == 5){
require(msg.value == 0.5 ether, "Participation fee in Autopool is 0.5 ETH");
require(!isUserExists(msg.sender, 5), "User already registered in AP5");
uint eventCount = pool_slots_5[activeSlot_ap5].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_5[activeSlot_ap5].userAddress,
pool_slots_5[activeSlot_ap5].id,
idToAddress[users[pool_slots_5[activeSlot_ap5].userAddress].referrerId],
5
));
pool_slots_5[activeSlot_ap5].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user5 = UsersPool({
id: newSlotId_ap5,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_5[msg.sender] = user5;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap5,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_5[newSlotId_ap5] = _newSlot;
newUserId_ap5++;
emit RegisterUserEvent(newSlotId_ap5, msg.sender, idToAddress[_referrerId], 5, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 5);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 5);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap5++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_5[activeSlot_ap5].userAddress, 1, 5);
users[pool_slots_5[activeSlot_ap5].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_5[activeSlot_ap5].referrerId > 0) {
payUpline(idToAddress[pool_slots_5[activeSlot_ap5].referrerId], 1, 5);
users[idToAddress[pool_slots_5[activeSlot_ap5].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 5);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_5[activeSlot_ap5].eventsCount++;
}
}
else if(_fromPool == 6){
require(msg.value == 0.7 ether, "Participation fee in Autopool is 0.7 ETH");
require(!isUserExists(msg.sender, 6), "User already registered in AP6");
uint eventCount = pool_slots_6[activeSlot_ap6].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_6[activeSlot_ap6].userAddress,
pool_slots_6[activeSlot_ap6].id,
idToAddress[users[pool_slots_6[activeSlot_ap6].userAddress].referrerId],
6
));
pool_slots_6[activeSlot_ap6].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user6 = UsersPool({
id: newSlotId_ap6,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_6[msg.sender] = user6;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap6,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_6[newSlotId_ap6] = _newSlot;
newUserId_ap6++;
emit RegisterUserEvent(newSlotId_ap6, msg.sender, idToAddress[_referrerId], 6, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 6);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 6);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap6++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_6[activeSlot_ap6].userAddress, 1, 6);
users[pool_slots_6[activeSlot_ap6].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_6[activeSlot_ap6].referrerId > 0) {
payUpline(idToAddress[pool_slots_6[activeSlot_ap6].referrerId], 1, 6);
users[idToAddress[pool_slots_6[activeSlot_ap6].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 6);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_6[activeSlot_ap6].eventsCount++;
}
}else{
require(msg.value == 1 ether, "Participation fee in Autopool is 1 ETH");
require(!isUserExists(msg.sender, 7), "User already registered in AP7");
uint eventCount = pool_slots_7[activeSlot_ap7].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_7[activeSlot_ap7].userAddress,
pool_slots_7[activeSlot_ap7].id,
idToAddress[users[pool_slots_7[activeSlot_ap7].userAddress].referrerId],
7
));
pool_slots_7[activeSlot_ap7].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user7 = UsersPool({
id: newSlotId_ap7,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_7[msg.sender] = user7;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap7,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_7[newSlotId_ap7] = _newSlot;
newUserId_ap7++;
emit RegisterUserEvent(newSlotId_ap7, msg.sender, idToAddress[_referrerId], 7, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 7);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 7);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap7++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_7[activeSlot_ap7].userAddress, 1, 7);
users[pool_slots_7[activeSlot_ap7].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_7[activeSlot_ap7].referrerId > 0) {
payUpline(idToAddress[pool_slots_7[activeSlot_ap7].referrerId], 1, 7);
users[idToAddress[pool_slots_7[activeSlot_ap7].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 7);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_7[activeSlot_ap7].eventsCount++;
}
}
}
function reinvestSlot(address _userAddress, uint _userId, address _sponsorAddress, uint8 _fromPool) private returns (bool _isReinvested) {
}
function payUpline(address _sponsorAddress, uint8 _refLevel, uint8 _fromPool) private returns (uint distributeAmount) {
}
function payFirstLine(address _sponsorAddress, uint payAmount, uint8 _fromPool) private returns (uint distributeAmount) {
}
function isUserQualified(address _userAddress) public view returns (bool) {
}
function isUserExists(address _userAddress, uint8 _autopool) public view returns (bool) {
}
function getUserReferrals(address _userAddress)
public
view
returns (address[] memory)
{
}
}
| isUserQualified(msg.sender),"User not qualified in AP1" | 352,604 | isUserQualified(msg.sender) |
"User already registered in AP2" | pragma solidity >=0.5.12 <0.7.0;
contract way2eth {
struct User {
uint id;
uint referrerCount;
uint referrerId;
uint earnedFromPool;
uint earnedFromRef;
uint earnedFromGlobal;
address[] referrals;
}
struct UsersPool {
uint id;
uint referrerId;
uint reinvestCount;
}
struct PoolSlots {
uint id;
address userAddress;
uint referrerId;
uint8 eventsCount;
}
modifier validReferrerId(uint _referrerId) {
}
event RegisterUserEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event ReinvestEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event DistributeUplineEvent(uint amount, address indexed _sponsorAddress, address indexed _fromAddress, uint _level, uint8 _fromPool, uint _time);
event ReferralPaymentEvent(uint amount, address indexed _from, address indexed _to, uint8 indexed _fromPool, uint _time);
mapping(address => User) public users;
mapping(address => UsersPool) public users_2;
mapping(uint => PoolSlots) public pool_slots_2;
mapping(address => UsersPool) public users_3;
mapping(uint => PoolSlots) public pool_slots_3;
mapping(address => UsersPool) public users_4;
mapping(uint => PoolSlots) public pool_slots_4;
mapping(address => UsersPool) public users_5;
mapping(uint => PoolSlots) public pool_slots_5;
mapping(address => UsersPool) public users_6;
mapping(uint => PoolSlots) public pool_slots_6;
mapping(address => UsersPool) public users_7;
mapping(uint => PoolSlots) public pool_slots_7;
mapping(address => UsersPool) public users_8;
mapping(uint => PoolSlots) public pool_slots_8;
mapping(uint => address) public idToAddress;
mapping (uint => uint) public uplineAmount;
uint public newUserId = 1;
uint public newUserId_ap2 = 1;
uint public newUserId_ap3 = 1;
uint public newUserId_ap4 = 1;
uint public newUserId_ap5 = 1;
uint public newUserId_ap6 = 1;
uint public newUserId_ap7 = 1;
uint public newUserId_ap8 = 1;
uint public newSlotId_ap2 = 1;
uint public activeSlot_ap2 = 1;
uint public newSlotId_ap3 = 1;
uint public activeSlot_ap3 = 1;
uint public newSlotId_ap4 = 1;
uint public activeSlot_ap4 = 1;
uint public newSlotId_ap5 = 1;
uint public activeSlot_ap5 = 1;
uint public newSlotId_ap6 = 1;
uint public activeSlot_ap6 = 1;
uint public newSlotId_ap7 = 1;
uint public activeSlot_ap7 = 1;
uint public newSlotId_ap8 = 1;
uint public activeSlot_ap8 = 1;
address public owner;
constructor(address _ownerAddress) public {
}
function participatePool1(uint _referrerId)
public
payable
validReferrerId(_referrerId)
{
}
function participatePool2(uint8 _fromPool)
public
payable
{
if(_fromPool == 2 || _fromPool == 3 || _fromPool == 4 || _fromPool == 5 || _fromPool == 6 || _fromPool == 7){
require(isUserExists(msg.sender, 1), "User not present in AP1");
require(isUserQualified(msg.sender), "User not qualified in AP1");
}
if(_fromPool == 2){
require(msg.value == 0.2 ether, "Participation fee in Autopool is 0.2 ETH");
require(<FILL_ME>)
uint eventCount = pool_slots_2[activeSlot_ap2].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_2[activeSlot_ap2].userAddress,
pool_slots_2[activeSlot_ap2].id,
idToAddress[users[pool_slots_2[activeSlot_ap2].userAddress].referrerId],
2
));
pool_slots_2[activeSlot_ap2].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user2 = UsersPool({
id: newSlotId_ap2,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_2[msg.sender] = user2;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap2,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_2[newSlotId_ap2] = _newSlot;
newUserId_ap2++;
emit RegisterUserEvent(newSlotId_ap2, msg.sender, idToAddress[_referrerId], 2, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 2);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 2);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap2++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_2[activeSlot_ap2].userAddress, 1, 2);
users[pool_slots_2[activeSlot_ap2].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_2[activeSlot_ap2].referrerId > 0) {
payUpline(idToAddress[pool_slots_2[activeSlot_ap2].referrerId], 1, 2);
users[idToAddress[pool_slots_2[activeSlot_ap2].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 2);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_2[activeSlot_ap2].eventsCount++;
}
}else if(_fromPool == 3){
require(msg.value == 0.3 ether, "Participation fee in Autopool is 0.3 ETH");
require(!isUserExists(msg.sender, 3), "User already registered in AP3");
uint eventCount = pool_slots_3[activeSlot_ap3].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_3[activeSlot_ap3].userAddress,
pool_slots_3[activeSlot_ap3].id,
idToAddress[users[pool_slots_3[activeSlot_ap3].userAddress].referrerId],
3
));
pool_slots_3[activeSlot_ap3].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user3 = UsersPool({
id: newSlotId_ap3,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_3[msg.sender] = user3;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap3,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_3[newSlotId_ap3] = _newSlot;
newUserId_ap3++;
emit RegisterUserEvent(newSlotId_ap3, msg.sender, idToAddress[_referrerId], 3, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 3);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 3);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap3++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_3[activeSlot_ap3].userAddress, 1, 3);
users[pool_slots_3[activeSlot_ap3].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_3[activeSlot_ap3].referrerId > 0) {
payUpline(idToAddress[pool_slots_3[activeSlot_ap3].referrerId], 1, 3);
users[idToAddress[pool_slots_3[activeSlot_ap3].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 3);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_3[activeSlot_ap3].eventsCount++;
}
}
else if(_fromPool == 4){
require(msg.value == 0.4 ether, "Participation fee in Autopool is 0.4 ETH");
require(!isUserExists(msg.sender, 4), "User already registered in AP4");
uint eventCount = pool_slots_4[activeSlot_ap4].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_4[activeSlot_ap4].userAddress,
pool_slots_4[activeSlot_ap4].id,
idToAddress[users[pool_slots_4[activeSlot_ap4].userAddress].referrerId],
4
));
pool_slots_4[activeSlot_ap4].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user4 = UsersPool({
id: newSlotId_ap4,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_4[msg.sender] = user4;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap4,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_4[newSlotId_ap4] = _newSlot;
newUserId_ap4++;
emit RegisterUserEvent(newSlotId_ap4, msg.sender, idToAddress[_referrerId], 4, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 4);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 4);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap4++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_4[activeSlot_ap4].userAddress, 1, 4);
users[pool_slots_4[activeSlot_ap4].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_4[activeSlot_ap4].referrerId > 0) {
payUpline(idToAddress[pool_slots_4[activeSlot_ap4].referrerId], 1, 4);
users[idToAddress[pool_slots_4[activeSlot_ap4].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 4);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_4[activeSlot_ap4].eventsCount++;
}
}
else if(_fromPool == 5){
require(msg.value == 0.5 ether, "Participation fee in Autopool is 0.5 ETH");
require(!isUserExists(msg.sender, 5), "User already registered in AP5");
uint eventCount = pool_slots_5[activeSlot_ap5].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_5[activeSlot_ap5].userAddress,
pool_slots_5[activeSlot_ap5].id,
idToAddress[users[pool_slots_5[activeSlot_ap5].userAddress].referrerId],
5
));
pool_slots_5[activeSlot_ap5].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user5 = UsersPool({
id: newSlotId_ap5,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_5[msg.sender] = user5;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap5,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_5[newSlotId_ap5] = _newSlot;
newUserId_ap5++;
emit RegisterUserEvent(newSlotId_ap5, msg.sender, idToAddress[_referrerId], 5, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 5);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 5);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap5++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_5[activeSlot_ap5].userAddress, 1, 5);
users[pool_slots_5[activeSlot_ap5].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_5[activeSlot_ap5].referrerId > 0) {
payUpline(idToAddress[pool_slots_5[activeSlot_ap5].referrerId], 1, 5);
users[idToAddress[pool_slots_5[activeSlot_ap5].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 5);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_5[activeSlot_ap5].eventsCount++;
}
}
else if(_fromPool == 6){
require(msg.value == 0.7 ether, "Participation fee in Autopool is 0.7 ETH");
require(!isUserExists(msg.sender, 6), "User already registered in AP6");
uint eventCount = pool_slots_6[activeSlot_ap6].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_6[activeSlot_ap6].userAddress,
pool_slots_6[activeSlot_ap6].id,
idToAddress[users[pool_slots_6[activeSlot_ap6].userAddress].referrerId],
6
));
pool_slots_6[activeSlot_ap6].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user6 = UsersPool({
id: newSlotId_ap6,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_6[msg.sender] = user6;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap6,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_6[newSlotId_ap6] = _newSlot;
newUserId_ap6++;
emit RegisterUserEvent(newSlotId_ap6, msg.sender, idToAddress[_referrerId], 6, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 6);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 6);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap6++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_6[activeSlot_ap6].userAddress, 1, 6);
users[pool_slots_6[activeSlot_ap6].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_6[activeSlot_ap6].referrerId > 0) {
payUpline(idToAddress[pool_slots_6[activeSlot_ap6].referrerId], 1, 6);
users[idToAddress[pool_slots_6[activeSlot_ap6].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 6);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_6[activeSlot_ap6].eventsCount++;
}
}else{
require(msg.value == 1 ether, "Participation fee in Autopool is 1 ETH");
require(!isUserExists(msg.sender, 7), "User already registered in AP7");
uint eventCount = pool_slots_7[activeSlot_ap7].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_7[activeSlot_ap7].userAddress,
pool_slots_7[activeSlot_ap7].id,
idToAddress[users[pool_slots_7[activeSlot_ap7].userAddress].referrerId],
7
));
pool_slots_7[activeSlot_ap7].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user7 = UsersPool({
id: newSlotId_ap7,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_7[msg.sender] = user7;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap7,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_7[newSlotId_ap7] = _newSlot;
newUserId_ap7++;
emit RegisterUserEvent(newSlotId_ap7, msg.sender, idToAddress[_referrerId], 7, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 7);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 7);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap7++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_7[activeSlot_ap7].userAddress, 1, 7);
users[pool_slots_7[activeSlot_ap7].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_7[activeSlot_ap7].referrerId > 0) {
payUpline(idToAddress[pool_slots_7[activeSlot_ap7].referrerId], 1, 7);
users[idToAddress[pool_slots_7[activeSlot_ap7].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 7);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_7[activeSlot_ap7].eventsCount++;
}
}
}
function reinvestSlot(address _userAddress, uint _userId, address _sponsorAddress, uint8 _fromPool) private returns (bool _isReinvested) {
}
function payUpline(address _sponsorAddress, uint8 _refLevel, uint8 _fromPool) private returns (uint distributeAmount) {
}
function payFirstLine(address _sponsorAddress, uint payAmount, uint8 _fromPool) private returns (uint distributeAmount) {
}
function isUserQualified(address _userAddress) public view returns (bool) {
}
function isUserExists(address _userAddress, uint8 _autopool) public view returns (bool) {
}
function getUserReferrals(address _userAddress)
public
view
returns (address[] memory)
{
}
}
| !isUserExists(msg.sender,2),"User already registered in AP2" | 352,604 | !isUserExists(msg.sender,2) |
null | pragma solidity >=0.5.12 <0.7.0;
contract way2eth {
struct User {
uint id;
uint referrerCount;
uint referrerId;
uint earnedFromPool;
uint earnedFromRef;
uint earnedFromGlobal;
address[] referrals;
}
struct UsersPool {
uint id;
uint referrerId;
uint reinvestCount;
}
struct PoolSlots {
uint id;
address userAddress;
uint referrerId;
uint8 eventsCount;
}
modifier validReferrerId(uint _referrerId) {
}
event RegisterUserEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event ReinvestEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event DistributeUplineEvent(uint amount, address indexed _sponsorAddress, address indexed _fromAddress, uint _level, uint8 _fromPool, uint _time);
event ReferralPaymentEvent(uint amount, address indexed _from, address indexed _to, uint8 indexed _fromPool, uint _time);
mapping(address => User) public users;
mapping(address => UsersPool) public users_2;
mapping(uint => PoolSlots) public pool_slots_2;
mapping(address => UsersPool) public users_3;
mapping(uint => PoolSlots) public pool_slots_3;
mapping(address => UsersPool) public users_4;
mapping(uint => PoolSlots) public pool_slots_4;
mapping(address => UsersPool) public users_5;
mapping(uint => PoolSlots) public pool_slots_5;
mapping(address => UsersPool) public users_6;
mapping(uint => PoolSlots) public pool_slots_6;
mapping(address => UsersPool) public users_7;
mapping(uint => PoolSlots) public pool_slots_7;
mapping(address => UsersPool) public users_8;
mapping(uint => PoolSlots) public pool_slots_8;
mapping(uint => address) public idToAddress;
mapping (uint => uint) public uplineAmount;
uint public newUserId = 1;
uint public newUserId_ap2 = 1;
uint public newUserId_ap3 = 1;
uint public newUserId_ap4 = 1;
uint public newUserId_ap5 = 1;
uint public newUserId_ap6 = 1;
uint public newUserId_ap7 = 1;
uint public newUserId_ap8 = 1;
uint public newSlotId_ap2 = 1;
uint public activeSlot_ap2 = 1;
uint public newSlotId_ap3 = 1;
uint public activeSlot_ap3 = 1;
uint public newSlotId_ap4 = 1;
uint public activeSlot_ap4 = 1;
uint public newSlotId_ap5 = 1;
uint public activeSlot_ap5 = 1;
uint public newSlotId_ap6 = 1;
uint public activeSlot_ap6 = 1;
uint public newSlotId_ap7 = 1;
uint public activeSlot_ap7 = 1;
uint public newSlotId_ap8 = 1;
uint public activeSlot_ap8 = 1;
address public owner;
constructor(address _ownerAddress) public {
}
function participatePool1(uint _referrerId)
public
payable
validReferrerId(_referrerId)
{
}
function participatePool2(uint8 _fromPool)
public
payable
{
if(_fromPool == 2 || _fromPool == 3 || _fromPool == 4 || _fromPool == 5 || _fromPool == 6 || _fromPool == 7){
require(isUserExists(msg.sender, 1), "User not present in AP1");
require(isUserQualified(msg.sender), "User not qualified in AP1");
}
if(_fromPool == 2){
require(msg.value == 0.2 ether, "Participation fee in Autopool is 0.2 ETH");
require(!isUserExists(msg.sender, 2), "User already registered in AP2");
uint eventCount = pool_slots_2[activeSlot_ap2].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(<FILL_ME>)
pool_slots_2[activeSlot_ap2].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user2 = UsersPool({
id: newSlotId_ap2,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_2[msg.sender] = user2;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap2,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_2[newSlotId_ap2] = _newSlot;
newUserId_ap2++;
emit RegisterUserEvent(newSlotId_ap2, msg.sender, idToAddress[_referrerId], 2, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 2);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 2);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap2++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_2[activeSlot_ap2].userAddress, 1, 2);
users[pool_slots_2[activeSlot_ap2].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_2[activeSlot_ap2].referrerId > 0) {
payUpline(idToAddress[pool_slots_2[activeSlot_ap2].referrerId], 1, 2);
users[idToAddress[pool_slots_2[activeSlot_ap2].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 2);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_2[activeSlot_ap2].eventsCount++;
}
}else if(_fromPool == 3){
require(msg.value == 0.3 ether, "Participation fee in Autopool is 0.3 ETH");
require(!isUserExists(msg.sender, 3), "User already registered in AP3");
uint eventCount = pool_slots_3[activeSlot_ap3].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_3[activeSlot_ap3].userAddress,
pool_slots_3[activeSlot_ap3].id,
idToAddress[users[pool_slots_3[activeSlot_ap3].userAddress].referrerId],
3
));
pool_slots_3[activeSlot_ap3].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user3 = UsersPool({
id: newSlotId_ap3,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_3[msg.sender] = user3;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap3,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_3[newSlotId_ap3] = _newSlot;
newUserId_ap3++;
emit RegisterUserEvent(newSlotId_ap3, msg.sender, idToAddress[_referrerId], 3, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 3);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 3);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap3++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_3[activeSlot_ap3].userAddress, 1, 3);
users[pool_slots_3[activeSlot_ap3].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_3[activeSlot_ap3].referrerId > 0) {
payUpline(idToAddress[pool_slots_3[activeSlot_ap3].referrerId], 1, 3);
users[idToAddress[pool_slots_3[activeSlot_ap3].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 3);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_3[activeSlot_ap3].eventsCount++;
}
}
else if(_fromPool == 4){
require(msg.value == 0.4 ether, "Participation fee in Autopool is 0.4 ETH");
require(!isUserExists(msg.sender, 4), "User already registered in AP4");
uint eventCount = pool_slots_4[activeSlot_ap4].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_4[activeSlot_ap4].userAddress,
pool_slots_4[activeSlot_ap4].id,
idToAddress[users[pool_slots_4[activeSlot_ap4].userAddress].referrerId],
4
));
pool_slots_4[activeSlot_ap4].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user4 = UsersPool({
id: newSlotId_ap4,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_4[msg.sender] = user4;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap4,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_4[newSlotId_ap4] = _newSlot;
newUserId_ap4++;
emit RegisterUserEvent(newSlotId_ap4, msg.sender, idToAddress[_referrerId], 4, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 4);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 4);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap4++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_4[activeSlot_ap4].userAddress, 1, 4);
users[pool_slots_4[activeSlot_ap4].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_4[activeSlot_ap4].referrerId > 0) {
payUpline(idToAddress[pool_slots_4[activeSlot_ap4].referrerId], 1, 4);
users[idToAddress[pool_slots_4[activeSlot_ap4].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 4);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_4[activeSlot_ap4].eventsCount++;
}
}
else if(_fromPool == 5){
require(msg.value == 0.5 ether, "Participation fee in Autopool is 0.5 ETH");
require(!isUserExists(msg.sender, 5), "User already registered in AP5");
uint eventCount = pool_slots_5[activeSlot_ap5].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_5[activeSlot_ap5].userAddress,
pool_slots_5[activeSlot_ap5].id,
idToAddress[users[pool_slots_5[activeSlot_ap5].userAddress].referrerId],
5
));
pool_slots_5[activeSlot_ap5].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user5 = UsersPool({
id: newSlotId_ap5,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_5[msg.sender] = user5;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap5,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_5[newSlotId_ap5] = _newSlot;
newUserId_ap5++;
emit RegisterUserEvent(newSlotId_ap5, msg.sender, idToAddress[_referrerId], 5, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 5);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 5);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap5++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_5[activeSlot_ap5].userAddress, 1, 5);
users[pool_slots_5[activeSlot_ap5].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_5[activeSlot_ap5].referrerId > 0) {
payUpline(idToAddress[pool_slots_5[activeSlot_ap5].referrerId], 1, 5);
users[idToAddress[pool_slots_5[activeSlot_ap5].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 5);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_5[activeSlot_ap5].eventsCount++;
}
}
else if(_fromPool == 6){
require(msg.value == 0.7 ether, "Participation fee in Autopool is 0.7 ETH");
require(!isUserExists(msg.sender, 6), "User already registered in AP6");
uint eventCount = pool_slots_6[activeSlot_ap6].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_6[activeSlot_ap6].userAddress,
pool_slots_6[activeSlot_ap6].id,
idToAddress[users[pool_slots_6[activeSlot_ap6].userAddress].referrerId],
6
));
pool_slots_6[activeSlot_ap6].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user6 = UsersPool({
id: newSlotId_ap6,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_6[msg.sender] = user6;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap6,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_6[newSlotId_ap6] = _newSlot;
newUserId_ap6++;
emit RegisterUserEvent(newSlotId_ap6, msg.sender, idToAddress[_referrerId], 6, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 6);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 6);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap6++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_6[activeSlot_ap6].userAddress, 1, 6);
users[pool_slots_6[activeSlot_ap6].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_6[activeSlot_ap6].referrerId > 0) {
payUpline(idToAddress[pool_slots_6[activeSlot_ap6].referrerId], 1, 6);
users[idToAddress[pool_slots_6[activeSlot_ap6].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 6);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_6[activeSlot_ap6].eventsCount++;
}
}else{
require(msg.value == 1 ether, "Participation fee in Autopool is 1 ETH");
require(!isUserExists(msg.sender, 7), "User already registered in AP7");
uint eventCount = pool_slots_7[activeSlot_ap7].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_7[activeSlot_ap7].userAddress,
pool_slots_7[activeSlot_ap7].id,
idToAddress[users[pool_slots_7[activeSlot_ap7].userAddress].referrerId],
7
));
pool_slots_7[activeSlot_ap7].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user7 = UsersPool({
id: newSlotId_ap7,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_7[msg.sender] = user7;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap7,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_7[newSlotId_ap7] = _newSlot;
newUserId_ap7++;
emit RegisterUserEvent(newSlotId_ap7, msg.sender, idToAddress[_referrerId], 7, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 7);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 7);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap7++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_7[activeSlot_ap7].userAddress, 1, 7);
users[pool_slots_7[activeSlot_ap7].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_7[activeSlot_ap7].referrerId > 0) {
payUpline(idToAddress[pool_slots_7[activeSlot_ap7].referrerId], 1, 7);
users[idToAddress[pool_slots_7[activeSlot_ap7].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 7);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_7[activeSlot_ap7].eventsCount++;
}
}
}
function reinvestSlot(address _userAddress, uint _userId, address _sponsorAddress, uint8 _fromPool) private returns (bool _isReinvested) {
}
function payUpline(address _sponsorAddress, uint8 _refLevel, uint8 _fromPool) private returns (uint distributeAmount) {
}
function payFirstLine(address _sponsorAddress, uint payAmount, uint8 _fromPool) private returns (uint distributeAmount) {
}
function isUserQualified(address _userAddress) public view returns (bool) {
}
function isUserExists(address _userAddress, uint8 _autopool) public view returns (bool) {
}
function getUserReferrals(address _userAddress)
public
view
returns (address[] memory)
{
}
}
| reinvestSlot(pool_slots_2[activeSlot_ap2].userAddress,pool_slots_2[activeSlot_ap2].id,idToAddress[users[pool_slots_2[activeSlot_ap2].userAddress].referrerId],2) | 352,604 | reinvestSlot(pool_slots_2[activeSlot_ap2].userAddress,pool_slots_2[activeSlot_ap2].id,idToAddress[users[pool_slots_2[activeSlot_ap2].userAddress].referrerId],2) |
"User already registered in AP3" | pragma solidity >=0.5.12 <0.7.0;
contract way2eth {
struct User {
uint id;
uint referrerCount;
uint referrerId;
uint earnedFromPool;
uint earnedFromRef;
uint earnedFromGlobal;
address[] referrals;
}
struct UsersPool {
uint id;
uint referrerId;
uint reinvestCount;
}
struct PoolSlots {
uint id;
address userAddress;
uint referrerId;
uint8 eventsCount;
}
modifier validReferrerId(uint _referrerId) {
}
event RegisterUserEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event ReinvestEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event DistributeUplineEvent(uint amount, address indexed _sponsorAddress, address indexed _fromAddress, uint _level, uint8 _fromPool, uint _time);
event ReferralPaymentEvent(uint amount, address indexed _from, address indexed _to, uint8 indexed _fromPool, uint _time);
mapping(address => User) public users;
mapping(address => UsersPool) public users_2;
mapping(uint => PoolSlots) public pool_slots_2;
mapping(address => UsersPool) public users_3;
mapping(uint => PoolSlots) public pool_slots_3;
mapping(address => UsersPool) public users_4;
mapping(uint => PoolSlots) public pool_slots_4;
mapping(address => UsersPool) public users_5;
mapping(uint => PoolSlots) public pool_slots_5;
mapping(address => UsersPool) public users_6;
mapping(uint => PoolSlots) public pool_slots_6;
mapping(address => UsersPool) public users_7;
mapping(uint => PoolSlots) public pool_slots_7;
mapping(address => UsersPool) public users_8;
mapping(uint => PoolSlots) public pool_slots_8;
mapping(uint => address) public idToAddress;
mapping (uint => uint) public uplineAmount;
uint public newUserId = 1;
uint public newUserId_ap2 = 1;
uint public newUserId_ap3 = 1;
uint public newUserId_ap4 = 1;
uint public newUserId_ap5 = 1;
uint public newUserId_ap6 = 1;
uint public newUserId_ap7 = 1;
uint public newUserId_ap8 = 1;
uint public newSlotId_ap2 = 1;
uint public activeSlot_ap2 = 1;
uint public newSlotId_ap3 = 1;
uint public activeSlot_ap3 = 1;
uint public newSlotId_ap4 = 1;
uint public activeSlot_ap4 = 1;
uint public newSlotId_ap5 = 1;
uint public activeSlot_ap5 = 1;
uint public newSlotId_ap6 = 1;
uint public activeSlot_ap6 = 1;
uint public newSlotId_ap7 = 1;
uint public activeSlot_ap7 = 1;
uint public newSlotId_ap8 = 1;
uint public activeSlot_ap8 = 1;
address public owner;
constructor(address _ownerAddress) public {
}
function participatePool1(uint _referrerId)
public
payable
validReferrerId(_referrerId)
{
}
function participatePool2(uint8 _fromPool)
public
payable
{
if(_fromPool == 2 || _fromPool == 3 || _fromPool == 4 || _fromPool == 5 || _fromPool == 6 || _fromPool == 7){
require(isUserExists(msg.sender, 1), "User not present in AP1");
require(isUserQualified(msg.sender), "User not qualified in AP1");
}
if(_fromPool == 2){
require(msg.value == 0.2 ether, "Participation fee in Autopool is 0.2 ETH");
require(!isUserExists(msg.sender, 2), "User already registered in AP2");
uint eventCount = pool_slots_2[activeSlot_ap2].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_2[activeSlot_ap2].userAddress,
pool_slots_2[activeSlot_ap2].id,
idToAddress[users[pool_slots_2[activeSlot_ap2].userAddress].referrerId],
2
));
pool_slots_2[activeSlot_ap2].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user2 = UsersPool({
id: newSlotId_ap2,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_2[msg.sender] = user2;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap2,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_2[newSlotId_ap2] = _newSlot;
newUserId_ap2++;
emit RegisterUserEvent(newSlotId_ap2, msg.sender, idToAddress[_referrerId], 2, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 2);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 2);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap2++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_2[activeSlot_ap2].userAddress, 1, 2);
users[pool_slots_2[activeSlot_ap2].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_2[activeSlot_ap2].referrerId > 0) {
payUpline(idToAddress[pool_slots_2[activeSlot_ap2].referrerId], 1, 2);
users[idToAddress[pool_slots_2[activeSlot_ap2].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 2);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_2[activeSlot_ap2].eventsCount++;
}
}else if(_fromPool == 3){
require(msg.value == 0.3 ether, "Participation fee in Autopool is 0.3 ETH");
require(<FILL_ME>)
uint eventCount = pool_slots_3[activeSlot_ap3].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_3[activeSlot_ap3].userAddress,
pool_slots_3[activeSlot_ap3].id,
idToAddress[users[pool_slots_3[activeSlot_ap3].userAddress].referrerId],
3
));
pool_slots_3[activeSlot_ap3].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user3 = UsersPool({
id: newSlotId_ap3,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_3[msg.sender] = user3;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap3,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_3[newSlotId_ap3] = _newSlot;
newUserId_ap3++;
emit RegisterUserEvent(newSlotId_ap3, msg.sender, idToAddress[_referrerId], 3, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 3);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 3);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap3++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_3[activeSlot_ap3].userAddress, 1, 3);
users[pool_slots_3[activeSlot_ap3].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_3[activeSlot_ap3].referrerId > 0) {
payUpline(idToAddress[pool_slots_3[activeSlot_ap3].referrerId], 1, 3);
users[idToAddress[pool_slots_3[activeSlot_ap3].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 3);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_3[activeSlot_ap3].eventsCount++;
}
}
else if(_fromPool == 4){
require(msg.value == 0.4 ether, "Participation fee in Autopool is 0.4 ETH");
require(!isUserExists(msg.sender, 4), "User already registered in AP4");
uint eventCount = pool_slots_4[activeSlot_ap4].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_4[activeSlot_ap4].userAddress,
pool_slots_4[activeSlot_ap4].id,
idToAddress[users[pool_slots_4[activeSlot_ap4].userAddress].referrerId],
4
));
pool_slots_4[activeSlot_ap4].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user4 = UsersPool({
id: newSlotId_ap4,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_4[msg.sender] = user4;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap4,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_4[newSlotId_ap4] = _newSlot;
newUserId_ap4++;
emit RegisterUserEvent(newSlotId_ap4, msg.sender, idToAddress[_referrerId], 4, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 4);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 4);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap4++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_4[activeSlot_ap4].userAddress, 1, 4);
users[pool_slots_4[activeSlot_ap4].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_4[activeSlot_ap4].referrerId > 0) {
payUpline(idToAddress[pool_slots_4[activeSlot_ap4].referrerId], 1, 4);
users[idToAddress[pool_slots_4[activeSlot_ap4].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 4);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_4[activeSlot_ap4].eventsCount++;
}
}
else if(_fromPool == 5){
require(msg.value == 0.5 ether, "Participation fee in Autopool is 0.5 ETH");
require(!isUserExists(msg.sender, 5), "User already registered in AP5");
uint eventCount = pool_slots_5[activeSlot_ap5].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_5[activeSlot_ap5].userAddress,
pool_slots_5[activeSlot_ap5].id,
idToAddress[users[pool_slots_5[activeSlot_ap5].userAddress].referrerId],
5
));
pool_slots_5[activeSlot_ap5].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user5 = UsersPool({
id: newSlotId_ap5,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_5[msg.sender] = user5;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap5,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_5[newSlotId_ap5] = _newSlot;
newUserId_ap5++;
emit RegisterUserEvent(newSlotId_ap5, msg.sender, idToAddress[_referrerId], 5, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 5);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 5);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap5++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_5[activeSlot_ap5].userAddress, 1, 5);
users[pool_slots_5[activeSlot_ap5].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_5[activeSlot_ap5].referrerId > 0) {
payUpline(idToAddress[pool_slots_5[activeSlot_ap5].referrerId], 1, 5);
users[idToAddress[pool_slots_5[activeSlot_ap5].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 5);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_5[activeSlot_ap5].eventsCount++;
}
}
else if(_fromPool == 6){
require(msg.value == 0.7 ether, "Participation fee in Autopool is 0.7 ETH");
require(!isUserExists(msg.sender, 6), "User already registered in AP6");
uint eventCount = pool_slots_6[activeSlot_ap6].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_6[activeSlot_ap6].userAddress,
pool_slots_6[activeSlot_ap6].id,
idToAddress[users[pool_slots_6[activeSlot_ap6].userAddress].referrerId],
6
));
pool_slots_6[activeSlot_ap6].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user6 = UsersPool({
id: newSlotId_ap6,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_6[msg.sender] = user6;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap6,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_6[newSlotId_ap6] = _newSlot;
newUserId_ap6++;
emit RegisterUserEvent(newSlotId_ap6, msg.sender, idToAddress[_referrerId], 6, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 6);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 6);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap6++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_6[activeSlot_ap6].userAddress, 1, 6);
users[pool_slots_6[activeSlot_ap6].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_6[activeSlot_ap6].referrerId > 0) {
payUpline(idToAddress[pool_slots_6[activeSlot_ap6].referrerId], 1, 6);
users[idToAddress[pool_slots_6[activeSlot_ap6].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 6);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_6[activeSlot_ap6].eventsCount++;
}
}else{
require(msg.value == 1 ether, "Participation fee in Autopool is 1 ETH");
require(!isUserExists(msg.sender, 7), "User already registered in AP7");
uint eventCount = pool_slots_7[activeSlot_ap7].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_7[activeSlot_ap7].userAddress,
pool_slots_7[activeSlot_ap7].id,
idToAddress[users[pool_slots_7[activeSlot_ap7].userAddress].referrerId],
7
));
pool_slots_7[activeSlot_ap7].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user7 = UsersPool({
id: newSlotId_ap7,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_7[msg.sender] = user7;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap7,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_7[newSlotId_ap7] = _newSlot;
newUserId_ap7++;
emit RegisterUserEvent(newSlotId_ap7, msg.sender, idToAddress[_referrerId], 7, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 7);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 7);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap7++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_7[activeSlot_ap7].userAddress, 1, 7);
users[pool_slots_7[activeSlot_ap7].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_7[activeSlot_ap7].referrerId > 0) {
payUpline(idToAddress[pool_slots_7[activeSlot_ap7].referrerId], 1, 7);
users[idToAddress[pool_slots_7[activeSlot_ap7].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 7);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_7[activeSlot_ap7].eventsCount++;
}
}
}
function reinvestSlot(address _userAddress, uint _userId, address _sponsorAddress, uint8 _fromPool) private returns (bool _isReinvested) {
}
function payUpline(address _sponsorAddress, uint8 _refLevel, uint8 _fromPool) private returns (uint distributeAmount) {
}
function payFirstLine(address _sponsorAddress, uint payAmount, uint8 _fromPool) private returns (uint distributeAmount) {
}
function isUserQualified(address _userAddress) public view returns (bool) {
}
function isUserExists(address _userAddress, uint8 _autopool) public view returns (bool) {
}
function getUserReferrals(address _userAddress)
public
view
returns (address[] memory)
{
}
}
| !isUserExists(msg.sender,3),"User already registered in AP3" | 352,604 | !isUserExists(msg.sender,3) |
null | pragma solidity >=0.5.12 <0.7.0;
contract way2eth {
struct User {
uint id;
uint referrerCount;
uint referrerId;
uint earnedFromPool;
uint earnedFromRef;
uint earnedFromGlobal;
address[] referrals;
}
struct UsersPool {
uint id;
uint referrerId;
uint reinvestCount;
}
struct PoolSlots {
uint id;
address userAddress;
uint referrerId;
uint8 eventsCount;
}
modifier validReferrerId(uint _referrerId) {
}
event RegisterUserEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event ReinvestEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event DistributeUplineEvent(uint amount, address indexed _sponsorAddress, address indexed _fromAddress, uint _level, uint8 _fromPool, uint _time);
event ReferralPaymentEvent(uint amount, address indexed _from, address indexed _to, uint8 indexed _fromPool, uint _time);
mapping(address => User) public users;
mapping(address => UsersPool) public users_2;
mapping(uint => PoolSlots) public pool_slots_2;
mapping(address => UsersPool) public users_3;
mapping(uint => PoolSlots) public pool_slots_3;
mapping(address => UsersPool) public users_4;
mapping(uint => PoolSlots) public pool_slots_4;
mapping(address => UsersPool) public users_5;
mapping(uint => PoolSlots) public pool_slots_5;
mapping(address => UsersPool) public users_6;
mapping(uint => PoolSlots) public pool_slots_6;
mapping(address => UsersPool) public users_7;
mapping(uint => PoolSlots) public pool_slots_7;
mapping(address => UsersPool) public users_8;
mapping(uint => PoolSlots) public pool_slots_8;
mapping(uint => address) public idToAddress;
mapping (uint => uint) public uplineAmount;
uint public newUserId = 1;
uint public newUserId_ap2 = 1;
uint public newUserId_ap3 = 1;
uint public newUserId_ap4 = 1;
uint public newUserId_ap5 = 1;
uint public newUserId_ap6 = 1;
uint public newUserId_ap7 = 1;
uint public newUserId_ap8 = 1;
uint public newSlotId_ap2 = 1;
uint public activeSlot_ap2 = 1;
uint public newSlotId_ap3 = 1;
uint public activeSlot_ap3 = 1;
uint public newSlotId_ap4 = 1;
uint public activeSlot_ap4 = 1;
uint public newSlotId_ap5 = 1;
uint public activeSlot_ap5 = 1;
uint public newSlotId_ap6 = 1;
uint public activeSlot_ap6 = 1;
uint public newSlotId_ap7 = 1;
uint public activeSlot_ap7 = 1;
uint public newSlotId_ap8 = 1;
uint public activeSlot_ap8 = 1;
address public owner;
constructor(address _ownerAddress) public {
}
function participatePool1(uint _referrerId)
public
payable
validReferrerId(_referrerId)
{
}
function participatePool2(uint8 _fromPool)
public
payable
{
if(_fromPool == 2 || _fromPool == 3 || _fromPool == 4 || _fromPool == 5 || _fromPool == 6 || _fromPool == 7){
require(isUserExists(msg.sender, 1), "User not present in AP1");
require(isUserQualified(msg.sender), "User not qualified in AP1");
}
if(_fromPool == 2){
require(msg.value == 0.2 ether, "Participation fee in Autopool is 0.2 ETH");
require(!isUserExists(msg.sender, 2), "User already registered in AP2");
uint eventCount = pool_slots_2[activeSlot_ap2].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_2[activeSlot_ap2].userAddress,
pool_slots_2[activeSlot_ap2].id,
idToAddress[users[pool_slots_2[activeSlot_ap2].userAddress].referrerId],
2
));
pool_slots_2[activeSlot_ap2].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user2 = UsersPool({
id: newSlotId_ap2,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_2[msg.sender] = user2;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap2,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_2[newSlotId_ap2] = _newSlot;
newUserId_ap2++;
emit RegisterUserEvent(newSlotId_ap2, msg.sender, idToAddress[_referrerId], 2, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 2);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 2);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap2++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_2[activeSlot_ap2].userAddress, 1, 2);
users[pool_slots_2[activeSlot_ap2].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_2[activeSlot_ap2].referrerId > 0) {
payUpline(idToAddress[pool_slots_2[activeSlot_ap2].referrerId], 1, 2);
users[idToAddress[pool_slots_2[activeSlot_ap2].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 2);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_2[activeSlot_ap2].eventsCount++;
}
}else if(_fromPool == 3){
require(msg.value == 0.3 ether, "Participation fee in Autopool is 0.3 ETH");
require(!isUserExists(msg.sender, 3), "User already registered in AP3");
uint eventCount = pool_slots_3[activeSlot_ap3].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(<FILL_ME>)
pool_slots_3[activeSlot_ap3].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user3 = UsersPool({
id: newSlotId_ap3,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_3[msg.sender] = user3;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap3,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_3[newSlotId_ap3] = _newSlot;
newUserId_ap3++;
emit RegisterUserEvent(newSlotId_ap3, msg.sender, idToAddress[_referrerId], 3, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 3);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 3);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap3++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_3[activeSlot_ap3].userAddress, 1, 3);
users[pool_slots_3[activeSlot_ap3].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_3[activeSlot_ap3].referrerId > 0) {
payUpline(idToAddress[pool_slots_3[activeSlot_ap3].referrerId], 1, 3);
users[idToAddress[pool_slots_3[activeSlot_ap3].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 3);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_3[activeSlot_ap3].eventsCount++;
}
}
else if(_fromPool == 4){
require(msg.value == 0.4 ether, "Participation fee in Autopool is 0.4 ETH");
require(!isUserExists(msg.sender, 4), "User already registered in AP4");
uint eventCount = pool_slots_4[activeSlot_ap4].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_4[activeSlot_ap4].userAddress,
pool_slots_4[activeSlot_ap4].id,
idToAddress[users[pool_slots_4[activeSlot_ap4].userAddress].referrerId],
4
));
pool_slots_4[activeSlot_ap4].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user4 = UsersPool({
id: newSlotId_ap4,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_4[msg.sender] = user4;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap4,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_4[newSlotId_ap4] = _newSlot;
newUserId_ap4++;
emit RegisterUserEvent(newSlotId_ap4, msg.sender, idToAddress[_referrerId], 4, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 4);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 4);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap4++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_4[activeSlot_ap4].userAddress, 1, 4);
users[pool_slots_4[activeSlot_ap4].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_4[activeSlot_ap4].referrerId > 0) {
payUpline(idToAddress[pool_slots_4[activeSlot_ap4].referrerId], 1, 4);
users[idToAddress[pool_slots_4[activeSlot_ap4].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 4);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_4[activeSlot_ap4].eventsCount++;
}
}
else if(_fromPool == 5){
require(msg.value == 0.5 ether, "Participation fee in Autopool is 0.5 ETH");
require(!isUserExists(msg.sender, 5), "User already registered in AP5");
uint eventCount = pool_slots_5[activeSlot_ap5].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_5[activeSlot_ap5].userAddress,
pool_slots_5[activeSlot_ap5].id,
idToAddress[users[pool_slots_5[activeSlot_ap5].userAddress].referrerId],
5
));
pool_slots_5[activeSlot_ap5].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user5 = UsersPool({
id: newSlotId_ap5,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_5[msg.sender] = user5;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap5,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_5[newSlotId_ap5] = _newSlot;
newUserId_ap5++;
emit RegisterUserEvent(newSlotId_ap5, msg.sender, idToAddress[_referrerId], 5, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 5);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 5);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap5++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_5[activeSlot_ap5].userAddress, 1, 5);
users[pool_slots_5[activeSlot_ap5].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_5[activeSlot_ap5].referrerId > 0) {
payUpline(idToAddress[pool_slots_5[activeSlot_ap5].referrerId], 1, 5);
users[idToAddress[pool_slots_5[activeSlot_ap5].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 5);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_5[activeSlot_ap5].eventsCount++;
}
}
else if(_fromPool == 6){
require(msg.value == 0.7 ether, "Participation fee in Autopool is 0.7 ETH");
require(!isUserExists(msg.sender, 6), "User already registered in AP6");
uint eventCount = pool_slots_6[activeSlot_ap6].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_6[activeSlot_ap6].userAddress,
pool_slots_6[activeSlot_ap6].id,
idToAddress[users[pool_slots_6[activeSlot_ap6].userAddress].referrerId],
6
));
pool_slots_6[activeSlot_ap6].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user6 = UsersPool({
id: newSlotId_ap6,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_6[msg.sender] = user6;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap6,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_6[newSlotId_ap6] = _newSlot;
newUserId_ap6++;
emit RegisterUserEvent(newSlotId_ap6, msg.sender, idToAddress[_referrerId], 6, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 6);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 6);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap6++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_6[activeSlot_ap6].userAddress, 1, 6);
users[pool_slots_6[activeSlot_ap6].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_6[activeSlot_ap6].referrerId > 0) {
payUpline(idToAddress[pool_slots_6[activeSlot_ap6].referrerId], 1, 6);
users[idToAddress[pool_slots_6[activeSlot_ap6].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 6);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_6[activeSlot_ap6].eventsCount++;
}
}else{
require(msg.value == 1 ether, "Participation fee in Autopool is 1 ETH");
require(!isUserExists(msg.sender, 7), "User already registered in AP7");
uint eventCount = pool_slots_7[activeSlot_ap7].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_7[activeSlot_ap7].userAddress,
pool_slots_7[activeSlot_ap7].id,
idToAddress[users[pool_slots_7[activeSlot_ap7].userAddress].referrerId],
7
));
pool_slots_7[activeSlot_ap7].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user7 = UsersPool({
id: newSlotId_ap7,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_7[msg.sender] = user7;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap7,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_7[newSlotId_ap7] = _newSlot;
newUserId_ap7++;
emit RegisterUserEvent(newSlotId_ap7, msg.sender, idToAddress[_referrerId], 7, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 7);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 7);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap7++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_7[activeSlot_ap7].userAddress, 1, 7);
users[pool_slots_7[activeSlot_ap7].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_7[activeSlot_ap7].referrerId > 0) {
payUpline(idToAddress[pool_slots_7[activeSlot_ap7].referrerId], 1, 7);
users[idToAddress[pool_slots_7[activeSlot_ap7].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 7);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_7[activeSlot_ap7].eventsCount++;
}
}
}
function reinvestSlot(address _userAddress, uint _userId, address _sponsorAddress, uint8 _fromPool) private returns (bool _isReinvested) {
}
function payUpline(address _sponsorAddress, uint8 _refLevel, uint8 _fromPool) private returns (uint distributeAmount) {
}
function payFirstLine(address _sponsorAddress, uint payAmount, uint8 _fromPool) private returns (uint distributeAmount) {
}
function isUserQualified(address _userAddress) public view returns (bool) {
}
function isUserExists(address _userAddress, uint8 _autopool) public view returns (bool) {
}
function getUserReferrals(address _userAddress)
public
view
returns (address[] memory)
{
}
}
| reinvestSlot(pool_slots_3[activeSlot_ap3].userAddress,pool_slots_3[activeSlot_ap3].id,idToAddress[users[pool_slots_3[activeSlot_ap3].userAddress].referrerId],3) | 352,604 | reinvestSlot(pool_slots_3[activeSlot_ap3].userAddress,pool_slots_3[activeSlot_ap3].id,idToAddress[users[pool_slots_3[activeSlot_ap3].userAddress].referrerId],3) |
"User already registered in AP4" | pragma solidity >=0.5.12 <0.7.0;
contract way2eth {
struct User {
uint id;
uint referrerCount;
uint referrerId;
uint earnedFromPool;
uint earnedFromRef;
uint earnedFromGlobal;
address[] referrals;
}
struct UsersPool {
uint id;
uint referrerId;
uint reinvestCount;
}
struct PoolSlots {
uint id;
address userAddress;
uint referrerId;
uint8 eventsCount;
}
modifier validReferrerId(uint _referrerId) {
}
event RegisterUserEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event ReinvestEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event DistributeUplineEvent(uint amount, address indexed _sponsorAddress, address indexed _fromAddress, uint _level, uint8 _fromPool, uint _time);
event ReferralPaymentEvent(uint amount, address indexed _from, address indexed _to, uint8 indexed _fromPool, uint _time);
mapping(address => User) public users;
mapping(address => UsersPool) public users_2;
mapping(uint => PoolSlots) public pool_slots_2;
mapping(address => UsersPool) public users_3;
mapping(uint => PoolSlots) public pool_slots_3;
mapping(address => UsersPool) public users_4;
mapping(uint => PoolSlots) public pool_slots_4;
mapping(address => UsersPool) public users_5;
mapping(uint => PoolSlots) public pool_slots_5;
mapping(address => UsersPool) public users_6;
mapping(uint => PoolSlots) public pool_slots_6;
mapping(address => UsersPool) public users_7;
mapping(uint => PoolSlots) public pool_slots_7;
mapping(address => UsersPool) public users_8;
mapping(uint => PoolSlots) public pool_slots_8;
mapping(uint => address) public idToAddress;
mapping (uint => uint) public uplineAmount;
uint public newUserId = 1;
uint public newUserId_ap2 = 1;
uint public newUserId_ap3 = 1;
uint public newUserId_ap4 = 1;
uint public newUserId_ap5 = 1;
uint public newUserId_ap6 = 1;
uint public newUserId_ap7 = 1;
uint public newUserId_ap8 = 1;
uint public newSlotId_ap2 = 1;
uint public activeSlot_ap2 = 1;
uint public newSlotId_ap3 = 1;
uint public activeSlot_ap3 = 1;
uint public newSlotId_ap4 = 1;
uint public activeSlot_ap4 = 1;
uint public newSlotId_ap5 = 1;
uint public activeSlot_ap5 = 1;
uint public newSlotId_ap6 = 1;
uint public activeSlot_ap6 = 1;
uint public newSlotId_ap7 = 1;
uint public activeSlot_ap7 = 1;
uint public newSlotId_ap8 = 1;
uint public activeSlot_ap8 = 1;
address public owner;
constructor(address _ownerAddress) public {
}
function participatePool1(uint _referrerId)
public
payable
validReferrerId(_referrerId)
{
}
function participatePool2(uint8 _fromPool)
public
payable
{
if(_fromPool == 2 || _fromPool == 3 || _fromPool == 4 || _fromPool == 5 || _fromPool == 6 || _fromPool == 7){
require(isUserExists(msg.sender, 1), "User not present in AP1");
require(isUserQualified(msg.sender), "User not qualified in AP1");
}
if(_fromPool == 2){
require(msg.value == 0.2 ether, "Participation fee in Autopool is 0.2 ETH");
require(!isUserExists(msg.sender, 2), "User already registered in AP2");
uint eventCount = pool_slots_2[activeSlot_ap2].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_2[activeSlot_ap2].userAddress,
pool_slots_2[activeSlot_ap2].id,
idToAddress[users[pool_slots_2[activeSlot_ap2].userAddress].referrerId],
2
));
pool_slots_2[activeSlot_ap2].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user2 = UsersPool({
id: newSlotId_ap2,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_2[msg.sender] = user2;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap2,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_2[newSlotId_ap2] = _newSlot;
newUserId_ap2++;
emit RegisterUserEvent(newSlotId_ap2, msg.sender, idToAddress[_referrerId], 2, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 2);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 2);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap2++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_2[activeSlot_ap2].userAddress, 1, 2);
users[pool_slots_2[activeSlot_ap2].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_2[activeSlot_ap2].referrerId > 0) {
payUpline(idToAddress[pool_slots_2[activeSlot_ap2].referrerId], 1, 2);
users[idToAddress[pool_slots_2[activeSlot_ap2].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 2);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_2[activeSlot_ap2].eventsCount++;
}
}else if(_fromPool == 3){
require(msg.value == 0.3 ether, "Participation fee in Autopool is 0.3 ETH");
require(!isUserExists(msg.sender, 3), "User already registered in AP3");
uint eventCount = pool_slots_3[activeSlot_ap3].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_3[activeSlot_ap3].userAddress,
pool_slots_3[activeSlot_ap3].id,
idToAddress[users[pool_slots_3[activeSlot_ap3].userAddress].referrerId],
3
));
pool_slots_3[activeSlot_ap3].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user3 = UsersPool({
id: newSlotId_ap3,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_3[msg.sender] = user3;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap3,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_3[newSlotId_ap3] = _newSlot;
newUserId_ap3++;
emit RegisterUserEvent(newSlotId_ap3, msg.sender, idToAddress[_referrerId], 3, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 3);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 3);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap3++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_3[activeSlot_ap3].userAddress, 1, 3);
users[pool_slots_3[activeSlot_ap3].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_3[activeSlot_ap3].referrerId > 0) {
payUpline(idToAddress[pool_slots_3[activeSlot_ap3].referrerId], 1, 3);
users[idToAddress[pool_slots_3[activeSlot_ap3].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 3);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_3[activeSlot_ap3].eventsCount++;
}
}
else if(_fromPool == 4){
require(msg.value == 0.4 ether, "Participation fee in Autopool is 0.4 ETH");
require(<FILL_ME>)
uint eventCount = pool_slots_4[activeSlot_ap4].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_4[activeSlot_ap4].userAddress,
pool_slots_4[activeSlot_ap4].id,
idToAddress[users[pool_slots_4[activeSlot_ap4].userAddress].referrerId],
4
));
pool_slots_4[activeSlot_ap4].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user4 = UsersPool({
id: newSlotId_ap4,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_4[msg.sender] = user4;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap4,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_4[newSlotId_ap4] = _newSlot;
newUserId_ap4++;
emit RegisterUserEvent(newSlotId_ap4, msg.sender, idToAddress[_referrerId], 4, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 4);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 4);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap4++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_4[activeSlot_ap4].userAddress, 1, 4);
users[pool_slots_4[activeSlot_ap4].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_4[activeSlot_ap4].referrerId > 0) {
payUpline(idToAddress[pool_slots_4[activeSlot_ap4].referrerId], 1, 4);
users[idToAddress[pool_slots_4[activeSlot_ap4].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 4);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_4[activeSlot_ap4].eventsCount++;
}
}
else if(_fromPool == 5){
require(msg.value == 0.5 ether, "Participation fee in Autopool is 0.5 ETH");
require(!isUserExists(msg.sender, 5), "User already registered in AP5");
uint eventCount = pool_slots_5[activeSlot_ap5].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_5[activeSlot_ap5].userAddress,
pool_slots_5[activeSlot_ap5].id,
idToAddress[users[pool_slots_5[activeSlot_ap5].userAddress].referrerId],
5
));
pool_slots_5[activeSlot_ap5].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user5 = UsersPool({
id: newSlotId_ap5,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_5[msg.sender] = user5;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap5,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_5[newSlotId_ap5] = _newSlot;
newUserId_ap5++;
emit RegisterUserEvent(newSlotId_ap5, msg.sender, idToAddress[_referrerId], 5, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 5);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 5);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap5++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_5[activeSlot_ap5].userAddress, 1, 5);
users[pool_slots_5[activeSlot_ap5].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_5[activeSlot_ap5].referrerId > 0) {
payUpline(idToAddress[pool_slots_5[activeSlot_ap5].referrerId], 1, 5);
users[idToAddress[pool_slots_5[activeSlot_ap5].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 5);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_5[activeSlot_ap5].eventsCount++;
}
}
else if(_fromPool == 6){
require(msg.value == 0.7 ether, "Participation fee in Autopool is 0.7 ETH");
require(!isUserExists(msg.sender, 6), "User already registered in AP6");
uint eventCount = pool_slots_6[activeSlot_ap6].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_6[activeSlot_ap6].userAddress,
pool_slots_6[activeSlot_ap6].id,
idToAddress[users[pool_slots_6[activeSlot_ap6].userAddress].referrerId],
6
));
pool_slots_6[activeSlot_ap6].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user6 = UsersPool({
id: newSlotId_ap6,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_6[msg.sender] = user6;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap6,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_6[newSlotId_ap6] = _newSlot;
newUserId_ap6++;
emit RegisterUserEvent(newSlotId_ap6, msg.sender, idToAddress[_referrerId], 6, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 6);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 6);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap6++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_6[activeSlot_ap6].userAddress, 1, 6);
users[pool_slots_6[activeSlot_ap6].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_6[activeSlot_ap6].referrerId > 0) {
payUpline(idToAddress[pool_slots_6[activeSlot_ap6].referrerId], 1, 6);
users[idToAddress[pool_slots_6[activeSlot_ap6].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 6);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_6[activeSlot_ap6].eventsCount++;
}
}else{
require(msg.value == 1 ether, "Participation fee in Autopool is 1 ETH");
require(!isUserExists(msg.sender, 7), "User already registered in AP7");
uint eventCount = pool_slots_7[activeSlot_ap7].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_7[activeSlot_ap7].userAddress,
pool_slots_7[activeSlot_ap7].id,
idToAddress[users[pool_slots_7[activeSlot_ap7].userAddress].referrerId],
7
));
pool_slots_7[activeSlot_ap7].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user7 = UsersPool({
id: newSlotId_ap7,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_7[msg.sender] = user7;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap7,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_7[newSlotId_ap7] = _newSlot;
newUserId_ap7++;
emit RegisterUserEvent(newSlotId_ap7, msg.sender, idToAddress[_referrerId], 7, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 7);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 7);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap7++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_7[activeSlot_ap7].userAddress, 1, 7);
users[pool_slots_7[activeSlot_ap7].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_7[activeSlot_ap7].referrerId > 0) {
payUpline(idToAddress[pool_slots_7[activeSlot_ap7].referrerId], 1, 7);
users[idToAddress[pool_slots_7[activeSlot_ap7].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 7);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_7[activeSlot_ap7].eventsCount++;
}
}
}
function reinvestSlot(address _userAddress, uint _userId, address _sponsorAddress, uint8 _fromPool) private returns (bool _isReinvested) {
}
function payUpline(address _sponsorAddress, uint8 _refLevel, uint8 _fromPool) private returns (uint distributeAmount) {
}
function payFirstLine(address _sponsorAddress, uint payAmount, uint8 _fromPool) private returns (uint distributeAmount) {
}
function isUserQualified(address _userAddress) public view returns (bool) {
}
function isUserExists(address _userAddress, uint8 _autopool) public view returns (bool) {
}
function getUserReferrals(address _userAddress)
public
view
returns (address[] memory)
{
}
}
| !isUserExists(msg.sender,4),"User already registered in AP4" | 352,604 | !isUserExists(msg.sender,4) |
null | pragma solidity >=0.5.12 <0.7.0;
contract way2eth {
struct User {
uint id;
uint referrerCount;
uint referrerId;
uint earnedFromPool;
uint earnedFromRef;
uint earnedFromGlobal;
address[] referrals;
}
struct UsersPool {
uint id;
uint referrerId;
uint reinvestCount;
}
struct PoolSlots {
uint id;
address userAddress;
uint referrerId;
uint8 eventsCount;
}
modifier validReferrerId(uint _referrerId) {
}
event RegisterUserEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event ReinvestEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event DistributeUplineEvent(uint amount, address indexed _sponsorAddress, address indexed _fromAddress, uint _level, uint8 _fromPool, uint _time);
event ReferralPaymentEvent(uint amount, address indexed _from, address indexed _to, uint8 indexed _fromPool, uint _time);
mapping(address => User) public users;
mapping(address => UsersPool) public users_2;
mapping(uint => PoolSlots) public pool_slots_2;
mapping(address => UsersPool) public users_3;
mapping(uint => PoolSlots) public pool_slots_3;
mapping(address => UsersPool) public users_4;
mapping(uint => PoolSlots) public pool_slots_4;
mapping(address => UsersPool) public users_5;
mapping(uint => PoolSlots) public pool_slots_5;
mapping(address => UsersPool) public users_6;
mapping(uint => PoolSlots) public pool_slots_6;
mapping(address => UsersPool) public users_7;
mapping(uint => PoolSlots) public pool_slots_7;
mapping(address => UsersPool) public users_8;
mapping(uint => PoolSlots) public pool_slots_8;
mapping(uint => address) public idToAddress;
mapping (uint => uint) public uplineAmount;
uint public newUserId = 1;
uint public newUserId_ap2 = 1;
uint public newUserId_ap3 = 1;
uint public newUserId_ap4 = 1;
uint public newUserId_ap5 = 1;
uint public newUserId_ap6 = 1;
uint public newUserId_ap7 = 1;
uint public newUserId_ap8 = 1;
uint public newSlotId_ap2 = 1;
uint public activeSlot_ap2 = 1;
uint public newSlotId_ap3 = 1;
uint public activeSlot_ap3 = 1;
uint public newSlotId_ap4 = 1;
uint public activeSlot_ap4 = 1;
uint public newSlotId_ap5 = 1;
uint public activeSlot_ap5 = 1;
uint public newSlotId_ap6 = 1;
uint public activeSlot_ap6 = 1;
uint public newSlotId_ap7 = 1;
uint public activeSlot_ap7 = 1;
uint public newSlotId_ap8 = 1;
uint public activeSlot_ap8 = 1;
address public owner;
constructor(address _ownerAddress) public {
}
function participatePool1(uint _referrerId)
public
payable
validReferrerId(_referrerId)
{
}
function participatePool2(uint8 _fromPool)
public
payable
{
if(_fromPool == 2 || _fromPool == 3 || _fromPool == 4 || _fromPool == 5 || _fromPool == 6 || _fromPool == 7){
require(isUserExists(msg.sender, 1), "User not present in AP1");
require(isUserQualified(msg.sender), "User not qualified in AP1");
}
if(_fromPool == 2){
require(msg.value == 0.2 ether, "Participation fee in Autopool is 0.2 ETH");
require(!isUserExists(msg.sender, 2), "User already registered in AP2");
uint eventCount = pool_slots_2[activeSlot_ap2].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_2[activeSlot_ap2].userAddress,
pool_slots_2[activeSlot_ap2].id,
idToAddress[users[pool_slots_2[activeSlot_ap2].userAddress].referrerId],
2
));
pool_slots_2[activeSlot_ap2].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user2 = UsersPool({
id: newSlotId_ap2,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_2[msg.sender] = user2;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap2,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_2[newSlotId_ap2] = _newSlot;
newUserId_ap2++;
emit RegisterUserEvent(newSlotId_ap2, msg.sender, idToAddress[_referrerId], 2, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 2);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 2);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap2++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_2[activeSlot_ap2].userAddress, 1, 2);
users[pool_slots_2[activeSlot_ap2].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_2[activeSlot_ap2].referrerId > 0) {
payUpline(idToAddress[pool_slots_2[activeSlot_ap2].referrerId], 1, 2);
users[idToAddress[pool_slots_2[activeSlot_ap2].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 2);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_2[activeSlot_ap2].eventsCount++;
}
}else if(_fromPool == 3){
require(msg.value == 0.3 ether, "Participation fee in Autopool is 0.3 ETH");
require(!isUserExists(msg.sender, 3), "User already registered in AP3");
uint eventCount = pool_slots_3[activeSlot_ap3].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_3[activeSlot_ap3].userAddress,
pool_slots_3[activeSlot_ap3].id,
idToAddress[users[pool_slots_3[activeSlot_ap3].userAddress].referrerId],
3
));
pool_slots_3[activeSlot_ap3].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user3 = UsersPool({
id: newSlotId_ap3,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_3[msg.sender] = user3;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap3,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_3[newSlotId_ap3] = _newSlot;
newUserId_ap3++;
emit RegisterUserEvent(newSlotId_ap3, msg.sender, idToAddress[_referrerId], 3, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 3);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 3);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap3++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_3[activeSlot_ap3].userAddress, 1, 3);
users[pool_slots_3[activeSlot_ap3].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_3[activeSlot_ap3].referrerId > 0) {
payUpline(idToAddress[pool_slots_3[activeSlot_ap3].referrerId], 1, 3);
users[idToAddress[pool_slots_3[activeSlot_ap3].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 3);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_3[activeSlot_ap3].eventsCount++;
}
}
else if(_fromPool == 4){
require(msg.value == 0.4 ether, "Participation fee in Autopool is 0.4 ETH");
require(!isUserExists(msg.sender, 4), "User already registered in AP4");
uint eventCount = pool_slots_4[activeSlot_ap4].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(<FILL_ME>)
pool_slots_4[activeSlot_ap4].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user4 = UsersPool({
id: newSlotId_ap4,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_4[msg.sender] = user4;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap4,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_4[newSlotId_ap4] = _newSlot;
newUserId_ap4++;
emit RegisterUserEvent(newSlotId_ap4, msg.sender, idToAddress[_referrerId], 4, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 4);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 4);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap4++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_4[activeSlot_ap4].userAddress, 1, 4);
users[pool_slots_4[activeSlot_ap4].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_4[activeSlot_ap4].referrerId > 0) {
payUpline(idToAddress[pool_slots_4[activeSlot_ap4].referrerId], 1, 4);
users[idToAddress[pool_slots_4[activeSlot_ap4].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 4);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_4[activeSlot_ap4].eventsCount++;
}
}
else if(_fromPool == 5){
require(msg.value == 0.5 ether, "Participation fee in Autopool is 0.5 ETH");
require(!isUserExists(msg.sender, 5), "User already registered in AP5");
uint eventCount = pool_slots_5[activeSlot_ap5].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_5[activeSlot_ap5].userAddress,
pool_slots_5[activeSlot_ap5].id,
idToAddress[users[pool_slots_5[activeSlot_ap5].userAddress].referrerId],
5
));
pool_slots_5[activeSlot_ap5].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user5 = UsersPool({
id: newSlotId_ap5,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_5[msg.sender] = user5;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap5,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_5[newSlotId_ap5] = _newSlot;
newUserId_ap5++;
emit RegisterUserEvent(newSlotId_ap5, msg.sender, idToAddress[_referrerId], 5, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 5);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 5);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap5++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_5[activeSlot_ap5].userAddress, 1, 5);
users[pool_slots_5[activeSlot_ap5].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_5[activeSlot_ap5].referrerId > 0) {
payUpline(idToAddress[pool_slots_5[activeSlot_ap5].referrerId], 1, 5);
users[idToAddress[pool_slots_5[activeSlot_ap5].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 5);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_5[activeSlot_ap5].eventsCount++;
}
}
else if(_fromPool == 6){
require(msg.value == 0.7 ether, "Participation fee in Autopool is 0.7 ETH");
require(!isUserExists(msg.sender, 6), "User already registered in AP6");
uint eventCount = pool_slots_6[activeSlot_ap6].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_6[activeSlot_ap6].userAddress,
pool_slots_6[activeSlot_ap6].id,
idToAddress[users[pool_slots_6[activeSlot_ap6].userAddress].referrerId],
6
));
pool_slots_6[activeSlot_ap6].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user6 = UsersPool({
id: newSlotId_ap6,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_6[msg.sender] = user6;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap6,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_6[newSlotId_ap6] = _newSlot;
newUserId_ap6++;
emit RegisterUserEvent(newSlotId_ap6, msg.sender, idToAddress[_referrerId], 6, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 6);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 6);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap6++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_6[activeSlot_ap6].userAddress, 1, 6);
users[pool_slots_6[activeSlot_ap6].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_6[activeSlot_ap6].referrerId > 0) {
payUpline(idToAddress[pool_slots_6[activeSlot_ap6].referrerId], 1, 6);
users[idToAddress[pool_slots_6[activeSlot_ap6].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 6);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_6[activeSlot_ap6].eventsCount++;
}
}else{
require(msg.value == 1 ether, "Participation fee in Autopool is 1 ETH");
require(!isUserExists(msg.sender, 7), "User already registered in AP7");
uint eventCount = pool_slots_7[activeSlot_ap7].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_7[activeSlot_ap7].userAddress,
pool_slots_7[activeSlot_ap7].id,
idToAddress[users[pool_slots_7[activeSlot_ap7].userAddress].referrerId],
7
));
pool_slots_7[activeSlot_ap7].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user7 = UsersPool({
id: newSlotId_ap7,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_7[msg.sender] = user7;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap7,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_7[newSlotId_ap7] = _newSlot;
newUserId_ap7++;
emit RegisterUserEvent(newSlotId_ap7, msg.sender, idToAddress[_referrerId], 7, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 7);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 7);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap7++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_7[activeSlot_ap7].userAddress, 1, 7);
users[pool_slots_7[activeSlot_ap7].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_7[activeSlot_ap7].referrerId > 0) {
payUpline(idToAddress[pool_slots_7[activeSlot_ap7].referrerId], 1, 7);
users[idToAddress[pool_slots_7[activeSlot_ap7].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 7);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_7[activeSlot_ap7].eventsCount++;
}
}
}
function reinvestSlot(address _userAddress, uint _userId, address _sponsorAddress, uint8 _fromPool) private returns (bool _isReinvested) {
}
function payUpline(address _sponsorAddress, uint8 _refLevel, uint8 _fromPool) private returns (uint distributeAmount) {
}
function payFirstLine(address _sponsorAddress, uint payAmount, uint8 _fromPool) private returns (uint distributeAmount) {
}
function isUserQualified(address _userAddress) public view returns (bool) {
}
function isUserExists(address _userAddress, uint8 _autopool) public view returns (bool) {
}
function getUserReferrals(address _userAddress)
public
view
returns (address[] memory)
{
}
}
| reinvestSlot(pool_slots_4[activeSlot_ap4].userAddress,pool_slots_4[activeSlot_ap4].id,idToAddress[users[pool_slots_4[activeSlot_ap4].userAddress].referrerId],4) | 352,604 | reinvestSlot(pool_slots_4[activeSlot_ap4].userAddress,pool_slots_4[activeSlot_ap4].id,idToAddress[users[pool_slots_4[activeSlot_ap4].userAddress].referrerId],4) |
"User already registered in AP5" | pragma solidity >=0.5.12 <0.7.0;
contract way2eth {
struct User {
uint id;
uint referrerCount;
uint referrerId;
uint earnedFromPool;
uint earnedFromRef;
uint earnedFromGlobal;
address[] referrals;
}
struct UsersPool {
uint id;
uint referrerId;
uint reinvestCount;
}
struct PoolSlots {
uint id;
address userAddress;
uint referrerId;
uint8 eventsCount;
}
modifier validReferrerId(uint _referrerId) {
}
event RegisterUserEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event ReinvestEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event DistributeUplineEvent(uint amount, address indexed _sponsorAddress, address indexed _fromAddress, uint _level, uint8 _fromPool, uint _time);
event ReferralPaymentEvent(uint amount, address indexed _from, address indexed _to, uint8 indexed _fromPool, uint _time);
mapping(address => User) public users;
mapping(address => UsersPool) public users_2;
mapping(uint => PoolSlots) public pool_slots_2;
mapping(address => UsersPool) public users_3;
mapping(uint => PoolSlots) public pool_slots_3;
mapping(address => UsersPool) public users_4;
mapping(uint => PoolSlots) public pool_slots_4;
mapping(address => UsersPool) public users_5;
mapping(uint => PoolSlots) public pool_slots_5;
mapping(address => UsersPool) public users_6;
mapping(uint => PoolSlots) public pool_slots_6;
mapping(address => UsersPool) public users_7;
mapping(uint => PoolSlots) public pool_slots_7;
mapping(address => UsersPool) public users_8;
mapping(uint => PoolSlots) public pool_slots_8;
mapping(uint => address) public idToAddress;
mapping (uint => uint) public uplineAmount;
uint public newUserId = 1;
uint public newUserId_ap2 = 1;
uint public newUserId_ap3 = 1;
uint public newUserId_ap4 = 1;
uint public newUserId_ap5 = 1;
uint public newUserId_ap6 = 1;
uint public newUserId_ap7 = 1;
uint public newUserId_ap8 = 1;
uint public newSlotId_ap2 = 1;
uint public activeSlot_ap2 = 1;
uint public newSlotId_ap3 = 1;
uint public activeSlot_ap3 = 1;
uint public newSlotId_ap4 = 1;
uint public activeSlot_ap4 = 1;
uint public newSlotId_ap5 = 1;
uint public activeSlot_ap5 = 1;
uint public newSlotId_ap6 = 1;
uint public activeSlot_ap6 = 1;
uint public newSlotId_ap7 = 1;
uint public activeSlot_ap7 = 1;
uint public newSlotId_ap8 = 1;
uint public activeSlot_ap8 = 1;
address public owner;
constructor(address _ownerAddress) public {
}
function participatePool1(uint _referrerId)
public
payable
validReferrerId(_referrerId)
{
}
function participatePool2(uint8 _fromPool)
public
payable
{
if(_fromPool == 2 || _fromPool == 3 || _fromPool == 4 || _fromPool == 5 || _fromPool == 6 || _fromPool == 7){
require(isUserExists(msg.sender, 1), "User not present in AP1");
require(isUserQualified(msg.sender), "User not qualified in AP1");
}
if(_fromPool == 2){
require(msg.value == 0.2 ether, "Participation fee in Autopool is 0.2 ETH");
require(!isUserExists(msg.sender, 2), "User already registered in AP2");
uint eventCount = pool_slots_2[activeSlot_ap2].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_2[activeSlot_ap2].userAddress,
pool_slots_2[activeSlot_ap2].id,
idToAddress[users[pool_slots_2[activeSlot_ap2].userAddress].referrerId],
2
));
pool_slots_2[activeSlot_ap2].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user2 = UsersPool({
id: newSlotId_ap2,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_2[msg.sender] = user2;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap2,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_2[newSlotId_ap2] = _newSlot;
newUserId_ap2++;
emit RegisterUserEvent(newSlotId_ap2, msg.sender, idToAddress[_referrerId], 2, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 2);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 2);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap2++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_2[activeSlot_ap2].userAddress, 1, 2);
users[pool_slots_2[activeSlot_ap2].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_2[activeSlot_ap2].referrerId > 0) {
payUpline(idToAddress[pool_slots_2[activeSlot_ap2].referrerId], 1, 2);
users[idToAddress[pool_slots_2[activeSlot_ap2].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 2);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_2[activeSlot_ap2].eventsCount++;
}
}else if(_fromPool == 3){
require(msg.value == 0.3 ether, "Participation fee in Autopool is 0.3 ETH");
require(!isUserExists(msg.sender, 3), "User already registered in AP3");
uint eventCount = pool_slots_3[activeSlot_ap3].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_3[activeSlot_ap3].userAddress,
pool_slots_3[activeSlot_ap3].id,
idToAddress[users[pool_slots_3[activeSlot_ap3].userAddress].referrerId],
3
));
pool_slots_3[activeSlot_ap3].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user3 = UsersPool({
id: newSlotId_ap3,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_3[msg.sender] = user3;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap3,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_3[newSlotId_ap3] = _newSlot;
newUserId_ap3++;
emit RegisterUserEvent(newSlotId_ap3, msg.sender, idToAddress[_referrerId], 3, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 3);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 3);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap3++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_3[activeSlot_ap3].userAddress, 1, 3);
users[pool_slots_3[activeSlot_ap3].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_3[activeSlot_ap3].referrerId > 0) {
payUpline(idToAddress[pool_slots_3[activeSlot_ap3].referrerId], 1, 3);
users[idToAddress[pool_slots_3[activeSlot_ap3].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 3);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_3[activeSlot_ap3].eventsCount++;
}
}
else if(_fromPool == 4){
require(msg.value == 0.4 ether, "Participation fee in Autopool is 0.4 ETH");
require(!isUserExists(msg.sender, 4), "User already registered in AP4");
uint eventCount = pool_slots_4[activeSlot_ap4].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_4[activeSlot_ap4].userAddress,
pool_slots_4[activeSlot_ap4].id,
idToAddress[users[pool_slots_4[activeSlot_ap4].userAddress].referrerId],
4
));
pool_slots_4[activeSlot_ap4].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user4 = UsersPool({
id: newSlotId_ap4,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_4[msg.sender] = user4;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap4,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_4[newSlotId_ap4] = _newSlot;
newUserId_ap4++;
emit RegisterUserEvent(newSlotId_ap4, msg.sender, idToAddress[_referrerId], 4, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 4);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 4);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap4++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_4[activeSlot_ap4].userAddress, 1, 4);
users[pool_slots_4[activeSlot_ap4].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_4[activeSlot_ap4].referrerId > 0) {
payUpline(idToAddress[pool_slots_4[activeSlot_ap4].referrerId], 1, 4);
users[idToAddress[pool_slots_4[activeSlot_ap4].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 4);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_4[activeSlot_ap4].eventsCount++;
}
}
else if(_fromPool == 5){
require(msg.value == 0.5 ether, "Participation fee in Autopool is 0.5 ETH");
require(<FILL_ME>)
uint eventCount = pool_slots_5[activeSlot_ap5].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_5[activeSlot_ap5].userAddress,
pool_slots_5[activeSlot_ap5].id,
idToAddress[users[pool_slots_5[activeSlot_ap5].userAddress].referrerId],
5
));
pool_slots_5[activeSlot_ap5].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user5 = UsersPool({
id: newSlotId_ap5,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_5[msg.sender] = user5;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap5,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_5[newSlotId_ap5] = _newSlot;
newUserId_ap5++;
emit RegisterUserEvent(newSlotId_ap5, msg.sender, idToAddress[_referrerId], 5, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 5);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 5);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap5++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_5[activeSlot_ap5].userAddress, 1, 5);
users[pool_slots_5[activeSlot_ap5].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_5[activeSlot_ap5].referrerId > 0) {
payUpline(idToAddress[pool_slots_5[activeSlot_ap5].referrerId], 1, 5);
users[idToAddress[pool_slots_5[activeSlot_ap5].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 5);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_5[activeSlot_ap5].eventsCount++;
}
}
else if(_fromPool == 6){
require(msg.value == 0.7 ether, "Participation fee in Autopool is 0.7 ETH");
require(!isUserExists(msg.sender, 6), "User already registered in AP6");
uint eventCount = pool_slots_6[activeSlot_ap6].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_6[activeSlot_ap6].userAddress,
pool_slots_6[activeSlot_ap6].id,
idToAddress[users[pool_slots_6[activeSlot_ap6].userAddress].referrerId],
6
));
pool_slots_6[activeSlot_ap6].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user6 = UsersPool({
id: newSlotId_ap6,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_6[msg.sender] = user6;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap6,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_6[newSlotId_ap6] = _newSlot;
newUserId_ap6++;
emit RegisterUserEvent(newSlotId_ap6, msg.sender, idToAddress[_referrerId], 6, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 6);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 6);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap6++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_6[activeSlot_ap6].userAddress, 1, 6);
users[pool_slots_6[activeSlot_ap6].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_6[activeSlot_ap6].referrerId > 0) {
payUpline(idToAddress[pool_slots_6[activeSlot_ap6].referrerId], 1, 6);
users[idToAddress[pool_slots_6[activeSlot_ap6].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 6);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_6[activeSlot_ap6].eventsCount++;
}
}else{
require(msg.value == 1 ether, "Participation fee in Autopool is 1 ETH");
require(!isUserExists(msg.sender, 7), "User already registered in AP7");
uint eventCount = pool_slots_7[activeSlot_ap7].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_7[activeSlot_ap7].userAddress,
pool_slots_7[activeSlot_ap7].id,
idToAddress[users[pool_slots_7[activeSlot_ap7].userAddress].referrerId],
7
));
pool_slots_7[activeSlot_ap7].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user7 = UsersPool({
id: newSlotId_ap7,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_7[msg.sender] = user7;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap7,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_7[newSlotId_ap7] = _newSlot;
newUserId_ap7++;
emit RegisterUserEvent(newSlotId_ap7, msg.sender, idToAddress[_referrerId], 7, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 7);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 7);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap7++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_7[activeSlot_ap7].userAddress, 1, 7);
users[pool_slots_7[activeSlot_ap7].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_7[activeSlot_ap7].referrerId > 0) {
payUpline(idToAddress[pool_slots_7[activeSlot_ap7].referrerId], 1, 7);
users[idToAddress[pool_slots_7[activeSlot_ap7].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 7);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_7[activeSlot_ap7].eventsCount++;
}
}
}
function reinvestSlot(address _userAddress, uint _userId, address _sponsorAddress, uint8 _fromPool) private returns (bool _isReinvested) {
}
function payUpline(address _sponsorAddress, uint8 _refLevel, uint8 _fromPool) private returns (uint distributeAmount) {
}
function payFirstLine(address _sponsorAddress, uint payAmount, uint8 _fromPool) private returns (uint distributeAmount) {
}
function isUserQualified(address _userAddress) public view returns (bool) {
}
function isUserExists(address _userAddress, uint8 _autopool) public view returns (bool) {
}
function getUserReferrals(address _userAddress)
public
view
returns (address[] memory)
{
}
}
| !isUserExists(msg.sender,5),"User already registered in AP5" | 352,604 | !isUserExists(msg.sender,5) |
null | pragma solidity >=0.5.12 <0.7.0;
contract way2eth {
struct User {
uint id;
uint referrerCount;
uint referrerId;
uint earnedFromPool;
uint earnedFromRef;
uint earnedFromGlobal;
address[] referrals;
}
struct UsersPool {
uint id;
uint referrerId;
uint reinvestCount;
}
struct PoolSlots {
uint id;
address userAddress;
uint referrerId;
uint8 eventsCount;
}
modifier validReferrerId(uint _referrerId) {
}
event RegisterUserEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event ReinvestEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event DistributeUplineEvent(uint amount, address indexed _sponsorAddress, address indexed _fromAddress, uint _level, uint8 _fromPool, uint _time);
event ReferralPaymentEvent(uint amount, address indexed _from, address indexed _to, uint8 indexed _fromPool, uint _time);
mapping(address => User) public users;
mapping(address => UsersPool) public users_2;
mapping(uint => PoolSlots) public pool_slots_2;
mapping(address => UsersPool) public users_3;
mapping(uint => PoolSlots) public pool_slots_3;
mapping(address => UsersPool) public users_4;
mapping(uint => PoolSlots) public pool_slots_4;
mapping(address => UsersPool) public users_5;
mapping(uint => PoolSlots) public pool_slots_5;
mapping(address => UsersPool) public users_6;
mapping(uint => PoolSlots) public pool_slots_6;
mapping(address => UsersPool) public users_7;
mapping(uint => PoolSlots) public pool_slots_7;
mapping(address => UsersPool) public users_8;
mapping(uint => PoolSlots) public pool_slots_8;
mapping(uint => address) public idToAddress;
mapping (uint => uint) public uplineAmount;
uint public newUserId = 1;
uint public newUserId_ap2 = 1;
uint public newUserId_ap3 = 1;
uint public newUserId_ap4 = 1;
uint public newUserId_ap5 = 1;
uint public newUserId_ap6 = 1;
uint public newUserId_ap7 = 1;
uint public newUserId_ap8 = 1;
uint public newSlotId_ap2 = 1;
uint public activeSlot_ap2 = 1;
uint public newSlotId_ap3 = 1;
uint public activeSlot_ap3 = 1;
uint public newSlotId_ap4 = 1;
uint public activeSlot_ap4 = 1;
uint public newSlotId_ap5 = 1;
uint public activeSlot_ap5 = 1;
uint public newSlotId_ap6 = 1;
uint public activeSlot_ap6 = 1;
uint public newSlotId_ap7 = 1;
uint public activeSlot_ap7 = 1;
uint public newSlotId_ap8 = 1;
uint public activeSlot_ap8 = 1;
address public owner;
constructor(address _ownerAddress) public {
}
function participatePool1(uint _referrerId)
public
payable
validReferrerId(_referrerId)
{
}
function participatePool2(uint8 _fromPool)
public
payable
{
if(_fromPool == 2 || _fromPool == 3 || _fromPool == 4 || _fromPool == 5 || _fromPool == 6 || _fromPool == 7){
require(isUserExists(msg.sender, 1), "User not present in AP1");
require(isUserQualified(msg.sender), "User not qualified in AP1");
}
if(_fromPool == 2){
require(msg.value == 0.2 ether, "Participation fee in Autopool is 0.2 ETH");
require(!isUserExists(msg.sender, 2), "User already registered in AP2");
uint eventCount = pool_slots_2[activeSlot_ap2].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_2[activeSlot_ap2].userAddress,
pool_slots_2[activeSlot_ap2].id,
idToAddress[users[pool_slots_2[activeSlot_ap2].userAddress].referrerId],
2
));
pool_slots_2[activeSlot_ap2].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user2 = UsersPool({
id: newSlotId_ap2,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_2[msg.sender] = user2;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap2,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_2[newSlotId_ap2] = _newSlot;
newUserId_ap2++;
emit RegisterUserEvent(newSlotId_ap2, msg.sender, idToAddress[_referrerId], 2, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 2);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 2);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap2++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_2[activeSlot_ap2].userAddress, 1, 2);
users[pool_slots_2[activeSlot_ap2].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_2[activeSlot_ap2].referrerId > 0) {
payUpline(idToAddress[pool_slots_2[activeSlot_ap2].referrerId], 1, 2);
users[idToAddress[pool_slots_2[activeSlot_ap2].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 2);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_2[activeSlot_ap2].eventsCount++;
}
}else if(_fromPool == 3){
require(msg.value == 0.3 ether, "Participation fee in Autopool is 0.3 ETH");
require(!isUserExists(msg.sender, 3), "User already registered in AP3");
uint eventCount = pool_slots_3[activeSlot_ap3].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_3[activeSlot_ap3].userAddress,
pool_slots_3[activeSlot_ap3].id,
idToAddress[users[pool_slots_3[activeSlot_ap3].userAddress].referrerId],
3
));
pool_slots_3[activeSlot_ap3].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user3 = UsersPool({
id: newSlotId_ap3,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_3[msg.sender] = user3;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap3,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_3[newSlotId_ap3] = _newSlot;
newUserId_ap3++;
emit RegisterUserEvent(newSlotId_ap3, msg.sender, idToAddress[_referrerId], 3, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 3);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 3);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap3++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_3[activeSlot_ap3].userAddress, 1, 3);
users[pool_slots_3[activeSlot_ap3].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_3[activeSlot_ap3].referrerId > 0) {
payUpline(idToAddress[pool_slots_3[activeSlot_ap3].referrerId], 1, 3);
users[idToAddress[pool_slots_3[activeSlot_ap3].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 3);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_3[activeSlot_ap3].eventsCount++;
}
}
else if(_fromPool == 4){
require(msg.value == 0.4 ether, "Participation fee in Autopool is 0.4 ETH");
require(!isUserExists(msg.sender, 4), "User already registered in AP4");
uint eventCount = pool_slots_4[activeSlot_ap4].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_4[activeSlot_ap4].userAddress,
pool_slots_4[activeSlot_ap4].id,
idToAddress[users[pool_slots_4[activeSlot_ap4].userAddress].referrerId],
4
));
pool_slots_4[activeSlot_ap4].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user4 = UsersPool({
id: newSlotId_ap4,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_4[msg.sender] = user4;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap4,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_4[newSlotId_ap4] = _newSlot;
newUserId_ap4++;
emit RegisterUserEvent(newSlotId_ap4, msg.sender, idToAddress[_referrerId], 4, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 4);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 4);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap4++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_4[activeSlot_ap4].userAddress, 1, 4);
users[pool_slots_4[activeSlot_ap4].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_4[activeSlot_ap4].referrerId > 0) {
payUpline(idToAddress[pool_slots_4[activeSlot_ap4].referrerId], 1, 4);
users[idToAddress[pool_slots_4[activeSlot_ap4].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 4);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_4[activeSlot_ap4].eventsCount++;
}
}
else if(_fromPool == 5){
require(msg.value == 0.5 ether, "Participation fee in Autopool is 0.5 ETH");
require(!isUserExists(msg.sender, 5), "User already registered in AP5");
uint eventCount = pool_slots_5[activeSlot_ap5].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(<FILL_ME>)
pool_slots_5[activeSlot_ap5].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user5 = UsersPool({
id: newSlotId_ap5,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_5[msg.sender] = user5;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap5,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_5[newSlotId_ap5] = _newSlot;
newUserId_ap5++;
emit RegisterUserEvent(newSlotId_ap5, msg.sender, idToAddress[_referrerId], 5, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 5);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 5);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap5++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_5[activeSlot_ap5].userAddress, 1, 5);
users[pool_slots_5[activeSlot_ap5].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_5[activeSlot_ap5].referrerId > 0) {
payUpline(idToAddress[pool_slots_5[activeSlot_ap5].referrerId], 1, 5);
users[idToAddress[pool_slots_5[activeSlot_ap5].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 5);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_5[activeSlot_ap5].eventsCount++;
}
}
else if(_fromPool == 6){
require(msg.value == 0.7 ether, "Participation fee in Autopool is 0.7 ETH");
require(!isUserExists(msg.sender, 6), "User already registered in AP6");
uint eventCount = pool_slots_6[activeSlot_ap6].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_6[activeSlot_ap6].userAddress,
pool_slots_6[activeSlot_ap6].id,
idToAddress[users[pool_slots_6[activeSlot_ap6].userAddress].referrerId],
6
));
pool_slots_6[activeSlot_ap6].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user6 = UsersPool({
id: newSlotId_ap6,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_6[msg.sender] = user6;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap6,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_6[newSlotId_ap6] = _newSlot;
newUserId_ap6++;
emit RegisterUserEvent(newSlotId_ap6, msg.sender, idToAddress[_referrerId], 6, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 6);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 6);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap6++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_6[activeSlot_ap6].userAddress, 1, 6);
users[pool_slots_6[activeSlot_ap6].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_6[activeSlot_ap6].referrerId > 0) {
payUpline(idToAddress[pool_slots_6[activeSlot_ap6].referrerId], 1, 6);
users[idToAddress[pool_slots_6[activeSlot_ap6].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 6);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_6[activeSlot_ap6].eventsCount++;
}
}else{
require(msg.value == 1 ether, "Participation fee in Autopool is 1 ETH");
require(!isUserExists(msg.sender, 7), "User already registered in AP7");
uint eventCount = pool_slots_7[activeSlot_ap7].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_7[activeSlot_ap7].userAddress,
pool_slots_7[activeSlot_ap7].id,
idToAddress[users[pool_slots_7[activeSlot_ap7].userAddress].referrerId],
7
));
pool_slots_7[activeSlot_ap7].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user7 = UsersPool({
id: newSlotId_ap7,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_7[msg.sender] = user7;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap7,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_7[newSlotId_ap7] = _newSlot;
newUserId_ap7++;
emit RegisterUserEvent(newSlotId_ap7, msg.sender, idToAddress[_referrerId], 7, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 7);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 7);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap7++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_7[activeSlot_ap7].userAddress, 1, 7);
users[pool_slots_7[activeSlot_ap7].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_7[activeSlot_ap7].referrerId > 0) {
payUpline(idToAddress[pool_slots_7[activeSlot_ap7].referrerId], 1, 7);
users[idToAddress[pool_slots_7[activeSlot_ap7].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 7);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_7[activeSlot_ap7].eventsCount++;
}
}
}
function reinvestSlot(address _userAddress, uint _userId, address _sponsorAddress, uint8 _fromPool) private returns (bool _isReinvested) {
}
function payUpline(address _sponsorAddress, uint8 _refLevel, uint8 _fromPool) private returns (uint distributeAmount) {
}
function payFirstLine(address _sponsorAddress, uint payAmount, uint8 _fromPool) private returns (uint distributeAmount) {
}
function isUserQualified(address _userAddress) public view returns (bool) {
}
function isUserExists(address _userAddress, uint8 _autopool) public view returns (bool) {
}
function getUserReferrals(address _userAddress)
public
view
returns (address[] memory)
{
}
}
| reinvestSlot(pool_slots_5[activeSlot_ap5].userAddress,pool_slots_5[activeSlot_ap5].id,idToAddress[users[pool_slots_5[activeSlot_ap5].userAddress].referrerId],5) | 352,604 | reinvestSlot(pool_slots_5[activeSlot_ap5].userAddress,pool_slots_5[activeSlot_ap5].id,idToAddress[users[pool_slots_5[activeSlot_ap5].userAddress].referrerId],5) |
"User already registered in AP6" | pragma solidity >=0.5.12 <0.7.0;
contract way2eth {
struct User {
uint id;
uint referrerCount;
uint referrerId;
uint earnedFromPool;
uint earnedFromRef;
uint earnedFromGlobal;
address[] referrals;
}
struct UsersPool {
uint id;
uint referrerId;
uint reinvestCount;
}
struct PoolSlots {
uint id;
address userAddress;
uint referrerId;
uint8 eventsCount;
}
modifier validReferrerId(uint _referrerId) {
}
event RegisterUserEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event ReinvestEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event DistributeUplineEvent(uint amount, address indexed _sponsorAddress, address indexed _fromAddress, uint _level, uint8 _fromPool, uint _time);
event ReferralPaymentEvent(uint amount, address indexed _from, address indexed _to, uint8 indexed _fromPool, uint _time);
mapping(address => User) public users;
mapping(address => UsersPool) public users_2;
mapping(uint => PoolSlots) public pool_slots_2;
mapping(address => UsersPool) public users_3;
mapping(uint => PoolSlots) public pool_slots_3;
mapping(address => UsersPool) public users_4;
mapping(uint => PoolSlots) public pool_slots_4;
mapping(address => UsersPool) public users_5;
mapping(uint => PoolSlots) public pool_slots_5;
mapping(address => UsersPool) public users_6;
mapping(uint => PoolSlots) public pool_slots_6;
mapping(address => UsersPool) public users_7;
mapping(uint => PoolSlots) public pool_slots_7;
mapping(address => UsersPool) public users_8;
mapping(uint => PoolSlots) public pool_slots_8;
mapping(uint => address) public idToAddress;
mapping (uint => uint) public uplineAmount;
uint public newUserId = 1;
uint public newUserId_ap2 = 1;
uint public newUserId_ap3 = 1;
uint public newUserId_ap4 = 1;
uint public newUserId_ap5 = 1;
uint public newUserId_ap6 = 1;
uint public newUserId_ap7 = 1;
uint public newUserId_ap8 = 1;
uint public newSlotId_ap2 = 1;
uint public activeSlot_ap2 = 1;
uint public newSlotId_ap3 = 1;
uint public activeSlot_ap3 = 1;
uint public newSlotId_ap4 = 1;
uint public activeSlot_ap4 = 1;
uint public newSlotId_ap5 = 1;
uint public activeSlot_ap5 = 1;
uint public newSlotId_ap6 = 1;
uint public activeSlot_ap6 = 1;
uint public newSlotId_ap7 = 1;
uint public activeSlot_ap7 = 1;
uint public newSlotId_ap8 = 1;
uint public activeSlot_ap8 = 1;
address public owner;
constructor(address _ownerAddress) public {
}
function participatePool1(uint _referrerId)
public
payable
validReferrerId(_referrerId)
{
}
function participatePool2(uint8 _fromPool)
public
payable
{
if(_fromPool == 2 || _fromPool == 3 || _fromPool == 4 || _fromPool == 5 || _fromPool == 6 || _fromPool == 7){
require(isUserExists(msg.sender, 1), "User not present in AP1");
require(isUserQualified(msg.sender), "User not qualified in AP1");
}
if(_fromPool == 2){
require(msg.value == 0.2 ether, "Participation fee in Autopool is 0.2 ETH");
require(!isUserExists(msg.sender, 2), "User already registered in AP2");
uint eventCount = pool_slots_2[activeSlot_ap2].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_2[activeSlot_ap2].userAddress,
pool_slots_2[activeSlot_ap2].id,
idToAddress[users[pool_slots_2[activeSlot_ap2].userAddress].referrerId],
2
));
pool_slots_2[activeSlot_ap2].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user2 = UsersPool({
id: newSlotId_ap2,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_2[msg.sender] = user2;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap2,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_2[newSlotId_ap2] = _newSlot;
newUserId_ap2++;
emit RegisterUserEvent(newSlotId_ap2, msg.sender, idToAddress[_referrerId], 2, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 2);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 2);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap2++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_2[activeSlot_ap2].userAddress, 1, 2);
users[pool_slots_2[activeSlot_ap2].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_2[activeSlot_ap2].referrerId > 0) {
payUpline(idToAddress[pool_slots_2[activeSlot_ap2].referrerId], 1, 2);
users[idToAddress[pool_slots_2[activeSlot_ap2].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 2);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_2[activeSlot_ap2].eventsCount++;
}
}else if(_fromPool == 3){
require(msg.value == 0.3 ether, "Participation fee in Autopool is 0.3 ETH");
require(!isUserExists(msg.sender, 3), "User already registered in AP3");
uint eventCount = pool_slots_3[activeSlot_ap3].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_3[activeSlot_ap3].userAddress,
pool_slots_3[activeSlot_ap3].id,
idToAddress[users[pool_slots_3[activeSlot_ap3].userAddress].referrerId],
3
));
pool_slots_3[activeSlot_ap3].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user3 = UsersPool({
id: newSlotId_ap3,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_3[msg.sender] = user3;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap3,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_3[newSlotId_ap3] = _newSlot;
newUserId_ap3++;
emit RegisterUserEvent(newSlotId_ap3, msg.sender, idToAddress[_referrerId], 3, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 3);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 3);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap3++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_3[activeSlot_ap3].userAddress, 1, 3);
users[pool_slots_3[activeSlot_ap3].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_3[activeSlot_ap3].referrerId > 0) {
payUpline(idToAddress[pool_slots_3[activeSlot_ap3].referrerId], 1, 3);
users[idToAddress[pool_slots_3[activeSlot_ap3].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 3);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_3[activeSlot_ap3].eventsCount++;
}
}
else if(_fromPool == 4){
require(msg.value == 0.4 ether, "Participation fee in Autopool is 0.4 ETH");
require(!isUserExists(msg.sender, 4), "User already registered in AP4");
uint eventCount = pool_slots_4[activeSlot_ap4].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_4[activeSlot_ap4].userAddress,
pool_slots_4[activeSlot_ap4].id,
idToAddress[users[pool_slots_4[activeSlot_ap4].userAddress].referrerId],
4
));
pool_slots_4[activeSlot_ap4].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user4 = UsersPool({
id: newSlotId_ap4,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_4[msg.sender] = user4;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap4,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_4[newSlotId_ap4] = _newSlot;
newUserId_ap4++;
emit RegisterUserEvent(newSlotId_ap4, msg.sender, idToAddress[_referrerId], 4, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 4);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 4);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap4++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_4[activeSlot_ap4].userAddress, 1, 4);
users[pool_slots_4[activeSlot_ap4].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_4[activeSlot_ap4].referrerId > 0) {
payUpline(idToAddress[pool_slots_4[activeSlot_ap4].referrerId], 1, 4);
users[idToAddress[pool_slots_4[activeSlot_ap4].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 4);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_4[activeSlot_ap4].eventsCount++;
}
}
else if(_fromPool == 5){
require(msg.value == 0.5 ether, "Participation fee in Autopool is 0.5 ETH");
require(!isUserExists(msg.sender, 5), "User already registered in AP5");
uint eventCount = pool_slots_5[activeSlot_ap5].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_5[activeSlot_ap5].userAddress,
pool_slots_5[activeSlot_ap5].id,
idToAddress[users[pool_slots_5[activeSlot_ap5].userAddress].referrerId],
5
));
pool_slots_5[activeSlot_ap5].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user5 = UsersPool({
id: newSlotId_ap5,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_5[msg.sender] = user5;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap5,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_5[newSlotId_ap5] = _newSlot;
newUserId_ap5++;
emit RegisterUserEvent(newSlotId_ap5, msg.sender, idToAddress[_referrerId], 5, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 5);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 5);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap5++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_5[activeSlot_ap5].userAddress, 1, 5);
users[pool_slots_5[activeSlot_ap5].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_5[activeSlot_ap5].referrerId > 0) {
payUpline(idToAddress[pool_slots_5[activeSlot_ap5].referrerId], 1, 5);
users[idToAddress[pool_slots_5[activeSlot_ap5].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 5);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_5[activeSlot_ap5].eventsCount++;
}
}
else if(_fromPool == 6){
require(msg.value == 0.7 ether, "Participation fee in Autopool is 0.7 ETH");
require(<FILL_ME>)
uint eventCount = pool_slots_6[activeSlot_ap6].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_6[activeSlot_ap6].userAddress,
pool_slots_6[activeSlot_ap6].id,
idToAddress[users[pool_slots_6[activeSlot_ap6].userAddress].referrerId],
6
));
pool_slots_6[activeSlot_ap6].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user6 = UsersPool({
id: newSlotId_ap6,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_6[msg.sender] = user6;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap6,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_6[newSlotId_ap6] = _newSlot;
newUserId_ap6++;
emit RegisterUserEvent(newSlotId_ap6, msg.sender, idToAddress[_referrerId], 6, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 6);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 6);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap6++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_6[activeSlot_ap6].userAddress, 1, 6);
users[pool_slots_6[activeSlot_ap6].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_6[activeSlot_ap6].referrerId > 0) {
payUpline(idToAddress[pool_slots_6[activeSlot_ap6].referrerId], 1, 6);
users[idToAddress[pool_slots_6[activeSlot_ap6].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 6);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_6[activeSlot_ap6].eventsCount++;
}
}else{
require(msg.value == 1 ether, "Participation fee in Autopool is 1 ETH");
require(!isUserExists(msg.sender, 7), "User already registered in AP7");
uint eventCount = pool_slots_7[activeSlot_ap7].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_7[activeSlot_ap7].userAddress,
pool_slots_7[activeSlot_ap7].id,
idToAddress[users[pool_slots_7[activeSlot_ap7].userAddress].referrerId],
7
));
pool_slots_7[activeSlot_ap7].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user7 = UsersPool({
id: newSlotId_ap7,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_7[msg.sender] = user7;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap7,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_7[newSlotId_ap7] = _newSlot;
newUserId_ap7++;
emit RegisterUserEvent(newSlotId_ap7, msg.sender, idToAddress[_referrerId], 7, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 7);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 7);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap7++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_7[activeSlot_ap7].userAddress, 1, 7);
users[pool_slots_7[activeSlot_ap7].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_7[activeSlot_ap7].referrerId > 0) {
payUpline(idToAddress[pool_slots_7[activeSlot_ap7].referrerId], 1, 7);
users[idToAddress[pool_slots_7[activeSlot_ap7].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 7);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_7[activeSlot_ap7].eventsCount++;
}
}
}
function reinvestSlot(address _userAddress, uint _userId, address _sponsorAddress, uint8 _fromPool) private returns (bool _isReinvested) {
}
function payUpline(address _sponsorAddress, uint8 _refLevel, uint8 _fromPool) private returns (uint distributeAmount) {
}
function payFirstLine(address _sponsorAddress, uint payAmount, uint8 _fromPool) private returns (uint distributeAmount) {
}
function isUserQualified(address _userAddress) public view returns (bool) {
}
function isUserExists(address _userAddress, uint8 _autopool) public view returns (bool) {
}
function getUserReferrals(address _userAddress)
public
view
returns (address[] memory)
{
}
}
| !isUserExists(msg.sender,6),"User already registered in AP6" | 352,604 | !isUserExists(msg.sender,6) |
null | pragma solidity >=0.5.12 <0.7.0;
contract way2eth {
struct User {
uint id;
uint referrerCount;
uint referrerId;
uint earnedFromPool;
uint earnedFromRef;
uint earnedFromGlobal;
address[] referrals;
}
struct UsersPool {
uint id;
uint referrerId;
uint reinvestCount;
}
struct PoolSlots {
uint id;
address userAddress;
uint referrerId;
uint8 eventsCount;
}
modifier validReferrerId(uint _referrerId) {
}
event RegisterUserEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event ReinvestEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event DistributeUplineEvent(uint amount, address indexed _sponsorAddress, address indexed _fromAddress, uint _level, uint8 _fromPool, uint _time);
event ReferralPaymentEvent(uint amount, address indexed _from, address indexed _to, uint8 indexed _fromPool, uint _time);
mapping(address => User) public users;
mapping(address => UsersPool) public users_2;
mapping(uint => PoolSlots) public pool_slots_2;
mapping(address => UsersPool) public users_3;
mapping(uint => PoolSlots) public pool_slots_3;
mapping(address => UsersPool) public users_4;
mapping(uint => PoolSlots) public pool_slots_4;
mapping(address => UsersPool) public users_5;
mapping(uint => PoolSlots) public pool_slots_5;
mapping(address => UsersPool) public users_6;
mapping(uint => PoolSlots) public pool_slots_6;
mapping(address => UsersPool) public users_7;
mapping(uint => PoolSlots) public pool_slots_7;
mapping(address => UsersPool) public users_8;
mapping(uint => PoolSlots) public pool_slots_8;
mapping(uint => address) public idToAddress;
mapping (uint => uint) public uplineAmount;
uint public newUserId = 1;
uint public newUserId_ap2 = 1;
uint public newUserId_ap3 = 1;
uint public newUserId_ap4 = 1;
uint public newUserId_ap5 = 1;
uint public newUserId_ap6 = 1;
uint public newUserId_ap7 = 1;
uint public newUserId_ap8 = 1;
uint public newSlotId_ap2 = 1;
uint public activeSlot_ap2 = 1;
uint public newSlotId_ap3 = 1;
uint public activeSlot_ap3 = 1;
uint public newSlotId_ap4 = 1;
uint public activeSlot_ap4 = 1;
uint public newSlotId_ap5 = 1;
uint public activeSlot_ap5 = 1;
uint public newSlotId_ap6 = 1;
uint public activeSlot_ap6 = 1;
uint public newSlotId_ap7 = 1;
uint public activeSlot_ap7 = 1;
uint public newSlotId_ap8 = 1;
uint public activeSlot_ap8 = 1;
address public owner;
constructor(address _ownerAddress) public {
}
function participatePool1(uint _referrerId)
public
payable
validReferrerId(_referrerId)
{
}
function participatePool2(uint8 _fromPool)
public
payable
{
if(_fromPool == 2 || _fromPool == 3 || _fromPool == 4 || _fromPool == 5 || _fromPool == 6 || _fromPool == 7){
require(isUserExists(msg.sender, 1), "User not present in AP1");
require(isUserQualified(msg.sender), "User not qualified in AP1");
}
if(_fromPool == 2){
require(msg.value == 0.2 ether, "Participation fee in Autopool is 0.2 ETH");
require(!isUserExists(msg.sender, 2), "User already registered in AP2");
uint eventCount = pool_slots_2[activeSlot_ap2].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_2[activeSlot_ap2].userAddress,
pool_slots_2[activeSlot_ap2].id,
idToAddress[users[pool_slots_2[activeSlot_ap2].userAddress].referrerId],
2
));
pool_slots_2[activeSlot_ap2].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user2 = UsersPool({
id: newSlotId_ap2,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_2[msg.sender] = user2;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap2,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_2[newSlotId_ap2] = _newSlot;
newUserId_ap2++;
emit RegisterUserEvent(newSlotId_ap2, msg.sender, idToAddress[_referrerId], 2, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 2);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 2);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap2++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_2[activeSlot_ap2].userAddress, 1, 2);
users[pool_slots_2[activeSlot_ap2].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_2[activeSlot_ap2].referrerId > 0) {
payUpline(idToAddress[pool_slots_2[activeSlot_ap2].referrerId], 1, 2);
users[idToAddress[pool_slots_2[activeSlot_ap2].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 2);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_2[activeSlot_ap2].eventsCount++;
}
}else if(_fromPool == 3){
require(msg.value == 0.3 ether, "Participation fee in Autopool is 0.3 ETH");
require(!isUserExists(msg.sender, 3), "User already registered in AP3");
uint eventCount = pool_slots_3[activeSlot_ap3].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_3[activeSlot_ap3].userAddress,
pool_slots_3[activeSlot_ap3].id,
idToAddress[users[pool_slots_3[activeSlot_ap3].userAddress].referrerId],
3
));
pool_slots_3[activeSlot_ap3].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user3 = UsersPool({
id: newSlotId_ap3,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_3[msg.sender] = user3;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap3,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_3[newSlotId_ap3] = _newSlot;
newUserId_ap3++;
emit RegisterUserEvent(newSlotId_ap3, msg.sender, idToAddress[_referrerId], 3, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 3);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 3);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap3++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_3[activeSlot_ap3].userAddress, 1, 3);
users[pool_slots_3[activeSlot_ap3].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_3[activeSlot_ap3].referrerId > 0) {
payUpline(idToAddress[pool_slots_3[activeSlot_ap3].referrerId], 1, 3);
users[idToAddress[pool_slots_3[activeSlot_ap3].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 3);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_3[activeSlot_ap3].eventsCount++;
}
}
else if(_fromPool == 4){
require(msg.value == 0.4 ether, "Participation fee in Autopool is 0.4 ETH");
require(!isUserExists(msg.sender, 4), "User already registered in AP4");
uint eventCount = pool_slots_4[activeSlot_ap4].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_4[activeSlot_ap4].userAddress,
pool_slots_4[activeSlot_ap4].id,
idToAddress[users[pool_slots_4[activeSlot_ap4].userAddress].referrerId],
4
));
pool_slots_4[activeSlot_ap4].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user4 = UsersPool({
id: newSlotId_ap4,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_4[msg.sender] = user4;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap4,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_4[newSlotId_ap4] = _newSlot;
newUserId_ap4++;
emit RegisterUserEvent(newSlotId_ap4, msg.sender, idToAddress[_referrerId], 4, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 4);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 4);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap4++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_4[activeSlot_ap4].userAddress, 1, 4);
users[pool_slots_4[activeSlot_ap4].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_4[activeSlot_ap4].referrerId > 0) {
payUpline(idToAddress[pool_slots_4[activeSlot_ap4].referrerId], 1, 4);
users[idToAddress[pool_slots_4[activeSlot_ap4].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 4);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_4[activeSlot_ap4].eventsCount++;
}
}
else if(_fromPool == 5){
require(msg.value == 0.5 ether, "Participation fee in Autopool is 0.5 ETH");
require(!isUserExists(msg.sender, 5), "User already registered in AP5");
uint eventCount = pool_slots_5[activeSlot_ap5].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_5[activeSlot_ap5].userAddress,
pool_slots_5[activeSlot_ap5].id,
idToAddress[users[pool_slots_5[activeSlot_ap5].userAddress].referrerId],
5
));
pool_slots_5[activeSlot_ap5].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user5 = UsersPool({
id: newSlotId_ap5,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_5[msg.sender] = user5;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap5,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_5[newSlotId_ap5] = _newSlot;
newUserId_ap5++;
emit RegisterUserEvent(newSlotId_ap5, msg.sender, idToAddress[_referrerId], 5, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 5);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 5);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap5++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_5[activeSlot_ap5].userAddress, 1, 5);
users[pool_slots_5[activeSlot_ap5].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_5[activeSlot_ap5].referrerId > 0) {
payUpline(idToAddress[pool_slots_5[activeSlot_ap5].referrerId], 1, 5);
users[idToAddress[pool_slots_5[activeSlot_ap5].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 5);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_5[activeSlot_ap5].eventsCount++;
}
}
else if(_fromPool == 6){
require(msg.value == 0.7 ether, "Participation fee in Autopool is 0.7 ETH");
require(!isUserExists(msg.sender, 6), "User already registered in AP6");
uint eventCount = pool_slots_6[activeSlot_ap6].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(<FILL_ME>)
pool_slots_6[activeSlot_ap6].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user6 = UsersPool({
id: newSlotId_ap6,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_6[msg.sender] = user6;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap6,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_6[newSlotId_ap6] = _newSlot;
newUserId_ap6++;
emit RegisterUserEvent(newSlotId_ap6, msg.sender, idToAddress[_referrerId], 6, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 6);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 6);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap6++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_6[activeSlot_ap6].userAddress, 1, 6);
users[pool_slots_6[activeSlot_ap6].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_6[activeSlot_ap6].referrerId > 0) {
payUpline(idToAddress[pool_slots_6[activeSlot_ap6].referrerId], 1, 6);
users[idToAddress[pool_slots_6[activeSlot_ap6].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 6);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_6[activeSlot_ap6].eventsCount++;
}
}else{
require(msg.value == 1 ether, "Participation fee in Autopool is 1 ETH");
require(!isUserExists(msg.sender, 7), "User already registered in AP7");
uint eventCount = pool_slots_7[activeSlot_ap7].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_7[activeSlot_ap7].userAddress,
pool_slots_7[activeSlot_ap7].id,
idToAddress[users[pool_slots_7[activeSlot_ap7].userAddress].referrerId],
7
));
pool_slots_7[activeSlot_ap7].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user7 = UsersPool({
id: newSlotId_ap7,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_7[msg.sender] = user7;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap7,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_7[newSlotId_ap7] = _newSlot;
newUserId_ap7++;
emit RegisterUserEvent(newSlotId_ap7, msg.sender, idToAddress[_referrerId], 7, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 7);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 7);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap7++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_7[activeSlot_ap7].userAddress, 1, 7);
users[pool_slots_7[activeSlot_ap7].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_7[activeSlot_ap7].referrerId > 0) {
payUpline(idToAddress[pool_slots_7[activeSlot_ap7].referrerId], 1, 7);
users[idToAddress[pool_slots_7[activeSlot_ap7].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 7);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_7[activeSlot_ap7].eventsCount++;
}
}
}
function reinvestSlot(address _userAddress, uint _userId, address _sponsorAddress, uint8 _fromPool) private returns (bool _isReinvested) {
}
function payUpline(address _sponsorAddress, uint8 _refLevel, uint8 _fromPool) private returns (uint distributeAmount) {
}
function payFirstLine(address _sponsorAddress, uint payAmount, uint8 _fromPool) private returns (uint distributeAmount) {
}
function isUserQualified(address _userAddress) public view returns (bool) {
}
function isUserExists(address _userAddress, uint8 _autopool) public view returns (bool) {
}
function getUserReferrals(address _userAddress)
public
view
returns (address[] memory)
{
}
}
| reinvestSlot(pool_slots_6[activeSlot_ap6].userAddress,pool_slots_6[activeSlot_ap6].id,idToAddress[users[pool_slots_6[activeSlot_ap6].userAddress].referrerId],6) | 352,604 | reinvestSlot(pool_slots_6[activeSlot_ap6].userAddress,pool_slots_6[activeSlot_ap6].id,idToAddress[users[pool_slots_6[activeSlot_ap6].userAddress].referrerId],6) |
"User already registered in AP7" | pragma solidity >=0.5.12 <0.7.0;
contract way2eth {
struct User {
uint id;
uint referrerCount;
uint referrerId;
uint earnedFromPool;
uint earnedFromRef;
uint earnedFromGlobal;
address[] referrals;
}
struct UsersPool {
uint id;
uint referrerId;
uint reinvestCount;
}
struct PoolSlots {
uint id;
address userAddress;
uint referrerId;
uint8 eventsCount;
}
modifier validReferrerId(uint _referrerId) {
}
event RegisterUserEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event ReinvestEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event DistributeUplineEvent(uint amount, address indexed _sponsorAddress, address indexed _fromAddress, uint _level, uint8 _fromPool, uint _time);
event ReferralPaymentEvent(uint amount, address indexed _from, address indexed _to, uint8 indexed _fromPool, uint _time);
mapping(address => User) public users;
mapping(address => UsersPool) public users_2;
mapping(uint => PoolSlots) public pool_slots_2;
mapping(address => UsersPool) public users_3;
mapping(uint => PoolSlots) public pool_slots_3;
mapping(address => UsersPool) public users_4;
mapping(uint => PoolSlots) public pool_slots_4;
mapping(address => UsersPool) public users_5;
mapping(uint => PoolSlots) public pool_slots_5;
mapping(address => UsersPool) public users_6;
mapping(uint => PoolSlots) public pool_slots_6;
mapping(address => UsersPool) public users_7;
mapping(uint => PoolSlots) public pool_slots_7;
mapping(address => UsersPool) public users_8;
mapping(uint => PoolSlots) public pool_slots_8;
mapping(uint => address) public idToAddress;
mapping (uint => uint) public uplineAmount;
uint public newUserId = 1;
uint public newUserId_ap2 = 1;
uint public newUserId_ap3 = 1;
uint public newUserId_ap4 = 1;
uint public newUserId_ap5 = 1;
uint public newUserId_ap6 = 1;
uint public newUserId_ap7 = 1;
uint public newUserId_ap8 = 1;
uint public newSlotId_ap2 = 1;
uint public activeSlot_ap2 = 1;
uint public newSlotId_ap3 = 1;
uint public activeSlot_ap3 = 1;
uint public newSlotId_ap4 = 1;
uint public activeSlot_ap4 = 1;
uint public newSlotId_ap5 = 1;
uint public activeSlot_ap5 = 1;
uint public newSlotId_ap6 = 1;
uint public activeSlot_ap6 = 1;
uint public newSlotId_ap7 = 1;
uint public activeSlot_ap7 = 1;
uint public newSlotId_ap8 = 1;
uint public activeSlot_ap8 = 1;
address public owner;
constructor(address _ownerAddress) public {
}
function participatePool1(uint _referrerId)
public
payable
validReferrerId(_referrerId)
{
}
function participatePool2(uint8 _fromPool)
public
payable
{
if(_fromPool == 2 || _fromPool == 3 || _fromPool == 4 || _fromPool == 5 || _fromPool == 6 || _fromPool == 7){
require(isUserExists(msg.sender, 1), "User not present in AP1");
require(isUserQualified(msg.sender), "User not qualified in AP1");
}
if(_fromPool == 2){
require(msg.value == 0.2 ether, "Participation fee in Autopool is 0.2 ETH");
require(!isUserExists(msg.sender, 2), "User already registered in AP2");
uint eventCount = pool_slots_2[activeSlot_ap2].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_2[activeSlot_ap2].userAddress,
pool_slots_2[activeSlot_ap2].id,
idToAddress[users[pool_slots_2[activeSlot_ap2].userAddress].referrerId],
2
));
pool_slots_2[activeSlot_ap2].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user2 = UsersPool({
id: newSlotId_ap2,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_2[msg.sender] = user2;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap2,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_2[newSlotId_ap2] = _newSlot;
newUserId_ap2++;
emit RegisterUserEvent(newSlotId_ap2, msg.sender, idToAddress[_referrerId], 2, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 2);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 2);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap2++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_2[activeSlot_ap2].userAddress, 1, 2);
users[pool_slots_2[activeSlot_ap2].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_2[activeSlot_ap2].referrerId > 0) {
payUpline(idToAddress[pool_slots_2[activeSlot_ap2].referrerId], 1, 2);
users[idToAddress[pool_slots_2[activeSlot_ap2].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 2);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_2[activeSlot_ap2].eventsCount++;
}
}else if(_fromPool == 3){
require(msg.value == 0.3 ether, "Participation fee in Autopool is 0.3 ETH");
require(!isUserExists(msg.sender, 3), "User already registered in AP3");
uint eventCount = pool_slots_3[activeSlot_ap3].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_3[activeSlot_ap3].userAddress,
pool_slots_3[activeSlot_ap3].id,
idToAddress[users[pool_slots_3[activeSlot_ap3].userAddress].referrerId],
3
));
pool_slots_3[activeSlot_ap3].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user3 = UsersPool({
id: newSlotId_ap3,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_3[msg.sender] = user3;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap3,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_3[newSlotId_ap3] = _newSlot;
newUserId_ap3++;
emit RegisterUserEvent(newSlotId_ap3, msg.sender, idToAddress[_referrerId], 3, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 3);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 3);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap3++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_3[activeSlot_ap3].userAddress, 1, 3);
users[pool_slots_3[activeSlot_ap3].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_3[activeSlot_ap3].referrerId > 0) {
payUpline(idToAddress[pool_slots_3[activeSlot_ap3].referrerId], 1, 3);
users[idToAddress[pool_slots_3[activeSlot_ap3].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 3);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_3[activeSlot_ap3].eventsCount++;
}
}
else if(_fromPool == 4){
require(msg.value == 0.4 ether, "Participation fee in Autopool is 0.4 ETH");
require(!isUserExists(msg.sender, 4), "User already registered in AP4");
uint eventCount = pool_slots_4[activeSlot_ap4].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_4[activeSlot_ap4].userAddress,
pool_slots_4[activeSlot_ap4].id,
idToAddress[users[pool_slots_4[activeSlot_ap4].userAddress].referrerId],
4
));
pool_slots_4[activeSlot_ap4].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user4 = UsersPool({
id: newSlotId_ap4,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_4[msg.sender] = user4;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap4,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_4[newSlotId_ap4] = _newSlot;
newUserId_ap4++;
emit RegisterUserEvent(newSlotId_ap4, msg.sender, idToAddress[_referrerId], 4, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 4);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 4);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap4++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_4[activeSlot_ap4].userAddress, 1, 4);
users[pool_slots_4[activeSlot_ap4].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_4[activeSlot_ap4].referrerId > 0) {
payUpline(idToAddress[pool_slots_4[activeSlot_ap4].referrerId], 1, 4);
users[idToAddress[pool_slots_4[activeSlot_ap4].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 4);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_4[activeSlot_ap4].eventsCount++;
}
}
else if(_fromPool == 5){
require(msg.value == 0.5 ether, "Participation fee in Autopool is 0.5 ETH");
require(!isUserExists(msg.sender, 5), "User already registered in AP5");
uint eventCount = pool_slots_5[activeSlot_ap5].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_5[activeSlot_ap5].userAddress,
pool_slots_5[activeSlot_ap5].id,
idToAddress[users[pool_slots_5[activeSlot_ap5].userAddress].referrerId],
5
));
pool_slots_5[activeSlot_ap5].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user5 = UsersPool({
id: newSlotId_ap5,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_5[msg.sender] = user5;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap5,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_5[newSlotId_ap5] = _newSlot;
newUserId_ap5++;
emit RegisterUserEvent(newSlotId_ap5, msg.sender, idToAddress[_referrerId], 5, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 5);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 5);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap5++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_5[activeSlot_ap5].userAddress, 1, 5);
users[pool_slots_5[activeSlot_ap5].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_5[activeSlot_ap5].referrerId > 0) {
payUpline(idToAddress[pool_slots_5[activeSlot_ap5].referrerId], 1, 5);
users[idToAddress[pool_slots_5[activeSlot_ap5].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 5);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_5[activeSlot_ap5].eventsCount++;
}
}
else if(_fromPool == 6){
require(msg.value == 0.7 ether, "Participation fee in Autopool is 0.7 ETH");
require(!isUserExists(msg.sender, 6), "User already registered in AP6");
uint eventCount = pool_slots_6[activeSlot_ap6].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_6[activeSlot_ap6].userAddress,
pool_slots_6[activeSlot_ap6].id,
idToAddress[users[pool_slots_6[activeSlot_ap6].userAddress].referrerId],
6
));
pool_slots_6[activeSlot_ap6].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user6 = UsersPool({
id: newSlotId_ap6,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_6[msg.sender] = user6;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap6,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_6[newSlotId_ap6] = _newSlot;
newUserId_ap6++;
emit RegisterUserEvent(newSlotId_ap6, msg.sender, idToAddress[_referrerId], 6, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 6);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 6);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap6++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_6[activeSlot_ap6].userAddress, 1, 6);
users[pool_slots_6[activeSlot_ap6].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_6[activeSlot_ap6].referrerId > 0) {
payUpline(idToAddress[pool_slots_6[activeSlot_ap6].referrerId], 1, 6);
users[idToAddress[pool_slots_6[activeSlot_ap6].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 6);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_6[activeSlot_ap6].eventsCount++;
}
}else{
require(msg.value == 1 ether, "Participation fee in Autopool is 1 ETH");
require(<FILL_ME>)
uint eventCount = pool_slots_7[activeSlot_ap7].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_7[activeSlot_ap7].userAddress,
pool_slots_7[activeSlot_ap7].id,
idToAddress[users[pool_slots_7[activeSlot_ap7].userAddress].referrerId],
7
));
pool_slots_7[activeSlot_ap7].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user7 = UsersPool({
id: newSlotId_ap7,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_7[msg.sender] = user7;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap7,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_7[newSlotId_ap7] = _newSlot;
newUserId_ap7++;
emit RegisterUserEvent(newSlotId_ap7, msg.sender, idToAddress[_referrerId], 7, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 7);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 7);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap7++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_7[activeSlot_ap7].userAddress, 1, 7);
users[pool_slots_7[activeSlot_ap7].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_7[activeSlot_ap7].referrerId > 0) {
payUpline(idToAddress[pool_slots_7[activeSlot_ap7].referrerId], 1, 7);
users[idToAddress[pool_slots_7[activeSlot_ap7].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 7);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_7[activeSlot_ap7].eventsCount++;
}
}
}
function reinvestSlot(address _userAddress, uint _userId, address _sponsorAddress, uint8 _fromPool) private returns (bool _isReinvested) {
}
function payUpline(address _sponsorAddress, uint8 _refLevel, uint8 _fromPool) private returns (uint distributeAmount) {
}
function payFirstLine(address _sponsorAddress, uint payAmount, uint8 _fromPool) private returns (uint distributeAmount) {
}
function isUserQualified(address _userAddress) public view returns (bool) {
}
function isUserExists(address _userAddress, uint8 _autopool) public view returns (bool) {
}
function getUserReferrals(address _userAddress)
public
view
returns (address[] memory)
{
}
}
| !isUserExists(msg.sender,7),"User already registered in AP7" | 352,604 | !isUserExists(msg.sender,7) |
null | pragma solidity >=0.5.12 <0.7.0;
contract way2eth {
struct User {
uint id;
uint referrerCount;
uint referrerId;
uint earnedFromPool;
uint earnedFromRef;
uint earnedFromGlobal;
address[] referrals;
}
struct UsersPool {
uint id;
uint referrerId;
uint reinvestCount;
}
struct PoolSlots {
uint id;
address userAddress;
uint referrerId;
uint8 eventsCount;
}
modifier validReferrerId(uint _referrerId) {
}
event RegisterUserEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event ReinvestEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event DistributeUplineEvent(uint amount, address indexed _sponsorAddress, address indexed _fromAddress, uint _level, uint8 _fromPool, uint _time);
event ReferralPaymentEvent(uint amount, address indexed _from, address indexed _to, uint8 indexed _fromPool, uint _time);
mapping(address => User) public users;
mapping(address => UsersPool) public users_2;
mapping(uint => PoolSlots) public pool_slots_2;
mapping(address => UsersPool) public users_3;
mapping(uint => PoolSlots) public pool_slots_3;
mapping(address => UsersPool) public users_4;
mapping(uint => PoolSlots) public pool_slots_4;
mapping(address => UsersPool) public users_5;
mapping(uint => PoolSlots) public pool_slots_5;
mapping(address => UsersPool) public users_6;
mapping(uint => PoolSlots) public pool_slots_6;
mapping(address => UsersPool) public users_7;
mapping(uint => PoolSlots) public pool_slots_7;
mapping(address => UsersPool) public users_8;
mapping(uint => PoolSlots) public pool_slots_8;
mapping(uint => address) public idToAddress;
mapping (uint => uint) public uplineAmount;
uint public newUserId = 1;
uint public newUserId_ap2 = 1;
uint public newUserId_ap3 = 1;
uint public newUserId_ap4 = 1;
uint public newUserId_ap5 = 1;
uint public newUserId_ap6 = 1;
uint public newUserId_ap7 = 1;
uint public newUserId_ap8 = 1;
uint public newSlotId_ap2 = 1;
uint public activeSlot_ap2 = 1;
uint public newSlotId_ap3 = 1;
uint public activeSlot_ap3 = 1;
uint public newSlotId_ap4 = 1;
uint public activeSlot_ap4 = 1;
uint public newSlotId_ap5 = 1;
uint public activeSlot_ap5 = 1;
uint public newSlotId_ap6 = 1;
uint public activeSlot_ap6 = 1;
uint public newSlotId_ap7 = 1;
uint public activeSlot_ap7 = 1;
uint public newSlotId_ap8 = 1;
uint public activeSlot_ap8 = 1;
address public owner;
constructor(address _ownerAddress) public {
}
function participatePool1(uint _referrerId)
public
payable
validReferrerId(_referrerId)
{
}
function participatePool2(uint8 _fromPool)
public
payable
{
if(_fromPool == 2 || _fromPool == 3 || _fromPool == 4 || _fromPool == 5 || _fromPool == 6 || _fromPool == 7){
require(isUserExists(msg.sender, 1), "User not present in AP1");
require(isUserQualified(msg.sender), "User not qualified in AP1");
}
if(_fromPool == 2){
require(msg.value == 0.2 ether, "Participation fee in Autopool is 0.2 ETH");
require(!isUserExists(msg.sender, 2), "User already registered in AP2");
uint eventCount = pool_slots_2[activeSlot_ap2].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_2[activeSlot_ap2].userAddress,
pool_slots_2[activeSlot_ap2].id,
idToAddress[users[pool_slots_2[activeSlot_ap2].userAddress].referrerId],
2
));
pool_slots_2[activeSlot_ap2].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user2 = UsersPool({
id: newSlotId_ap2,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_2[msg.sender] = user2;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap2,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_2[newSlotId_ap2] = _newSlot;
newUserId_ap2++;
emit RegisterUserEvent(newSlotId_ap2, msg.sender, idToAddress[_referrerId], 2, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 2);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 2);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap2++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_2[activeSlot_ap2].userAddress, 1, 2);
users[pool_slots_2[activeSlot_ap2].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_2[activeSlot_ap2].referrerId > 0) {
payUpline(idToAddress[pool_slots_2[activeSlot_ap2].referrerId], 1, 2);
users[idToAddress[pool_slots_2[activeSlot_ap2].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 2);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_2[activeSlot_ap2].eventsCount++;
}
}else if(_fromPool == 3){
require(msg.value == 0.3 ether, "Participation fee in Autopool is 0.3 ETH");
require(!isUserExists(msg.sender, 3), "User already registered in AP3");
uint eventCount = pool_slots_3[activeSlot_ap3].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_3[activeSlot_ap3].userAddress,
pool_slots_3[activeSlot_ap3].id,
idToAddress[users[pool_slots_3[activeSlot_ap3].userAddress].referrerId],
3
));
pool_slots_3[activeSlot_ap3].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user3 = UsersPool({
id: newSlotId_ap3,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_3[msg.sender] = user3;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap3,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_3[newSlotId_ap3] = _newSlot;
newUserId_ap3++;
emit RegisterUserEvent(newSlotId_ap3, msg.sender, idToAddress[_referrerId], 3, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 3);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 3);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap3++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_3[activeSlot_ap3].userAddress, 1, 3);
users[pool_slots_3[activeSlot_ap3].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_3[activeSlot_ap3].referrerId > 0) {
payUpline(idToAddress[pool_slots_3[activeSlot_ap3].referrerId], 1, 3);
users[idToAddress[pool_slots_3[activeSlot_ap3].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 3);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_3[activeSlot_ap3].eventsCount++;
}
}
else if(_fromPool == 4){
require(msg.value == 0.4 ether, "Participation fee in Autopool is 0.4 ETH");
require(!isUserExists(msg.sender, 4), "User already registered in AP4");
uint eventCount = pool_slots_4[activeSlot_ap4].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_4[activeSlot_ap4].userAddress,
pool_slots_4[activeSlot_ap4].id,
idToAddress[users[pool_slots_4[activeSlot_ap4].userAddress].referrerId],
4
));
pool_slots_4[activeSlot_ap4].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user4 = UsersPool({
id: newSlotId_ap4,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_4[msg.sender] = user4;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap4,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_4[newSlotId_ap4] = _newSlot;
newUserId_ap4++;
emit RegisterUserEvent(newSlotId_ap4, msg.sender, idToAddress[_referrerId], 4, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 4);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 4);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap4++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_4[activeSlot_ap4].userAddress, 1, 4);
users[pool_slots_4[activeSlot_ap4].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_4[activeSlot_ap4].referrerId > 0) {
payUpline(idToAddress[pool_slots_4[activeSlot_ap4].referrerId], 1, 4);
users[idToAddress[pool_slots_4[activeSlot_ap4].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 4);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_4[activeSlot_ap4].eventsCount++;
}
}
else if(_fromPool == 5){
require(msg.value == 0.5 ether, "Participation fee in Autopool is 0.5 ETH");
require(!isUserExists(msg.sender, 5), "User already registered in AP5");
uint eventCount = pool_slots_5[activeSlot_ap5].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_5[activeSlot_ap5].userAddress,
pool_slots_5[activeSlot_ap5].id,
idToAddress[users[pool_slots_5[activeSlot_ap5].userAddress].referrerId],
5
));
pool_slots_5[activeSlot_ap5].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user5 = UsersPool({
id: newSlotId_ap5,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_5[msg.sender] = user5;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap5,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_5[newSlotId_ap5] = _newSlot;
newUserId_ap5++;
emit RegisterUserEvent(newSlotId_ap5, msg.sender, idToAddress[_referrerId], 5, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 5);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 5);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap5++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_5[activeSlot_ap5].userAddress, 1, 5);
users[pool_slots_5[activeSlot_ap5].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_5[activeSlot_ap5].referrerId > 0) {
payUpline(idToAddress[pool_slots_5[activeSlot_ap5].referrerId], 1, 5);
users[idToAddress[pool_slots_5[activeSlot_ap5].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 5);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_5[activeSlot_ap5].eventsCount++;
}
}
else if(_fromPool == 6){
require(msg.value == 0.7 ether, "Participation fee in Autopool is 0.7 ETH");
require(!isUserExists(msg.sender, 6), "User already registered in AP6");
uint eventCount = pool_slots_6[activeSlot_ap6].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(reinvestSlot(
pool_slots_6[activeSlot_ap6].userAddress,
pool_slots_6[activeSlot_ap6].id,
idToAddress[users[pool_slots_6[activeSlot_ap6].userAddress].referrerId],
6
));
pool_slots_6[activeSlot_ap6].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user6 = UsersPool({
id: newSlotId_ap6,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_6[msg.sender] = user6;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap6,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_6[newSlotId_ap6] = _newSlot;
newUserId_ap6++;
emit RegisterUserEvent(newSlotId_ap6, msg.sender, idToAddress[_referrerId], 6, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 6);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 6);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap6++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_6[activeSlot_ap6].userAddress, 1, 6);
users[pool_slots_6[activeSlot_ap6].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_6[activeSlot_ap6].referrerId > 0) {
payUpline(idToAddress[pool_slots_6[activeSlot_ap6].referrerId], 1, 6);
users[idToAddress[pool_slots_6[activeSlot_ap6].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 6);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_6[activeSlot_ap6].eventsCount++;
}
}else{
require(msg.value == 1 ether, "Participation fee in Autopool is 1 ETH");
require(!isUserExists(msg.sender, 7), "User already registered in AP7");
uint eventCount = pool_slots_7[activeSlot_ap7].eventsCount;
uint newEventCount = eventCount + 1;
if (newEventCount == 3) {
require(<FILL_ME>)
pool_slots_7[activeSlot_ap7].eventsCount++;
}
uint _referrerId = users[msg.sender].referrerId;
UsersPool memory user7 = UsersPool({
id: newSlotId_ap7,
referrerId: _referrerId,
reinvestCount: uint(0)
});
users_7[msg.sender] = user7;
PoolSlots memory _newSlot = PoolSlots({
id: newSlotId_ap7,
userAddress: msg.sender,
referrerId: _referrerId,
eventsCount: uint8(0)
});
pool_slots_7[newSlotId_ap7] = _newSlot;
newUserId_ap7++;
emit RegisterUserEvent(newSlotId_ap7, msg.sender, idToAddress[_referrerId], 7, msg.value, now);
if (_referrerId > 0) {
payUpline(idToAddress[_referrerId], 1, 7);
users[idToAddress[_referrerId]].earnedFromRef += msg.value/2;
}
else{
payUpline(idToAddress[1], 1, 7);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
newSlotId_ap7++;
if (eventCount < 2) {
if(eventCount == 0) {
payUpline(pool_slots_7[activeSlot_ap7].userAddress, 1, 7);
users[pool_slots_7[activeSlot_ap7].userAddress].earnedFromGlobal += msg.value/2;
}
if(eventCount == 1) {
if (pool_slots_7[activeSlot_ap7].referrerId > 0) {
payUpline(idToAddress[pool_slots_7[activeSlot_ap7].referrerId], 1, 7);
users[idToAddress[pool_slots_7[activeSlot_ap7].referrerId]].earnedFromRef += msg.value/2;
}
else {
payUpline(idToAddress[1], 1, 7);
users[idToAddress[1]].earnedFromRef += msg.value/2;
}
}
pool_slots_7[activeSlot_ap7].eventsCount++;
}
}
}
function reinvestSlot(address _userAddress, uint _userId, address _sponsorAddress, uint8 _fromPool) private returns (bool _isReinvested) {
}
function payUpline(address _sponsorAddress, uint8 _refLevel, uint8 _fromPool) private returns (uint distributeAmount) {
}
function payFirstLine(address _sponsorAddress, uint payAmount, uint8 _fromPool) private returns (uint distributeAmount) {
}
function isUserQualified(address _userAddress) public view returns (bool) {
}
function isUserExists(address _userAddress, uint8 _autopool) public view returns (bool) {
}
function getUserReferrals(address _userAddress)
public
view
returns (address[] memory)
{
}
}
| reinvestSlot(pool_slots_7[activeSlot_ap7].userAddress,pool_slots_7[activeSlot_ap7].id,idToAddress[users[pool_slots_7[activeSlot_ap7].userAddress].referrerId],7) | 352,604 | reinvestSlot(pool_slots_7[activeSlot_ap7].userAddress,pool_slots_7[activeSlot_ap7].id,idToAddress[users[pool_slots_7[activeSlot_ap7].userAddress].referrerId],7) |
null | pragma solidity >=0.5.12 <0.7.0;
contract way2eth {
struct User {
uint id;
uint referrerCount;
uint referrerId;
uint earnedFromPool;
uint earnedFromRef;
uint earnedFromGlobal;
address[] referrals;
}
struct UsersPool {
uint id;
uint referrerId;
uint reinvestCount;
}
struct PoolSlots {
uint id;
address userAddress;
uint referrerId;
uint8 eventsCount;
}
modifier validReferrerId(uint _referrerId) {
}
event RegisterUserEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event ReinvestEvent(uint _userid, address indexed _user, address indexed _referrerAddress, uint8 indexed _autopool, uint _amount, uint _time);
event DistributeUplineEvent(uint amount, address indexed _sponsorAddress, address indexed _fromAddress, uint _level, uint8 _fromPool, uint _time);
event ReferralPaymentEvent(uint amount, address indexed _from, address indexed _to, uint8 indexed _fromPool, uint _time);
mapping(address => User) public users;
mapping(address => UsersPool) public users_2;
mapping(uint => PoolSlots) public pool_slots_2;
mapping(address => UsersPool) public users_3;
mapping(uint => PoolSlots) public pool_slots_3;
mapping(address => UsersPool) public users_4;
mapping(uint => PoolSlots) public pool_slots_4;
mapping(address => UsersPool) public users_5;
mapping(uint => PoolSlots) public pool_slots_5;
mapping(address => UsersPool) public users_6;
mapping(uint => PoolSlots) public pool_slots_6;
mapping(address => UsersPool) public users_7;
mapping(uint => PoolSlots) public pool_slots_7;
mapping(address => UsersPool) public users_8;
mapping(uint => PoolSlots) public pool_slots_8;
mapping(uint => address) public idToAddress;
mapping (uint => uint) public uplineAmount;
uint public newUserId = 1;
uint public newUserId_ap2 = 1;
uint public newUserId_ap3 = 1;
uint public newUserId_ap4 = 1;
uint public newUserId_ap5 = 1;
uint public newUserId_ap6 = 1;
uint public newUserId_ap7 = 1;
uint public newUserId_ap8 = 1;
uint public newSlotId_ap2 = 1;
uint public activeSlot_ap2 = 1;
uint public newSlotId_ap3 = 1;
uint public activeSlot_ap3 = 1;
uint public newSlotId_ap4 = 1;
uint public activeSlot_ap4 = 1;
uint public newSlotId_ap5 = 1;
uint public activeSlot_ap5 = 1;
uint public newSlotId_ap6 = 1;
uint public activeSlot_ap6 = 1;
uint public newSlotId_ap7 = 1;
uint public activeSlot_ap7 = 1;
uint public newSlotId_ap8 = 1;
uint public activeSlot_ap8 = 1;
address public owner;
constructor(address _ownerAddress) public {
}
function participatePool1(uint _referrerId)
public
payable
validReferrerId(_referrerId)
{
}
function participatePool2(uint8 _fromPool)
public
payable
{
}
function reinvestSlot(address _userAddress, uint _userId, address _sponsorAddress, uint8 _fromPool) private returns (bool _isReinvested) {
}
function payUpline(address _sponsorAddress, uint8 _refLevel, uint8 _fromPool) private returns (uint distributeAmount) {
}
function payFirstLine(address _sponsorAddress, uint payAmount, uint8 _fromPool) private returns (uint distributeAmount) {
}
function isUserQualified(address _userAddress) public view returns (bool) {
}
function isUserExists(address _userAddress, uint8 _autopool) public view returns (bool) {
require(<FILL_ME>)
if (_autopool == 1) return (users[_userAddress].id != 0);
if (_autopool == 2) return (users_2[_userAddress].id != 0);
if (_autopool == 3) return (users_3[_userAddress].id != 0);
if (_autopool == 4) return (users_4[_userAddress].id != 0);
if (_autopool == 5) return (users_5[_userAddress].id != 0);
if (_autopool == 6) return (users_6[_userAddress].id != 0);
if (_autopool == 7) return (users_7[_userAddress].id != 0);
}
function getUserReferrals(address _userAddress)
public
view
returns (address[] memory)
{
}
}
| (_autopool>0)&&(_autopool<=7) | 352,604 | (_autopool>0)&&(_autopool<=7) |
null | pragma solidity ^0.4.23;
library SafeMath {
function mul(uint a, uint b) internal returns (uint) {
}
function sub(uint a, uint b) internal returns (uint) {
}
function add(uint a, uint b) internal returns (uint) {
}
}
contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) returns (bool success) {}
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
/// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) returns (bool success) {}
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is Token {
function transfer(address _to, uint256 _value) returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
}
function balanceOf(address _owner) constant returns (uint256 balance) {
}
function approve(address _spender, uint256 _value) returns (bool success) {
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}
contract EphronTestCoin is StandardToken { // CHANGE THIS. Update the contract name.
/* Public variables of the token */
event FundTransfer(address backer, uint amount, bool isContribution);
/*
NOTE:
The following variables are OPTIONAL vanities. One does not have to include them.
They allow one to customise the token contract & in no way influences the core functionality.
Some wallets/interfaces might not even bother to look at this information.
*/
using SafeMath for uint;
string public name; // Token Name
uint8 public decimals; // How many decimals to show. To be standard complicant keep it 18
string public symbol; // An identifier: eg SBX, XPR etc..
string public version = 'H1.0';
uint256 public unitsOneEthCanBuy; // How many units of your coin can be bought by 1 ETH?
uint256 public totalEthInWei; // WEI is the smallest unit of ETH (the equivalent of cent in USD or satoshi in BTC). We'll store the total ETH raised via our ICO here.
address public fundsWallet; // Where should the raised ETH go?
uint public start;
uint public end;
// This is a constructor function
// which means the following function name has to match the contract name declared above
function EphronTestCoin(
uint startTime,
uint endTime,
uint256 initialSupply,
string tokenName,
string tokenSymbol,
uint256 etherCostOfEachToken
) {
}
// ---- FOR TEST ONLY ----
uint _current = 0;
function current() public returns (uint) {
}
function setCurrent(uint __current) {
}
function() payable{
totalEthInWei = totalEthInWei + msg.value;
uint256 amount = msg.value * unitsOneEthCanBuy;
require(balances[fundsWallet] >= amount);
require(<FILL_ME>)
balances[fundsWallet] = balances[fundsWallet] - amount;
balances[msg.sender] = balances[msg.sender] + amount;
Transfer(fundsWallet, msg.sender, amount); // Broadcast a message to the blockchain
//Transfer ether to fundsWallet
fundsWallet.transfer(msg.value);
}
/* Approves and then calls the receiving contract */
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
}
modifier afterDeadline() { }
function safeWithdrawal() afterDeadline {
}
}
| current()>=start&¤t()<=end | 352,621 | current()>=start&¤t()<=end |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.