Skip to content

Instantly share code, notes, and snippets.

@shahzaintariq

shahzaintariq/1_Storage.sol

Created July 20, 2020 15:33
Show Gist options
  • Save shahzaintariq/77c6fc962a2c29298c5c3e9edadc2e42 to your computer and use it in GitHub Desktop.
Save shahzaintariq/77c6fc962a2c29298c5c3e9edadc2e42 to your computer and use it in GitHub Desktop.
Download ZIP
Created using remix-ide: Realtime Ethereum Contract Compiler and Runtime. Load this file by pasting this gists URL or ID at https://remix.ethereum.org/#version=soljson-v0.6.6+commit.6c089d02.js&optimize=false&gist=
Raw
1_Storage.sol
pragma solidity >=0.4.22 <0.7.0;
/**
* @title Storage
* @dev Store & retreive value in a variable
*/
contract Storage {
uint256 number;
/**
* @dev Store value in variable
* @param num value to store
*/
function store(uint256 num) public {
number = num;
}
/**
* @dev Return value
* @return value of 'number'
*/
function retreive() public view returns (uint256){
return number;
}
}
Raw
2_Owner.sol
pragma solidity >=0.4.22 <0.7.0;
/**
* @title Owner
* @dev Set & change owner
*/
contract Owner {
address private owner;
// event for EVM logging
event OwnerSet(address indexed oldOwner, address indexed newOwner);
// modifier to check if caller is owner
modifier isOwner() {
// If the first argument of 'require' evaluates to 'false', execution terminates and all
// changes to the state and to Ether balances are reverted.
// This used to consume all gas in old EVM versions, but not anymore.
// It is often a good idea to use 'require' to check if functions are called correctly.
// As a second argument, you can also provide an explanation about what went wrong.
require(msg.sender == owner, "Caller is not owner");
_;
}
/**
* @dev Set contract deployer as owner
*/
constructor() public {
owner = msg.sender; // 'msg.sender' is sender of current call, contract deployer for a constructor
emit OwnerSet(address(0), owner);
}
/**
* @dev Change owner
* @param newOwner address of new owner
*/
function changeOwner(address newOwner) public isOwner {
emit OwnerSet(owner, newOwner);
owner = newOwner;
}
/**
* @dev Return owner address
* @return address of owner
*/
function getOwner() external view returns (address) {
return owner;
}
}
Raw
3_Ballot.sol
pragma solidity >=0.4.22 <0.7.0;
/**
* @title Ballot
* @dev Implements voting process along with vote delegation
*/
contract Ballot {
struct Voter {
uint weight; // weight is accumulated by delegation
bool voted; // if true, that person already voted
address delegate; // person delegated to
uint vote; // index of the voted proposal
}
struct Proposal {
// If you can limit the length to a certain number of bytes,
// always use one of bytes1 to bytes32 because they are much cheaper
bytes32 name; // short name (up to 32 bytes)
uint voteCount; // number of accumulated votes
}
address public chairperson;
mapping(address => Voter) public voters;
Proposal[] public proposals;
/**
* @dev Create a new ballot to choose one of 'proposalNames'.
* @param proposalNames names of proposals
*/
constructor(bytes32[] memory proposalNames) public {
chairperson = msg.sender;
voters[chairperson].weight = 1;
for (uint i = 0; i < proposalNames.length; i++) {
// 'Proposal({...})' creates a temporary
// Proposal object and 'proposals.push(...)'
// appends it to the end of 'proposals'.
proposals.push(Proposal({
name: proposalNames[i],
voteCount: 0
}));
}
}
/**
* @dev Give 'voter' the right to vote on this ballot. May only be called by 'chairperson'.
* @param voter address of voter
*/
function giveRightToVote(address voter) public {
require(
msg.sender == chairperson,
"Only chairperson can give right to vote."
);
require(
!voters[voter].voted,
"The voter already voted."
);
require(voters[voter].weight == 0);
voters[voter].weight = 1;
}
/**
* @dev Delegate your vote to the voter 'to'.
* @param to address to which vote is delegated
*/
function delegate(address to) public {
Voter storage sender = voters[msg.sender];
require(!sender.voted, "You already voted.");
require(to != msg.sender, "Self-delegation is disallowed.");
while (voters[to].delegate != address(0)) {
to = voters[to].delegate;
// We found a loop in the delegation, not allowed.
require(to != msg.sender, "Found loop in delegation.");
}
sender.voted = true;
sender.delegate = to;
Voter storage delegate_ = voters[to];
if (delegate_.voted) {
// If the delegate already voted,
// directly add to the number of votes
proposals[delegate_.vote].voteCount += sender.weight;
} else {
// If the delegate did not vote yet,
// add to her weight.
delegate_.weight += sender.weight;
}
}
/**
* @dev Give your vote (including votes delegated to you) to proposal 'proposals[proposal].name'.
* @param proposal index of proposal in the proposals array
*/
function vote(uint proposal) public {
Voter storage sender = voters[msg.sender];
require(sender.weight != 0, "Has no right to vote");
require(!sender.voted, "Already voted.");
sender.voted = true;
sender.vote = proposal;
// If 'proposal' is out of the range of the array,
// this will throw automatically and revert all
// changes.
proposals[proposal].voteCount += sender.weight;
}
/**
* @dev Computes the winning proposal taking all previous votes into account.
* @return winningProposal_ index of winning proposal in the proposals array
*/
function winningProposal() public view
returns (uint winningProposal_)
{
uint winningVoteCount = 0;
for (uint p = 0; p < proposals.length; p++) {
if (proposals[p].voteCount > winningVoteCount) {
winningVoteCount = proposals[p].voteCount;
winningProposal_ = p;
}
}
}
/**
* @dev Calls winningProposal() function to get the index of the winner contained in the proposals array and then
* @return winnerName_ the name of the winner
*/
function winnerName() public view
returns (bytes32 winnerName_)
{
winnerName_ = proposals[winningProposal()].name;
}
}
Raw
4_Ballot_test.sol
pragma solidity >=0.4.22 <0.7.0;
import "remix_tests.sol"; // this import is automatically injected by Remix.
import "./3_Ballot.sol";
contract BallotTest {
bytes32[] proposalNames;
Ballot ballotToTest;
function beforeAll () public {
proposalNames.push(bytes32("candidate1"));
ballotToTest = new Ballot(proposalNames);
}
function checkWinningProposal () public {
ballotToTest.vote(0);
Assert.equal(ballotToTest.winningProposal(), uint(0), "proposal at index 0 should be the winning proposal");
Assert.equal(ballotToTest.winnerName(), bytes32("candidate1"), "candidate1 should be the winner name");
}
function checkWinninProposalWithReturnValue () public view returns (bool) {
return ballotToTest.winningProposal() == 0;
}
}
Raw
Address.sol
pragma solidity ^0.6.2;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
/**
* @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 {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
Raw
cappedErc20Token.sol
pragma solidity ^0.6.1;
// import {ERC20TokenInterface} from './IERC20.sol';
// SPDX-License-Identifier: MIT
interface ERC20TokenInterface {
function totalSupply() external view returns (uint);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint);
function balanceOf(address tokenOwner) external view returns (uint256);
function allowance(address tokenOwner, address spender) external view returns (uint remaining);
function transfer(address to, uint tokens) external returns (bool success);
function approve(address spender, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) external returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @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) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @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) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @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) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
/**
* @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) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @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) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @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) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @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) {
require(b != 0, errorMessage);
return a % b;
}
}
contract ERC20 is ERC20TokenInterface{
using SafeMath for uint256;
string internal tName;
string internal tSymbol;
uint256 internal tTotalSupply;
uint256 internal tdecimals;
address internal owner;
uint256 internal capAmount;
uint256 internal lockTransaction;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allownce;
constructor(string memory _tokenName,string memory _symbol,uint256 _totalSupply,uint256 _decimals,uint256 _cappedAmount)public{
tName = _tokenName;
tSymbol = _symbol;
balances[msg.sender] += _totalSupply;
tTotalSupply = _totalSupply* 10**uint256(_decimals);
tdecimals = _decimals;
capAmount = _cappedAmount;
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "only owner can call this method");
_;
}
function name() override public view returns(string memory) { return tName;}
function symbol() override public view returns(string memory) { return tSymbol;}
function totalSupply()override public view returns(uint256) { return tTotalSupply;}
function decimals() override public view returns(uint256) { return tdecimals;}
function balanceOf(address tokenOwner) override public view returns(uint256){ return balances[tokenOwner]; }
function transfer(address to, uint token) override public returns(bool success){
require(balances[msg.sender] >= token, "you should have some token");
require(msg.sender != address(0), "Transfer from the zero address");
require(to != address(0), "Transfer to the zero address");
// require(lockTransaction < now, "transaction is currently locked");
balances[msg.sender] = balances[msg.sender].sub(token);
balances[to] = balances[to].add(token);
emit Transfer(msg.sender,to,token);
return true;
}
function approve(address spender, uint tokens) override public returns(bool success) {
require((tokens == 0) || (allownce[msg.sender][spender] == 0));
allownce[msg.sender][spender] = allownce[msg.sender][spender].add(tokens);
emit Approval(msg.sender, spender,tokens);
return true;
}
function allowance(address _owner, address spender) override public view returns(uint){
return allownce[_owner][spender];
}
function transferFrom(address from, address to, uint tokens) override public returns(bool success) {
require(balances[from] >= tokens);
require(allownce[from][msg.sender] >= tokens);
// require(lockTransaction < now, "transaction is currently locked");
require(to != address(0), "Transfer to the zero address");
balances[from] = balances[from].sub(tokens);
balances[to] = balances[to].add(tokens);
allownce[from][msg.sender] = allownce[from][msg.sender].sub(tokens);
emit Transfer(from,to,tokens);
return true;
}
function mint_token(address _address,uint256 _amount) public onlyOwner{
require(_address != address(0), "invailed address");
require(_amount > 0,"invailed Amount");
require(tTotalSupply.add(_amount) > capAmount, "amount exceed the limit");
balances[_address] = balances[_address].add(_amount);
tTotalSupply = tTotalSupply.add(_amount);
}
// function lock_trans(uint256 time) onlyOwner public{
// require(time > 0 && time > now ,"invailed Time");
// lockTransaction = time;
// }
}
Raw
contract_uk.sol
pragma solidity ^0.6.1;
// import './rolebase.sol';
// import './owner.sol';
contract Ownable {
address public owner;
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{
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @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) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Whitelist is Ownable {
mapping(address => bool) whitelist;
event AddedToWhitelist(address indexed account);
event RemovedFromWhitelist(address indexed account);
modifier onlyWhitelisted() {
require(isWhitelisted(msg.sender));
_;
}
function add(address _address) public onlyOwner {
whitelist[_address] = true;
emit AddedToWhitelist(_address);
}
function remove(address _address) public onlyOwner {
whitelist[_address] = false;
emit RemovedFromWhitelist(_address);
}
function isWhitelisted(address _address) public view returns(bool) {
return whitelist[_address];
}
}
contract RoleBasedAcl {
address creator;
mapping(address => mapping(string => mapping(string => bool))) roles;
mapping(address => mapping(string => bool)) roles2;
constructor() public{
creator = msg.sender;
}
modifier onlyFromOwner(){
require(creator == msg.sender);
_;
}
function adminRole (address entity, string memory role) public onlyFromOwner {
roles2[entity][role] = true;
}
function assignRole (address entity, string memory topic, string memory role) public hasRole('superadmin') {
roles[entity][topic][role] = true;
}
function unassignRole (address entity, string memory topic, string memory role) public hasRole('superadmin') {
roles[entity][topic][role] = false;
}
function isAssignedRole (address entity, string memory topic, string memory role)public view returns (bool) {
return roles[entity][topic][role];
}
modifier hasRole(string memory role) {
require(roles2[msg.sender][role],"only admin can run this");
_;
}
}
contract Tufa is RoleBasedAcl,Whitelist {
uint _token;
uint abc;
mapping(address => uint) authentications;
mapping(address => bool) tokenApprover;
event tokenEnrty(address indexed account, uint);
function accessToken() public returns (uint){
require(whitelist[msg.sender],"ERROR: you are not in whitelist");
abc = uint( uint(keccak256(abi.encodePacked(block.timestamp, block.difficulty))));
authentications[msg.sender] = abc;
tokenApprover[msg.sender] = true;
emit tokenEnrty(msg.sender, abc);
return abc;
}
function getClientToken(address prover) public returns (uint) {
require(tokenApprover[prover],"ERROR: you must asign token again");
uint token = authentications[prover];
tokenApprover[prover] = false;
emit tokenEnrty(prover, abc);
return token;
}
}
Raw
contractfomo.sol
pragma solidity ^0.6.0;
interface ERC20 {
function totalSupply() external view returns (uint256 supply);
function balanceOf(address _owner) external view returns (uint256 balance);
function transfer(address _to, uint256 _value)
external
returns (bool success);
function transferFrom(
address _from,
address _to,
uint256 _value
) external returns (bool success);
function approve(address _spender, uint256 _value)
external
returns (bool success);
function allowance(address _owner, address _spender)
external
view
returns (uint256 remaining);
function decimals() external view returns (uint256 digits);
event Approval(
address indexed _owner,
address indexed _spender,
uint256 _value
);
}
contract HexboxFomoEvents {
// fired at end of buy or reload
event onEndTx
(
uint256 compressedData,
uint256 compressedIDs,
bytes32 playerName,
address playerAddress,
uint256 hexTokenIn,
uint256 hexboxBought,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 cubeAmount,
uint256 genAmount,
uint256 potAmount
);
// fired whenever theres a withdraw
event onWithdraw
(
uint256 indexed playerID,
address playerAddress,
bytes32 playerName,
uint256 hexTokenOut,
uint256 timeStamp
);
// fired whenever a withdraw forces end round to be ran
event onWithdrawAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 hexTokenOut,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot
);
// fired whenever a player tries a buy after round timer
// hit zero, and causes end round to be ran.
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 hexTokenIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot
);
// fired whenever a player tries a reload after round timer
// hit zero, and causes end round to be ran.
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot
);
// fired whenever an affiliate is paid
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed roundID,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
}
// Contract Setup
contract modularLong is HexboxFomoEvents {}
contract HexboxFomo is modularLong {
using SafeMath for *;
using HexboxCalcLong for uint256;
address payable private comAddress_;
CubeInterface private cube;
UsernameInterface private username;
uint256 private startDate_;
// Configurables
string constant public name = "HexboxFomo";
string constant public symbol = "HXK";
uint256 constant private rndExtra_ = 24 hours; // Countdown before open
uint256 constant private rndInit_ = 1 hours; // round timer starts at this
uint256 constant private rndInc_ = 30 minutes; // every new leader adds 30 minutes to the timer
uint256 constant private rndMax_ = 72 hours; // max length a round timer can be
address internal constant tokenAddress = address(
0x000000000000000000000000000000
);
// Data Setup
uint256 public rID_; // round id number / total rounds that have happened
uint256 public pID_; // total number of players
// Player Data
mapping (address => uint256) public pIDxAddr_; // (addr => pID) returns player id by address
mapping (uint256 => HexboxFomoDatasets.Player) public plyr_; // (pID => data) player data
// (pID => rID => data) player round data by player id & round id
mapping (uint256 => mapping (uint256 => HexboxFomoDatasets.PlayerRounds)) public plyrRnds_;
// Round Data
mapping (uint256 => HexboxFomoDatasets.Round) public round_; // (rID => data) round data
uint256 public rndEth_;
// Constructor
constructor(address usernameAddress, address cubeAddress, address payable comAddress, uint256 startDate)
public
{
username = UsernameInterface(usernameAddress);
cube = CubeInterface(cubeAddress);
comAddress_ = comAddress;
startDate_ = startDate;
// PURCHASES
// 50% for HEXBOX holders, 20% for jackpot, 15% for CUBE holders, 10% for referral or CUBE holders, 5% dev fee
// Open the gates
// Set the round ID to 1
rID_ = 1;
// Set round 1 start to the cube start time + rndExtra_ (currently 24h)
// round_[1].strt = cube.startTime() + rndExtra_;
// Set round 1 end time to rndInit_ + rndExtra_ (currently 25 hr, 24h Extra, 1h init)
// round_[1].end = cube.startTime() + rndInit_ + rndExtra_;
// My attempt at changing the start date:
round_[1].strt = startDate_;
round_[1].end = startDate_ + rndInit_;
}
// Modifiers
/**
* @dev prevents contracts from interacting with fomo3d
*/
modifier isHuman() {
// If it's called from a contract, tx.origin would be the wallet that called the contract function. msg.sender would be the contract itself.
require(tx.origin == msg.sender);
_;
}
/**
* @dev sets boundaries for incoming tx
*/
modifier isWithinLimits(uint256 _hexToken) {
// Nothing to small or to big
require(_hexToken >= 10000000, "pocket lint: not a valid currency");
require(_hexToken <= 10000000000000000, "no buys > 100M, no");
_;
}
// Public Functions
/**
* @dev emergency buy uses last stored affiliate ID
*/
/**receive()
external
isHuman()
isWithinLimits(msg.value)
payable
{
// set up our tx event data and determine if player is new or not
HexboxFomoDatasets.EventReturns memory _eventData_ ;
_eventData_ = determinePID(_eventData_);
// fetch player id
uint256 _pID = pIDxAddr_[msg.sender];
// buy core
buyCore(_pID, plyr_[_pID].laff, _eventData_);
}**/
/**
* @dev converts all incoming hexToken to hexbox.
* @param _affCode the ID/address/name of the player who gets the affiliate fee
*/
function buyXaddr(address _affCode, uint256 _hexTokenAmount)
public
isHuman()
isWithinLimits(_hexTokenAmount)
{
ERC20 Hex = ERC20(tokenAddress);
require(Hex.transferFrom(msg.sender, address(this), _hexTokenAmount), "Not enough allowance");
// set up our tx event data and determine if player is new or not
HexboxFomoDatasets.EventReturns memory _eventData_;
_eventData_ = determinePID(_eventData_);
// fetch player id
uint256 _pID = pIDxAddr_[msg.sender];
// manage affiliate residuals
uint256 _affID;
// if no affiliate code was given or player tried to use their own, lolz
if (_affCode == address(0) || _affCode == msg.sender)
{
// use last stored affiliate code
_affID = plyr_[_pID].laff;
// if affiliate code was given
} else {
// get affiliate ID from aff Code
_affID = pIDxAddr_[_affCode];
if (_affID == 0) {
_affID = registerReferrer(_affCode);
}
// if affID is not the same as previously stored
if (_affID != plyr_[_pID].laff)
{
// update last affiliate
plyr_[_pID].laff = _affID;
}
}
// buy core
buyCore(_pID, _affID, _eventData_, _hexTokenAmount);
}
/**
* @dev essentially the same as buy, but instead of you sending hexToken
* from your wallet, it uses your unwithdrawn earnings.
* @param _affCode the ID/address/name of the player who gets the affiliate fee
* @param _hexToken amount of earnings to use (remainder returned to gen vault)
*/
function reLoadXaddr(address payable _affCode, uint256 _hexToken)
public
isHuman()
isWithinLimits(_hexToken)
{
// set up our tx event data
HexboxFomoDatasets.EventReturns memory _eventData_;
// fetch player ID
uint256 _pID = pIDxAddr_[msg.sender];
// manage affiliate residuals
uint256 _affID;
// if no affiliate code was given or player tried to use their own, lolz
if (_affCode == address(0) || _affCode == msg.sender)
{
// use last stored affiliate code
_affID = plyr_[_pID].laff;
// if affiliate code was given
} else {
// get affiliate ID from aff Code
_affID = pIDxAddr_[_affCode];
// set up new referrer if necessary
if (_affID == 0) {
_affID = registerReferrer(_affCode);
}
// if affID is not the same as previously stored
if (_affID != plyr_[_pID].laff)
{
// update last affiliate
plyr_[_pID].laff = _affID;
}
}
// reload core
reLoadCore(_pID, _affID, _hexToken, _eventData_);
}
/**
* @dev withdraws all of your earnings.
*/
function withdraw()
public
isHuman()
{
ERC20 Hex = ERC20(tokenAddress);
// setup local rID
uint256 _rID = rID_;
// grab time
uint256 _now = now;
// fetch player ID
uint256 _pID = pIDxAddr_[msg.sender];
// setup temp var for player hexToken
uint256 _hexToken;
// check to see if round has ended and no one has run round end yet
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
// set up our tx event data
HexboxFomoDatasets.EventReturns memory _eventData_;
// end the round (distributes pot)
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
// get their earnings
_hexToken = withdrawEarnings(_pID);
// gib moni
if (_hexToken > 0)
Hex.transfer(plyr_[_pID].addr,_hexToken);
// build event data
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
// fire withdraw and distribute event
emit HexboxFomoEvents.onWithdrawAndDistribute
(
msg.sender,
username.getNameByAddress(plyr_[_pID].addr),
_hexToken,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot
);
// in any other situation
} else {
// get their earnings
_hexToken = withdrawEarnings(_pID);
// gib moni
if (_hexToken > 0)
Hex.transfer(plyr_[_pID].addr,_hexToken);
// fire withdraw event
emit HexboxFomoEvents.onWithdraw(_pID, msg.sender, username.getNameByAddress(plyr_[_pID].addr), _hexToken, _now);
}
}
// Getters
/**
* @dev return minimum purchase in HEXBOX for 1 timer increment
* @return minimum purchase in HEXBOX for 1 timer increment (in wei format)
*/
function getIncrementPrice()
public
view
returns(uint256)
{
// setup local rID
uint256 _rID = rID_;
// grab pot
uint256 _pot = round_[_rID].pot;
return (_pot / 100000000).mul(10000000000);
}
/**
* @dev return the price buyer will pay for next 1 individual hexbox.
* @return price for next hexbox bought (in wei format)
*/
function getBuyPrice()
public
view
returns(uint256)
{
// setup local rID
uint256 _rID = rID_;
// grab time
uint256 _now = now;
// are we in a round?
if (_now > round_[_rID].strt && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].hexbox.add(100000000)).hexTokenRec(100000000) );
else // rounds over. need price for new round
return ( 750000000 ); // init
}
/**
* @dev returns time left. dont spam this, you'll ddos yourself from your node
* provider
* @return time left in seconds
*/
function getTimeLeft()
public
view
returns(uint256)
{
// setup local rID
// Get the round ID
uint256 _rID = rID_;
// grab time
// Get the current time
uint256 _now = now;
// If the round hasn't ended yet
if (_now < round_[_rID].end)
// If the round has staretd
if (_now > round_[_rID].strt)
// Return the round end time - now
return( (round_[_rID].end).sub(_now) );
else
// Return the time to start?
return( (round_[_rID].strt).sub(_now) );
else
return(0);
}
/**
* @dev returns player earnings per vaults
* @return winnings vault
* @return general vault
* @return affiliate vault
*/
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256, uint256, uint256)
{
// setup local rID
// Set the round id
uint256 _rID = rID_;
// if round has ended. but round end has not been run (so contract has not distributed winnings)
if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
// if player is winner
if (round_[_rID].plyr == _pID)
{
return
(
(plyr_[_pID].win).add(round_[_rID].pot),
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
// if player is not the winner
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
}
// if round is still going on, or round has ended and round end has been ran
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff
);
}
}
/**
* solidity hates stack limits. this lets us avoid that hate
*/
function getPlayerVaultsHelper(uint256 _pID, uint256 _rID)
private
view
returns(uint256)
{
return round_[_rID].mask.mul(plyrRnds_[_pID][_rID].hexbox) / 100000000;
}
/**
* @dev returns all current round info needed for front end
* @return round id
* @return total hexbox for round
* @return time round ends
* @return time round started
* @return current pot
* @return current player in leads address
* @return current player in leads name
* @return hexToken spent in current round
*/
function getCurrentRoundInfo()
public
view
returns(uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256)
{
// setup local rID
uint256 _rID = rID_;
return
(
_rID, //0
round_[_rID].hexbox, //1
round_[_rID].end, //2
round_[_rID].strt, //3
round_[_rID].pot, //4
plyr_[round_[_rID].plyr].addr, //5
username.getNameByAddress(plyr_[round_[_rID].plyr].addr), //6
rndEth_ //7
);
}
/**
* @dev returns player info based on address. if no address is given, it will
* use msg.sender
* @param _addr address of the player you want to lookup
* @return player ID
* @return player name
* @return hexbox owned (current round)
* @return winnings vault
* @return general vault
* @return affiliate vault
* @return player round hexToken
*/
function getPlayerInfoByAddress(address _addr)
public
view
returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256)
{
// setup local rID
uint256 _rID = rID_;
if (_addr == address(0))
{
_addr == msg.sender;
}
uint256 _pID = pIDxAddr_[_addr];
return
(
_pID, //0
username.getNameByAddress(_addr), //1
plyrRnds_[_pID][_rID].hexbox, //2
plyr_[_pID].win, //3
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)), //4
plyr_[_pID].aff, //5
plyrRnds_[_pID][_rID].hexToken //6
);
}
// Core Logic
/**
* @dev logic runs whenever a buy order is executed. determines how to handle
* incoming hexToken depending on if we are in an active round or not
* Player ID, Ref ID, Event Data, Hex Amount
*/
function buyCore(uint256 _pID, uint256 _affID, HexboxFomoDatasets.EventReturns memory _eventData_, uint256 _hexTokenAmount)
private
{
// setup local rID
uint256 _rID = rID_;
// grab time
uint256 _now = now;
// if round is active
if (_now > round_[_rID].strt && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
// call core
core(_rID, _pID, _hexTokenAmount, _affID, _eventData_);
// if round is not active
} else {
// check to see if end round needs to be ran
if (_now > round_[_rID].end && round_[_rID].ended == false)
{
// end the round (distributes pot) & start new round
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
// build event data
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
// fire buy and distribute event
emit HexboxFomoEvents.onBuyAndDistribute
(
msg.sender,
username.getNameByAddress(plyr_[_pID].addr),
_hexTokenAmount,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot
);
}
// put hexToken in players vault
plyr_[_pID].gen = plyr_[_pID].gen.add(_hexTokenAmount);
}
}
/**
* @dev logic runs whenever a reload order is executed. determines how to handle
* incoming hexToken depending on if we are in an active round or not
*/
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _hexToken, HexboxFomoDatasets.EventReturns memory _eventData_)
private
{
// setup local rID
uint256 _rID = rID_;
// grab time
uint256 _now = now;
// if round is active
if (_now > round_[_rID].strt && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
// get earnings from all vaults and return unused to gen vault
// because we use a custom safemath library. this will throw if player
// tried to spend more hexToken than they have.
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_hexToken);
// call core
core(_rID, _pID, _hexToken, _affID, _eventData_);
// if round is not active and end round needs to be ran
} else if (_now > round_[_rID].end && round_[_rID].ended == false) {
// end the round (distributes pot) & start new round
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
// build event data
_eventData_.compressedData = _eventData_.compressedData + (_now * 100000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
// fire buy and distribute event
emit HexboxFomoEvents.onReLoadAndDistribute
(
msg.sender,
username.getNameByAddress(plyr_[_pID].addr),
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot
);
}
}
/**
* @dev this is the core logic for any buy/reload that happens while a round
* is live.
*/
function core(uint256 _rID, uint256 _pID, uint256 _hexToken, uint256 _affID, HexboxFomoDatasets.EventReturns memory _eventData_)
private
{
// if player is new to round
if (plyrRnds_[_pID][_rID].hexbox == 0)
_eventData_ = managePlayer(_pID, _eventData_);
// early round hexToken limiter
if (round_[_rID].hexToken < 150000000000000 && plyrRnds_[_pID][_rID].hexToken.add(_hexToken) > 100000000)
{
uint256 _availableLimit = (100000000).sub(plyrRnds_[_pID][_rID].hexToken);
uint256 _refund = _hexToken.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_hexToken = _availableLimit;
}
// if hexToken left is greater than min hexToken allowed (sorry no pocket lint)
if (_hexToken > 10000000)
{
// mint the new hexbox
uint256 _hexbox = (round_[_rID].hexToken).hexboxRec(_hexToken);
if (_hexbox >= getIncrementPrice())
{
updateTimer(_rID);
// set new leaders
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
// set the new leader bool to true
_eventData_.compressedData = _eventData_.compressedData + 100;
}
// update player
plyrRnds_[_pID][_rID].hexbox = _hexbox.add(plyrRnds_[_pID][_rID].hexbox);
plyrRnds_[_pID][_rID].hexToken = _hexToken.add(plyrRnds_[_pID][_rID].hexToken);
// update round
round_[_rID].hexbox = _hexbox.add(round_[_rID].hexbox);
round_[_rID].hexToken = _hexToken.add(round_[_rID].hexToken);
rndEth_ = _hexToken.add(rndEth_);
// distribute hexToken
_eventData_ = distributeExternal(_rID, _pID, _hexToken, _affID, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _hexToken, _hexbox, _eventData_);
// call end tx function to fire end tx event.
endTx(_pID, _hexToken, _hexbox, _eventData_);
}
}
// Calculators
/**
* @dev calculates unmasked earnings (just calculates, does not update mask)
* @return earnings in wei format
*/
function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast)
private
view
returns(uint256)
{
return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].hexbox)) / (100000000)).sub(plyrRnds_[_pID][_rIDlast].mask) );
}
/**
* @dev returns the amount of hexbox you would get given an amount of hexToken.
* @param _rID round ID you want price for
* @param _hexToken amount of hexToken sent in
* @return hexbox received
*/
function calcHexboxReceived(uint256 _rID, uint256 _hexToken)
public
view
returns(uint256)
{
// grab time
uint256 _now = now;
// are we in a round?
if (_now > round_[_rID].strt && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].hexToken).hexboxRec(_hexToken) );
else // rounds over. need hexbox for new round
return ( (_hexToken).hexbox() );
}
/**
* @dev returns current hexToken price for X hexbox.
* @param _hexbox number of hexbox desired (in 18 decimal format)
* @return amount of hexToken needed to send
*/
function iWantXHexbox(uint256 _hexbox)
public
view
returns(uint256)
{
// setup local rID
uint256 _rID = rID_;
// grab time
uint256 _now = now;
// are we in a round?
if (_now > round_[_rID].strt && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].hexbox.add(_hexbox)).hexTokenRec(_hexbox) );
else // rounds over. need price for new round
return ( (_hexbox).hexToken() );
}
// Tools
/**
* @dev gets existing or registers new pID. use this when a player may be new
* @return pID
*/
function determinePID(HexboxFomoDatasets.EventReturns memory _eventData_)
private
returns (HexboxFomoDatasets.EventReturns memory)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
pID_++;
pIDxAddr_[msg.sender] = pID_;
plyr_[pID_].addr = msg.sender;
// set the new player bool to true
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
function registerReferrer(address _affCode)
private
returns (uint256 affID)
{
pID_++;
pIDxAddr_[_affCode] = pID_;
plyr_[pID_].addr = _affCode;
return pID_;
}
/**
* @dev decides if round end needs to be run & new round started. and if
* player unmasked earnings from previously played rounds need to be moved.
*/
function managePlayer(uint256 _pID, HexboxFomoDatasets.EventReturns memory _eventData_)
private
returns (HexboxFomoDatasets.EventReturns memory)
{
// if player has played a previous round, move their unmasked earnings
// from that round to gen vault.
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
// update player's last round played
plyr_[_pID].lrnd = rID_;
// set the joined round bool to true
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
/**
* @dev ends the round. manages paying out winner/splitting up pot
*/
function endRound(HexboxFomoDatasets.EventReturns memory _eventData_)
private
returns (HexboxFomoDatasets.EventReturns memory)
{
// setup local rID
uint256 _rID = rID_;
// grab our winning player
uint256 _winPID = round_[_rID].plyr;
// Entire 20% of buys / pot value
uint256 _win = round_[_rID].pot;
// pay our winner
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
// prepare event data
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = username.getNameByAddress(plyr_[_winPID].addr);
_eventData_.amountWon = _win;
_eventData_.newPot = 0;
// start next round
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_);
round_[_rID].pot = 0;
return(_eventData_);
}
/**
* @dev moves any unmasked earnings to gen vault. updates earnings mask
*/
function updateGenVault(uint256 _pID, uint256 _rIDlast)
private
{
uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast);
if (_earnings > 0)
{
// put in gen vault
plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen);
// zero out their earnings by updating mask
plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask);
}
}
/**
* @dev increment timer if hexbox requirement is met
*/
function updateTimer(uint256 _rID)
private
{
// grab time
uint256 _now = now;
// calculate time based on number of hexbox bought
uint256 _newTime;
if (_now > round_[_rID].end && round_[_rID].plyr == 0)
_newTime = rndInc_.add(_now);
else
_newTime = rndInc_.add(round_[_rID].end);
// compare to max and set new end time
if (_newTime < (rndMax_).add(_now))
round_[_rID].end = _newTime;
else
round_[_rID].end = rndMax_.add(_now);
}
/**
* @dev distributes hexToken based on fees to com, aff, and cube
*/
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _hexToken, uint256 _affID, HexboxFomoDatasets.EventReturns memory _eventData_)
private
returns(HexboxFomoDatasets.EventReturns memory)
{
ERC20 Hex = ERC20(tokenAddress);
uint256 _cube;
// 5% for the developers :)
uint256 _com = _hexToken / 20;
Hex.transfer(comAddress_, _com);
// 10% for aff or CUBE holders
uint256 _aff = _hexToken / 10;
if (_affID != _pID && _affID != 0) {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit HexboxFomoEvents.onAffiliatePayout(_affID, plyr_[_affID].addr, username.getNameByAddress(plyr_[_affID].addr), _rID, _pID, _aff, now);
} else {
_cube = _aff;
}
// 15% for CUBE holders
_cube = _cube.add((_hexToken.mul(15)) / (100));
if (_cube > 0)
{
// distribute to CUBE
Hex.approve(address(this), _cube);
cube.distribute.value(_cube)();
// set up event data
_eventData_.cubeAmount = _cube.add(_eventData_.cubeAmount);
}
return(_eventData_);
}
/**
* @dev distributes hexToken based on fees to gen and pot
*/
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _hexToken, uint256 _hexbox, HexboxFomoDatasets.EventReturns memory _eventData_)
private
returns(HexboxFomoDatasets.EventReturns memory)
{
// 50% for HEXBOX holders
uint256 _gen = (_hexToken.mul(50)) / 100;
// update hexToken balance (hexToken = hexToken - (developers (5%) + aff share (10%)) + cube share (15%))
_hexToken = _hexToken.sub((_hexToken.mul(30)) / 100);
// 20% for winner
uint256 _pot = _hexToken.sub(_gen);
// distribute gen share (thats what updateMasks() does) and adjust
// balances for dust.
uint256 _dust = updateMasks(_rID, _pID, _gen, _hexbox);
if (_dust > 0)
_gen = _gen.sub(_dust);
// add the 20% + dust
round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot);
// set up event data
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
}
/**
* @dev updates masks for round and player when hexbox are bought
* @return dust left over
*/
function updateMasks(uint256 _rID, uint256 _pID, uint256 _gen, uint256 _hexbox)
private
returns(uint256)
{
/* MASKING NOTES
earnings masks are a tricky thing for people to wrap their minds around.
the basic thing to understand here. is were going to have a global
tracker based on profit per share for each round, that increases in
relevant proportion to the increase in share supply.
the player will have an additional mask that basically says "based
on the rounds mask, my shares, and how much i've already withdrawn,
how much is still owed to me?"
*/
// calc profit per hexbox & round mask based on this buy: (dust goes to pot)
uint256 _ppt = (_gen.mul(100000000)) / (round_[_rID].hexbox);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
// calculate player earning from their own buy (only based on the hexbox
// they just bought). & update player earnings mask
uint256 _pearn = (_ppt.mul(_hexbox)) / (100000000);
plyrRnds_[_pID][_rID].mask = (((round_[_rID].mask.mul(_hexbox)) / (100000000)).sub(_pearn)).add(plyrRnds_[_pID][_rID].mask);
// calculate & return dust
return(_gen.sub((_ppt.mul(round_[_rID].hexbox)) / (100000000)));
}
/**
* @dev adds up unmasked earnings, & vault earnings, sets them all to 0
* @return earnings in wei format
*/
function withdrawEarnings(uint256 _pID)
private
returns(uint256)
{
// update gen vault
updateGenVault(_pID, plyr_[_pID].lrnd);
// from vaults
uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff);
if (_earnings > 0)
{
plyr_[_pID].win = 0;
plyr_[_pID].gen = 0;
plyr_[_pID].aff = 0;
}
return(_earnings);
}
/**
* @dev prepares compression data and fires event for buy or reload tx's
*/
function endTx(uint256 _pID, uint256 _hexToken, uint256 _hexbox, HexboxFomoDatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + ( now * 1000000000000000000 );
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit HexboxFomoEvents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
username.getNameByAddress(plyr_[_pID].addr),
msg.sender,
_hexToken,
_hexbox,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.cubeAmount,
_eventData_.genAmount,
_eventData_.potAmount
);
}
}
// Structs
library HexboxFomoDatasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr; // winner address
bytes32 winnerName; // winner name
uint256 amountWon; // amount won
uint256 newPot; // amount in new pot
uint256 cubeAmount; // amount distributed to cube
uint256 genAmount; // amount distributed to gen
uint256 potAmount; // amount added to pot
}
struct Player {
address addr; // player address
bytes32 name; // player name
uint256 win; // winnings vault
uint256 gen; // general vault
uint256 aff; // affiliate vault
uint256 lrnd; // last round played
uint256 laff; // last affiliate id used
}
struct PlayerRounds {
uint256 hexToken; // hexToken player has added to round (used for hexToken limiter)
uint256 hexbox; // hexbox
uint256 mask; // player mask
}
struct Round {
uint256 plyr; // pID of player in lead
uint256 end; // time ends/ended
bool ended; // has round end function been ran
uint256 strt; // time round started
uint256 hexbox; // hexbox
uint256 hexToken; // total hexToken in
uint256 pot; // hexToken to pot (during round) / final amount paid to winner (after round ends)
uint256 mask; // global mask
}
}
// Key Calculator
library HexboxCalcLong {
using SafeMath for *;
/**
* @dev calculates number of hexbox received given X hexToken
* @param _curEth current amount of hexToken in contract
* @param _newEth hexToken being spent
* @return amount of ticket purchased
*/
function hexboxRec(uint256 _curEth, uint256 _newEth)
internal
pure
returns (uint256)
{
return(hexbox((_curEth).add(_newEth)).sub(hexbox(_curEth)));
}
/**
* @dev calculates amount of hexToken received if you sold X hexbox
* @param _curHexbox current amount of hexbox that exist
* @param _sellHexbox amount of hexbox you wish to sell
* @return amount of hexToken received
*/
function hexTokenRec(uint256 _curHexbox, uint256 _sellHexbox)
internal
pure
returns (uint256)
{
return((hexToken(_curHexbox)).sub(hexToken(_curHexbox.sub(_sellHexbox))));
}
/**
* @dev calculates how many hexbox would exist with given an amount of hexToken
* @param _hexToken hexToken "in contract"
* @return number of hexbox that would exist
*/
function hexbox(uint256 _hexToken)
internal
pure
returns(uint256)
{
return ((((((_hexToken).mul(100000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000);
}
/**
* @dev calculates how much hexToken would be in contract given a number of hexbox
* @param _hexbox number of hexbox "in contract"
* @return hexToken that would exists
*/
function hexToken(uint256 _hexbox)
internal
pure
returns(uint256)
{
return ((78125000).mul(_hexbox.sq()).add(((149999843750000).mul(_hexbox.mul(100000000))) / (2))) / ((100000000).sq());
}
}
// Interfaces
interface UsernameInterface {
function getNameByAddress(address _addr) external view returns (bytes32);
}
interface CubeInterface {
function distribute() external payable;
function startTime() external view returns (uint256);
}
/**
* @title SafeMath v0.1.9
* @dev Math operations with safety checks that throw on error
* change notes: original SafeMath library from OpenZeppelin modified by Inventor
* - added sqrt
* - added sq
* - added pwr
* - changed asserts to requires with error log outputs
* - removed div, its useless
*/
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
/**
* @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)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
/**
* @dev gives square root of given x.
*/
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
/**
* @dev gives square. multiplies x by x
*/
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
/**
* @dev x to the power of y
*/
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for ( uint256 i = 1; i < y; i++ )
z = mul(z,x);
return (z);
}
}
}
Raw
ERC165.sol
pragma solidity ^0.6.0;
import "./IERC165.sol";
/**
* @dev Implementation of the {IERC165} interface.
*
* Contracts may inherit from this and call {_registerInterface} to declare
* their support of an interface.
*/
contract ERC165 is IERC165 {
/*
* bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7
*/
bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
/**
* @dev Mapping of interface ids to whether or not it's supported.
*/
mapping(bytes4 => bool) private _supportedInterfaces;
constructor () internal {
// Derived contracts need only register support for their own interfaces,
// we register support for ERC165 itself here
_registerInterface(_INTERFACE_ID_ERC165);
}
/**
* @dev See {IERC165-supportsInterface}.
*
* Time complexity O(1), guaranteed to always use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) public view override returns (bool) {
return _supportedInterfaces[interfaceId];
}
/**
* @dev Registers the contract as an implementer of the interface defined by
* `interfaceId`. Support of the actual ERC165 interface is automatic and
* registering its interface id is not required.
*
* See {IERC165-supportsInterface}.
*
* Requirements:
*
* - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).
*/
function _registerInterface(bytes4 interfaceId) internal virtual {
require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
_supportedInterfaces[interfaceId] = true;
}
}
Raw
erc20.sol
pragma solidity ^0.6.1;
import {ERC20TokenInterface} from './IERC20.sol';
import 'https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/SafeMath.sol';
contract ERC20 is ERC20TokenInterface{
using SafeMath for uint256;
string internal tName;
string internal tSymbol;
uint256 internal tTotalSupply;
uint256 internal tdecimals;
uint256 internal price;
address internal owner;
address internal delegatedAddres;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allownce;
mapping(address => uint256) time;
constructor(string memory _tokenName,string memory _symbol,uint256 _totalSupply,uint256 _decimals, uint _priceInWei)public{
tName = _tokenName;
tSymbol = _symbol;
tTotalSupply = _totalSupply* 10**uint256(_decimals);
tdecimals = _decimals;
owner = msg.sender;
price = _priceInWei;
balances[msg.sender] = balances[msg.sender].add(tTotalSupply);
}
modifier onlyOwner() {
require(msg.sender == owner, "only owner can call this method");
_;
}
fallback() external payable{
buy_token();
}
function name() override public view returns(string memory) { return tName;}
function symbol() override public view returns(string memory) { return tSymbol;}
function totalSupply()override public view returns(uint256) { return tTotalSupply;}
function decimals() override public view returns(uint256) { return tdecimals;}
function balanceOf(address tokenOwner) override public view returns(uint256){ return balances[tokenOwner]; }
function transfer(address to, uint token) override public returns(bool success){
require(balances[msg.sender] >= token, "you should have some token");
balances[msg.sender] = balances[msg.sender].sub(token);
balances[to] = balances[to].add(token);
emit Transfer(msg.sender,to,token);
return true;
}
function approve(address spender, uint tokens) override public returns(bool success) {
require((tokens == 0) || (allownce[msg.sender][spender] == 0));
allownce[msg.sender][spender] = allownce[msg.sender][spender].add(tokens);
emit Approval(msg.sender, spender,tokens);
return true;
}
function allowance(address _owner, address spender) override public view returns(uint){
return allownce[_owner][spender];
}
function transferFrom(address from, address to, uint tokens) override public returns(bool success) {
require(balances[from] >= tokens);
require(allownce[from][msg.sender] >= tokens);
balances[from] = balances[from].sub(tokens);
balances[to] = balances[to].add(tokens);
allownce[from][msg.sender] = allownce[from][msg.sender].sub(tokens);
emit Transfer(from,to,tokens);
return true;
}
function buy_token() public payable returns(bool) {
require(msg.value > 0 ether, "invailed amount");
require(tx.origin == msg.sender,"should be external owned account");
uint256 wei_unit = (1 ether)/price;
uint256 final_price = msg.value * wei_unit;
balances[owner] -= final_price;
balances[msg.sender] += final_price;
time[msg.sender] = now.add(30 days);
// address(uint160(owner)).transfer(msg.value);
return true;
}
function withdrwal_all_fund() onlyOwner payable public returns(bool){
payable(owner).transfer(address(this).balance);
}
function delegate_address_for_price(address _addres) onlyOwner public returns(bool){
delegatedAddres = _addres;
return true;
}
function update_price(uint _price) public returns(bool){
require(msg.sender == owner || msg.sender == delegatedAddres, "only special account are allowed");
price = _price;
return true;
}
function transfer_ownership(address _newOwner) onlyOwner public returns(bool){
owner = _newOwner;
return true;
}
function checkBalance() public view returns(uint){
return address(this).balance;
}
function return_token(uint _amount) public returns(bool){
require(_amount <= balances[msg.sender],"invailed amount");
require(time[msg.sender] >= now , "cannot return when time is over");
uint256 temp_price = (_amount.mul(price)).div(1 ether);
require(temp_price <= address(this).balance,"account doesnot have enought fund for returning you ammount");
balances[owner] = balances[owner].add(temp_price);
balances[msg.sender] = balances[msg.sender].sub(temp_price);
payable(msg.sender).transfer(temp_price);
}
}
Raw
ERC721.sol
pragma solidity ^0.6.0;
import "./IERC721.sol";
import "./ERC165.sol";
import 'https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/SafeMath.sol';
import 'https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Address.sol';
/**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/
contract ERC721 is ERC165, IERC721{
using SafeMath for uint256;
using Address for address;
uint _totalSupply;
// Mapping from holder address to their set of owned tokens
mapping (address => uint256[]) internal _holderTokens;
//mapping for holding index of token in holder
mapping(address => mapping(uint256 => uint256)) internal _holderTokenIndex;
// token mapping from token ids to their owners
mapping(uint256 => address) internal _tokenOwners;
// Mapping from token ID to approved address
mapping (uint256 => address) internal _tokenApprovals;
/**
* For a given account, for a given operator, store whether that operator is
* allowed to transfer and modify assets on behalf of them.
*/
mapping (address => mapping (address => bool)) internal _operatorApprovals;
//
// Token name
string private _name;
// Token symbol
string private _symbol;
// Optional mapping for token URIs
mapping(uint256 => string) internal _tokenURIs;
// Base URI
string private _baseURI;
/*
* bytes4(keccak256('balanceOf(address)')) == 0x70a08231
* bytes4(keccak256('ownerOf(uint256)')) == 0x6352211e
* bytes4(keccak256('approve(address,uint256)')) == 0x095ea7b3
* bytes4(keccak256('getApproved(uint256)')) == 0x081812fc
* bytes4(keccak256('setApprovalForAll(address,bool)')) == 0xa22cb465
* bytes4(keccak256('isApprovedForAll(address,address)')) == 0xe985e9c5
* bytes4(keccak256('transferFrom(address,address,uint256)')) == 0x23b872dd
* bytes4(keccak256('safeTransferFrom(address,address,uint256)')) == 0x42842e0e
* bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)')) == 0xb88d4fde
*
* => 0x70a08231 ^ 0x6352211e ^ 0x095ea7b3 ^ 0x081812fc ^
* 0xa22cb465 ^ 0xe985e9c ^ 0x23b872dd ^ 0x42842e0e ^ 0xb88d4fde == 0x80ac58cd
*/
bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;
/*
* bytes4(keccak256('name()')) == 0x06fdde03
* bytes4(keccak256('symbol()')) == 0x95d89b41
* bytes4(keccak256('tokenURI(uint256)')) == 0xc87b56dd
*
* => 0x06fdde03 ^ 0x95d89b41 ^ 0xc87b56dd == 0x5b5e139f
*/
bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
/*
* bytes4(keccak256('totalSupply()')) == 0x18160ddd
* bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) == 0x2f745c59
* bytes4(keccak256('tokenByIndex(uint256)')) == 0x4f6ccce7
*
* => 0x18160ddd ^ 0x2f745c59 ^ 0x4f6ccce7 == 0x780e9d63
*/
bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(_INTERFACE_ID_ERC721);
}
/**
* @dev Gets the balance of the specified address.
* @param owner address to query the balance of
* @return uint256 representing the amount owned by the passed address
*/
function balanceOf(address owner) public view override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
return _holderTokens[owner].length;
}
/**
* @dev Gets the owner of the specified token ID.
* @param tokenId uint256 ID of the token to query the owner of
* @return address currently marked as the owner of the given token ID
*/
function ownerOf(uint256 tokenId) public view override returns (address) {
address owner = _tokenOwners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
/**
* @dev Gets index of particular token from Owner's collection
* @param tokenId uint256 ID of the token to query the index of
* @param owner address
* @return uint256 index of token
*/
function indexOf(address owner, uint256 tokenId) public view returns (uint256){
require(tokenId > 0,"ERC721: Query for non existent token");
require(owner != address(0), "ERC721: owner query for nonexistent token");
return _holderTokenIndex[owner][tokenId];
}
/**
* @dev Gets the token ID at a given index of the tokens list of the requested owner.
* @param owner address owning the tokens list to be accessed
* @param index uint256 representing the index to be accessed of the requested tokens list
* @return uint256 token ID at the given index of the tokens list owned by the requested address
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {
return _holderTokens[owner][index];
}
/**
* @dev Gets the token name.
* @return string representing the token name
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev Gets the token symbol.
* @return string representing the token symbol
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
* @dev Gets the total amount of tokens stored by the contract.
* @return uint256 representing the total amount of tokens
*/
function totalSupply() public view returns (uint256) {
// _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds
return _totalSupply;
}
/**
* @dev Approves another address to transfer the given token ID
* The zero address indicates there is no approved address.
* There can only be one approved address per token at a given time.
* Can only be called by the token owner or an approved operator.
* @param to address to be approved for the given token ID
* @param tokenId uint256 ID of the token to be approved
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(msg.sender == owner || isApprovedForAll(owner, msg.sender),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
/**
* @dev Gets the approved address for a token ID, or zero if no address set
* Reverts if the token ID does not exist.
* @param tokenId uint256 ID of the token to query the approval of
* @return address currently approved for the given token ID
*/
function getApproved(uint256 tokenId) public view override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev Sets or unsets the approval of a given operator
* An operator is allowed to transfer all tokens of the sender on their behalf.
* @param operator operator address to set the approval
* @param approved representing the status of the approval to be set
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != msg.sender, "ERC721: approve to caller");
_operatorApprovals[msg.sender][operator] = approved;
emit ApprovalForAll(msg.sender, operator, approved);
}
/**
* @dev Tells whether an operator is approved by a given owner.
* @param owner owner address which you want to query the approval of
* @param operator operator address which you want to query the approval of
* @return bool whether the given operator is approved by the given owner
*/
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev Transfers the ownership of a given token ID to another address.
* Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
* Requires the msg.sender to be the owner, approved, or operator.
* @param from current owner of the token
* @param to address to receive the ownership of the given token ID
* @param tokenId uint256 ID of the token to be transferred
*/
function transferFrom(address from, address to, uint256 tokenId) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(msg.sender, tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
/**
* @dev Returns whether the specified token exists.
* @param tokenId uint256 ID of the token to query the existence of
* @return bool whether the token exists
*/
function _exists(uint256 tokenId) internal view returns (bool) {
require(tokenId > 0,"ERC721: Token does not exist");
address owner = ownerOf(tokenId);
if(owner != address(0))
return true;
else
return false;
}
/**
* @dev Returns whether the given spender can transfer a given token ID.
* @param spender address of the spender to query
* @param tokenId uint256 ID of the token to be transferred
* @return bool whether the msg.sender is approved for the given token ID,
* is an operator of the owner, or is the owner of the token
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
/**
* @dev Internal function to mint a new token.
* Reverts if the given token ID already exists.
* @param to The address that will own the minted token
* @param tokenId uint256 ID of the token to be minted
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
//require(!_exists(tokenId), "ERC721: token already minted");
_totalSupply = _totalSupply.add(1);
_tokenOwners[tokenId] = to;
//push new token in owner
_holderTokens[to].push(tokenId);
//stored new index
_holderTokenIndex[to][tokenId]= _holderTokens[to].length;
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Internal function to burn a specific token.
* Reverts if the token does not exist.
* @param tokenId uint256 ID of the token being burned
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ownerOf(tokenId);
// Clear approvals
_approve(address(0), tokenId);
// Clear metadata (if any)
if (bytes(_tokenURIs[tokenId]).length != 0) {
delete _tokenURIs[tokenId];
}
_totalSupply = _totalSupply.sub(1);
uint index = indexOf(owner,tokenId);
_holderTokens[owner][index] = 0;
_holderTokenIndex[owner][tokenId] = 0;
_tokenOwners[tokenId]=address(0);
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Internal function to transfer ownership of a given token ID to another address.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
* @param from current owner of the token
* @param to address to receive the ownership of the given token ID
* @param tokenId uint256 ID of the token to be transferred
*/
function _transfer(address from, address to, uint256 tokenId) internal virtual {
require(ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
// Clear approvals from the previous owner
_approve(address(0), tokenId);
uint256 fromIndex = indexOf(from,tokenId);
uint256 toIndex = indexOf(to,tokenId);
//removing from From Address
_holderTokens[from][fromIndex] = 0;
_holderTokens[to][toIndex] = tokenId;
_tokenOwners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
/**
* @dev Internal function to set the token URI for a given token.
*
* Reverts if the token ID does not exist.
*
* TIP: If all token IDs share a prefix (for example, if your URIs look like
* `https://api.myproject.com/token/<id>`), use {_setBaseURI} to store
* it and save gas.
*/
function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token");
_tokenURIs[tokenId] = _tokenURI;
}
function _approve(address to, uint256 tokenId) private {
_tokenApprovals[tokenId] = to;
emit Approval(ownerOf(tokenId), to, tokenId);
}
}
Raw
eth_div.sol
pragma solidity ^0.6.0;
import 'https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/SafeMath.sol';
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/Ownable.sol";
contract eth_divis is Ownable{
using SafeMath for uint256;
uint public totalPlayers;
uint public totalPayout;
uint public totalInvested;
uint private minDepositSize = 0.08 ether;
uint private interestRateDivisor = 1000000000000;
uint public commissionDivisor = 100;
uint private minuteRate = 2314808; //DAILY 20%
address developerAddr;
address marketingAddr;
struct Player {
uint trxDeposit;
uint time;
uint interestProfit;
uint affRewards;
uint payoutSum;
address affFrom;
uint256 aff1sum;
}
mapping(address => Player) public players;
mapping(address => uint256) public withdrwalTime;
constructor(address _developer, address _marketingAddr) public {
developerAddr = _developer;
marketingAddr = _marketingAddr;
}
function register(address _addr, address _affAddr) private{
Player storage player = players[_addr];
player.affFrom = _affAddr;
address _affAddr1 = _affAddr;
players[_affAddr1].aff1sum = players[_affAddr1].aff1sum.add(1);
}
fallback () external payable {
}
function deposit(address _affAddr) public payable {
// require(now >= releaseTime, "not time yet!");
collect(msg.sender);
require(msg.value >= minDepositSize);
uint depositAmount = msg.value;
Player storage player = players[msg.sender];
if (player.time == 0) {
player.time = now;
totalPlayers++;
if(_affAddr != address(0) && players[_affAddr].trxDeposit > 0){
register(msg.sender, _affAddr);
}
else{
register(msg.sender, payable(owner()));
}
}
player.trxDeposit = player.trxDeposit.add(depositAmount);
distributeRef(msg.value, player.affFrom);
totalInvested = totalInvested.add(depositAmount);
withdrwalTime[msg.sender] = now.add(1 minutes);
// uint devEarn = depositAmount.mul(devCommission).div(commissionDivisor);
// payable(owner()).transfer(devEarn);
}
function withdraw() public {
collect(msg.sender);
require(players[msg.sender].interestProfit > 0);
require(withdrwalTime[msg.sender] <= now, "ERROR: cannot withdrwal twice in one day wait for 24h");
transferPayout(msg.sender, ((players[msg.sender].interestProfit).mul(20)).div(100));
reinvest();
withdrwalTime[msg.sender] = now.add(1 minutes);
}
function reinvest() public {
collect(msg.sender);
Player storage player = players[msg.sender];
uint256 depositAmount = ((player.interestProfit).mul(5)).div(100);
require(address(this).balance >= depositAmount);
player.interestProfit = 0;
player.trxDeposit = player.trxDeposit.add(depositAmount);
distributeRef(depositAmount, player.affFrom);
// uint devEarn = depositAmount.mul(devCommission).div(commissionDivisor);
// payable(owner()).transfer(devEarn);
}
function collect(address _addr) internal {
Player storage player = players[_addr];
uint secPassed = now.sub(player.time);
if (secPassed > 0 && player.time > 0) {
uint collectProfit = (player.trxDeposit.mul(secPassed.mul(minuteRate))).div(interestRateDivisor);
player.interestProfit = player.interestProfit.add(collectProfit);
player.time = player.time.add(secPassed);
}
}
function transferPayout(address _receiver, uint _amount) internal {
if (_amount > 0 && _receiver != address(0)) {
uint contractBalance = address(this).balance;
if (contractBalance > 0) {
uint payout = _amount > contractBalance ? contractBalance : _amount;
totalPayout = totalPayout.add(payout);
Player storage player = players[_receiver];
player.payoutSum = player.payoutSum.add(payout);
player.interestProfit = player.interestProfit.sub(payout);
msg.sender.transfer(payout);
}
}
}
function distributeRef(uint256 _trx, address _affFrom) private{
uint256 _allaff = (_trx.mul(15)).div(100);
uint256 _devfee = (_trx.mul(3)).div(100);
uint256 _marketingFee = (_trx.mul(2)).div(100);
address _affAddr1 = _affFrom;
uint256 _affRewards = 0;
if (_affAddr1 != address(0)) {
players[_affAddr1].affRewards = _affRewards.add(players[_affAddr1].affRewards);
payable(_affAddr1).transfer(_affRewards);
}
if(_allaff > 0 ){
payable(owner()).transfer(_allaff);
}
payable(developerAddr).transfer(_devfee);
payable(marketingAddr).transfer(_marketingFee);
}
function getProfit(address _addr) public view returns (uint) {
address playerAddress= _addr;
uint256 collectProfit;
Player storage player = players[playerAddress];
require(player.time > 0);
uint secPassed = now.sub(player.time);
if (secPassed > 0) {
collectProfit = (player.trxDeposit.mul(secPassed.mul(minuteRate))).div(interestRateDivisor);
}
return collectProfit.add(player.interestProfit);
}
}
Raw
example.sol
// SPDX-License-Identifier: BSD-3-Clause
pragma solidity 0.6.8;
contract Example {
struct Account {
bool exists;
address sponsor;
}
mapping(address => Account) public members;
address internal owner;
constructor(address _addr) public {
owner = msg.sender;
createAccount(_addr, _addr, true);
}
function registration(address _sponsor) external payable {
require((0.04 ether) == msg.value, "Require .04 eth to register!");
createAccount(msg.sender, _sponsor, false);
}
function createAccount(address _addr, address _sponsor, bool _initial) internal {
require(!members[_addr].exists, "Already a member!");
if (_initial == false) {
require(members[_sponsor].exists, "Sponsor dont exist!");
}
members[_addr] = Account({sponsor: _sponsor, exists: true});
}
}
Raw
expenseapp.sol
pragma solidity ^0.6.0;
pragma experimental ABIEncoderV2;
contract expense{
mapping(address => string[]) public text;
mapping(address => uint[])public amount;
event transaction(address, string, uint);
function addTransaction(string memory _text, uint _amount) public {
text[msg.sender].push(_text);
amount[msg.sender].push(_amount);
emit transaction(msg.sender, _text,_amount);
}
function returndata() public view returns(string[] memory,uint[] memory){
return (text[msg.sender],amount[msg.sender]);
}
}
Raw
fiverr_project_2.sol
/**
*Submitted for verification at Etherscan.io on 2020-04-22
*/
pragma solidity 0.5.16;
// Owner Handler
contract ownerShip // Auction Contract Owner and OwherShip change
{
//Global storage declaration
address public ownerWallet;
address private newOwner;
//Event defined for ownership transfered
event OwnershipTransferredEv(address indexed previousOwner, address indexed newOwner);
//Sets owner only on first run
constructor() public
{
//Set contract owner
ownerWallet = msg.sender;
emit OwnershipTransferredEv(address(0), msg.sender);
}
function transferOwnership(address _newOwner) public onlyOwner
{
newOwner = _newOwner;
}
//the reason for this flow is to protect owners from sending ownership to unintended address due to human error
function acceptOwnership() public
{
require(msg.sender == newOwner);
emit OwnershipTransferredEv(ownerWallet, newOwner);
ownerWallet = newOwner;
newOwner = address(0);
}
//This will restrict function only for owner where attached
modifier onlyOwner()
{
require(msg.sender == ownerWallet);
_;
}
}
contract Ethbull is ownerShip {
uint maxDownLimit = 2;
uint levelLifeTime = 8640000; // = 100 days;
uint public lastIDCount = 0;
struct userInfo {
bool joined;
uint id;
uint referrerID;
address[] referral;
mapping(uint => uint) levelExpired;
}
mapping(uint => uint) public priceOfLevel;
mapping (address => userInfo) public userInfos;
mapping (uint => address) public userAddressByID;
event regLevelEv(uint indexed _userID, address indexed _userWallet, uint indexed _referrerID, address _refererWallet, uint _originalReferrer, uint _time);
event levelBuyEv(address indexed _user, uint _level, uint _amount, uint _time);
event paidForLevelEv(address indexed _user, address indexed _referral, uint _level, uint _amount, uint _time);
event lostForLevelEv(address indexed _user, address indexed _referral, uint _level, uint _amount, uint _time);
constructor() public {
priceOfLevel[1] = 0.07 ether;
priceOfLevel[2] = 0.1 ether;
priceOfLevel[3] = 0.2 ether;
priceOfLevel[4] = 0.4 ether;
priceOfLevel[5] = 1 ether;
priceOfLevel[6] = 2.5 ether;
priceOfLevel[7] = 5 ether;
priceOfLevel[8] = 10 ether;
priceOfLevel[9] = 20 ether;
priceOfLevel[10] = 40 ether;
userInfo memory UserInfo;
lastIDCount++;
UserInfo = userInfo({
joined: true,
id: lastIDCount,
referrerID: 0,
referral: new address[](0)
});
userInfos[ownerWallet] = UserInfo;
userAddressByID[lastIDCount] = ownerWallet;
for(uint i = 1; i <= 10; i++) {
userInfos[ownerWallet].levelExpired[i] = 99999999999;
emit paidForLevelEv(ownerWallet, address(0), i, priceOfLevel[i], now);
}
emit regLevelEv(lastIDCount, msg.sender, 0, address(0), 0, now);
}
function () external payable {
uint level;
if(msg.value == priceOfLevel[1]) level = 1;
else if(msg.value == priceOfLevel[2]) level = 2;
else if(msg.value == priceOfLevel[3]) level = 3;
else if(msg.value == priceOfLevel[4]) level = 4;
else if(msg.value == priceOfLevel[5]) level = 5;
else if(msg.value == priceOfLevel[6]) level = 6;
else if(msg.value == priceOfLevel[7]) level = 7;
else if(msg.value == priceOfLevel[8]) level = 8;
else if(msg.value == priceOfLevel[9]) level = 9;
else if(msg.value == priceOfLevel[10]) level = 10;
else revert('Incorrect Value send');
if(userInfos[msg.sender].joined) buyLevel(level);
else if(level == 1) {
uint refId = 1;
address referrer = bytesToAddress(msg.data);
if(userInfos[referrer].joined) refId = userInfos[referrer].id;
regUser(refId);
}
else revert('Please buy first level for 0.03 ETH');
}
function regUser(uint _referrerID) public payable {
uint originalReferrerID = _referrerID;
require(!userInfos[msg.sender].joined, 'User exist');
require(_referrerID > 0 && _referrerID <= lastIDCount, 'Incorrect referrer Id');
require(msg.value == priceOfLevel[1], 'Incorrect Value');
if(userInfos[userAddressByID[_referrerID]].referral.length >= maxDownLimit) _referrerID = userInfos[findFreeReferrer(userAddressByID[_referrerID])].id;
userInfo memory UserInfo;
lastIDCount++;
UserInfo = userInfo({
joined: true,
id: lastIDCount,
referrerID: _referrerID,
referral: new address[](0)
});
userInfos[msg.sender] = UserInfo;
userAddressByID[lastIDCount] = msg.sender;
userInfos[msg.sender].levelExpired[1] = now + levelLifeTime;
userInfos[userAddressByID[_referrerID]].referral.push(msg.sender);
payForLevel(1, msg.sender);
emit regLevelEv(lastIDCount, msg.sender, _referrerID, userAddressByID[_referrerID], originalReferrerID, now);
emit levelBuyEv(msg.sender, 1, msg.value, now);
}
function buyLevel(uint _level) public payable {
require(userInfos[msg.sender].joined, 'User not exist');
require(_level > 0 && _level <= 10, 'Incorrect level');
//owner can buy levels without paying anything
if(msg.sender!=ownerWallet){
require(msg.value == priceOfLevel[_level], 'Incorrect Value');
}
if(_level == 1) {
userInfos[msg.sender].levelExpired[1] += levelLifeTime;
}
else {
for(uint l =_level - 1; l > 0; l--) require(userInfos[msg.sender].levelExpired[l] >= now, 'Buy the previous level');
if(userInfos[msg.sender].levelExpired[_level] == 0) userInfos[msg.sender].levelExpired[_level] = now + levelLifeTime;
else userInfos[msg.sender].levelExpired[_level] += levelLifeTime;
}
payForLevel(_level, msg.sender);
emit levelBuyEv(msg.sender, _level, msg.value, now);
}
function payForLevel(uint _level, address _user) internal {
address referer;
address referer1;
address referer2;
address referer3;
address referer4;
if(_level == 1 || _level == 6) {
referer = userAddressByID[userInfos[_user].referrerID];
}
else if(_level == 2 || _level == 7) {
referer1 = userAddressByID[userInfos[_user].referrerID];
referer = userAddressByID[userInfos[referer1].referrerID];
}
else if(_level == 3 || _level == 8) {
referer1 = userAddressByID[userInfos[_user].referrerID];
referer2 = userAddressByID[userInfos[referer1].referrerID];
referer = userAddressByID[userInfos[referer2].referrerID];
}
else if(_level == 4 || _level == 9) {
referer1 = userAddressByID[userInfos[_user].referrerID];
referer2 = userAddressByID[userInfos[referer1].referrerID];
referer3 = userAddressByID[userInfos[referer2].referrerID];
referer = userAddressByID[userInfos[referer3].referrerID];
}
else if(_level == 5 || _level == 10) {
referer1 = userAddressByID[userInfos[_user].referrerID];
referer2 = userAddressByID[userInfos[referer1].referrerID];
referer3 = userAddressByID[userInfos[referer2].referrerID];
referer4 = userAddressByID[userInfos[referer3].referrerID];
referer = userAddressByID[userInfos[referer4].referrerID];
}
if(!userInfos[referer].joined) referer = userAddressByID[1];
bool sent = false;
if(userInfos[referer].levelExpired[_level] >= now) {
sent = address(uint160(referer)).send(priceOfLevel[_level]);
if (sent) {
emit paidForLevelEv(referer, msg.sender, _level, msg.value, now);
}
}
if(!sent) {
emit lostForLevelEv(referer, msg.sender, _level, msg.value, now);
payForLevel(_level, referer);
}
}
function findFreeReferrer(address _user) public view returns(address) {
if(userInfos[_user].referral.length < maxDownLimit) return _user;
address[] memory referrals = new address[](126);
referrals[0] = userInfos[_user].referral[0];
referrals[1] = userInfos[_user].referral[1];
address freeReferrer;
bool noFreeReferrer = true;
for(uint i = 0; i < 126; i++) {
if(userInfos[referrals[i]].referral.length == maxDownLimit) {
if(i < 62) {
referrals[(i+1)*2] = userInfos[referrals[i]].referral[0];
referrals[(i+1)*2+1] = userInfos[referrals[i]].referral[1];
}
}
else {
noFreeReferrer = false;
freeReferrer = referrals[i];
break;
}
}
require(!noFreeReferrer, 'No Free Referrer');
return freeReferrer;
}
function viewUserReferral(address _user) public view returns(address[] memory) {
return userInfos[_user].referral;
}
function viewUserLevelExpired(address _user, uint _level) public view returns(uint) {
return userInfos[_user].levelExpired[_level];
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
function viewTimestampSinceJoined(address usr) public view returns(uint256[10] memory timeSinceJoined )
{
if(userInfos[usr].joined)
{
for(uint256 i=0;i<10;i++)
{
uint256 t = userInfos[usr].levelExpired[i+1];
if(t>now)
{
timeSinceJoined[i] = (t-now);
}
}
}
return timeSinceJoined;
}
}
Raw
flashloan.sol
pragma solidity ^0.6.6;
import "https://github.com/aave/flashloan-box/blob/Remix/contracts/aave/FlashLoanReceiverBase.sol";
import "https://github.com/aave/flashloan-box/blob/Remix/contracts/aave/ILendingPoolAddressesProvider.sol";
import "https://github.com/aave/flashloan-box/blob/Remix/contracts/aave/ILendingPool.sol";
abstract contract Flashloan is FlashLoanReceiverBase {
constructor(address _addressProvider) FlashLoanReceiverBase(_addressProvider) public {}
/**
This function is called after your contract has received the flash loaned amount
*/
function executeOperation(
address _reserve,
uint256 _amount,
uint256 _fee
// bytes calldata _params
)
external
// override
{
require(_amount <= getBalanceInternal(address(this), _reserve), "Invalid balance, was the flashLoan successful?");
//
// Your logic goes here.
// !! Ensure that *this contract* has enough of `_reserve` funds to payback the `_fee` !!
//
uint totalDebt = _amount.add(_fee);
transferFundsBackToPoolInternal(_reserve, totalDebt);
}
/**
Flash loan 1000000000000000000 wei (1 ether) worth of `_asset`
*/
function flashloan(address _asset) public onlyOwner {
bytes memory data = "";
uint amount = 1 ether;
ILendingPool lendingPool = ILendingPool(addressesProvider.getLendingPool());
lendingPool.flashLoan(address(this), _asset, amount, data);
}
}
Raw
h3x.sol
/**
*Submitted for verification at Etherscan.io on 2020-06-01
*/
/**
*
* Richard Hart is Satoshi.
*
*/
pragma solidity ^0.5.13;
interface Callable {
function tokenCallback(address _from, uint256 _tokens, bytes calldata _data) external returns (bool);
}
contract H3X {
uint256 constant private FLOAT_SCALAR = 2**64;
uint256 constant private INITIAL_SUPPLY = 3e26;
uint256 constant private temp = 15;
uint256 constant private BURN_RATE = temp/2; // 10% per tx
uint256 constant private SUPPLY_FLOOR = 1; // 1% of 300M = 3M
uint256 constant private MIN_FREEZE_AMOUNT = 1e20; // 100 minimum
string constant public name = "H3X";
string constant public symbol = "H3X";
uint8 constant public decimals = 18;
struct User {
bool whitelisted;
uint256 balance;
uint256 frozen;
mapping(address => uint256) allowance;
int256 scaledPayout;
}
struct Info {
uint256 totalSupply;
uint256 totalFrozen;
mapping(address => User) users;
uint256 scaledPayoutPerToken;
address admin;
}
Info private info;
event Transfer(address indexed from, address indexed to, uint256 tokens);
event Approval(address indexed owner, address indexed spender, uint256 tokens);
event Whitelist(address indexed user, bool status);
event Freeze(address indexed owner, uint256 tokens);
event Unfreeze(address indexed owner, uint256 tokens);
event Collect(address indexed owner, uint256 tokens);
event Burn(uint256 tokens);
constructor() public {
info.admin = msg.sender;
info.totalSupply = INITIAL_SUPPLY;
info.users[msg.sender].balance = INITIAL_SUPPLY;
emit Transfer(address(0x0), msg.sender, INITIAL_SUPPLY);
whitelist(msg.sender, true);
}
function freeze(uint256 _tokens) external {
_freeze(_tokens);
}
function unfreeze(uint256 _tokens) external {
_unfreeze(_tokens);
}
function collect() external returns (uint256) {
uint256 _dividends = dividendsOf(msg.sender);
require(_dividends >= 0);
info.users[msg.sender].scaledPayout += int256(_dividends * FLOAT_SCALAR);
info.users[msg.sender].balance += _dividends;
emit Transfer(address(this), msg.sender, _dividends);
emit Collect(msg.sender, _dividends);
return _dividends;
}
function burn(uint256 _tokens) external {
require(balanceOf(msg.sender) >= _tokens);
info.users[msg.sender].balance -= _tokens;
uint256 _burnedAmount = _tokens;
if (info.totalFrozen > 0) {
_burnedAmount /= 2;
info.scaledPayoutPerToken += _burnedAmount * FLOAT_SCALAR / info.totalFrozen;
emit Transfer(msg.sender, address(this), _burnedAmount);
}
info.totalSupply -= _burnedAmount;
emit Transfer(msg.sender, address(0x0), _burnedAmount);
emit Burn(_burnedAmount);
}
function distribute(uint256 _tokens) external {
require(info.totalFrozen > 0);
require(balanceOf(msg.sender) >= _tokens);
info.users[msg.sender].balance -= _tokens;
info.scaledPayoutPerToken += _tokens * FLOAT_SCALAR / info.totalFrozen;
emit Transfer(msg.sender, address(this), _tokens);
}
function transfer(address _to, uint256 _tokens) external returns (bool) {
_transfer(msg.sender, _to, _tokens);
return true;
}
function approve(address _spender, uint256 _tokens) external returns (bool) {
info.users[msg.sender].allowance[_spender] = _tokens;
emit Approval(msg.sender, _spender, _tokens);
return true;
}
function transferFrom(address _from, address _to, uint256 _tokens) external returns (bool) {
require(info.users[_from].allowance[msg.sender] >= _tokens);
info.users[_from].allowance[msg.sender] -= _tokens;
_transfer(_from, _to, _tokens);
return true;
}
function transferAndCall(address _to, uint256 _tokens, bytes calldata _data) external returns (bool) {
uint256 _transferred = _transfer(msg.sender, _to, _tokens);
uint32 _size;
assembly {
_size := extcodesize(_to)
}
if (_size > 0) {
require(Callable(_to).tokenCallback(msg.sender, _transferred, _data));
}
return true;
}
function bulkTransfer(address[] calldata _receivers, uint256[] calldata _amounts) external {
require(_receivers.length == _amounts.length);
for (uint256 i = 0; i < _receivers.length; i++) {
_transfer(msg.sender, _receivers[i], _amounts[i]);
}
}
function whitelist(address _user, bool _status) public {
require(msg.sender == info.admin);
info.users[_user].whitelisted = _status;
emit Whitelist(_user, _status);
}
function totalSupply() public view returns (uint256) {
return info.totalSupply;
}
function totalFrozen() public view returns (uint256) {
return info.totalFrozen;
}
function balanceOf(address _user) public view returns (uint256) {
return info.users[_user].balance - frozenOf(_user);
}
function frozenOf(address _user) public view returns (uint256) {
return info.users[_user].frozen;
}
function dividendsOf(address _user) public view returns (uint256) {
return uint256(int256(info.scaledPayoutPerToken * info.users[_user].frozen) - info.users[_user].scaledPayout) / FLOAT_SCALAR;
}
function allowance(address _user, address _spender) public view returns (uint256) {
return info.users[_user].allowance[_spender];
}
function isWhitelisted(address _user) public view returns (bool) {
return info.users[_user].whitelisted;
}
function allInfoFor(address _user) public view returns (uint256 totalTokenSupply, uint256 totalTokensFrozen, uint256 userBalance, uint256 userFrozen, uint256 userDividends) {
return (totalSupply(), totalFrozen(), balanceOf(_user), frozenOf(_user), dividendsOf(_user));
}
function _transfer(address _from, address _to, uint256 _tokens) internal returns (uint256) {
require(balanceOf(_from) >= _tokens);
info.users[_from].balance -= _tokens;
uint256 _burnedAmount = _tokens * BURN_RATE / 100;
if (totalSupply() - _burnedAmount < INITIAL_SUPPLY * SUPPLY_FLOOR / 100 || isWhitelisted(_from)) {
_burnedAmount = 0;
}
uint256 _transferred = _tokens - _burnedAmount;
info.users[_to].balance += _transferred;
emit Transfer(_from, _to, _transferred);
if (_burnedAmount > 0) {
if (info.totalFrozen > 0) {
_burnedAmount /= 2;
info.scaledPayoutPerToken += _burnedAmount * FLOAT_SCALAR / info.totalFrozen;
emit Transfer(_from, address(this), _burnedAmount);
}
info.totalSupply -= _burnedAmount;
emit Transfer(_from, address(0x0), _burnedAmount);
emit Burn(_burnedAmount);
}
return _transferred;
}
function _freeze(uint256 _amount) internal {
require(balanceOf(msg.sender) >= _amount,"ERROR: invailed balance");
require(frozenOf(msg.sender) + _amount >= MIN_FREEZE_AMOUNT,"ERROR: not minimum freez amountr");
info.totalFrozen += _amount;
info.users[msg.sender].frozen += _amount;
info.users[msg.sender].scaledPayout += int256(_amount * info.scaledPayoutPerToken);
emit Transfer(msg.sender, address(this), _amount);
emit Freeze(msg.sender, _amount);
}
function _unfreeze(uint256 _amount) internal {
require(frozenOf(msg.sender) >= _amount);
uint256 _burnedAmount = _amount * BURN_RATE / 100;
info.scaledPayoutPerToken += _burnedAmount * FLOAT_SCALAR / info.totalFrozen;
info.totalFrozen -= _amount;
info.users[msg.sender].balance -= _burnedAmount;
info.users[msg.sender].frozen -= _amount;
info.users[msg.sender].scaledPayout -= int256(_amount * info.scaledPayoutPerToken);
emit Transfer(address(this), msg.sender, _amount - _burnedAmount);
emit Unfreeze(msg.sender, _amount);
}
}
Raw
hexdex.sol
/**
*Submitted for verification at Etherscan.io on 2020-06-05
*/
pragma solidity ^0.5.15;
interface ERC20 {
function totalSupply() external view returns (uint256 supply);
function balanceOf(address _owner) external view returns (uint256 balance);
function transfer(address _to, uint256 _value)
external
returns (bool success);
function transferFrom(
address _from,
address _to,
uint256 _value
) external returns (bool success);
function approve(address _spender, uint256 _value)
external
returns (bool success);
function allowance(address _owner, address _spender)
external
view
returns (uint256 remaining);
function decimals() external view returns (uint256 digits);
event Approval(
address indexed _owner,
address indexed _spender,
uint256 _value
);
}
contract HexDex {
/*=================================
= MODIFIERS =
=================================*/
// only people with tokens
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
// only people with profits
modifier onlyStronghands() {
require(myDividends(true) > 0);
_;
}
modifier onlyAdmin() {
require(msg.sender == administrator);
_;
}
/*==============================
= EVENTS =
==============================*/
event onTokenPurchase(
address indexed customerAddress,
bytes32 customerName,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
bool isReinvest
);
event onTokenSell(
address indexed customerAddress,
bytes32 customerName,
uint256 tokensBurned,
uint256 ethereumEarned
);
event onWithdraw(
address indexed customerAddress,
bytes32 customerName,
uint256 ethereumWithdrawn
);
// ERC20
event Transfer(address indexed from, address indexed to, uint256 tokens);
/*=====================================
= CONFIGURABLES =
=====================================*/
string public name = "HexDex";
string public symbol = "H3D";
uint8 public constant decimals = 8;
uint8 internal constant dividendFee_ = 10; // 10%
uint256 internal constant HEX_CENT = 1e6;
uint256 internal constant HEX = 1e8;
uint256 internal constant tokenPriceInitial_ = 1 * HEX;
uint256 internal constant tokenPriceIncremental_ = 10 * HEX_CENT;
uint256 internal constant magnitude = 2**64;
address internal constant tokenAddress = address(
0x2b591e99afE9f32eAA6214f7B7629768c40Eeb39
);
uint256 internal cubeStartTime = now;
// admin for premine lock
address internal administrator;
// ambassadors
uint256 ambassadorLimit = HEX * 20000; // 20k hex per ambassador
uint256 devLimit = HEX * 100000;
mapping(address => bool) public ambassadors; // who the ambassadors are
mapping(address => bool) public dev;
address[33] ambassadorList = [
0xc951D3463EbBa4e9Ec8dDfe1f42bc5895C46eC8f,
0xe8f49490d2b172870b3B225e9fcD39b5D68b2e9E,
0x5161e1380cd661D7d993c8a3b3E57b059Ad8d7A4,
0x4Ca9046dcd4C8712450250208D7eD6fCEbAf75a5,
0xC697BE0b5b82284391A878B226e2f9AfC6B94710,
0x5cB87df0834cd82297C63eF075421401995914ae,
0x53F403421110BA93086BCFB40e80C7346035aDF6,
0x11ba6C4732B1a7f30deA51C23b8ED4c1F88dCD57,
0xb7032661C1DA18A52830A5e97bdE5569ed3c2A5F,
0x73c371F85246797e4f7f68F7F46b9261EBa2F853,
0xffc1eD0C150890c163D940146565df6064588d3e,
0x5DD516f5dC0E68C5A37D20284Dabd754e35AfF1c,
0x554fdECe1B1319075d7Bf2F5137076C21A202249,
0xcF7b442C41795e874b223D4ADeED8cda87A23d00,
0x87cb806192eC699398511c7aB44b3595C051D13C,
0x1c2c72269ce1aD29933F090547b4102a9c398f34,
0x9b411116f92504562EDCf3a1b14Ae226Bc1489Fc,
0x2E7E5DE7D87A29B16284092B19891c80B0F43eCa,
0xada8694dd1B511E72F467e7242E7123088aED064,
0x5269BF8720946b5c38FBf361a947bA9D30C91313,
0x21e0111e60D5449BdBa67ee6c014B5384644a714,
0xB96d8107D613b6b593b4531Fc353B282af7fbeF5,
0x71A4b5895A077806E8cd9F85a5253A9DEbd593fD,
0x73018870D10173ae6F71Cac3047ED3b6d175F274,
0x8E2Efa9eD16f07d9B153D295d35025FD677BaE99,
0x112b3496AAD76CD34a29C335266A968D65fBa10a,
0x9D7a76fD386eDEB3A871c3A096Ca875aDc1a55b7,
0x05227e4FA98a6415ef1927E902dc781AA7eD518a,
0x18600fE707D883c1FD16f002A09241D630270233,
0x8ec43a855007c61Ce75406DB8b2079207F7d597a,
0x09a054B60bd3B908791B55eEE81b515B93831E99,
0x982D72A38A2CB0ed8F2fae5B22C122f1C9c89a13,
0xa683C1b815997a7Fa38f6178c84675FC4c79AC2B
];
address[10] devList = [
0x818F1B08E38376E9635C5bE156B8786317e833b3,
0xa765a22C97c38c8Ce50FEA453cE92723C7637AA2,
0xEe54D208f62368B4efFe176CB548A317dcAe963F,
0x43678bB266e75F50Fbe5927128Ab51930b447eaB,
0x5138240E96360ad64010C27eB0c685A8b2eDE4F2,
0x39E00115d71313fD5983DE3Cf2b5820dd3Cc4447,
0xcFAa3449DFfB82Bf5B37e42FbCf43170c6C8e4AD,
0x90D20d17Cc9e07020bB490c5e34f486286d3Eeb2,
0x074F21a36217d7615d0202faA926aEFEBB5a9999,
0xAA7A7C2DECB180f68F11E975e6D92B5Dc06083A6
];
uint256 numAmbassadorsDeposited;
function depositPremine() public {
require(ambassadors[msg.sender]); // require them to be an ambassador
ambassadors[msg.sender] = false; // make them not an ambassador after this transaction! so they can't buy in twice
ERC20 Hex = ERC20(tokenAddress);
// you must deposit EXACTLY 20k
Hex.transferFrom(msg.sender, address(this), ambassadorLimit);
numAmbassadorsDeposited++;
}
uint256 numDevDeposited;
function depositDevPremine() public {
require(dev[msg.sender]);
dev[msg.sender] = false;
ERC20 Hex = ERC20(tokenAddress);
Hex.transferFrom(msg.sender, address(this), devLimit);
numDevDeposited++;
}
function executePremineBuy() public onlyAdmin() {
require(now < cubeStartTime);
ERC20 Hex = ERC20(tokenAddress);
// first buy in with 1 hex so that we don't black hole a bunch of stuff
Hex.transferFrom(msg.sender, address(this), 1 * HEX);
purchaseTokens(1 * HEX, address(0x0), false);
// then buy in the full amount with the amount of hex in the contract minus 1
purchaseTokens(
Hex.balanceOf(address(this)) - (1 * HEX),
address(0x0),
false
);
// now that we have a bunch of tokens, transfer them out to each ambassador fairly!
uint256 premineTokenShare = tokenSupply_ /
(numAmbassadorsDeposited + (numDevDeposited * 5));
for (uint256 i = 0; i < 33; i++) {
// if this call returns false, it means the person is NO LONGER an ambassador - which means they HAVE deposited
// which means we SHOULD give them their token share!
if (ambassadors[ambassadorList[i]] == false) {
transfer(ambassadorList[i], premineTokenShare);
}
}
for (uint256 j = 0; j < 10; j++) {
// if this call returns false, it means the person is NO LONGER an ambassador - which means they HAVE deposited
// which means we SHOULD give them their token share!
if (dev[devList[j]] == false) {
transfer(devList[j], premineTokenShare * 5);
}
}
}
function restart() public onlyAdmin() {
require(now < cubeStartTime);
// Only called if something goes wrong during premine
ERC20 Hex = ERC20(tokenAddress);
Hex.transfer(administrator, Hex.balanceOf(address(this)));
}
// username interface
UsernameInterface private username;
/*================================
= DATASETS =
================================*/
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => bool) internal approvedDistributors;
uint256 internal tokenSupply_ = 0;
uint256 internal profitPerShare_;
/*=======================================
= PUBLIC FUNCTIONS =
=======================================*/
/*
* -- APPLICATION ENTRY POINTS --
*/
constructor(address usernameAddress, uint256 when_start) public {
ambassadors[0xc951D3463EbBa4e9Ec8dDfe1f42bc5895C46eC8f] = true;
ambassadors[0xe8f49490d2b172870b3B225e9fcD39b5D68b2e9E] = true;
ambassadors[0x5161e1380cd661D7d993c8a3b3E57b059Ad8d7A4] = true;
ambassadors[0x4Ca9046dcd4C8712450250208D7eD6fCEbAf75a5] = true;
ambassadors[0xC697BE0b5b82284391A878B226e2f9AfC6B94710] = true;
ambassadors[0x5cB87df0834cd82297C63eF075421401995914ae] = true;
ambassadors[0x53F403421110BA93086BCFB40e80C7346035aDF6] = true;
ambassadors[0x11ba6C4732B1a7f30deA51C23b8ED4c1F88dCD57] = true;
ambassadors[0xb7032661C1DA18A52830A5e97bdE5569ed3c2A5F] = true;
ambassadors[0x73c371F85246797e4f7f68F7F46b9261EBa2F853] = true;
ambassadors[0xffc1eD0C150890c163D940146565df6064588d3e] = true;
ambassadors[0x5DD516f5dC0E68C5A37D20284Dabd754e35AfF1c] = true;
ambassadors[0x554fdECe1B1319075d7Bf2F5137076C21A202249] = true;
ambassadors[0xcF7b442C41795e874b223D4ADeED8cda87A23d00] = true;
ambassadors[0x87cb806192eC699398511c7aB44b3595C051D13C] = true;
ambassadors[0x1c2c72269ce1aD29933F090547b4102a9c398f34] = true;
ambassadors[0x9b411116f92504562EDCf3a1b14Ae226Bc1489Fc] = true;
ambassadors[0x2E7E5DE7D87A29B16284092B19891c80B0F43eCa] = true;
ambassadors[0xada8694dd1B511E72F467e7242E7123088aED064] = true;
ambassadors[0x5269BF8720946b5c38FBf361a947bA9D30C91313] = true;
ambassadors[0x21e0111e60D5449BdBa67ee6c014B5384644a714] = true;
ambassadors[0xB96d8107D613b6b593b4531Fc353B282af7fbeF5] = true;
ambassadors[0x71A4b5895A077806E8cd9F85a5253A9DEbd593fD] = true;
ambassadors[0x73018870D10173ae6F71Cac3047ED3b6d175F274] = true;
ambassadors[0x8E2Efa9eD16f07d9B153D295d35025FD677BaE99] = true;
ambassadors[0x112b3496AAD76CD34a29C335266A968D65fBa10a] = true;
ambassadors[0x9D7a76fD386eDEB3A871c3A096Ca875aDc1a55b7] = true;
ambassadors[0x05227e4FA98a6415ef1927E902dc781AA7eD518a] = true;
ambassadors[0x18600fE707D883c1FD16f002A09241D630270233] = true;
ambassadors[0x8ec43a855007c61Ce75406DB8b2079207F7d597a] = true;
ambassadors[0x09a054B60bd3B908791B55eEE81b515B93831E99] = true;
ambassadors[0x982D72A38A2CB0ed8F2fae5B22C122f1C9c89a13] = true;
ambassadors[0xa683C1b815997a7Fa38f6178c84675FC4c79AC2B] = true;
dev[0x818F1B08E38376E9635C5bE156B8786317e833b3] = true;
dev[0xa765a22C97c38c8Ce50FEA453cE92723C7637AA2] = true;
dev[0xEe54D208f62368B4efFe176CB548A317dcAe963F] = true;
dev[0x43678bB266e75F50Fbe5927128Ab51930b447eaB] = true;
dev[0x5138240E96360ad64010C27eB0c685A8b2eDE4F2] = true;
dev[0x39E00115d71313fD5983DE3Cf2b5820dd3Cc4447] = true;
dev[0xcFAa3449DFfB82Bf5B37e42FbCf43170c6C8e4AD] = true;
dev[0x90D20d17Cc9e07020bB490c5e34f486286d3Eeb2] = true;
dev[0x074F21a36217d7615d0202faA926aEFEBB5a9999] = true;
dev[0xAA7A7C2DECB180f68F11E975e6D92B5Dc06083A6] = true;
username = UsernameInterface(usernameAddress);
cubeStartTime = when_start;
administrator = msg.sender;
}
function startTime() public view returns (uint256 _startTime) {
_startTime = cubeStartTime;
}
function approveDistributor(address newDistributor) public onlyAdmin() {
approvedDistributors[newDistributor] = true;
}
/**
* Converts all incoming ethereum to tokens for the caller, and passes down the referral addy (if any)
*/
function buy(address _referredBy, uint256 amount) public returns (uint256) {
ERC20 Hex = ERC20(tokenAddress);
Hex.transferFrom(msg.sender, address(this), amount);
purchaseTokens(amount, _referredBy, false);
}
/**
* refuse to receive any tokens directly sent
*
*/
function() external payable {
revert();
}
function distribute(uint256 amount) external payable {
require(approvedDistributors[msg.sender] == true);
ERC20 Hex = ERC20(tokenAddress);
Hex.transferFrom(msg.sender, address(this), amount);
profitPerShare_ = SafeMath.add(
profitPerShare_,
(amount * magnitude) / tokenSupply_
);
}
/**
* Converts all of caller's dividends to tokens.
*/
function reinvest() public onlyStronghands() {
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256)(_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
purchaseTokens(_dividends, address(0x0), true);
}
/**
* Alias of sell() and withdraw().
*/
function exit() public {
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
withdraw();
}
/**
* Withdraws all of the callers earnings.
*/
function withdraw() public onlyStronghands() {
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256)(_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// lambo delivery service
ERC20 Hex = ERC20(tokenAddress);
Hex.transfer(_customerAddress, _dividends);
// fire event
emit onWithdraw(
_customerAddress,
username.getNameByAddress(msg.sender),
_dividends
);
}
/**
* Liquifies tokens to ethereum.
*/
function sell(uint256 _amountOfTokens) public onlyBagholders() {
// setup data
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(
tokenBalanceLedger_[_customerAddress],
_tokens
);
// update dividends tracker
int256 _updatedPayouts = (int256)(
profitPerShare_ * _tokens + (_taxedEthereum * magnitude)
);
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(
profitPerShare_,
(_dividends * magnitude) / tokenSupply_
);
}
// fire event
emit onTokenSell(
_customerAddress,
username.getNameByAddress(msg.sender),
_tokens,
_taxedEthereum
);
}
/**
* To heck with the transfer fee
* Who needs it
*/
function transfer(address _toAddress, uint256 _amountOfTokens)
public
onlyBagholders()
returns (bool)
{
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if (myDividends(true) > 0) withdraw();
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(
tokenBalanceLedger_[_customerAddress],
_amountOfTokens
);
tokenBalanceLedger_[_toAddress] = SafeMath.add(
tokenBalanceLedger_[_toAddress],
_amountOfTokens
);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256)(
profitPerShare_ * _amountOfTokens
);
payoutsTo_[_toAddress] += (int256)(profitPerShare_ * _amountOfTokens);
// fire event
emit Transfer(_customerAddress, _toAddress, _amountOfTokens);
// ERC20
return true;
}
/*---------- HELPERS AND CALCULATORS ----------*/
/**
* Method to view the current Ethereum stored in the contract
* Example: totalEthereumBalance()
*/
function totalEthereumBalance() public view returns (uint256) {
return address(this).balance;
}
/**
* Retrieve the total token supply.
*/
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
/**
* Retrieve the number of aambassadors deposited.
*/
function numAmbassadorsDep() public view returns (uint256) {
return numAmbassadorsDeposited;
}
/**
* Retrieve the number of developers deposited.
*/
function numDevDep() public view returns (uint256) {
return numDevDeposited;
}
/**
* Retrieve the tokens owned by the caller.
*/
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
/**
* Retrieve the dividends owned by the caller.
* If `_includeReferralBonus` is to to 1/true, the referral bonus will be included in the calculations.
* The reason for this, is that in the frontend, we will want to get the total divs (global + ref)
* But in the internal calculations, we want them separate.
*/
function myDividends(bool _includeReferralBonus)
public
view
returns (uint256)
{
address _customerAddress = msg.sender;
return
_includeReferralBonus
? dividendsOf(_customerAddress) +
referralBalance_[_customerAddress]
: dividendsOf(_customerAddress);
}
/**
* Retrieve the token balance of any single address.
*/
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
/**
* Retrieve the dividend balance of any single address.
*/
function dividendsOf(address _customerAddress)
public
view
returns (uint256)
{
return
(uint256)(
(int256)(
profitPerShare_ * tokenBalanceLedger_[_customerAddress]
) - payoutsTo_[_customerAddress]
) / magnitude;
}
/**
* Return the sell price of 1 individual token.
*/
function sellPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e8);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
/**
* Return the buy price of 1 individual token.
*/
function buyPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e8);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
/**
* Function for the frontend to dynamically retrieve the price scaling of buy orders.
*/
function calculateTokensReceived(uint256 _ethereumToSpend)
public
view
returns (uint256)
{
uint256 _dividends = SafeMath.div(_ethereumToSpend, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
/**
* Function for the frontend to dynamically retrieve the price scaling of sell orders.
*/
function calculateEthereumReceived(uint256 _tokensToSell)
public
view
returns (uint256)
{
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
/*==========================================
= INTERNAL FUNCTIONS =
==========================================*/
function purchaseTokens(
uint256 _incomingEthereum,
address _referredBy,
bool isReinvest
) internal returns (uint256) {
if (now < startTime()) {
require(msg.sender == administrator);
}
// data setup
uint256 _undividedDividends = SafeMath.div(
_incomingEthereum,
dividendFee_
);
uint256 _referralBonus = SafeMath.div(_undividedDividends, 3);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(
_incomingEthereum,
_undividedDividends
);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(
_amountOfTokens > 0 &&
(SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_)
);
// is the user referred by a masternode?
if (
// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != msg.sender
) {
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(
referralBalance_[_referredBy],
_referralBonus
);
} else {
// no ref purchase
// add the referral bonus back to the global dividends
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
// we can't give people infinite ethereum
if (tokenSupply_ > 0) {
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
// take the amount of dividends gained through this transaction, and allocates them evenly to each shareholder
profitPerShare_ += ((_dividends * magnitude) / (tokenSupply_));
// calculate the amount of tokens the customer receives over his purchase
_fee =
_fee -
(_fee -
(_amountOfTokens *
((_dividends * magnitude) / (tokenSupply_))));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[msg.sender] = SafeMath.add(
tokenBalanceLedger_[msg.sender],
_amountOfTokens
);
// Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them;
//really i know you think you do but you don't
int256 _updatedPayouts = (int256)(
(profitPerShare_ * _amountOfTokens) - _fee
);
payoutsTo_[msg.sender] += _updatedPayouts;
// fire event
emit onTokenPurchase(
msg.sender,
username.getNameByAddress(msg.sender),
_incomingEthereum,
_amountOfTokens,
_referredBy,
isReinvest
);
return _amountOfTokens;
}
/**
* Calculate Token price based on an amount of incoming ethereum
* It's an algorithm, hopefully we gave you the whitepaper with it in scientific notation;
* Some conversions occurred to prevent decimal errors or underflows / overflows in solidity code.
*/
function ethereumToTokens_(uint256 _ethereum)
internal
view
returns (uint256)
{
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e8;
uint256 _tokensReceived = ((
SafeMath.sub(
(
sqrt(
(_tokenPriceInitial**2) +
(2 *
(tokenPriceIncremental_ * 1e8) *
(_ethereum * 1e8)) +
(((tokenPriceIncremental_)**2) *
(tokenSupply_**2)) +
(2 *
(tokenPriceIncremental_) *
_tokenPriceInitial *
tokenSupply_)
)
),
_tokenPriceInitial
)
) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
/**
* Calculate token sell value.
* It's an algorithm, hopefully we gave you the whitepaper with it in scientific notation;
* Some conversions occurred to prevent decimal errors or underflows / overflows in solidity code.
*/
function tokensToEthereum_(uint256 _tokens)
internal
view
returns (uint256)
{
uint256 tokens_ = (_tokens + 1e8);
uint256 _tokenSupply = (tokenSupply_ + 1e8);
uint256 _etherReceived = (SafeMath.sub(
(((tokenPriceInitial_ +
(tokenPriceIncremental_ * (_tokenSupply / 1e8))) -
tokenPriceIncremental_) * (tokens_ - 1e8)),
(tokenPriceIncremental_ * ((tokens_**2 - tokens_) / 1e8)) / 2
) / 1e8);
return _etherReceived;
}
//This is where all your gas goes apparently
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
interface UsernameInterface {
function getNameByAddress(address _addr) external view returns (bytes32);
}
/**
* @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) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
/**
* @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) {
require(b <= a);
return a - b;
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
Raw
IERC165.sol
pragma solidity ^0.6.0;
/**
* @dev Interface of the ERC165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[EIP].
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ERC165Checker}).
*
* For an implementation, see {ERC165}.
*/
interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
Raw
IERC20.sol
pragma solidity ^0.6.1;
interface ERC20TokenInterface {
function totalSupply() external view returns (uint);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint);
function balanceOf(address tokenOwner) external view returns (uint256);
function allowance(address tokenOwner, address spender) external view returns (uint remaining);
function transfer(address to, uint tokens) external returns (bool success);
function approve(address spender, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) external returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
Raw
IERC721.sol
pragma solidity ^0.6.2;
import "./IERC165.sol";
/**
* @dev Required interface of an ERC721 compliant contract.
*/
interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transfered from `from` to `to`.
*/
event Transfer(
address indexed from,
address indexed to,
uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
event Approval(
address indexed owner,
address indexed approved,
uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
*/
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/**
* @dev Returns the number of tokens in ``owner``'s account.
*/
function balanceOf(address owner) external view returns (uint256 balance);
/**
* @dev Returns the owner of the `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function ownerOf(uint256 tokenId) external view returns (address owner);
/**
* @dev Transfers `tokenId` token from `from` to `to`.
*
* WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
*
* Requirements:
*
* - `from`, `to` cannot be zero.
* - `tokenId` token must be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
*
* Emits a {Transfer} event.
*/
function transferFrom(address from, address to, uint256 tokenId) external;
/**
* @dev Gives permission to `to` to transfer `tokenId` token to another account.
* The approval is cleared when the token is transferred.
*
* Only a single account can be approved at a time, so approving the zero address clears previous approvals.
*
* Requirements:
*
* - The caller must own the token or be an approved operator.
* - `tokenId` must exist.
*
* Emits an {Approval} event.
*/
function approve(address to, uint256 tokenId) external;
/**
* @dev Returns the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function getApproved(uint256 tokenId) external view returns (address operator);
/**
* @dev Approve or remove `operator` as an operator for the caller.
* Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
*
* Requirements:
*
* - The `operator` cannot be the caller.
*
* Emits an {ApprovalForAll} event.
*/
function setApprovalForAll(address operator, bool _approved) external;
/**
* @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
*
* See {setApprovalForAll}
*/
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
Raw
million_money.sol
pragma solidity 0.5.11;
contract MillionMoney {
address public ownerWallet;
// MillionMoney public oldSC = MillionMoney(0x4Dcf60F0cb42c22Df36994CCBebd0b281C57003A);
// uint oldSCUserId = 1;
struct UserStruct {
bool isExist;
uint id;
uint referrerID;
address[] referral_M1;
address[] referral_M1;
mapping(uint => uint) levelExpired;
}
uint REFERRER_1_LEVEL_LIMIT = 2;
uint PERIOD_LENGTH = 100 days;
mapping(uint => uint) public LEVEL_PRICE;
mapping (address => UserStruct) public users;
mapping (uint => address) public userList;
uint public currUserID = 0;
event regLevelEvent(address indexed _user, address indexed _referrer, uint _time);
event buyLevelEvent(address indexed _user, uint _level, uint _time);
event prolongateLevelEvent(address indexed _user, uint _level, uint _time);
event getMoneyForLevelEvent(address indexed _user, address indexed _referral, uint _level, uint _time);
event lostMoneyForLevelEvent(address indexed _user, address indexed _referral, uint _level, uint _time);
constructor() public {
ownerWallet = msg.sender;
LEVEL_PRICE[1] = 0.03 ether;
LEVEL_PRICE[2] = 0.05 ether;
LEVEL_PRICE[3] = 0.1 ether;
LEVEL_PRICE[4] = 0.4 ether;
LEVEL_PRICE[5] = 1 ether;
LEVEL_PRICE[6] = 2.5 ether;
LEVEL_PRICE[7] = 5 ether;
LEVEL_PRICE[8] = 10 ether;
LEVEL_PRICE[9] = 20 ether;
LEVEL_PRICE[10] = 40 ether;
UserStruct memory userStruct;
currUserID++;
userStruct = UserStruct({
isExist: true,
id: currUserID,
referrerID: 0,
referral: new address[](0)
});
users[ownerWallet] = userStruct;
userList[currUserID] = ownerWallet;
for(uint i = 1; i <= 10; i++) {
users[ownerWallet].levelExpired[i] = 55555555555;
}
}
function () external payable {
uint level;
if(msg.value == LEVEL_PRICE[1]) level = 1;
else if(msg.value == LEVEL_PRICE[2]) level = 2;
else if(msg.value == LEVEL_PRICE[3]) level = 3;
else if(msg.value == LEVEL_PRICE[4]) level = 4;
else if(msg.value == LEVEL_PRICE[5]) level = 5;
else if(msg.value == LEVEL_PRICE[6]) level = 6;
else if(msg.value == LEVEL_PRICE[7]) level = 7;
else if(msg.value == LEVEL_PRICE[8]) level = 8;
else if(msg.value == LEVEL_PRICE[9]) level = 9;
else if(msg.value == LEVEL_PRICE[10]) level = 10;
else revert('Incorrect Value send');
if(users[msg.sender].isExist) buyLevel(level);
else if(level == 1) {
uint refId = 0;
address referrer = bytesToAddress(msg.data);
if(users[referrer].isExist) refId = users[referrer].id;
else revert('Incorrect referrer');
regUser(refId);
}
else revert('Please buy first level for 0.03 ETH');
}
function regUser(uint _referrerID) public payable {
require(address(oldSC) == address(0), 'Initialize not finished');
require(!users[msg.sender].isExist, 'User exist');
require(_referrerID > 0 && _referrerID <= currUserID, 'Incorrect referrer Id');
require(msg.value == LEVEL_PRICE[1], 'Incorrect Value');
if(users[userList[_referrerID]].referral.length >= REFERRER_1_LEVEL_LIMIT) _referrerID = users[findFreeReferrer(userList[_referrerID])].id;
UserStruct memory userStruct;
currUserID++;
userStruct = UserStruct({
isExist: true,
id: currUserID,
referrerID: _referrerID,
referral: new address[](0)
});
users[msg.sender] = userStruct;
userList[currUserID] = msg.sender;
users[msg.sender].levelExpired[1] = now + PERIOD_LENGTH;
users[userList[_referrerID]].referral.push(msg.sender);
payForLevel(1, msg.sender);
emit regLevelEvent(msg.sender, userList[_referrerID], now);
}
function buyLevel(uint _level) public payable {
require(users[msg.sender].isExist, 'User not exist');
require(_level > 0 && _level <= 10, 'Incorrect level');
if(_level == 1) {
require(msg.value == LEVEL_PRICE[1], 'Incorrect Value');
users[msg.sender].levelExpired[1] += PERIOD_LENGTH;
}
else {
require(msg.value == LEVEL_PRICE[_level], 'Incorrect Value');
for(uint l =_level - 1; l > 0; l--) require(users[msg.sender].levelExpired[l] >= now, 'Buy the previous level');
if(users[msg.sender].levelExpired[_level] == 0) users[msg.sender].levelExpired[_level] = now + PERIOD_LENGTH;
else users[msg.sender].levelExpired[_level] += PERIOD_LENGTH;
}
payForLevel(_level, msg.sender);
emit buyLevelEvent(msg.sender, _level, now);
}
function syncWithOldSC(uint limit) public {
require(address(oldSC) != address(0), 'Initialize closed');
require(msg.sender == ownerWallet, 'Access denied');
for(uint i = 0; i < limit; i++) {
address user = oldSC.userList(oldSCUserId);
(bool isExist,, uint referrerID) = oldSC.users(user);
if(isExist) {
oldSCUserId++;
address ref = oldSC.userList(referrerID);
if(!users[user].isExist && users[ref].isExist) {
users[user].isExist = true;
users[user].id = ++currUserID;
users[user].referrerID = users[ref].id;
userList[currUserID] = user;
users[ref].referral.push(user);
for(uint j = 1; j <= 8; j++) {
users[user].levelExpired[j] = oldSC.viewUserLevelExpired(user, j);
}
emit regLevelEvent(user, ref, block.timestamp);
}
}
else break;
}
}
function syncClose() external {
require(address(oldSC) != address(0), 'Initialize already closed');
require(msg.sender == ownerWallet, 'Access denied');
oldSC = MillionMoney(0);
}
function payForLevel(uint _level, address _user) internal {
address referer;
address referer1;
address referer2;
address referer3;
address referer4;
if(_level == 1 || _level == 6) {
referer = userList[users[_user].referrerID];
}
else if(_level == 2 || _level == 7) {
referer1 = userList[users[_user].referrerID];
referer = userList[users[referer1].referrerID];
}
else if(_level == 3 || _level == 8) {
referer1 = userList[users[_user].referrerID];
referer2 = userList[users[referer1].referrerID];
referer = userList[users[referer2].referrerID];
}
else if(_level == 4 || _level == 9) {
referer1 = userList[users[_user].referrerID];
referer2 = userList[users[referer1].referrerID];
referer3 = userList[users[referer2].referrerID];
referer = userList[users[referer3].referrerID];
}
else if(_level == 5 || _level == 10) {
referer1 = userList[users[_user].referrerID];
referer2 = userList[users[referer1].referrerID];
referer3 = userList[users[referer2].referrerID];
referer4 = userList[users[referer3].referrerID];
referer = userList[users[referer4].referrerID];
}
if(!users[referer].isExist) referer = userList[1];
bool sent = false;
if(users[referer].levelExpired[_level] >= now) {
sent = address(uint160(referer)).send(LEVEL_PRICE[_level]);
if (sent) {
emit getMoneyForLevelEvent(referer, msg.sender, _level, now);
}
}
if(!sent) {
emit lostMoneyForLevelEvent(referer, msg.sender, _level, now);
payForLevel(_level, referer);
}
}
function findFreeReferrer(address _user) public view returns(address) {
if(users[_user].referral.length < REFERRER_1_LEVEL_LIMIT) return _user;
address[] memory referrals = new address[](126);
referrals[0] = users[_user].referral[0];
referrals[1] = users[_user].referral[1];
address freeReferrer;
bool noFreeReferrer = true;
for(uint i = 0; i < 126; i++) {
if(users[referrals[i]].referral.length == REFERRER_1_LEVEL_LIMIT) {
if(i < 62) {
referrals[(i+1)*2] = users[referrals[i]].referral[0];
referrals[(i+1)*2+1] = users[referrals[i]].referral[1];
}
}
else {
noFreeReferrer = false;
freeReferrer = referrals[i];
break;
}
}
require(!noFreeReferrer, 'No Free Referrer');
return freeReferrer;
}
function viewUserReferral(address _user) public view returns(address[] memory) {
return users[_user].referral;
}
function viewUserLevelExpired(address _user, uint _level) public view returns(uint) {
return users[_user].levelExpired[_level];
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
Raw
million_money_1.sol
pragma solidity 0.5.11;
contract MillionMoney {
address public ownerWallet;
// MillionMoney public oldSC = MillionMoney(0x4Dcf60F0cb42c22Df36994CCBebd0b281C57003A);
// uint oldSCUserId = 1;
struct UserStruct {
bool isExist;
uint id;
uint referrerID;
address[] referral;
mapping(uint => uint) levelExpired;
}
uint REFERRER_1_LEVEL_LIMIT = 2;
uint PERIOD_LENGTH = 100 days;
mapping(uint => uint) public LEVEL_PRICE;
mapping (address => UserStruct) public users;
mapping (uint => address) public userList;
uint public currUserID = 0;
event regLevelEvent(address indexed _user, address indexed _referrer, uint _time);
event buyLevelEvent(address indexed _user, uint _level, uint _time);
event prolongateLevelEvent(address indexed _user, uint _level, uint _time);
event getMoneyForLevelEvent(address indexed _user, address indexed _referral, uint _level, uint _time);
event lostMoneyForLevelEvent(address indexed _user, address indexed _referral, uint _level, uint _time);
event for_testing(string);
constructor() public {
ownerWallet = msg.sender;
LEVEL_PRICE[1] = 0.03 ether;
LEVEL_PRICE[2] = 0.05 ether;
LEVEL_PRICE[3] = 0.1 ether;
LEVEL_PRICE[4] = 0.4 ether;
LEVEL_PRICE[5] = 1 ether;
LEVEL_PRICE[6] = 2.5 ether;
LEVEL_PRICE[7] = 5 ether;
LEVEL_PRICE[8] = 10 ether;
LEVEL_PRICE[9] = 20 ether;
LEVEL_PRICE[10] = 40 ether;
UserStruct memory userStruct;
currUserID++;
userStruct = UserStruct({
isExist: true,
id: currUserID,
referrerID: 0,
referral: new address[](0)
});
users[ownerWallet] = userStruct;
userList[currUserID] = ownerWallet;
for(uint i = 1; i <= 10; i++) {
users[ownerWallet].levelExpired[i] = 55555555555;
}
}
function () external payable {
uint level;
if(msg.value == LEVEL_PRICE[1]) level = 1;
else if(msg.value == LEVEL_PRICE[2]) level = 2;
else if(msg.value == LEVEL_PRICE[3]) level = 3;
else if(msg.value == LEVEL_PRICE[4]) level = 4;
else if(msg.value == LEVEL_PRICE[5]) level = 5;
else if(msg.value == LEVEL_PRICE[6]) level = 6;
else if(msg.value == LEVEL_PRICE[7]) level = 7;
else if(msg.value == LEVEL_PRICE[8]) level = 8;
else if(msg.value == LEVEL_PRICE[9]) level = 9;
else if(msg.value == LEVEL_PRICE[10]) level = 10;
else revert('Incorrect Value send');
if(users[msg.sender].isExist) buyLevel(level);
else if(level == 1) {
uint refId = 0;
address referrer = bytesToAddress(msg.data);
if(users[referrer].isExist) refId = users[referrer].id;
else revert('Incorrect referrer');
regUser(refId);
}
else revert('Please buy first level for 0.03 ETH');
}
function regUser(uint _referrerID) public payable {
// require(address(oldSC) == address(0), 'Initialize not finished');
require(!users[msg.sender].isExist, 'User exist');
require(_referrerID > 0 && _referrerID <= currUserID, 'Incorrect referrer Id');
require(msg.value == LEVEL_PRICE[1], 'Incorrect Value');
if(users[userList[_referrerID]].referral.length >= REFERRER_1_LEVEL_LIMIT) _referrerID = users[findFreeReferrer(userList[_referrerID])].id;
UserStruct memory userStruct;
currUserID++;
userStruct = UserStruct({
isExist: true,
id: currUserID,
referrerID: _referrerID,
referral: new address[](0)
});
users[msg.sender] = userStruct;
userList[currUserID] = msg.sender;
users[msg.sender].levelExpired[1] = now + PERIOD_LENGTH;
users[userList[_referrerID]].referral.push(msg.sender);
payForLevel(1, msg.sender);
emit regLevelEvent(msg.sender, userList[_referrerID], now);
}
function buyLevel(uint _level) public payable {
require(users[msg.sender].isExist, 'User not exist');
require(_level > 0 && _level <= 10, 'Incorrect level');
if(_level == 1) {
require(msg.value == LEVEL_PRICE[1], 'Incorrect Value');
users[msg.sender].levelExpired[1] += PERIOD_LENGTH;
}
else {
require(msg.value == LEVEL_PRICE[_level], 'Incorrect Value');
for(uint l =_level - 1; l > 0; l--) require(users[msg.sender].levelExpired[l] >= now, 'Buy the previous level');
if(users[msg.sender].levelExpired[_level] == 0) users[msg.sender].levelExpired[_level] = now + PERIOD_LENGTH;
else users[msg.sender].levelExpired[_level] += PERIOD_LENGTH;
}
payForLevel(_level, msg.sender);
emit buyLevelEvent(msg.sender, _level, now);
}
// function syncWithOldSC(uint limit) public {
// require(address(oldSC) != address(0), 'Initialize closed');
// require(msg.sender == ownerWallet, 'Access denied');
// for(uint i = 0; i < limit; i++) {
// address user = oldSC.userList(oldSCUserId);
// (bool isExist,, uint referrerID) = oldSC.users(user);
// if(isExist) {
// oldSCUserId++;
// address ref = oldSC.userList(referrerID);
// if(!users[user].isExist && users[ref].isExist) {
// users[user].isExist = true;
// users[user].id = ++currUserID;
// users[user].referrerID = users[ref].id;
// userList[currUserID] = user;
// users[ref].referral.push(user);
// for(uint j = 1; j <= 8; j++) {
// users[user].levelExpired[j] = oldSC.viewUserLevelExpired(user, j);
// }
// emit regLevelEvent(user, ref, block.timestamp);
// }
// }
// else break;
// }
// }
// function syncClose() external {
// require(address(oldSC) != address(0), 'Initialize already closed');
// require(msg.sender == ownerWallet, 'Access denied');
// oldSC = MillionMoney(0);
// }
function payForLevel(uint _level, address _user) internal {
address referer;
address referer1;
// address referer2;
// address referer3;
// address referer4;
if(_level == 1 || _level == 3){
referer = userList[users[_user].referrerID];
emit for_testing("level 1 & 3");
}
if(_level == 2 || _level == 4){
referer1 = userList[users[_user].referrerID];
referer = userList[users[referer1].referrerID];
emit for_testing("level 2 & 4");
}
// if(_level == 1 || _level == 6) {
// referer = userList[users[_user].referrerID];
// }
// else if(_level == 2 || _level == 7) {
// referer1 = userList[users[_user].referrerID];
// referer = userList[users[referer1].referrerID];
// }
// else if(_level == 3 || _level == 8) {
// referer1 = userList[users[_user].referrerID];
// referer2 = userList[users[referer1].referrerID];
// referer = userList[users[referer2].referrerID];
// }
// else if(_level == 4 || _level == 9) {
// referer1 = userList[users[_user].referrerID];
// referer2 = userList[users[referer1].referrerID];
// referer3 = userList[users[referer2].referrerID];
// referer = userList[users[referer3].referrerID];
// }
// else if(_level == 5 || _level == 10) {
// referer1 = userList[users[_user].referrerID];
// referer2 = userList[users[referer1].referrerID];
// referer3 = userList[users[referer2].referrerID];
// referer4 = userList[users[referer3].referrerID];
// referer = userList[users[referer4].referrerID];
// }
if(!users[referer].isExist) referer = userList[1];
bool sent = false;
if(users[referer].levelExpired[_level] >= now) {
sent = address(uint160(referer)).send(LEVEL_PRICE[_level]);
if (sent) {
emit getMoneyForLevelEvent(referer, msg.sender, _level, now);
}
}
if(!sent) {
emit lostMoneyForLevelEvent(referer, msg.sender, _level, now);
payForLevel(_level, referer);
}
}
function findFreeReferrer(address _user) public view returns(address) {
if(users[_user].referral.length < REFERRER_1_LEVEL_LIMIT) return _user;
address[] memory referrals = new address[](126);
referrals[0] = users[_user].referral[0];
referrals[1] = users[_user].referral[1];
address freeReferrer;
bool noFreeReferrer = true;
for(uint i = 0; i < 126; i++) {
if(users[referrals[i]].referral.length == REFERRER_1_LEVEL_LIMIT) {
if(i < 62) {
referrals[(i+1)*2] = users[referrals[i]].referral[0];
referrals[(i+1)*2+1] = users[referrals[i]].referral[1];
}
}
else {
noFreeReferrer = false;
freeReferrer = referrals[i];
break;
}
}
require(!noFreeReferrer, 'No Free Referrer');
return freeReferrer;
}
function viewUserReferral(address _user) public view returns(address[] memory) {
return users[_user].referral;
}
function viewUserLevelExpired(address _user, uint _level) public view returns(uint) {
return users[_user].levelExpired[_level];
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
Raw
mlm_auto_pool.sol
/**
*Submitted for verification at Etherscan.io on 2020-03-31
*/
pragma solidity 0.5.11;
contract BullRun {
address public ownerWallet;
uint public currUserID = 0;
uint public pool1currUserID = 0;
uint public pool2currUserID = 0;
uint public pool3currUserID = 0;
uint public pool1activeUserID = 0;
uint public pool2activeUserID = 0;
uint public pool3activeUserID = 0;
uint public unlimited_level_price=0;
struct UserStruct {
bool isExist;
uint id;
uint referrerID;
uint referredUsers;
mapping(uint => uint) levelExpired;
}
struct PoolUserStruct {
bool isExist;
uint id;
uint payment_received;
}
mapping (address => UserStruct) public users;
mapping (uint => address) public userList;
mapping (address => PoolUserStruct) public pool1users;
mapping (uint => address) public pool1userList;
mapping (address => PoolUserStruct) public pool2users;
mapping (uint => address) public pool2userList;
mapping (address => PoolUserStruct) public pool3users;
mapping (uint => address) public pool3userList;
mapping(uint => uint) public LEVEL_PRICE;
uint REGESTRATION_FESS=0.05 ether;
uint pool1_price=0.1 ether;
uint pool2_price=0.2 ether ;
uint pool3_price=0.5 ether;
event regLevelEvent(address indexed _user, address indexed _referrer, uint _time);
event getMoneyForLevelEvent(address indexed _user, address indexed _referral, uint _level, uint _time);
event getMoneyForPoolLevelEvent(address indexed _user,address indexed _referral,uint _level, uint _time);
event regPoolEntry(address indexed _user,uint _level, uint _time);
event getPoolPayment(address indexed _user,address indexed _receiver, uint _level, uint _time);
UserStruct[] public requests;
constructor() public {
ownerWallet = msg.sender;
LEVEL_PRICE[1] = 0.01 ether;
LEVEL_PRICE[2] = 0.005 ether;
LEVEL_PRICE[3] = 0.0025 ether;
LEVEL_PRICE[4] = 0.00025 ether;
unlimited_level_price=0.00025 ether;
UserStruct memory userStruct;
currUserID++;
userStruct = UserStruct({
isExist: true,
id: currUserID,
referrerID: 0,
referredUsers:0
});
users[ownerWallet] = userStruct;
userList[currUserID] = ownerWallet;
PoolUserStruct memory pooluserStruct;
pool1currUserID++;
pooluserStruct = PoolUserStruct({
isExist:true,
id:pool1currUserID,
payment_received:0
});
pool1activeUserID=pool1currUserID;
pool1users[msg.sender] = pooluserStruct;
pool1userList[pool1currUserID]=msg.sender;
pool2currUserID++;
pooluserStruct = PoolUserStruct({
isExist:true,
id:pool2currUserID,
payment_received:0
});
pool2activeUserID=pool2currUserID;
pool2users[msg.sender] = pooluserStruct;
pool2userList[pool2currUserID]=msg.sender;
pool3currUserID++;
pooluserStruct = PoolUserStruct({
isExist:true,
id:pool3currUserID,
payment_received:0
});
pool3activeUserID=pool3currUserID;
pool3users[msg.sender] = pooluserStruct;
pool3userList[pool3currUserID]=msg.sender;
}
function regUser(uint _referrerID) public payable {
require(!users[msg.sender].isExist, "User Exists");
require(_referrerID > 0 && _referrerID <= currUserID, 'Incorrect referral ID');
require(msg.value == REGESTRATION_FESS, 'Incorrect Value');
UserStruct memory userStruct;
currUserID++;
userStruct = UserStruct({
isExist: true,
id: currUserID,
referrerID: _referrerID,
referredUsers:0
});
users[msg.sender] = userStruct;
userList[currUserID]=msg.sender;
users[userList[users[msg.sender].referrerID]].referredUsers=users[userList[users[msg.sender].referrerID]].referredUsers+1;
payReferral(1,msg.sender);
emit regLevelEvent(msg.sender, userList[_referrerID], now);
}
function payReferral(uint _level, address _user) internal {
address referer;
referer = userList[users[_user].referrerID];
bool sent = false;
uint level_price_local=0;
if(_level>4){
level_price_local=unlimited_level_price;
}
else{
level_price_local=LEVEL_PRICE[_level];
}
sent = address(uint160(referer)).send(level_price_local);
if (sent) {
emit getMoneyForLevelEvent(referer, msg.sender, _level, now);
if(_level < 100 && users[referer].referrerID >= 1){
payReferral(_level+1,referer);
}
}
if(!sent) {
// emit lostMoneyForLevelEvent(referer, msg.sender, _level, now);
payReferral(_level, referer);
}
}
function buyPool1() public payable {
require(users[msg.sender].isExist, "User Not Registered");
require(!pool1users[msg.sender].isExist, "Already in AutoPool");
require(msg.value == pool1_price, 'Incorrect Value');
PoolUserStruct memory userStruct;
address pool1Currentuser=pool1userList[pool1activeUserID];
pool1currUserID++;
userStruct = PoolUserStruct({
isExist:true,
id:pool1currUserID,
payment_received:0
});
pool1users[msg.sender] = userStruct;
pool1userList[pool1currUserID]=msg.sender;
bool sent = false;
//for refrrea;l
address referer = userList[users[msg.sender].referrerID];
uint for_ref = pool1_price*10;
uint price_for_ref = for_ref*100;
address(uint160(referer)).send(price_for_ref);
uint temp = pool1_price*10;
uint temp_pool1_price = temp/100;
for(uint i=1; i<=8; i++){
address addr = pool1userList[i];
if(addr == msg.sender){break;}
address(uint160(addr)).send(temp_pool1_price);
emit getMoneyForPoolLevelEvent(msg.sender,addr, 1, now);
}
uint for_owner = pool1_price*10;
uint price_for_owner = for_owner/100;
sent = address(uint160(ownerWallet)).send(price_for_owner);
if (sent) {
pool1users[pool1Currentuser].payment_received+=1;
if(pool1users[pool1Currentuser].payment_received>=2)
{
pool1activeUserID+=1;
}
emit getPoolPayment(msg.sender,pool1Currentuser, 1, now);
}
emit regPoolEntry(msg.sender, 1, now);
}
function buyPool2() public payable {
require(users[msg.sender].isExist, "User Not Registered");
require(!pool2users[msg.sender].isExist, "Already in AutoPool");
require(msg.value == pool2_price, 'Incorrect Value');
require(users[msg.sender].referredUsers>=1, "Must need 1 referral");
PoolUserStruct memory userStruct;
address pool2Currentuser=pool2userList[pool2activeUserID];
pool2currUserID++;
userStruct = PoolUserStruct({
isExist:true,
id:pool2currUserID,
payment_received:0
});
pool2users[msg.sender] = userStruct;
pool2userList[pool2currUserID]=msg.sender;
bool sent = false;
//for refrreal
address referer = userList[users[msg.sender].referrerID];
uint for_ref = pool2_price*10;
uint price_for_ref = for_ref*100;
address(uint160(referer)).send(price_for_ref);
//for upline
uint temp = pool2_price*10;
uint temp_pool2_price = temp/100;
for(uint i=1; i<=8; i++){
address addr = pool2userList[i];
if(addr == msg.sender){break;}
address(uint160(addr)).send(temp_pool2_price);
emit getMoneyForPoolLevelEvent(msg.sender,addr, 2, now);
}
//for owner
uint for_owner = pool2_price*10;
uint price_for_owner = for_owner/100;
sent = address(uint160(ownerWallet)).send(price_for_owner);
if (sent) {
pool2users[pool2Currentuser].payment_received+=1;
if(pool2users[pool2Currentuser].payment_received>=3)
{
pool2activeUserID+=1;
}
emit getPoolPayment(msg.sender,pool2Currentuser, 2, now);
}
emit regPoolEntry(msg.sender,2, now);
}
function buyPool3() public payable {
require(users[msg.sender].isExist, "User Not Registered");
require(!pool3users[msg.sender].isExist, "Already in AutoPool");
require(msg.value == pool3_price, 'Incorrect Value');
require(users[msg.sender].referredUsers>=2, "Must need 2 referral");
PoolUserStruct memory userStruct;
address pool3Currentuser=pool3userList[pool3activeUserID];
pool3currUserID++;
userStruct = PoolUserStruct({
isExist:true,
id:pool3currUserID,
payment_received:0
});
pool3users[msg.sender] = userStruct;
pool3userList[pool3currUserID]=msg.sender;
bool sent = false;
//for refrreal
address referer = userList[users[msg.sender].referrerID];
uint for_ref = pool3_price*10;
uint price_for_ref = for_ref*100;
address(uint160(referer)).send(price_for_ref);
//for upline
uint temp = pool3_price*10;
uint temp_pool3_price = temp/100;
for(uint i=1; i<=8; i++){
address addr = pool3userList[i];
if(addr == msg.sender){break;}
address(uint160(addr)).send(temp_pool3_price);
emit getMoneyForPoolLevelEvent(msg.sender,addr, 3, now);
}
//for owner
uint for_owner = pool3_price*10;
uint price_for_owner = for_owner/100;
sent = address(uint160(ownerWallet)).send(price_for_owner);
if (sent) {
pool3users[pool3Currentuser].payment_received+=1;
if(pool3users[pool3Currentuser].payment_received>=3)
{
pool3activeUserID+=1;
}
emit getPoolPayment(msg.sender,pool3Currentuser, 3, now);
}
emit regPoolEntry(msg.sender,3, now);
}
function getEthBalance() public view returns(uint) {
return address(this).balance;
}
// function sendBalance() public {
// // if (!address(uint160(ownerWallet)).send(getEthBalance()))
// // {
// // }
// }
}
Raw
mmmbe.sol
pragma solidity ^0.5.16;
import "./SafeMath.sol";
import "./token.sol";
contract MMMEBSCcontract {
constructor(address paxtoken) public{
token = PAXImplementation(paxtoken);
deployTime = now;
tokenAdd = paxtoken;
mAd = msg.sender;
sAd = msg.sender;
veAm = 1000000000000000;
}
insurancesub public insurance;
using SafeMath for uint256;
PAXImplementation token;
address public tokenAdd;
address public mAd;
address public sAd;
address public lastContractAddress;
address _contractaddress;
address _phcontractaddress;
address public insuranceAdd;
uint256 public deployTime;
uint256 public totalInsuranceSubContract;
uint256 public totalPhSubContract;
uint256 public veAm;
Contracts[] public contractDatabase;
PHcontracts[] public phcontractDatabase;
GHamounts[] public ghamountDatabase;
address[] public contracts;
address[] public phcontracts;
mapping (string => address) public orderIDdetail;
mapping (address => uint256) public getInsPosition;
mapping (address => uint256) public getPhPosition;
mapping (address => uint256) public balances;
mapping (string => uint256) public ghOrderID;
struct Contracts {
string orderid;
address contractadd;
uint256 totalamount;
address registeredUserAdd;
}
struct PHcontracts {
string phorderid;
address phcontractadd;
uint256 phtotalamount;
address phregisteredUserAdd;
}
struct GHamounts {
string ghorderid;
uint256 ghtotalamount;
address ghregisteredUserAdd;
}
event ContractGenerated (
uint256 _ID,
string indexed _orderid,
address _contractadd,
uint256 _totalamount,
address _userAddress
);
event PhContractGenerated (
uint256 _phID,
string indexed _phorderid,
address _phcontractadd,
uint256 _phtotalamount,
address registeredUserAdd
);
event GhGenerated (
uint256 _ghID,
string indexed _ghorderid,
uint256 _ghtotalamount,
address _ghuserAddress
);
event InsuranceFundUpdate(
address indexed user,
uint256 insuranceAmount
);
event FundsTransfered(
string indexed AmountType,
uint256 Amount
);
modifier onSad() {
require(msg.sender == sAd, "only sAd");
_;
}
modifier onMan() {
require(msg.sender == mAd || msg.sender == sAd, "only mAn");
_;
}
function adMan(address _manAd) public onSad {
mAd = _manAd;
}
function remMan() public onSad {
mAd = sAd;
}
function addInsuranceContract(address _insuranceContractAdd) public onSad{
insuranceAdd = _insuranceContractAdd;
}
function () external payable {
balances[msg.sender] += msg.value;
}
function feeC() public view returns (uint256) {
return address(this).balance;
}
function witE() public onMan{
msg.sender.transfer(address(this).balance);
emit FundsTransfered("eth", address(this).balance);
}
function tokC() public view returns (uint256){
return token.balanceOf(address(this));
}
function gethelp(address userAddress, uint256 tokens, string memory OrderID) public onMan {
require(token.balanceOf(address(this)) >= tokens);
token.transfer(userAddress, tokens);
ghamountDatabase.push(GHamounts({
ghorderid: OrderID,
ghtotalamount : tokens,
ghregisteredUserAdd : userAddress
}));
ghOrderID[OrderID] = ghamountDatabase.length - 1;
emit FundsTransfered("Send GH", tokens);
}
function generateInsuranceOrder(uint256 amount, string memory OrderID, address userAddress)
public onMan
payable
returns(address newContract)
{
insurancesub c = (new insurancesub).value(msg.value)(OrderID, tokenAdd, amount, mAd, insuranceAdd,userAddress);
_contractaddress = address(c);
orderIDdetail[OrderID] = _contractaddress;
contractDatabase.push(Contracts({
orderid: OrderID,
contractadd: _contractaddress,
totalamount : amount,
registeredUserAdd : userAddress
}));
getInsPosition[_contractaddress] = contractDatabase.length - 1;
totalInsuranceSubContract = contractDatabase.length;
contracts.push(address(c));
lastContractAddress = address(c);
emit ContractGenerated (
contractDatabase.length - 1,
OrderID,
address(c),
amount,
userAddress
);
return address(c);
}
function generatePHorder(uint256 amount, string memory OrderID, address userAddress)
public onMan
payable
returns(address newContract)
{
phsubcontract p = (new phsubcontract).value(msg.value)(OrderID, tokenAdd, amount, mAd, address(this) ,userAddress);
_phcontractaddress = address(p);
orderIDdetail[OrderID] = _phcontractaddress;
phcontractDatabase.push(PHcontracts({
phorderid: OrderID,
phcontractadd: _phcontractaddress,
phtotalamount : amount,
phregisteredUserAdd : userAddress
}));
getPhPosition[_phcontractaddress] = phcontractDatabase.length - 1;
totalPhSubContract = phcontractDatabase.length;
phcontracts.push(address(p));
lastContractAddress = address(p);
emit PhContractGenerated (
phcontractDatabase.length - 1,
OrderID,
_phcontractaddress,
amount,
userAddress
);
return address(p);
}
function getInsContractCount()
public
view
returns(uint InsContractCount)
{
return contracts.length;
}
function getPhContractCount()
public
view
returns(uint phContractCount)
{
return phcontracts.length;
}
function upVerAm(uint256 _nAm) public onSad{
veAm = _nAm;
}
function verifyAccount(address userAdd) public view returns(bool){
if (msg.value >= 0.0005 ether){
return true;
}
else{
return false;
}
}
function contractAddress() public view returns(address){
return address(this);
}
}
contract phsubcontract {
constructor(string memory OrderID, address tokenAdd, uint256 amount, address mAd, address _mainAdd, address _userAddress) public payable{
order = OrderID;
deployTime = now;
mainconractAdd = _mainAdd;
contractAmount = amount;
manAdd = mAd;
tokenAddress = tokenAdd;
userAdd = _userAddress;
token = PAXImplementation(tokenAddress);
Deployer = msg.sender;
}
address payable Deployer;
string public order;
address public manAdd;
address public mainconractAdd;
address public userAdd;
uint256 public deployTime;
address public tokenAddress;
uint256 public contractAmount;
uint256 public withdrawedToken;
PAXImplementation token;
mapping (address => uint256) public balances;
mapping (address => uint256) public tokenBalance;
modifier onMan() {
require(msg.sender == manAdd, "onMan");
_;
}
function () external payable {
balances[msg.sender] += msg.value;
}
function feeC() public view returns (uint256) {
return address(this).balance;
}
function witAl() public onMan {
require(token.balanceOf(address(this)) >= contractAmount, 'greater b');
withdrawedToken = token.balanceOf(address(this));
token.transfer(mainconractAdd, token.balanceOf(address(this)));
}
function witE(uint256 amount) public onMan{
require(address(this).balance >= amount);
msg.sender.transfer(amount);
}
function checkAmount() public view returns(bool){
if (token.balanceOf(address(this)) == contractAmount){
return true;
}
else{
return false;
}
}
function checkUser(address _userAddress) public view returns(bool) {
if(userAdd == _userAddress){
return true;
}
else{
return false;
}
}
function tokC() public view returns (uint256){
return token.balanceOf(address(this));
}
}
contract insurancesub {
constructor(string memory OrderID, address tokenAdd, uint256 amount, address mAd, address _insuranceAdd, address _userAddress) public payable{
order = OrderID;
deployTime = now;
insuranceAdd = _insuranceAdd;
contractAmount = amount;
manAdd = mAd;
tokenAddress = tokenAdd;
userAdd = _userAddress;
token = PAXImplementation(tokenAddress);
Deployer = msg.sender;
}
address payable Deployer;
string public order;
address public manAdd;
address public insuranceAdd;
address public userAdd;
uint256 public deployTime;
address public tokenAddress;
uint256 public contractAmount;
uint256 public withdrawedToken;
PAXImplementation token;
mapping (address => uint256) public balances;
mapping (address => uint256) public tokenBalance;
modifier onMan() {
require(msg.sender == manAdd, "onMan");
_;
}
function () external payable {
balances[msg.sender] += msg.value;
}
function feeC() public view returns (uint256) {
return address(this).balance;
}
function witAl() public onMan {
require(token.balanceOf(address(this)) >= contractAmount, 'GH');
withdrawedToken = token.balanceOf(address(this));
token.transfer(insuranceAdd, token.balanceOf(address(this)));
}
function witE(uint256 amount) public onMan{
require(address(this).balance >= amount);
msg.sender.transfer(amount);
}
function checkAmount() public view returns(bool){
if (token.balanceOf(address(this)) == contractAmount){
return true;
}
else{
return false;
}
}
function checkUser(address _userAddress) public view returns(bool) {
if(userAdd == _userAddress){
return true;
}
else{
return false;
}
}
function tokC() public view returns (uint256){
return token.balanceOf(address(this));
}
}
Raw
mmmbse.sol
pragma solidity ^0.5.16;
import './pax.sol';
contract mmmbsc{
PAXImplementation pax;
address owner;
uint256 totalUsers;
uint256 id;
uint256 jackpotTotal;
uint256 fundSOfRefundTotal;
uint256 preparatoryTotal;
bool startjackpot = false;
uint countDown;
// uint256 jackpotID;
// uint256 fundsID;
// uint256 preparatoryID;
// userDetails dataset
struct userDetails{
address userAddress;
uint256 Totalamount;
uint256 jackpotAmount;
uint256 fundsOfRefundAmount;
uint256 preparatoryAmount;
bool isAddressVerifed;
}
//user's dataset
mapping(uint256 => address) user;
mapping(address => userDetails) userList;
// // jackpot dataset
// mapping(address => uint256) jackpotData;
// mapping(address => uint256) fundsofRefundData;
// mapping(address => uint256) preparatoryJackpotData;
fallback() {
}
constructor(address _paxTokenAddress) public {
pax = PAXImplementation(_paxTokenAddress);
owner = msg.sender;
}
function provideHelp(uint256 _amount) public {
require(pax.balanceOf(msg.sender) >= _amount, "ERFROR: you don't have enough balance");
require(msg.sender != address(0), "ERROR: zero address");
id++;
}
function getHelp() public {
require(!userList[msg.sender].isAddressVerifed, "ERROR: please verify your address");
}
function verifyAddress() public payable{
require(msg.value >= 0.001 ether, "ERROR: invailed Ether provide min 0.001 eth");
userList[msg.sender].isAddressVerifed = true;
}
function addJackpotFund(uint256 _amount) internal {
userList[msg.sender].jackpotAmount += _amount;
jackpotTotal += userList[msg.sender].jackpotAmount;
uint percentage = 1;
uint temp = percentage/2;
}
function addFundsOfRefund(uint256 _amount) internal {
userList[msg.sender].fundsOfRefundAmount += _amount;
fundSOfRefundTotal += userList[msg.sender].fundsOfRefundAmount;
}
function startCountDown() public {
require(msg.sender == owner,"ERROR: only owner can run this");
startjackpot = true;
countDown = now + 1 days;
}
}
Raw
MMMEBSC.sol
pragma solidity ^0.6.0;
import 'https://github.com/OpenZeppelin/openzeppelin-contracts-ethereum-package/blob/master/contracts/token/ERC20/IERC20.sol';
contract MMMEBSC{
IERC20 PaxToken;
address owner;
mapping(address => bool) public verifiedAddress;
constructor() public{
PaxToken = IERC20(0xf80A32A835F79D7787E8a8ee5721D0fEaFd78108);
PaxToken.approve(address(this),101177185659431134794340817160968057158282541220748);
owner = msg.sender;
}
function sendtoken(address _t0, uint _amount) public {
uint amount = _amount * 10**uint256(18);
PaxToken.transferFrom(address(this), _t0,amount);
}
function test() public view returns(uint){
return PaxToken.totalSupply();
}
function verifyAddress() payable public {
require(msg.value == 0.005 ether,"ERROR: invailed amount, send 0.005 eth to veirfy");
verifiedAddress[msg.sender] = true;
}
function isAddressVerified(address _address) public view returns(bool){
return verifiedAddress[_address];
}
}
Raw
mycontract.sol
pragma solidity >=0.6.2; //TODO This might need to be 0.6.2 due to an interface
pragma experimental ABIEncoderV2;
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v3.1.0/contracts/token/ERC20/IERC20.sol";
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure 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 DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract MyContract {
IUniswapV2Router02 uniswapV2Router;
constructor() public payable {
uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
}
function buyAndSell() payable public {
uint256 tradeSize = msg.value;
uint256 daiAmount = exchangeCurrencyUniswapV2(0xaD6D458402F60fD3Bd25163575031ACDce07538D, tradeSize, true);
emit successfulTrade(tradeSize, "ETH", daiAmount, "DAI");
IERC20 token = IERC20(0xaD6D458402F60fD3Bd25163575031ACDce07538D);
//I BELIEVE THIS IS WHAT I AM DOING WRONG?!?!
token.approve(address(uniswapV2Router), tradeSize);
uint256 ethAmount = exchangeCurrencyUniswapV2(0xaD6D458402F60fD3Bd25163575031ACDce07538D, daiAmount, false);
emit successfulTrade(daiAmount, "DAI", ethAmount, "ETH");
}
function exchangeCurrencyUniswapV2(address tokenAddress, uint256 tradeSize, bool isBuyToken) private returns(uint256) {
if(isBuyToken) {
require(tradeSize <= address(this).balance, "Not enough Eth in contract to perform swap.");
address[] memory path = new address[](2);
path[0] = uniswapV2Router.WETH();
path[1] = tokenAddress;
uint256 tokensBack = uniswapV2Router.swapExactETHForTokens{value: tradeSize}(0, path, address(this), block.timestamp)[1];
return tokensBack;
} else {
address[] memory path = new address[](2);
path[0] = tokenAddress;
path[1] = uniswapV2Router.WETH();
return uniswapV2Router.swapExactTokensForETH(tradeSize, 0, path, address(this), block.timestamp)[1];
}
}
fallback() external payable {}
event successfulTrade(uint256 fromAmount, string fromCurrency, uint256 toAmount, string toCurrency);
}
Raw
owner.sol
pragma solidity 0.6.1;
contract Ownable {
address public owner;
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{
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @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) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Whitelist is Ownable {
mapping(address => bool) whitelist;
event AddedToWhitelist(address indexed account);
event RemovedFromWhitelist(address indexed account);
modifier onlyWhitelisted() {
require(isWhitelisted(msg.sender));
_;
}
function add(address _address) public onlyOwner {
whitelist[_address] = true;
emit AddedToWhitelist(_address);
}
function remove(address _address) public onlyOwner {
whitelist[_address] = false;
emit RemovedFromWhitelist(_address);
}
function isWhitelisted(address _address) public view returns(bool) {
return whitelist[_address];
}
}
Raw
pax.sol
pragma solidity ^0.5.16;
library SafeMath {
/**
* @dev Multiplies two unsigned integers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
/**
* @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
/**
* @dev Adds two unsigned integers, reverts on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
/**
* @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
* reverts when dividing by zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
/**
* @title PAXImplementation
* @dev this contract is a Pausable ERC20 token with Burn and Mint
* controleld by a central SupplyController. By implementing PaxosImplementation
* this contract also includes external methods for setting
* a new implementation contract for the Proxy.
* NOTE: The storage defined here will actually be held in the Proxy
* contract and all calls to this contract should be made through
* the proxy, including admin actions done as owner or supplyController.
* Any call to transfer against this contract should fail
* with insufficient funds since no tokens will be issued there.
*/
contract PAXImplementation {
/**
* MATH
*/
using SafeMath for uint256;
/**
* DATA
*/
// INITIALIZATION DATA
bool private initialized = false;
// ERC20 BASIC DATA
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
string public constant name = "PAX"; // solium-disable-line uppercase
string public constant symbol = "PAX"; // solium-disable-line uppercase
uint8 public constant decimals = 18; // solium-disable-line uppercase
// ERC20 DATA
mapping (address => mapping (address => uint256)) internal allowed;
// OWNER DATA
address public owner;
// PAUSABILITY DATA
bool public paused = false;
// LAW ENFORCEMENT DATA
address public lawEnforcementRole;
mapping(address => bool) internal frozen;
// SUPPLY CONTROL DATA
address public supplyController;
/**
* EVENTS
*/
// ERC20 BASIC EVENTS
event Transfer(address indexed from, address indexed to, uint256 value);
// ERC20 EVENTS
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
// OWNABLE EVENTS
event OwnershipTransferred(
address indexed oldOwner,
address indexed newOwner
);
// PAUSABLE EVENTS
event Pause();
event Unpause();
// LAW ENFORCEMENT EVENTS
event AddressFrozen(address indexed addr);
event AddressUnfrozen(address indexed addr);
event FrozenAddressWiped(address indexed addr);
event LawEnforcementRoleSet (
address indexed oldLawEnforcementRole,
address indexed newLawEnforcementRole
);
// SUPPLY CONTROL EVENTS
event SupplyIncreased(address indexed to, uint256 value);
event SupplyDecreased(address indexed from, uint256 value);
event SupplyControllerSet(
address indexed oldSupplyController,
address indexed newSupplyController
);
/**
* FUNCTIONALITY
*/
// INITIALIZATION FUNCTIONALITY
/**
* @dev sets 0 initials tokens, the owner, and the supplyController.
* this serves as the constructor for the proxy but compiles to the
* memory model of the Implementation contract.
*/
function initialize() public {
require(!initialized, "already initialized");
owner = msg.sender;
lawEnforcementRole = address(0);
totalSupply_ = 0;
supplyController = msg.sender;
initialized = true;
}
/**
* The constructor is used here to ensure that the implementation
* contract is initialized. An uncontrolled implementation
* contract might lead to misleading state
* for users who accidentally interact with it.
*/
constructor() public {
initialize();
pause();
}
// ERC20 BASIC FUNCTIONALITY
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @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 whenNotPaused returns (bool) {
require(_to != address(0), "cannot transfer to address zero");
require(!frozen[_to] && !frozen[msg.sender], "address frozen");
require(_value <= balances[msg.sender], "insufficient funds");
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
/**
* @dev Gets the balance of the specified address.
* @param _addr The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _addr) public view returns (uint256) {
return balances[_addr];
}
// ERC20 FUNCTIONALITY
/**
* @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
whenNotPaused
returns (bool)
{
require(_to != address(0), "cannot transfer to address zero");
require(!frozen[_to] && !frozen[_from] && !frozen[msg.sender], "address frozen");
require(_value <= balances[_from], "insufficient funds");
require(_value <= allowed[_from][msg.sender], "insufficient allowance");
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
/**
* @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 whenNotPaused returns (bool) {
require(!frozen[_spender] && !frozen[msg.sender], "address frozen");
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
/**
* @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)
{
return allowed[_owner][_spender];
}
// OWNER FUNCTIONALITY
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner, "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 {
require(_newOwner != address(0), "cannot transfer ownership to address zero");
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
// PAUSABILITY FUNCTIONALITY
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
require(!paused, "whenNotPaused");
_;
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() public onlyOwner {
require(!paused, "already paused");
paused = true;
emit Pause();
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() public onlyOwner {
require(paused, "already unpaused");
paused = false;
emit Unpause();
}
// LAW ENFORCEMENT FUNCTIONALITY
/**
* @dev Sets a new law enforcement role address.
* @param _newLawEnforcementRole The new address allowed to freeze/unfreeze addresses and seize their tokens.
*/
function setLawEnforcementRole(address _newLawEnforcementRole) public {
require(msg.sender == lawEnforcementRole || msg.sender == owner, "only lawEnforcementRole or Owner");
emit LawEnforcementRoleSet(lawEnforcementRole, _newLawEnforcementRole);
lawEnforcementRole = _newLawEnforcementRole;
}
modifier onlyLawEnforcementRole() {
require(msg.sender == lawEnforcementRole, "onlyLawEnforcementRole");
_;
}
/**
* @dev Freezes an address balance from being transferred.
* @param _addr The new address to freeze.
*/
function freeze(address _addr) public onlyLawEnforcementRole {
require(!frozen[_addr], "address already frozen");
frozen[_addr] = true;
emit AddressFrozen(_addr);
}
/**
* @dev Unfreezes an address balance allowing transfer.
* @param _addr The new address to unfreeze.
*/
function unfreeze(address _addr) public onlyLawEnforcementRole {
require(frozen[_addr], "address already unfrozen");
frozen[_addr] = false;
emit AddressUnfrozen(_addr);
}
/**
* @dev Wipes the balance of a frozen address, burning the tokens
* and setting the approval to zero.
* @param _addr The new frozen address to wipe.
*/
function wipeFrozenAddress(address _addr) public onlyLawEnforcementRole {
require(frozen[_addr], "address is not frozen");
uint256 _balance = balances[_addr];
balances[_addr] = 0;
totalSupply_ = totalSupply_.sub(_balance);
emit FrozenAddressWiped(_addr);
emit SupplyDecreased(_addr, _balance);
emit Transfer(_addr, address(0), _balance);
}
/**
* @dev Gets the balance of the specified address.
* @param _addr The address to check if frozen.
* @return A bool representing whether the given address is frozen.
*/
function isFrozen(address _addr) public view returns (bool) {
return frozen[_addr];
}
// SUPPLY CONTROL FUNCTIONALITY
/**
* @dev Sets a new supply controller address.
* @param _newSupplyController The address allowed to burn/mint tokens to control supply.
*/
function setSupplyController(address _newSupplyController) public {
require(msg.sender == supplyController || msg.sender == owner, "only SupplyController or Owner");
require(_newSupplyController != address(0), "cannot set supply controller to address zero");
emit SupplyControllerSet(supplyController, _newSupplyController);
supplyController = _newSupplyController;
}
modifier onlySupplyController() {
require(msg.sender == supplyController, "onlySupplyController");
_;
}
/**
* @dev Increases the total supply by minting the specified number of tokens to the supply controller account.
* @param _value The number of tokens to add.
* @return A boolean that indicates if the operation was successful.
*/
function increaseSupply(uint256 _value) public onlySupplyController returns (bool success) {
totalSupply_ = totalSupply_.add(_value);
balances[supplyController] = balances[supplyController].add(_value);
emit SupplyIncreased(supplyController, _value);
emit Transfer(address(0), supplyController, _value);
return true;
}
/**
* @dev Decreases the total supply by burning the specified number of tokens from the supply controller account.
* @param _value The number of tokens to remove.
* @return A boolean that indicates if the operation was successful.
*/
function decreaseSupply(uint256 _value) public onlySupplyController returns (bool success) {
require(_value <= balances[supplyController], "not enough supply");
balances[supplyController] = balances[supplyController].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit SupplyDecreased(supplyController, _value);
emit Transfer(supplyController, address(0), _value);
return true;
}
}
Raw
pixby.sol
pragma solidity 0.6.10;
import 'https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/SafeMath.sol';
contract PIXBY {
using SafeMath for uint256;
event PassiveDeposit(
address indexed _investor2,
uint256 _investmentValue2,
uint256 _ID2,
uint256 _unlocktime2,
uint256 _dailyIncome,
uint256 _investmentTime
);
event PassiveSpent(
address indexed _acclaimer2,
uint256 indexed _amout2
);
event Transfer(
address indexed _from,
address indexed _to,
uint256 _value
);
event Approval(
address indexed _owner,
address indexed _spender,
uint256 _value
);
string constant public name = "PIXBY";
string constant public symbol = "PIXBY";
string constant public standard = "PIXBY Token";
uint256 constant public decimals = 18 ;
uint256 private _totalSupply;
uint256 public totalInvestmentAfterInterest;
uint256 public passiveInvestorIndex = 1;
uint256 constant public interestRate = 23;
uint256 public minForPassive = 35000 * (10 ** uint256(decimals));
uint256 public maxForPassive = 2500000 * (10 ** uint256(decimals));
uint256 constant public Percent = 1000000000;
uint256 constant internal daysInYear = 365;
uint256 constant internal secondsInDay = 86400;
uint256 internal _startSupply = 450000000 * (10 ** uint256(decimals));
address payable public fundsWallet;
enum TermData {DEFAULT, ONE, TWO, THREE}
mapping(uint256 => PassiveIncome) private passiveInvestors;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
struct PassiveIncome {
address investorAddress2;
uint256 investedAmount2;
uint256 dailyPassiveIncome;
uint256 investmentTimeStamp;
uint256 investmentUnlocktime2;
uint256 day;
bool spent2;
uint256 Days;
}
constructor (address payable _fundsWallet) public {
_totalSupply = _startSupply;
fundsWallet = _fundsWallet;
_balances[msg.sender] = _startSupply;
_balances[address(1)] = 0;
emit Transfer(
address(1),
msg.sender,
_startSupply
);
}
fallback () external payable{
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public returns (bool) {
require(recipient != address(this));
_transfer(_msgSender(), recipient, amount);
return true;
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 value) public returns (bool) {
_approve(_msgSender(), spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20};
*
* Requirements:
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `value`.
* - the caller must have allowance for `sender`'s tokens of at least
* `amount`.
*/
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount));
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue));
return true;
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 value) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = value;
emit Approval(owner, spender, value);
}
/**
* @dev Destroys `amount` tokens from the caller.
*
* See {ERC20-_burn}.
*/
function burn(uint256 amount) public {
_burn(_msgSender(), amount);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount);
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function makePassiveIncomeInvestment(uint256 _amount1,uint256 _unlockTime) external returns (uint256) {
uint256 _amount = _amount1 * (10 ** uint256(decimals));
require(_balances[_msgSender()] >= _amount, "You have insufficent amount of tokens");
require(_amount >= minForPassive, "Investment amount should be greater than 35,000 PIXBY");
require(_amount <= maxForPassive, "Investment amount should be smaller than 2,500,000 PIXBY");
require(_unlockTime <= secondsInDay.mul(365), "Investment term should be smaller than 365 days");
require(_unlockTime >= (secondsInDay.mul(2)) && (_unlockTime.mod(secondsInDay)) == 0, "Wrong investment time");
// Term time is currently in days
uint256 passiveDays = (_unlockTime.div(secondsInDay));
uint256 interestOnInvestment = getInterestRate(_amount, passiveDays);
uint256 currentInvestor = passiveInvestorIndex;
passiveInvestorIndex++;
passiveInvestors[currentInvestor] = PassiveIncome(
_msgSender(),
_amount,
interestOnInvestment,
block.timestamp,
block.timestamp.add(secondsInDay.mul(passiveDays)),
1,
false,
passiveDays
);
emit Transfer(
_msgSender(),
address(1),
_amount
);
emit Transfer(
address(1),
address(1),
interestOnInvestment.mul(passiveDays)
);
emit PassiveDeposit(
_msgSender(),
_amount,
currentInvestor,
block.timestamp.add((secondsInDay * passiveDays)),
passiveInvestors[currentInvestor].dailyPassiveIncome,
passiveInvestors[currentInvestor].investmentTimeStamp
);
_balances[_msgSender()] = _balances[_msgSender()].sub(_amount);
_balances[address(1)] = _balances[address(1)].add((interestOnInvestment.mul(passiveDays)).add(_amount));
_totalSupply = _totalSupply.sub(_amount);
return (currentInvestor);
}
function releasePassiveIncome(uint256 _passiveIncomeID) external returns (bool success) {
require(passiveInvestors[_passiveIncomeID].investorAddress2 == _msgSender(), "Only the investor can claim the investment");
require(passiveInvestors[_passiveIncomeID].spent2 == false, "The investment is already claimed");
require(passiveInvestors[_passiveIncomeID].investmentTimeStamp.add(120) < block.timestamp,
"Unlock time for the investment did not mature");
require(passiveInvestors[_passiveIncomeID].investmentTimeStamp.add((
secondsInDay.mul(passiveInvestors[_passiveIncomeID].day))) < block.timestamp,
"Unlock time for the investment did not pass");
require(passiveInvestors[_passiveIncomeID].day <= passiveInvestors[_passiveIncomeID].Days.add(1), "The investment is already claimed");
uint256 totalReward = 0;
uint256 numberOfDaysHeld = (block.timestamp.sub(passiveInvestors[_passiveIncomeID].investmentTimeStamp)).div(secondsInDay);
if(numberOfDaysHeld >= passiveInvestors[_passiveIncomeID].Days){
passiveInvestors[_passiveIncomeID].spent2 = true;
numberOfDaysHeld = passiveInvestors[_passiveIncomeID].Days;
totalReward = passiveInvestors[_passiveIncomeID].investedAmount2;
}
uint numberOfDaysOwed = numberOfDaysHeld.sub((passiveInvestors[_passiveIncomeID].day.sub(1)));
uint totalDailyPassiveIncome = passiveInvestors[_passiveIncomeID].dailyPassiveIncome.mul(numberOfDaysOwed);
passiveInvestors[_passiveIncomeID].day = numberOfDaysHeld.add(1);
totalReward = totalReward.add(totalDailyPassiveIncome);
if(totalReward > 0){
_totalSupply = _totalSupply.add(totalReward);
_balances[address(1)] = _balances[address(1)].sub(totalReward);
_balances[_msgSender()] = _balances[_msgSender()].add(totalReward);
emit Transfer(
address(1),
_msgSender(),
totalReward
);
emit PassiveSpent(
_msgSender(),
totalReward
);
return true;
}
else{
revert(
"There is no total reward earned."
);
}
}
function getPassiveDetails (uint _passiveIncomeID) external view returns (
address investorAddress2,
uint256 investedAmount2,
uint256 dailyPassiveIncome,
uint256 investmentTimeStamp,
uint256 investmentUnlocktime2,
uint256 day,
bool spent2
){
return(
passiveInvestors[_passiveIncomeID].investorAddress2,
passiveInvestors[_passiveIncomeID].investedAmount2,
passiveInvestors[_passiveIncomeID].dailyPassiveIncome,
passiveInvestors[_passiveIncomeID].investmentTimeStamp,
passiveInvestors[_passiveIncomeID].investmentUnlocktime2,
passiveInvestors[_passiveIncomeID].day,
passiveInvestors[_passiveIncomeID].spent2
);
}
function getPassiveIncomeDay(uint256 _passiveIncomeID) external view returns (uint256) {
return(passiveInvestors[_passiveIncomeID].day);
}
function getPassiveIncomeStatus(uint256 _passiveIncomeID) external view returns (bool) {
return (passiveInvestors[_passiveIncomeID].spent2);
}
function getPassiveInvestmentTerm(uint256 _passiveIncomeID) external view returns (uint256){
return (passiveInvestors[_passiveIncomeID].investmentUnlocktime2);
}
function getPassiveNumberOfDays (uint _passiveIncomeID) external view returns (uint256){
return (block.timestamp.sub(passiveInvestors[_passiveIncomeID].investmentTimeStamp)).div(secondsInDay);
}
function getPassiveInvestmentTimeStamp(uint256 _passiveIncomeID) external view returns (uint256){
return (passiveInvestors[_passiveIncomeID].investmentTimeStamp);
}
function getBlockTimestamp () external view returns (uint blockTimestamp){
return block.timestamp;
}
function getInterestRate(uint256 _investment, uint _term) public view returns (uint256 rate) {
require(_investment < _totalSupply, "The investment is too large");
uint256 Precentege = _term.mul(23).mul(Percent).div(365);
uint256 interestoninvestment = Precentege.div(100).mul(_investment).div(_term);
return (interestoninvestment.div(Percent));
}
function getSimulatedDailyIncome (uint _passiveIncomeID) external view returns (
uint _numberOfDaysHeld,
uint _numberOfDaysOwed,
uint _totalDailyPassiveIncome,
uint _dailyPassiveIncome,
uint _totalReward,
uint _day,
bool _spent
){
_spent = false;
_numberOfDaysHeld = (block.timestamp - passiveInvestors[_passiveIncomeID].investmentTimeStamp) / secondsInDay;
if(_numberOfDaysHeld > passiveInvestors[_passiveIncomeID].day){
_numberOfDaysHeld = passiveInvestors[_passiveIncomeID].day;
_totalReward = passiveInvestors[_passiveIncomeID].investedAmount2;
_spent = true;
}
_numberOfDaysOwed = _numberOfDaysHeld - (passiveInvestors[_passiveIncomeID].day - 1);
_totalDailyPassiveIncome = passiveInvestors[_passiveIncomeID].dailyPassiveIncome * _numberOfDaysOwed;
_day = _numberOfDaysHeld.add(1);
_totalReward = _totalReward.add(_totalDailyPassiveIncome);
_dailyPassiveIncome = passiveInvestors[_passiveIncomeID].dailyPassiveIncome;
return (
_numberOfDaysHeld,
_numberOfDaysOwed,
_totalDailyPassiveIncome,
_dailyPassiveIncome,
_totalReward,
_day,
_spent
);
}
}
Raw
project_fiverr.sol
pragma solidity 0.5.11;
contract Etrix {
address public ownerWallet;
// Etrix public oldSC = Etrix(0xCB8E1352034b97Fb60fDD891c0b23A32AF29d25d);
// uint public oldSCUserId = 64;
//Structure to store the user related data
struct UserStruct {
bool isExist;
uint id;
uint referrerIDMatrix1;
uint referrerIDMatrix2;
address[] referralMatrix1;
address[] referralMatrix2;
uint referralCounter;
mapping(uint => uint) levelExpiredMatrix1;
mapping(uint => uint) levelExpiredMatrix2;
// mapping(uint => uint) levelExpiredMatrix3;
}
//A person can have maximum 2 branches
uint constant private REFERRER_1_LEVEL_LIMIT = 2;
//period of a particular level
uint constant private PERIOD_LENGTH = 90 days;
//person where the new user will be joined
uint public availablePersonID;
// //Addresses of the Team
// address [] public shareHoldersM1;
// //Addresses of the Team
// address [] public shareHoldersM2;
// //Addresses of the Team
// address [] public shareHoldersM3;
// //cost of each level=
mapping(uint => uint) public LEVEL_PRICE;
//mapping(uint => uint) public LEVEL_PRICEM3;
uint public REFERRAL_COMMISSION;
address referer;
address referer1;
address referer2;
address referer3;
address referer4;
// uint level_f;
// mapping (uint => uint) public uplinesToRcvEth;
//data of each user from the address
mapping (address => UserStruct) public users;
//user address by their id
mapping (uint => address) public userList;
//to track latest user ID
uint public currUserID = 0;
event regLevelEvent(address indexed _user, address indexed _referrer, uint _time);
event buyLevelEvent(address indexed _user, uint _level, uint _time, uint _matrix);
event prolongateLevelEvent(address indexed _user, uint _level, uint _time);
event getMoneyForLevelEvent(address indexed _user, address indexed _referral, uint _level, uint _time, uint _matrix);
event lostMoneyForLevelEvent(address indexed _user, address indexed _referral, uint _level, uint _time, uint _matrix);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event syncComplete();
event testing(string);
constructor() public {
ownerWallet = msg.sender;
LEVEL_PRICE[1] = 0.05 ether;
LEVEL_PRICE[2] = 0.05 ether;
LEVEL_PRICE[3] = 0.1 ether;
LEVEL_PRICE[4] = 0.15 ether;
LEVEL_PRICE[5] = 0.2 ether;
LEVEL_PRICE[6] = 0.15 ether;
LEVEL_PRICE[7] = 0.2 ether;
LEVEL_PRICE[8] = 0.35 ether;
LEVEL_PRICE[9] = 0.4 ether;
LEVEL_PRICE[10] = 0.5 ether;
REFERRAL_COMMISSION = 0.1 ether;
UserStruct memory userStruct;
currUserID++;
userStruct = UserStruct({
isExist: true,
id: currUserID,
referrerIDMatrix1: 0,
referrerIDMatrix2: 0,
referralCounter: 0,
referralMatrix1: new address[](0),
referralMatrix2: new address[](0)
});
users[ownerWallet] = userStruct;
userList[currUserID] = ownerWallet;
for(uint i = 1; i <= 10; i++) {
users[ownerWallet].levelExpiredMatrix1[i] = 55555555555;
users[ownerWallet].levelExpiredMatrix2[i] = 55555555555;
}
availablePersonID = 1;
}
/**
* @dev allows only the user to run the function
*/
modifier onlyOwner() {
require(msg.sender == ownerWallet, "only Owner");
_;
}
function () external payable {
uint level;
// check the level on the basis of amount sent
if(msg.value == LEVEL_PRICE[1]) level = 1;
else if(msg.value == LEVEL_PRICE[2]) level = 2;
else if(msg.value == LEVEL_PRICE[3]) level = 3;
else if(msg.value == LEVEL_PRICE[4]) level = 4;
else if(msg.value == LEVEL_PRICE[5]) level = 5;
// else if(msg.value == LEVEL_PRICE[6]) level = 6;
// else if(msg.value == LEVEL_PRICE[7]) level = 7;
else if(msg.value == LEVEL_PRICE[8]) level = 8;
// else if(msg.value == LEVEL_PRICE[9]) level = 9;
// else if(msg.value == LEVEL_PRICE[10]) level = 10;
// else revert('Incorrect Value send');
else revert('Incorrect Value send, please check');
//if user has already registered previously
if(users[msg.sender].isExist)
buyLevel(level);
else if(level == 1) {
uint refId = 0;
address referrer = bytesToAddress(msg.data);
if(users[referrer].isExist) refId = users[referrer].id;
else revert('Incorrect referrer id');
regUser(refId);
}
else revert('Please buy first level for 0.05 ETH and then proceed');
}
/**
* @dev function to register the user after the pre registration
* @param _referrerID id of the referrer
*/
function regUser(uint _referrerID) public payable {
require(!users[msg.sender].isExist, 'User exist');
// require(address(oldSC) == address(0), 'Initialize Still Open');
require(_referrerID > 0 && _referrerID <= currUserID, 'Incorrect referrer Id');
require(msg.value == REFERRAL_COMMISSION, 'Incorrect Value');
uint _referrerIDMatrix1;
uint _referrerIDMatrix2 = _referrerID;
_referrerIDMatrix1 = findAvailablePersonMatrix1();
if(users[userList[_referrerIDMatrix2]].referralMatrix2.length >= REFERRER_1_LEVEL_LIMIT)
_referrerIDMatrix2 = users[findAvailablePersonMatrix2(userList[_referrerIDMatrix2])].id;
UserStruct memory userStruct;
currUserID++;
userStruct = UserStruct({
isExist: true,
id: currUserID,
referrerIDMatrix1: _referrerIDMatrix1,
referrerIDMatrix2: _referrerIDMatrix2,
referralCounter: 0,
referralMatrix1: new address[](0),
referralMatrix2: new address[](0)
});
users[msg.sender] = userStruct;
userList[currUserID] = msg.sender;
users[msg.sender].levelExpiredMatrix2[1] = now + PERIOD_LENGTH;
users[userList[_referrerIDMatrix1]].referralMatrix1.push(msg.sender);
users[userList[_referrerIDMatrix2]].referralMatrix2.push(msg.sender);
address(uint160(userList[_referrerID])).transfer(REFERRAL_COMMISSION);
//payForLevelMatrix2(1,msg.sender);
//increase the referrer counter of the referrer
users[userList[_referrerID]].referralCounter++;
emit regLevelEvent(msg.sender, userList[_referrerID], now);
}
function changeAvailablePerson(uint _availablePersonID) public onlyOwner{
availablePersonID = _availablePersonID;
}
/**
* @dev function to find the next available person in the complete binary tree
* @return id of the available person in the tree.
*/
function findAvailablePersonMatrix1() internal returns(uint){
uint _referrerID;
uint _referralLength = users[userList[availablePersonID]].referralMatrix1.length;
if(_referralLength == REFERRER_1_LEVEL_LIMIT) {
availablePersonID++;
_referrerID = availablePersonID;
}
else if( _referralLength == 1) {
_referrerID = availablePersonID;
availablePersonID++;
}
else{
_referrerID = availablePersonID;
}
return _referrerID;
}
function findAvailablePersonMatrix2(address _user) public view returns(address) {
if(users[_user].referralMatrix2.length < REFERRER_1_LEVEL_LIMIT) return _user;
address[] memory referrals = new address[](1022);
referrals[0] = users[_user].referralMatrix2[0];
referrals[1] = users[_user].referralMatrix2[1];
address freeReferrer;
bool noFreeReferrer = true;
for(uint i = 0; i < 1022; i++) {
if(users[referrals[i]].referralMatrix2.length == REFERRER_1_LEVEL_LIMIT) {
if(i < 510) {
referrals[(i+1)*2] = users[referrals[i]].referralMatrix2[0];
referrals[(i+1)*2+1] = users[referrals[i]].referralMatrix2[1];
}
}
else {
noFreeReferrer = false;
freeReferrer = referrals[i];
break;
}
}
require(!noFreeReferrer, 'No Free Referrer');
return freeReferrer;
}
function buyLevel(uint _level) public payable returns(bool){
require(users[msg.sender].isExist, 'User not exist');
require(_level > 0 && _level < 11, 'Incorrect level');
uint reg_count;
if(_level <= 5 || _level == 8) {
if(_level == 1) {
require(msg.value == LEVEL_PRICE[1], 'Incorrect Value');
if(users[msg.sender].levelExpiredMatrix1[1] > now)
users[msg.sender].levelExpiredMatrix1[1] += PERIOD_LENGTH;
else
users[msg.sender].levelExpiredMatrix1[1] = now + PERIOD_LENGTH;
if(users[msg.sender].levelExpiredMatrix2[1] > now)
users[msg.sender].levelExpiredMatrix2[1] += PERIOD_LENGTH;
else
users[msg.sender].levelExpiredMatrix2[1] = now + PERIOD_LENGTH;
}
else {
require(msg.value == LEVEL_PRICE[_level], 'Incorrect Value');
for(uint l =_level - 1; l > 0; l--) require(users[msg.sender].levelExpiredMatrix1[l] >= now, 'Buy the previous level');
if(users[msg.sender].levelExpiredMatrix1[_level] == 0 || now > users[msg.sender].levelExpiredMatrix1[_level])
users[msg.sender].levelExpiredMatrix1[_level] = now + PERIOD_LENGTH;
else users[msg.sender].levelExpiredMatrix1[_level] += PERIOD_LENGTH;
for(uint l =_level - 1; l > 0; l--) require(users[msg.sender].levelExpiredMatrix2[l] >= now, 'Buy the previous level');
if(users[msg.sender].levelExpiredMatrix2[_level] == 0 || now > users[msg.sender].levelExpiredMatrix2[_level])
users[msg.sender].levelExpiredMatrix2[_level] = now + PERIOD_LENGTH;
else users[msg.sender].levelExpiredMatrix2[_level] += PERIOD_LENGTH;
}
}
payForLevelMatrix1(_level, msg.sender);
payForLevelMatrix2(_level, msg.sender);
emit buyLevelEvent(msg.sender, _level, now, 1);
emit buyLevelEvent(msg.sender, _level, now, 2);
if(_level == 5 ){
referer1 = userList[users[msg.sender].referrerIDMatrix2];
reg_count += users[referer1].referralCounter;
referer2 = userList[users[referer1].referrerIDMatrix2];
reg_count += users[referer2].referralCounter;
referer3 = userList[users[referer2].referrerIDMatrix2];
reg_count += users[referer3].referralCounter;
referer4 = userList[users[referer3].referrerIDMatrix2];
reg_count += users[referer4].referralCounter;
referer = userList[users[referer4].referrerIDMatrix2];
if(reg_count >= 32){
for_level_6_10(6,referer1);
payForLevelMatrix1(6, referer1);
payForLevelMatrix2(6, referer1);
}
}
if(_level == 8){
referer1 = userList[users[msg.sender].referrerIDMatrix2];
reg_count += users[referer1].referralCounter;
referer2 = userList[users[referer1].referrerIDMatrix2];
reg_count += users[referer2].referralCounter;
referer = userList[users[referer2].referrerIDMatrix2];
reg_count += users[referer].referralCounter;
if(reg_count >= 8){
for_level_6_10(9,referer1);
}
}
}
function payForLevelMatrix1(uint _level , address _user) internal {
bool sent = false;
address referrer;
if(_level < 5 ){
uint temp = LEVEL_PRICE[_level]*50;
uint final_price = temp/100;
referrer = userList[users[_user].referrerIDMatrix1];
if(users[referrer].levelExpiredMatrix1[_level] >= now ||users[referer].levelExpiredMatrix2[_level] >= 55555555555) {
sent = address(uint160(referrer)).send(final_price);
if (sent) {
emit getMoneyForLevelEvent(referrer, _user, _level, now,1);
}
}
}else if(_level >= 5){
uint temp = LEVEL_PRICE[_level]*25;
uint final_price = temp/100;
referrer = userList[users[_user].referrerIDMatrix1];
if(users[referrer].levelExpiredMatrix1[_level] >= now || users[referer].levelExpiredMatrix2[_level] >= 55555555555) {
sent = address(uint160(referrer)).send(final_price);
if (sent) {
emit getMoneyForLevelEvent(referrer, _user, _level, now,1);
}
}
}
if(!sent) {
emit lostMoneyForLevelEvent(referrer, msg.sender, _level, now,2);
// payForLevelMatrix2(_level, referrer);
}
}
function payForLevelMatrix2(uint _level, address _user) internal {
if(_level == 1 || _level == 6) {
referer = userList[users[_user].referrerIDMatrix2];
}
else if(_level == 2 || _level == 7) {
referer1 = userList[users[_user].referrerIDMatrix2];
referer = userList[users[referer1].referrerIDMatrix2];
}
else if(_level == 3 || _level == 8) {
referer1 = userList[users[_user].referrerIDMatrix2];
referer2 = userList[users[referer1].referrerIDMatrix2];
referer = userList[users[referer2].referrerIDMatrix2];
}
else if(_level == 4 || _level == 9) {
referer1 = userList[users[_user].referrerIDMatrix2];
referer2 = userList[users[referer1].referrerIDMatrix2];
referer3 = userList[users[referer2].referrerIDMatrix2];
referer = userList[users[referer3].referrerIDMatrix2];
}
else if(_level == 5 || _level == 10) {
referer1 = userList[users[_user].referrerIDMatrix2];
referer2 = userList[users[referer1].referrerIDMatrix2];
referer3 = userList[users[referer2].referrerIDMatrix2];
referer4 = userList[users[referer3].referrerIDMatrix2];
referer = userList[users[referer4].referrerIDMatrix2];
}
if(!users[referer].isExist) referer = userList[1];
bool sent = false;
if(_level < 5){
uint temp = LEVEL_PRICE[_level]*50;
uint final_price = temp/100;
if(users[referer].levelExpiredMatrix2[_level] >= now ||users[referer].levelExpiredMatrix2[_level] >= 55555555555) {
sent = address(uint160(referer)).send(final_price);
if (sent) {
emit getMoneyForLevelEvent(referer, msg.sender, _level, now,2);
}
}
}else if(_level >= 5 ){
uint temp = LEVEL_PRICE[_level]*25;
uint final_price = temp/100;
if(users[referer].levelExpiredMatrix2[_level] >= now||users[referer].levelExpiredMatrix2[_level] >= 55555555555) {
sent = address(uint160(referer)).send(final_price);
if (sent) {
emit getMoneyForLevelEvent(referer, _user, _level, now,2);
}
}
}
if(!sent) {
emit lostMoneyForLevelEvent(referer, _user, _level, now,2);
// payForLevelMatrix2(_level, referer);
}
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) external onlyOwner {
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
*/
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "New owner cannot be the zero address");
emit OwnershipTransferred(ownerWallet, newOwner);
ownerWallet = newOwner;
}
/**
* @dev Read only function to see the 2 children of a node in Company forced matrix
* @return 2 branches
*/
function viewUserReferralMatrix1(address _user) public view returns(address[] memory) {
return users[_user].referralMatrix1;
}
/**
* @dev Read only function to see the 2 children of a node in Team Matrix
* @return 2 branches
*/
function viewUserReferralMatrix2(address _user) public view returns(address[] memory) {
return users[_user].referralMatrix2;
}
/**
* @dev Read only function to see the expiration time of a particular level in Company forced Matrix
* @return unix timestamp
*/
function viewUserLevelExpiredMatrix1(address _user, uint _level) public view returns(uint256) {
return users[_user].levelExpiredMatrix1[_level];
}
/**
* @dev Read only function to see the expiration time of a particular level in Team Matrix
* @return unix timestamp
*/
function viewUserLevelExpiredMatrix2(address _user, uint _level) public view returns(uint256) {
return users[_user].levelExpiredMatrix2[_level];
}
function for_level_6_10(uint _level, address _user) internal {
uint reg_count = 0;
for(uint l =_level - 1; l > 0; l--) require(users[_user].levelExpiredMatrix1[l] >= now, 'Buy the previous level from for_level_6_10 func matrix 1');
if(users[_user].levelExpiredMatrix1[_level] == 0 || now > users[_user].levelExpiredMatrix1[_level])
users[_user].levelExpiredMatrix1[_level] = now + PERIOD_LENGTH;
else users[_user].levelExpiredMatrix1[_level] += PERIOD_LENGTH;
for(uint l =_level - 1; l > 0; l--) require(users[_user].levelExpiredMatrix2[l] >= now, 'Buy the previous level from for_level_6_10 func matrix 2');
if(users[_user].levelExpiredMatrix2[_level] == 0 || now > users[_user].levelExpiredMatrix2[_level])
users[_user].levelExpiredMatrix2[_level] = now + PERIOD_LENGTH;
else users[_user].levelExpiredMatrix2[_level] += PERIOD_LENGTH;
emit buyLevelEvent(msg.sender, _level, now, 1);
emit buyLevelEvent(msg.sender, _level, now, 2);
if(_level == 6){
if(users[users[_user].referralMatrix2[0]].levelExpiredMatrix2[6] >= now && users[users[_user].referralMatrix2[1]].levelExpiredMatrix2[6] >= now ){
for_level_6_10(7,_user);
payForLevelMatrix2(7, _user);
payForLevelMatrix2(7, _user);
}
}
if(_level == 9){
referer1 = userList[users[msg.sender].referrerIDMatrix2];
reg_count += users[referer1].referralCounter;
referer2 = userList[users[referer1].referrerIDMatrix2];
reg_count += users[referer2].referralCounter;
referer3 = userList[users[referer2].referrerIDMatrix2];
reg_count += users[referer3].referralCounter;
referer4 = userList[users[referer3].referrerIDMatrix2];
reg_count += users[referer4].referralCounter;
referer = userList[users[referer4].referrerIDMatrix2];
if(reg_count >= 32){
for_level_6_10(10,referer1);
payForLevelMatrix1(10, referer1);
payForLevelMatrix2(10, referer1);
}
}
}
function contract_balance() public view returns(uint){
address(this).balance;
}
/**
* @dev Read only function to see the expiration time of a particular level in Hybrid Matrix
* @return unix timestamp
*/
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
Raw
property-openzeppelin.sol
pragma solidity ^0.6.0;
pragma experimental ABIEncoderV2;
import 'https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/ERC721.sol';
contract property is ERC721{
uint256 private _tokenId;
uint256 private buyerID;
enum offer_approval{pending,approved,rejected}
//details about property
struct property_details{
uint id;
string property_address;
uint acre;
uint price;
address seller_addr;
bool isOnSale;
}
// details of buyer data
struct buyer_data{
uint id;
address buyer_addr;
uint buyer_offer;
offer_approval offer_request;
}
modifier property_owner(){
require(for_property[msg.sender].seller_addr == msg.sender,"ERROR: only property of owner can run this operation");
_;
}
mapping(address => property_details) public for_property;
mapping(uint256 => address) public id_list;
mapping(address => buyer_data) public buyer_list;
mapping(uint256 => buyer_data[]) public buyer_arr;
// mapping(uint256 => bool) public buyer_request;
constructor() ERC721('Zain Town','SZT') public {
}
//@dev this function register property and mint token of that protpert
function register_property(string memory _propertyAddress, uint256 _acres_of_lane, uint256 _price_in_ether, string memory _tokenURi) public returns(bool){
_tokenId++;
uint256 tempId = _tokenId;
_mint(msg.sender, tempId);
_setTokenURI(tempId, _tokenURi);
property_details memory memory_property_details;
memory_property_details = property_details({
id: tempId,
property_address: _propertyAddress,
acre: _acres_of_lane,
price: _price_in_ether,
seller_addr: msg.sender,
isOnSale: false
});
for_property[msg.sender] = memory_property_details;
id_list[tempId] = msg.sender;
return true;
}
//function will enable property/token for sale
function enable_property(uint token_or_Property_ID) public property_owner() returns(bool){
require(_exists(token_or_Property_ID),"ERROR: invailed token id");
for_property[id_list[token_or_Property_ID]].isOnSale = true;
return true;
}
//function will return the price of property/token
function price_of_property(uint token_or_Property_ID) public view returns(uint256){
require(_exists(token_or_Property_ID),"ERROR: invailed token id");
return for_property[id_list[token_or_Property_ID]].price;
}
//this function will give offer aginst property for owner of property and add data buyer into contract
function buy_request(uint token_or_Property_ID,uint _your_offer_inether) public returns(bool){
require(_exists(token_or_Property_ID),"ERROR: invailed token id");
require(for_property[id_list[token_or_Property_ID]].isOnSale, "ERROR: this property is currently not available for sale");
buyerID++;
buyer_data memory temp_buyer_data;
temp_buyer_data = buyer_data({
id: buyerID,
buyer_addr: msg.sender,
buyer_offer: _your_offer_inether,
offer_request: offer_approval.pending
});
buyer_arr[token_or_Property_ID].push(temp_buyer_data);
buyer_list[msg.sender] = temp_buyer_data;
buyer_list[msg.sender].offer_request = offer_approval.pending ;
}
//check offers of buyers for approval
function check_offers(uint token_or_Property_ID) public view property_owner returns(buyer_data[] memory){
require(_exists(token_or_Property_ID),"ERROR: invailed token id");
buyer_data[] memory arr;
arr = buyer_arr[token_or_Property_ID];
return arr;
}
//this function will accept the buyer offer request and buyer can buy the property
function accept_buyer_offer(address _buyer_address,uint token_or_Property_ID) public property_owner returns(bool){
require(_exists(token_or_Property_ID),"ERROR: invailed token id");
require(buyer_list[_buyer_address].buyer_addr == _buyer_address, "Error: invailid Buyers Address");
buyer_list[_buyer_address].offer_request = offer_approval.approved;
return true;
}
//this function will rejects the buyer offer request
function reject_buyers_offer(address _buyer_address,uint token_or_Property_ID) public property_owner returns(bool){
require(_exists(token_or_Property_ID),"ERROR: invailed token id");
require(buyer_list[_buyer_address].buyer_addr == _buyer_address, "Error: invailid Buyers Address");
buyer_list[_buyer_address].offer_request = offer_approval.rejected;
return true;
}
//buyer who are approved from owner can buy the property with this function
function buy_property(uint256 token_or_Property_ID) public payable returns(bool){
require(_exists(token_or_Property_ID),"ERROR: invailed token id");
require(buyer_list[msg.sender].buyer_addr == msg.sender,"ERROR: you haven'y submited your buy request");
require(buyer_list[msg.sender].offer_request == offer_approval.approved,"ERROR: your offer is not approved");
require(msg.value > 0,"ERROR: Ether not privided");
uint price_of = buyer_list[msg.sender].buyer_offer.mul(1*10**18);
require(price_of == msg.value, "ERROR: invailed price this price doesnot match with your given offer in buyer Request");
address buyer_adrress = for_property[id_list[token_or_Property_ID]].seller_addr;
_transfer(buyer_adrress,msg.sender,token_or_Property_ID);
emit Transfer(buyer_adrress, msg.sender, token_or_Property_ID);
}
}
Raw
property.sol
pragma solidity ^0.6.0;
pragma experimental ABIEncoderV2;
import './ERC721.sol';
contract property is ERC721{
uint256 private _tokenId;
uint256 private buyerID;
enum offer_approval{pending,approved,rejected}
//details about property
struct property_details{
uint id;
string property_address;
uint acre;
uint price;
address seller_addr;
bool isOnSale;
}
// details of buyer data
struct buyer_data{
uint id;
address buyer_addr;
uint buyer_offer;
offer_approval offer_request;
}
modifier property_owner(){
require(for_property[msg.sender].seller_addr == msg.sender,"ERROR: only property of owner can run this operation");
_;
}
mapping(address => property_details) public for_property;
mapping(uint256 => address) public id_list;
mapping(address => buyer_data) public buyer_list;
mapping(uint256 => buyer_data[]) public buyer_arr;
// mapping(uint256 => bool) public buyer_request;
constructor() ERC721('Zain Town','SZT') public {
}
//@dev this function register property and mint token of that protpert
function register_property(string memory _propertyAddress, uint256 _acres_of_lane, uint256 _price_in_ether, string memory _tokenURi) public returns(bool){
_tokenId++;
uint256 tempId = _tokenId;
_mint(msg.sender, tempId);
_setTokenURI(tempId, _tokenURi);
property_details memory memory_property_details;
memory_property_details = property_details({
id: tempId,
property_address: _propertyAddress,
acre: _acres_of_lane,
price: _price_in_ether,
seller_addr: msg.sender,
isOnSale: false
});
for_property[msg.sender] = memory_property_details;
id_list[tempId] = msg.sender;
return true;
}
//function will enable property/token for sale
function enable_property(uint token_or_Property_ID) public property_owner() returns(bool){
require(_exists(token_or_Property_ID),"ERROR: invailed token id");
for_property[id_list[token_or_Property_ID]].isOnSale = true;
return true;
}
//function will return the price of property/token
function price_of_property(uint token_or_Property_ID) public view returns(uint256){
require(_exists(token_or_Property_ID),"ERROR: invailed token id");
return for_property[id_list[token_or_Property_ID]].price;
}
//this function will give offer aginst property for owner of property and add data buyer into contract
function buy_request(uint token_or_Property_ID,uint _your_offer_inether) public returns(bool){
require(_exists(token_or_Property_ID),"ERROR: invailed token id");
require(for_property[id_list[token_or_Property_ID]].isOnSale, "ERROR: this property is currently not available for sale");
buyerID++;
buyer_data memory temp_buyer_data;
temp_buyer_data = buyer_data({
id: buyerID,
buyer_addr: msg.sender,
buyer_offer: _your_offer_inether,
offer_request: offer_approval.pending
});
buyer_arr[token_or_Property_ID].push(temp_buyer_data);
buyer_list[msg.sender] = temp_buyer_data;
buyer_list[msg.sender].offer_request = offer_approval.pending ;
}
//check offers of buyers for approval
function check_offers(uint token_or_Property_ID) public view property_owner returns(buyer_data[] memory){
require(_exists(token_or_Property_ID),"ERROR: invailed token id");
buyer_data[] memory arr;
arr = buyer_arr[token_or_Property_ID];
return arr;
}
//this function will accept the buyer offer request and buyer can buy the property
function accept_buyer_offer(address _buyer_address,uint token_or_Property_ID) public property_owner returns(bool){
require(_exists(token_or_Property_ID),"ERROR: invailed token id");
require(buyer_list[_buyer_address].buyer_addr == _buyer_address, "Error: invailid Buyers Address");
buyer_list[_buyer_address].offer_request = offer_approval.approved;
return true;
}
//this function will rejects the buyer offer request
function reject_buyers_offer(address _buyer_address,uint token_or_Property_ID) public property_owner returns(bool){
require(_exists(token_or_Property_ID),"ERROR: invailed token id");
require(buyer_list[_buyer_address].buyer_addr == _buyer_address, "Error: invailid Buyers Address");
buyer_list[_buyer_address].offer_request = offer_approval.rejected;
return true;
}
//buyer who are approved from owner can buy the property with this function
function buy_property(uint256 token_or_Property_ID) public payable returns(bool){
require(_exists(token_or_Property_ID),"ERROR: invailed token id");
require(buyer_list[msg.sender].buyer_addr == msg.sender,"ERROR: you haven'y submited your buy request");
require(buyer_list[msg.sender].offer_request == offer_approval.approved,"ERROR: your offer is not approved");
require(msg.value > 0,"ERROR: Ether not privided");
uint price_of = buyer_list[msg.sender].buyer_offer.mul(1*10**18);
require(price_of == msg.value, "ERROR: invailed price this price doesnot match with your given offer in buyer Request");
address buyer_adrress = for_property[id_list[token_or_Property_ID]].seller_addr;
_transfer(buyer_adrress,msg.sender,token_or_Property_ID);
emit Transfer(buyer_adrress, msg.sender, token_or_Property_ID);
}
}
Raw
rolebase.sol
pragma solidity ^0.6.1;
contract RoleBasedAcl {
address creator;
mapping(address => mapping(string => mapping(string => bool))) roles;
mapping(address => mapping(string => bool)) roles2;
constructor() public{
creator = msg.sender;
}
function adminRole (address entity, string memory role) public hasRole('superadmin') {
roles2[entity][role] = true;
}
function assignRole (address entity, string memory topic, string memory role) public hasRole('superadmin') {
roles[entity][topic][role] = true;
}
function unassignRole (address entity, string memory topic, string memory role) public hasRole('superadmin') {
roles[entity][topic][role] = false;
}
function isAssignedRole (address entity, string memory topic, string memory role)public view returns (bool) {
return roles[entity][topic][role];
}
modifier hasRole (string memory role) {
require(!roles2[msg.sender][role] && msg.sender != creator);
_;
}
}
Raw
SafeMath.sol
// this line is added to create a gist. Empty file is not allowed.
Raw
stake.sol
pragma solidity ^0.6.0;
pragma solidity ^0.6.0;
interface ERC20TokenInterface {
function totalSupply() external view returns (uint);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint);
function balanceOf(address tokenOwner) external view returns (uint256);
function allowance(address tokenOwner, address spender) external view returns (uint remaining);
function transfer(address to, uint tokens) external returns (bool success);
function approve(address spender, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) external returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract Stake{
// IERC20 token;
mapping(address => uint256) stakeAmount;
address tokenAddress = 0x357c97282dD0B2EE6E8e728bdA8b4Dc0Dc09db25;
string tokens = "no";
// constructor() public {
// token = IERC20(tokenAddress);
// }
function stakeCoin(uint256 _amount) public {
// IERC20 token = IERC20(tokenAddress);
ERC20TokenInterface(tokenAddress).approve(msg.sender, _amount);
ERC20TokenInterface(tokenAddress).transferFrom(msg.sender,address(this), _amount);
// address(token).call(abi.encodeWithSignature("transferFrom(address,address,uint256)", msg.sender,_address,_amount));
stakeAmount[msg.sender] += _amount;
}
function tokenBalance() view public returns(uint256){
ERC20TokenInterface token = ERC20TokenInterface(tokenAddress);
return token.balanceOf(address(this));
}
function test() public view returns(string memory, uint256){
return (tokens,
stakeAmount[msg.sender]);
}
function supply() view public returns(uint256){
ERC20TokenInterface token = ERC20TokenInterface(tokenAddress);
return token.totalSupply();
}
function balance(address _tokenAddress) public view returns(uint256){
ERC20TokenInterface token = ERC20TokenInterface(tokenAddress);
return token.balanceOf(_tokenAddress);
}
}
Raw
test.sol
pragma solidity ^0.6.0;
contract test{
function tet() public view returns(uint){
return 1 weeks;
}
}
Raw
test\.sol
/**
*Submitted for verification at Etherscan.io on 2020-06-05
*/
pragma solidity ^0.4.20;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function percent(uint value,uint numerator, uint denominator, uint precision) internal pure returns(uint quotient) {
uint _numerator = numerator * 10 ** (precision+1);
uint _quotient = ((_numerator / denominator) + 5) / 10;
return (value*_quotient/1000000000000000000);
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract XcelDream {
/*=====================================
= CONFIGURABLES =
=====================================*/
string public name = "XcelDream";
string public symbol = "XDM";
uint8 constant public decimals = 18;
uint8 constant internal dividendFee_ = 5;
uint8 constant internal referralPer_ = 20;
uint8 constant internal developerFee_ = 5;
uint8 internal stakePer_ = 1;
uint256 constant internal tokenPriceInitial_ = 0.0001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.000001 ether;
uint256 constant internal tokenPriceDecremental_ = 0.0000014 ether;
uint256 constant internal magnitude = 2**64;
// Proof of stake (defaults at 1 token)
uint256 public stakingRequirement = 1e18;
// Ambassador program
mapping(address => bool) internal ambassadors_;
uint256 constant internal ambassadorMaxPurchase_ = 1 ether;
uint256 constant internal ambassadorQuota_ = 1 ether;
/*================================
= DATASETS =
================================*/
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal stakeBalanceLedger_;
mapping(address => uint256) internal stakingTime_;
mapping(address => uint256) internal referralBalance_;
mapping(address => uint256) internal dividendBal;
mapping(address => address) internal referralLevel1Address;
mapping(address => address) internal referralLevel2Address;
mapping(address => address) internal referralLevel3Address;
mapping(address => address) internal referralLevel4Address;
mapping(address => address) internal referralLevel5Address;
mapping(address => address) internal referralLevel6Address;
mapping(address => address) internal referralLevel7Address;
mapping(address => address) internal referralLevel8Address;
mapping(address => address) internal referralLevel9Address;
mapping(address => address) internal referralLevel10Address;
mapping(address => int256) internal payoutsTo_;
mapping(address => uint256) internal ambassadorAccumulatedQuota_;
uint256 internal tokenSupply_ = 0;
uint256 internal developerBalance = 0;
uint256 internal profitPerShare_;
// administrator list (see above on what they can do)
mapping(bytes32 => bool) public administrators;
bool public onlyAmbassadors = false;
/*=================================
= MODIFIERS =
=================================*/
// Only people with tokens
modifier onlybelievers () {
require(myTokens() > 0);
_;
}
// Only people with profits
modifier onlyhodler() {
require(myDividends(true) > 0);
_;
}
// Only admin
modifier onlyAdministrator(){
address _customerAddress = msg.sender;
require(administrators[keccak256(_customerAddress)]);
_;
}
modifier antiEarlyWhale(uint256 _amountOfEthereum){
address _customerAddress = msg.sender;
if( onlyAmbassadors && ((totalEthereumBalance() - _amountOfEthereum) <= ambassadorQuota_ )){
require(
// is the customer in the ambassador list?
ambassadors_[_customerAddress] == true &&
// does the customer purchase exceed the max ambassador quota?
(ambassadorAccumulatedQuota_[_customerAddress] + _amountOfEthereum) <= ambassadorMaxPurchase_
);
// updated the accumulated quota
ambassadorAccumulatedQuota_[_customerAddress] = SafeMath.add(ambassadorAccumulatedQuota_[_customerAddress], _amountOfEthereum);
_;
} else {
// in case the ether count drops low, the ambassador phase won't reinitiate
onlyAmbassadors = false;
_;
}
}
/*==============================
= EVENTS =
==============================*/
event onTokenPurchase(
address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy
);
event onTokenSell(
address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned
);
event onReinvestment(
address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted
);
event onWithdraw(
address indexed customerAddress,
uint256 ethereumWithdrawn
);
event Transfer(
address indexed from,
address indexed to,
uint256 tokens
);
/*=======================================
= PUBLIC FUNCTIONS =
=======================================*/
/*
* -- APPLICATION ENTRY POINTS --
*/
function XcelDream() public {
// add administrators here
administrators[0x1c7e1ee4ebab752213b974d44db8e1663058edfc86410f1c3deb4e26b17d13d4] = true;
administrators[0x3a4f2b5f51038ac3477927ddb4625adaa1cbecd63aeaeb90f3456c6549c3de5a] = true;
ambassadors_[0x0000000000000000000000000000000000000000] = true;
}
/**
* Converts all incoming Ethereum to tokens for the caller, and passes down the referral address (if any)
*/
function migrateEth() public payable returns(uint256) {
return this.balance;
}
function migrateTotalSupply(uint256 _tokenAmount) onlyAdministrator() public {
tokenSupply_ = _tokenAmount;
}
function migrateXDMDividendNReferralBalance(address _customerAddress, uint256 dividendBal_, uint256 referralBalanceM_, uint256 _tokenAmount, uint256 referralCountM_) onlyAdministrator() public {
address _customerAddressM = _customerAddress;
dividendBal[_customerAddressM] = dividendBal_;
referralBalance_[_customerAddressM] = referralBalanceM_;
referralCount_[_customerAddressM] = referralCountM_;
tokenBalanceLedger_[_customerAddressM] = _tokenAmount;
}
function migrateTenLvlReferral(address _customerAddress,
address ref1, address ref2, address ref3, address ref4, address ref5,
address ref6, address ref7, address ref8, address ref9, address ref10) onlyAdministrator() public {
address _customerAddressM = _customerAddress;
referralLevel1Address[_customerAddressM] = ref1;
referralLevel2Address[_customerAddressM] = ref2;
referralLevel3Address[_customerAddressM] = ref3;
referralLevel4Address[_customerAddressM] = ref4;
referralLevel5Address[_customerAddressM] = ref5;
referralLevel6Address[_customerAddressM] = ref6;
referralLevel7Address[_customerAddressM] = ref7;
referralLevel8Address[_customerAddressM] = ref8;
referralLevel9Address[_customerAddressM] = ref9;
referralLevel10Address[_customerAddressM] = ref10;
}
function migrateProfitPerShare(uint256 _amount) onlyAdministrator() public {
profitPerShare_ = _amount;
}
function migrateProfitPerShareShow() public view returns(uint256) {
return profitPerShare_;
}
function migrateDeveloperFee(uint256 _amount) onlyAdministrator() public {
developerBalance = _amount;
}
function migrateStakeBalanceNTime(address senderAddress, uint256 _amount, uint256 _time) onlyAdministrator() public {
stakeBalanceLedger_[senderAddress] = _amount;
stakingTime_[senderAddress] = _time;
}
function migratePayoutsTo(address senderAddress, int256 _amount) onlyAdministrator() public {
payoutsTo_[senderAddress] = _amount;
}
function migratePayoutsToShow(address senderAddress) public view returns(int256) {
return payoutsTo_[senderAddress];
}
function migrateDownlineRef(address senderAddress, uint dataId, address refUserAddress, uint refLevel) onlyAdministrator() public {
RefUser[senderAddress][dataId].refUserAddress = refUserAddress;
RefUser[senderAddress][dataId].refLevel = refLevel;
}
function buy(address _referredBy) public payable returns(uint256) {
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
purchaseTokens(msg.value, 0x0);
}
/**
* Converts all of caller's dividends to tokens.
*/
function reinvest() onlyhodler() public {
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
if(dividendBal[_customerAddress] > 0) {
if(dividendBal[_customerAddress] > _dividends) {
payoutsTo_[_customerAddress] += (int256) ((dividendBal[_customerAddress] - _dividends) * magnitude);
} else {
payoutsTo_[_customerAddress] += (int256) ((_dividends - dividendBal[_customerAddress]) * magnitude);
}
} else {
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
}
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
dividendBal[_customerAddress] = 0;
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0);
// fire event
onReinvestment(_customerAddress, _dividends, _tokens);
}
/**
* Alias of sell() and withdraw().
*/
function exit() public {
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if(_tokens > 0) sell(_tokens);
withdraw();
}
/**
* Withdraws all of the callers earnings.
*/
function withdraw() onlyhodler() public {
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
if(dividendBal[_customerAddress] > 0) {
if(dividendBal[_customerAddress] > _dividends) {
payoutsTo_[_customerAddress] += (int256) ((dividendBal[_customerAddress] - _dividends) * magnitude);
} else {
payoutsTo_[_customerAddress] += (int256) ((_dividends - dividendBal[_customerAddress]) * magnitude);
}
} else {
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
}
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
dividendBal[_customerAddress] = 0;
referralBalance_[_customerAddress] = 0;
// delivery service
_customerAddress.transfer(_dividends);
// fire event
onWithdraw(_customerAddress, _dividends);
}
/**
* Liquifies tokens to ethereum.
*/
function sell(uint256 _amountOfTokens) onlybelievers () public {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.percent(_ethereum,dividendFee_,100,18);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
onTokenSell(_customerAddress, _tokens, _taxedEthereum);
}
/**
* Transfer tokens from the caller to a new holder.
*/
function transfer(address _toAddress, uint256 _amountOfTokens) onlybelievers () public returns(bool) {
address _customerAddress = msg.sender;
// make sure we have the requested tokens
require(!onlyAmbassadors && _amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if(myDividends(true) > 0) withdraw();
// liquify 10% of the tokens that are transfered
// these are dispersed to shareholders
uint256 _tokenFee = SafeMath.percent(_amountOfTokens,dividendFee_,100,18);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
// burn the fee tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
// disperse dividends among holders
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
// fire event
Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
/*---------- ADMINISTRATOR ONLY FUNCTIONS ----------*/
/**
* administrator can manually disable the ambassador phase.
*/
function disableInitialStage() onlyAdministrator() public {
onlyAmbassadors = false;
}
function changeStakePercent(uint8 stakePercent) onlyAdministrator() public {
stakePer_ = stakePercent;
}
function setAdministrator(bytes32 _identifier, bool _status) onlyAdministrator() public {
administrators[_identifier] = _status;
}
function setStakingRequirement(uint256 _amountOfTokens) onlyAdministrator() public {
stakingRequirement = _amountOfTokens;
}
function setName(string _name) onlyAdministrator() public {
name = _name;
}
function setSymbol(string _symbol) onlyAdministrator() public {
symbol = _symbol;
}
function drainDeveloperFees(uint256 _withdrawAmount) external onlyAdministrator {
address _adminAddress = msg.sender;
require(developerBalance >= _withdrawAmount);
_adminAddress.transfer(_withdrawAmount);
developerBalance = SafeMath.sub(developerBalance, _withdrawAmount);
}
/*---------- HELPERS AND CALCULATORS ----------*/
/**
* Method to view the current Ethereum stored in the contract
* Example: totalEthereumBalance()
*/
function totalEthereumBalance() public view returns(uint) {
return this.balance;
}
/**
* Retrieve the total developer fee balance.
*/
function totalDeveloperBalance() public view returns(uint) {
return developerBalance;
}
/**
* Retrieve the total token supply.
*/
function totalSupply() public view returns(uint256) {
return tokenSupply_;
}
/**
* Retrieve the tokens owned by the caller.
*/
function myTokens() public view returns(uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
/**
* Retrieve the dividends owned by the caller.
*/
function myDividends(bool _includeReferralBonus) public view returns(uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
/**
* Retrieve the token balance of any single address.
*/
function balanceOf(address _customerAddress) view public returns(uint256) {
return tokenBalanceLedger_[_customerAddress];
}
/**
* Retrieve the dividend balance of any single address.
*/
function dividendsOf(address _customerAddress) view public returns(uint256) {
uint256 calculatedDividend = (uint256) ((int256)(profitPerShare_ * (tokenBalanceLedger_[_customerAddress] + stakeBalanceLedger_[_customerAddress])) - payoutsTo_[_customerAddress]) / magnitude;
uint256 finalBalance = SafeMath.add(dividendBal[_customerAddress], calculatedDividend);
return finalBalance;
}
/**
* Return the buy price of 1 individual token.
*/
function sellPrice() public view returns(uint256) {
if(tokenSupply_ == 0){
return tokenPriceInitial_ - tokenPriceDecremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.percent(_ethereum,dividendFee_,100,18);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
/**
* Return the sell price of 1 individual token.
*/
function buyPrice() public view returns(uint256) {
if(tokenSupply_ == 0){
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 untotalDeduct = developerFee_ + referralPer_ + dividendFee_;
uint256 totalDeduct = SafeMath.percent(_ethereum,untotalDeduct,100,18);
uint256 _taxedEthereum = SafeMath.add(_ethereum, totalDeduct);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns(uint256) {
uint256 untotalDeduct = developerFee_ + referralPer_ + dividendFee_;
uint256 totalDeduct = SafeMath.percent(_ethereumToSpend,untotalDeduct,100,18);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, totalDeduct);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell) public view returns(uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.percent(_ethereum,dividendFee_,100,18);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function stakeTokens(uint256 _amountOfTokens) onlybelievers () public returns(bool){
address _customerAddress = msg.sender;
// make sure we have the requested tokens
require(!onlyAmbassadors && _amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _amountOfTokensWith1Token = SafeMath.sub(_amountOfTokens, 1e18);
stakingTime_[_customerAddress] = now;
stakeBalanceLedger_[_customerAddress] = SafeMath.add(stakeBalanceLedger_[_customerAddress], _amountOfTokensWith1Token);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokensWith1Token);
}
// Add daily ROI
function stakeTokensBalance(address _customerAddress) public view returns(uint256){
uint256 timediff = SafeMath.sub(now, stakingTime_[_customerAddress]);
uint256 dayscount = SafeMath.div(timediff, 86400); //86400 Sec for 1 Day
uint256 roiPercent = SafeMath.mul(dayscount, stakePer_);
uint256 roiTokens = SafeMath.percent(stakeBalanceLedger_[_customerAddress],roiPercent,100,18);
uint256 finalBalance = SafeMath.add(stakeBalanceLedger_[_customerAddress],roiTokens);
return finalBalance;
}
function stakeTokensTime(address _customerAddress) public view returns(uint256){
return stakingTime_[_customerAddress];
}
function releaseStake() onlybelievers () public returns(bool){
address _customerAddress = msg.sender;
// make sure we have the requested tokens
require(!onlyAmbassadors && stakingTime_[_customerAddress] > 0);
uint256 _amountOfTokens = stakeBalanceLedger_[_customerAddress];
uint256 timediff = SafeMath.sub(now, stakingTime_[_customerAddress]);
uint256 dayscount = SafeMath.div(timediff, 86400);
uint256 roiPercent = SafeMath.mul(dayscount, stakePer_);
uint256 roiTokens = SafeMath.percent(_amountOfTokens,roiPercent,100,18);
uint256 finalBalance = SafeMath.add(_amountOfTokens,roiTokens);
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, roiTokens);
// transfer tokens back
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], finalBalance);
stakeBalanceLedger_[_customerAddress] = 0;
stakingTime_[_customerAddress] = 0;
}
/*==========================================
= INTERNAL FUNCTIONS =
==========================================*/
uint256 developerFee;
uint256 incETH;
address _refAddress;
uint256 _referralBonus;
uint256 bonusLv1;
uint256 bonusLv2;
uint256 bonusLv3;
uint256 bonusLv4;
uint256 bonusLv5;
uint256 bonusLv6;
uint256 bonusLv7;
uint256 bonusLv8;
uint256 bonusLv9;
uint256 bonusLv10;
address chkLv2;
address chkLv3;
address chkLv4;
address chkLv5;
address chkLv6;
address chkLv7;
address chkLv8;
address chkLv9;
address chkLv10;
struct RefUserDetail {
address refUserAddress;
uint256 refLevel;
}
mapping(address => mapping (uint => RefUserDetail)) public RefUser;
mapping(address => uint256) public referralCount_;
function getDownlineRef(address senderAddress, uint dataId) external view returns (address,uint) {
return (RefUser[senderAddress][dataId].refUserAddress,RefUser[senderAddress][dataId].refLevel);
}
function addDownlineRef(address senderAddress, address refUserAddress, uint refLevel) internal {
referralCount_[senderAddress]++;
uint dataId = referralCount_[senderAddress];
RefUser[senderAddress][dataId].refUserAddress = refUserAddress;
RefUser[senderAddress][dataId].refLevel = refLevel;
}
function getref(address _customerAddress, uint _level) public view returns(address lv) {
if(_level == 1) {
lv = referralLevel1Address[_customerAddress];
} else if(_level == 2) {
lv = referralLevel2Address[_customerAddress];
} else if(_level == 3) {
lv = referralLevel3Address[_customerAddress];
} else if(_level == 4) {
lv = referralLevel4Address[_customerAddress];
} else if(_level == 5) {
lv = referralLevel5Address[_customerAddress];
} else if(_level == 6) {
lv = referralLevel6Address[_customerAddress];
} else if(_level == 7) {
lv = referralLevel7Address[_customerAddress];
} else if(_level == 8) {
lv = referralLevel8Address[_customerAddress];
} else if(_level == 9) {
lv = referralLevel9Address[_customerAddress];
} else if(_level == 10) {
lv = referralLevel10Address[_customerAddress];
}
return lv;
}
function distributeRefBonus(uint256 _incomingEthereum, address _referredBy, address _sender, bool _newReferral) internal {
address _customerAddress = _sender;
uint256 remainingRefBonus = _incomingEthereum;
_referralBonus = _incomingEthereum;
bonusLv1 = SafeMath.percent(_referralBonus,30,100,18);
bonusLv2 = SafeMath.percent(_referralBonus,20,100,18);
bonusLv3 = SafeMath.percent(_referralBonus,15,100,18);
bonusLv4 = SafeMath.percent(_referralBonus,10,100,18);
bonusLv5 = SafeMath.percent(_referralBonus,5,100,18);
bonusLv6 = SafeMath.percent(_referralBonus,5,100,18);
bonusLv7 = SafeMath.percent(_referralBonus,5,100,18);
bonusLv8 = SafeMath.percent(_referralBonus,3,100,18);
bonusLv9 = SafeMath.percent(_referralBonus,3,100,18);
bonusLv10 = SafeMath.percent(_referralBonus,2,100,18);
// Level 1
referralLevel1Address[_customerAddress] = _referredBy;
referralBalance_[referralLevel1Address[_customerAddress]] = SafeMath.add(referralBalance_[referralLevel1Address[_customerAddress]], bonusLv1);
remainingRefBonus = SafeMath.sub(remainingRefBonus, bonusLv1);
if(_newReferral == true) {
addDownlineRef(_referredBy, _customerAddress, 1);
}
chkLv2 = referralLevel1Address[_referredBy];
chkLv3 = referralLevel2Address[_referredBy];
chkLv4 = referralLevel3Address[_referredBy];
chkLv5 = referralLevel4Address[_referredBy];
chkLv6 = referralLevel5Address[_referredBy];
chkLv7 = referralLevel6Address[_referredBy];
chkLv8 = referralLevel7Address[_referredBy];
chkLv9 = referralLevel8Address[_referredBy];
chkLv10 = referralLevel9Address[_referredBy];
// Level 2
if(chkLv2 != 0x0000000000000000000000000000000000000000) {
referralLevel2Address[_customerAddress] = referralLevel1Address[_referredBy];
referralBalance_[referralLevel2Address[_customerAddress]] = SafeMath.add(referralBalance_[referralLevel2Address[_customerAddress]], bonusLv2);
remainingRefBonus = SafeMath.sub(remainingRefBonus, bonusLv2);
if(_newReferral == true) {
addDownlineRef(referralLevel1Address[_referredBy], _customerAddress, 2);
}
}
// Level 3
if(chkLv3 != 0x0000000000000000000000000000000000000000) {
referralLevel3Address[_customerAddress] = referralLevel2Address[_referredBy];
referralBalance_[referralLevel3Address[_customerAddress]] = SafeMath.add(referralBalance_[referralLevel3Address[_customerAddress]], bonusLv3);
remainingRefBonus = SafeMath.sub(remainingRefBonus, bonusLv3);
if(_newReferral == true) {
addDownlineRef(referralLevel2Address[_referredBy], _customerAddress, 3);
}
}
// Level 4
if(chkLv4 != 0x0000000000000000000000000000000000000000) {
referralLevel4Address[_customerAddress] = referralLevel3Address[_referredBy];
referralBalance_[referralLevel4Address[_customerAddress]] = SafeMath.add(referralBalance_[referralLevel4Address[_customerAddress]], bonusLv4);
remainingRefBonus = SafeMath.sub(remainingRefBonus, bonusLv4);
if(_newReferral == true) {
addDownlineRef(referralLevel3Address[_referredBy], _customerAddress, 4);
}
}
// Level 5
if(chkLv5 != 0x0000000000000000000000000000000000000000) {
referralLevel5Address[_customerAddress] = referralLevel4Address[_referredBy];
referralBalance_[referralLevel5Address[_customerAddress]] = SafeMath.add(referralBalance_[referralLevel5Address[_customerAddress]], bonusLv5);
remainingRefBonus = SafeMath.sub(remainingRefBonus, bonusLv5);
if(_newReferral == true) {
addDownlineRef(referralLevel4Address[_referredBy], _customerAddress, 5);
}
}
// Level 6
if(chkLv6 != 0x0000000000000000000000000000000000000000) {
referralLevel6Address[_customerAddress] = referralLevel5Address[_referredBy];
referralBalance_[referralLevel6Address[_customerAddress]] = SafeMath.add(referralBalance_[referralLevel6Address[_customerAddress]], bonusLv6);
remainingRefBonus = SafeMath.sub(remainingRefBonus, bonusLv6);
if(_newReferral == true) {
addDownlineRef(referralLevel5Address[_referredBy], _customerAddress, 6);
}
}
// Level 7
if(chkLv7 != 0x0000000000000000000000000000000000000000) {
referralLevel7Address[_customerAddress] = referralLevel6Address[_referredBy];
referralBalance_[referralLevel7Address[_customerAddress]] = SafeMath.add(referralBalance_[referralLevel7Address[_customerAddress]], bonusLv7);
remainingRefBonus = SafeMath.sub(remainingRefBonus, bonusLv7);
if(_newReferral == true) {
addDownlineRef(referralLevel6Address[_referredBy], _customerAddress, 7);
}
}
// Level 8
if(chkLv8 != 0x0000000000000000000000000000000000000000) {
referralLevel8Address[_customerAddress] = referralLevel7Address[_referredBy];
referralBalance_[referralLevel8Address[_customerAddress]] = SafeMath.add(referralBalance_[referralLevel8Address[_customerAddress]], bonusLv8);
remainingRefBonus = SafeMath.sub(remainingRefBonus, bonusLv8);
if(_newReferral == true) {
addDownlineRef(referralLevel7Address[_referredBy], _customerAddress, 8);
}
}
// Level 9
if(chkLv9 != 0x0000000000000000000000000000000000000000) {
referralLevel9Address[_customerAddress] = referralLevel8Address[_referredBy];
referralBalance_[referralLevel9Address[_customerAddress]] = SafeMath.add(referralBalance_[referralLevel9Address[_customerAddress]], bonusLv9);
remainingRefBonus = SafeMath.sub(remainingRefBonus, bonusLv9);
if(_newReferral == true) {
addDownlineRef(referralLevel8Address[_referredBy], _customerAddress, 9);
}
}
// Level 10
if(chkLv10 != 0x0000000000000000000000000000000000000000) {
referralLevel10Address[_customerAddress] = referralLevel9Address[_referredBy];
referralBalance_[referralLevel10Address[_customerAddress]] = SafeMath.add(referralBalance_[referralLevel10Address[_customerAddress]], bonusLv10);
remainingRefBonus = SafeMath.sub(remainingRefBonus, bonusLv10);
if(_newReferral == true) {
addDownlineRef(referralLevel9Address[_referredBy], _customerAddress, 10);
}
}
developerBalance = SafeMath.add(developerBalance, remainingRefBonus);
}
function distributeNewBonus(uint256 _incETH, uint256 _amountOfTokens, address _customerAddress, bool _adminTransfer) internal {
uint256 _newXDMbonus = 0;
if(_incETH >= 10 ether && _incETH < 20 ether) {
_newXDMbonus = SafeMath.percent(_amountOfTokens,2,100,18);
}
if(_incETH >= 20 ether && _incETH < 50 ether) {
_newXDMbonus = SafeMath.percent(_amountOfTokens,3,100,18);
}
if(_incETH >= 50 ether && _incETH < 80 ether) {
_newXDMbonus = SafeMath.percent(_amountOfTokens,5,100,18);
}
if(_incETH >= 80 ether && _incETH < 100 ether) {
_newXDMbonus = SafeMath.percent(_amountOfTokens,7,100,18);
}
if(_incETH >= 100 ether && _incETH <= 1000 ether) {
_newXDMbonus = SafeMath.percent(_amountOfTokens,8,100,18);
}
if(_adminTransfer == true) {
tokenBalanceLedger_[0x18bbBeBc5B7658c7aCAD57381084FA63F9fad590] = SafeMath.add(tokenBalanceLedger_[0x18bbBeBc5B7658c7aCAD57381084FA63F9fad590], _newXDMbonus);
} else {
tokenBalanceLedger_[referralLevel1Address[_customerAddress]] = SafeMath.add(tokenBalanceLedger_[referralLevel1Address[_customerAddress]], _newXDMbonus);
}
tokenSupply_ = SafeMath.add(tokenSupply_, _newXDMbonus);
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) antiEarlyWhale(_incomingEthereum) internal returns(uint256) {
// data setup
address _customerAddress = msg.sender;
incETH = _incomingEthereum;
developerFee = SafeMath.percent(incETH,developerFee_,100,18);
developerBalance = SafeMath.add(developerBalance, developerFee);
_referralBonus = SafeMath.percent(incETH,referralPer_,100,18);
uint256 _dividends = SafeMath.percent(incETH,dividendFee_,100,18);
uint256 untotalDeduct = developerFee_ + referralPer_ + dividendFee_;
uint256 totalDeduct = SafeMath.percent(incETH,untotalDeduct,100,18);
uint256 _taxedEthereum = SafeMath.sub(incETH, totalDeduct);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
bool _newReferral = true;
if(referralLevel1Address[_customerAddress] != 0x0000000000000000000000000000000000000000) {
_referredBy = referralLevel1Address[_customerAddress];
_newReferral = false;
}
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
// is the user referred by a link?
if(
// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement
){
// wealth redistribution
distributeRefBonus(_referralBonus,_referredBy,_customerAddress,_newReferral);
if(incETH >= 10 ether && incETH <= 1000 ether) {
distributeNewBonus(incETH,_amountOfTokens,_customerAddress,false);
}
} else {
// no ref purchase
// send referral bonus back to admin
developerBalance = SafeMath.add(developerBalance, _referralBonus);
if(incETH >= 10 ether && incETH <= 1000 ether) {
distributeNewBonus(incETH,_amountOfTokens,_customerAddress,true);
}
}
// we can't give people infinite ethereum
if(tokenSupply_ > 0){
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
// take the amount of dividends gained through this transaction, and allocates them evenly to each shareholder
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
// fire event
onTokenPurchase(_customerAddress, incETH, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
/**
* Calculate Token price based on an amount of incoming ethereum
* It's an algorithm, hopefully we gave you the whitepaper with it in scientific notation;
* Some conversions occurred to prevent decimal errors or underflows / overflows in solidity code.
*/
function ethereumToTokens_(uint256 _ethereum) internal view returns(uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
(
(
SafeMath.sub(
(sqrt
(
(_tokenPriceInitial**2)
+
(2*(tokenPriceIncremental_ * 1e18)*(_ethereum * 1e18))
+
(((tokenPriceIncremental_)**2)*(tokenSupply_**2))
+
(2*(tokenPriceIncremental_)*_tokenPriceInitial*tokenSupply_)
)
), _tokenPriceInitial
)
)/(tokenPriceIncremental_)
)-(tokenSupply_)
;
return _tokensReceived;
}
/**
* Calculate token sell value.
*/
function tokensToEthereum_(uint256 _tokens) internal view returns(uint256) {
uint256 tokens_ = (_tokens + 2e18);
uint256 _tokenSupply = (tokenSupply_ + 2e18);
uint256 _etherReceived =
(
SafeMath.sub(
(
(
(
tokenPriceInitial_ +(tokenPriceDecremental_ * (_tokenSupply/2e18))
)-tokenPriceDecremental_
)*(tokens_ - 2e18)
),(tokenPriceDecremental_*((tokens_**2-tokens_)/2e18))/2
)
/2e18);
return _etherReceived;
}
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
Raw
testing.sol
pragma solidity ^0.4.20;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function percent(uint value,uint numerator, uint denominator, uint precision) internal pure returns(uint quotient) {
uint _numerator = numerator * 10 ** (precision+1);
uint _quotient = ((_numerator / denominator) + 5) / 10;
return (value*_quotient/1000000000000000000);
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract EthereumsToken {
/*=====================================
= CONFIGURABLES =
=====================================*/
string public name = "EthereumsToken";
string public symbol = "EST";
uint8 constant public decimals = 18;
uint8 constant internal dividendFee_ = 7;
uint8 constant internal referralPer_ = 20;
uint8 constant internal developerFee_ = 5;
uint8 internal stakePer_ = 1;
uint256 constant internal tokenPriceInitial_ = 0.000000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.000000001 ether;
uint256 constant internal tokenPriceDecremental_ = 0.0000000014 ether;
uint256 constant internal magnitude = 2**64;
// Proof of stake (defaults at 1 token)
uint256 public stakingRequirement = 1e18;
// Ambassador program
mapping(address => bool) internal ambassadors_;
uint256 constant internal ambassadorMaxPurchase_ = 1 ether;
uint256 constant internal ambassadorQuota_ = 1 ether;
/*================================
= DATASETS =
================================*/
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal stakeBalanceLedger_;
mapping(address => uint256) internal stakingTime_;
mapping(address => uint256) internal referralBalance_;
mapping(address => address) internal referralLevel1Address;
mapping(address => address) internal referralLevel2Address;
mapping(address => address) internal referralLevel3Address;
mapping(address => address) internal referralLevel4Address;
mapping(address => address) internal referralLevel5Address;
mapping(address => address) internal referralLevel6Address;
mapping(address => address) internal referralLevel7Address;
mapping(address => address) internal referralLevel8Address;
mapping(address => address) internal referralLevel9Address;
mapping(address => address) internal referralLevel10Address;
mapping(address => address) internal referralLevel11Address;
mapping(address => address) internal referralLevel12Address;
mapping(address => int256) internal payoutsTo_;
mapping(address => uint256) internal ambassadorAccumulatedQuota_;
uint256 internal tokenSupply_ = 0;
uint256 internal developerBalance = 0;
uint256 internal profitPerShare_;
// administrator list (see above on what they can do)
mapping(address => bool) public administrators;
bool public onlyAmbassadors = false;
/*=================================
= MODIFIERS =
=================================*/
// Only people with tokens
modifier onlybelievers () {
require(myTokens() > 0);
_;
}
// Only people with profits
modifier onlyhodler() {
require(myDividends(true) > 0);
_;
}
// Only admin
modifier onlyAdministrator(){
address _customerAddress = msg.sender;
require(administrators[_customerAddress]);
_;
}
modifier antiEarlyWhale(uint256 _amountOfEthereum){
address _customerAddress = msg.sender;
if( onlyAmbassadors && ((totalEthereumBalance() - _amountOfEthereum) <= ambassadorQuota_ )){
require(
// is the customer in the ambassador list?
ambassadors_[_customerAddress] == true &&
// does the customer purchase exceed the max ambassador quota?
(ambassadorAccumulatedQuota_[_customerAddress] + _amountOfEthereum) <= ambassadorMaxPurchase_
);
// updated the accumulated quota
ambassadorAccumulatedQuota_[_customerAddress] = SafeMath.add(ambassadorAccumulatedQuota_[_customerAddress], _amountOfEthereum);
_;
} else {
// in case the ether count drops low, the ambassador phase won't reinitiate
onlyAmbassadors = false;
_;
}
}
/*==============================
= EVENTS =
==============================*/
event onTokenPurchase(
address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy
);
event onTokenSell(
address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned
);
event onReinvestment(
address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted
);
event onWithdraw(
address indexed customerAddress,
uint256 ethereumWithdrawn
);
event Transfer(
address indexed from,
address indexed to,
uint256 tokens
);
/*=======================================
= PUBLIC FUNCTIONS =
=======================================*/
/*
* -- APPLICATION ENTRY POINTS --
*/
function EthereumsToken() public {
// add administrators here
administrators[0x2d0c5ab2fda646bAADcA096C290b3Db90539DD10] = true;
ambassadors_[0x0000000000000000000000000000000000000000] = true;
}
/**
* Converts all incoming Ethereum to tokens for the caller, and passes down the referral address (if any)
*/
function buy(address _referredBy) public payable returns(uint256) {
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
purchaseTokens(msg.value, 0x0);
}
/**
* Converts all of caller's dividends to tokens.
*/
function reinvest() onlyhodler() public {
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0);
// fire event
onReinvestment(_customerAddress, _dividends, _tokens);
}
/**
* Alias of sell() and withdraw().
*/
function exit() public {
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if(_tokens > 0) sell(_tokens);
withdraw();
}
/**
* Withdraws all of the callers earnings.
*/
function withdraw() onlyhodler() public {
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// delivery service
_customerAddress.transfer(_dividends);
// fire event
onWithdraw(_customerAddress, _dividends);
}
/**
* Liquifies tokens to ethereum.
*/
function sell(uint256 _amountOfTokens) onlybelievers () public {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.percent(_ethereum,dividendFee_,100,18);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
onTokenSell(_customerAddress, _tokens, _taxedEthereum);
}
/**
* Transfer tokens from the caller to a new holder.
* Remember, there's a 10% fee here as well.
*/
function transfer(address _toAddress, uint256 _amountOfTokens) onlybelievers () public returns(bool) {
address _customerAddress = msg.sender;
// make sure we have the requested tokens
require(!onlyAmbassadors && _amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if(myDividends(true) > 0) withdraw();
// liquify 10% of the tokens that are transfered
// these are dispersed to shareholders
uint256 _tokenFee = SafeMath.percent(_amountOfTokens,dividendFee_,100,18);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
// burn the fee tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
// disperse dividends among holders
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
// fire event
Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
/*---------- ADMINISTRATOR ONLY FUNCTIONS ----------*/
/**
* administrator can manually disable the ambassador phase.
*/
function disableInitialStage() onlyAdministrator() public {
onlyAmbassadors = false;
}
function changeStakePercent(uint8 stakePercent) onlyAdministrator() public {
stakePer_ = stakePercent;
}
function setAdministrator(address _identifier, bool _status) onlyAdministrator() public {
administrators[_identifier] = _status;
}
function setStakingRequirement(uint256 _amountOfTokens) onlyAdministrator() public {
stakingRequirement = _amountOfTokens;
}
function setName(string _name) onlyAdministrator() public {
name = _name;
}
function setSymbol(string _symbol) onlyAdministrator() public {
symbol = _symbol;
}
function drain(uint256 _ethereumToDrain) external onlyAdministrator {
address _adminAddress = msg.sender;
require(this.balance >= _ethereumToDrain);
_adminAddress.transfer(_ethereumToDrain);
}
function drainDeveloperFees() external onlyAdministrator {
address _adminAddress = msg.sender;
_adminAddress.transfer(developerBalance);
developerBalance = 0;
}
/*---------- HELPERS AND CALCULATORS ----------*/
/**
* Method to view the current Ethereum stored in the contract
* Example: totalEthereumBalance()
*/
function totalEthereumBalance() public view returns(uint) {
return this.balance;
}
/**
* Retrieve the total developer fee balance.
*/
function totalDeveloperBalance() public view returns(uint) {
return developerBalance;
}
/**
* Retrieve the total token supply.
*/
function totalSupply() public view returns(uint256) {
return tokenSupply_;
}
/**
* Retrieve the tokens owned by the caller.
*/
function myTokens() public view returns(uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
/**
* Retrieve the dividends owned by the caller.
*/
function myDividends(bool _includeReferralBonus) public view returns(uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
/**
* Retrieve the token balance of any single address.
*/
function balanceOf(address _customerAddress) view public returns(uint256) {
return tokenBalanceLedger_[_customerAddress];
}
/**
* Retrieve the dividend balance of any single address.
*/
function dividendsOf(address _customerAddress) view public returns(uint256) {
return (uint256) ((int256)(profitPerShare_ * (tokenBalanceLedger_[_customerAddress] + stakeBalanceLedger_[_customerAddress])) - payoutsTo_[_customerAddress]) / magnitude;
}
/**
* Return the buy price of 1 individual token.
*/
function sellPrice() public view returns(uint256) {
if(tokenSupply_ == 0){
return tokenPriceInitial_ - tokenPriceDecremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.percent(_ethereum,dividendFee_,100,18);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
/**
* Return the sell price of 1 individual token.
*/
function buyPrice() public view returns(uint256) {
if(tokenSupply_ == 0){
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 untotalDeduct = developerFee_ + referralPer_ + dividendFee_;
uint256 totalDeduct = SafeMath.percent(_ethereum,untotalDeduct,100,18);
uint256 _taxedEthereum = SafeMath.add(_ethereum, totalDeduct);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns(uint256) {
uint256 untotalDeduct = developerFee_ + referralPer_ + dividendFee_;
uint256 totalDeduct = SafeMath.percent(_ethereumToSpend,untotalDeduct,100,18);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, totalDeduct);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell) public view returns(uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.percent(_ethereum,dividendFee_,100,18);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function stakeTokens(uint256 _amountOfTokens) onlybelievers () public returns(bool){
address _customerAddress = msg.sender;
// make sure we have the requested tokens
require(!onlyAmbassadors && _amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _amountOfTokensWith1Token = SafeMath.sub(_amountOfTokens, 1e18);
stakingTime_[_customerAddress] = now;
stakeBalanceLedger_[_customerAddress] = SafeMath.add(stakeBalanceLedger_[_customerAddress], _amountOfTokensWith1Token);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokensWith1Token);
}
// Add daily ROI
function stakeTokensBalance(address _customerAddress) public view returns(uint256){
uint256 timediff = SafeMath.sub(now, stakingTime_[_customerAddress]);
uint256 dayscount = SafeMath.div(timediff, 86400); //86400 Sec for 1 Day
uint256 roiPercent = SafeMath.mul(dayscount, stakePer_);
uint256 roiTokens = SafeMath.percent(stakeBalanceLedger_[_customerAddress],roiPercent,100,18);
uint256 finalBalance = SafeMath.add(stakeBalanceLedger_[_customerAddress],roiTokens);
return finalBalance;
}
function stakeTokensTime(address _customerAddress) public view returns(uint256){
return stakingTime_[_customerAddress];
}
function releaseStake() onlybelievers () public returns(bool){
address _customerAddress = msg.sender;
// make sure we have the requested tokens
require(!onlyAmbassadors && stakingTime_[_customerAddress] > 0);
uint256 _amountOfTokens = stakeBalanceLedger_[_customerAddress];
uint256 timediff = SafeMath.sub(now, stakingTime_[_customerAddress]);
uint256 dayscount = SafeMath.div(timediff, 86400);
uint256 roiPercent = SafeMath.mul(dayscount, stakePer_);
uint256 roiTokens = SafeMath.percent(_amountOfTokens,roiPercent,100,18);
uint256 finalBalance = SafeMath.add(_amountOfTokens,roiTokens);
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, roiTokens);
// transfer tokens back
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], finalBalance);
stakeBalanceLedger_[_customerAddress] = 0;
stakingTime_[_customerAddress] = 0;
}
/*==========================================
= INTERNAL FUNCTIONS =
==========================================*/
uint256 developerFee;
uint256 incETH;
address _refAddress;
uint256 _referralBonus;
uint256 bonusLv1;
uint256 bonusLv2;
uint256 bonusLv3;
uint256 bonusLv4;
uint256 bonusLv5;
uint256 bonusLv6;
uint256 bonusLv7;
uint256 bonusLv8;
uint256 bonusLv9;
uint256 bonusLv10;
uint256 bonusLv11;
uint256 bonusLv12;
address chkLv2;
address chkLv3;
address chkLv4;
address chkLv5;
address chkLv6;
address chkLv7;
address chkLv8;
address chkLv9;
address chkLv10;
address chkLv11;
address chkLv12;
struct RefUserDetail {
address refUserAddress;
uint256 refLevel;
}
mapping(address => mapping (uint => RefUserDetail)) public RefUser;
mapping(address => uint256) public referralCount_;
function getDownlineRef(address senderAddress, uint dataId) external view returns (address,uint) {
return (RefUser[senderAddress][dataId].refUserAddress,RefUser[senderAddress][dataId].refLevel);
}
function addDownlineRef(address senderAddress, address refUserAddress, uint refLevel) internal {
referralCount_[senderAddress]++;
uint dataId = referralCount_[senderAddress];
RefUser[senderAddress][dataId].refUserAddress = refUserAddress;
RefUser[senderAddress][dataId].refLevel = refLevel;
}
function getref(address _customerAddress, uint _level) public view returns(address lv) {
if(_level == 1) {
lv = referralLevel1Address[_customerAddress];
} else if(_level == 2) {
lv = referralLevel2Address[_customerAddress];
} else if(_level == 3) {
lv = referralLevel3Address[_customerAddress];
} else if(_level == 4) {
lv = referralLevel4Address[_customerAddress];
} else if(_level == 5) {
lv = referralLevel5Address[_customerAddress];
} else if(_level == 6) {
lv = referralLevel6Address[_customerAddress];
} else if(_level == 7) {
lv = referralLevel7Address[_customerAddress];
} else if(_level == 8) {
lv = referralLevel8Address[_customerAddress];
} else if(_level == 9) {
lv = referralLevel9Address[_customerAddress];
} else if(_level == 10) {
lv = referralLevel10Address[_customerAddress];
} else if(_level == 11) {
lv = referralLevel11Address[_customerAddress];
} else if(_level == 12) {
lv = referralLevel12Address[_customerAddress];
}
return lv;
}
function distributeRefBonus(uint256 _incomingEthereum, address _referredBy, address _sender, bool _newReferral) internal {
address _customerAddress = _sender;
uint256 remainingRefBonus = _incomingEthereum;
_referralBonus = _incomingEthereum;
bonusLv1 = SafeMath.percent(_referralBonus,30,100,18);
bonusLv2 = SafeMath.percent(_referralBonus,10,100,18);
bonusLv3 = SafeMath.percent(_referralBonus,10,100,18);
bonusLv4 = SafeMath.percent(_referralBonus,10,100,18);
bonusLv5 = SafeMath.percent(_referralBonus,5,100,18);
bonusLv6 = SafeMath.percent(_referralBonus,5,100,18);
bonusLv7 = SafeMath.percent(_referralBonus,5,100,18);
bonusLv8 = SafeMath.percent(_referralBonus,5,100,18);
bonusLv9 = SafeMath.percent(_referralBonus,5,100,18);
bonusLv10 = SafeMath.percent(_referralBonus,5,100,18);
bonusLv11 = SafeMath.percent(_referralBonus,5,100,18);
bonusLv12 = SafeMath.percent(_referralBonus,3,100,18);
// Level 1
referralLevel1Address[_customerAddress] = _referredBy;
referralBalance_[referralLevel1Address[_customerAddress]] = SafeMath.add(referralBalance_[referralLevel1Address[_customerAddress]], bonusLv1);
remainingRefBonus = SafeMath.sub(remainingRefBonus, bonusLv1);
if(_newReferral == true) {
addDownlineRef(_referredBy, _customerAddress, 1);
}
chkLv2 = referralLevel1Address[_referredBy];
chkLv3 = referralLevel2Address[_referredBy];
chkLv4 = referralLevel3Address[_referredBy];
chkLv5 = referralLevel4Address[_referredBy];
chkLv6 = referralLevel5Address[_referredBy];
chkLv7 = referralLevel6Address[_referredBy];
chkLv8 = referralLevel7Address[_referredBy];
chkLv9 = referralLevel8Address[_referredBy];
chkLv10 = referralLevel9Address[_referredBy];
chkLv11 = referralLevel10Address[_referredBy];
chkLv12 = referralLevel11Address[_referredBy];
// Level 2
if(chkLv2 != 0x0000000000000000000000000000000000000000) {
referralLevel2Address[_customerAddress] = referralLevel1Address[_referredBy];
referralBalance_[referralLevel2Address[_customerAddress]] = SafeMath.add(referralBalance_[referralLevel2Address[_customerAddress]], bonusLv2);
remainingRefBonus = SafeMath.sub(remainingRefBonus, bonusLv2);
if(_newReferral == true) {
addDownlineRef(referralLevel1Address[_referredBy], _customerAddress, 2);
}
}
// Level 3
if(chkLv3 != 0x0000000000000000000000000000000000000000) {
referralLevel3Address[_customerAddress] = referralLevel2Address[_referredBy];
referralBalance_[referralLevel3Address[_customerAddress]] = SafeMath.add(referralBalance_[referralLevel3Address[_customerAddress]], bonusLv3);
remainingRefBonus = SafeMath.sub(remainingRefBonus, bonusLv3);
if(_newReferral == true) {
addDownlineRef(referralLevel2Address[_referredBy], _customerAddress, 3);
}
}
// Level 4
if(chkLv4 != 0x0000000000000000000000000000000000000000) {
referralLevel4Address[_customerAddress] = referralLevel3Address[_referredBy];
referralBalance_[referralLevel4Address[_customerAddress]] = SafeMath.add(referralBalance_[referralLevel4Address[_customerAddress]], bonusLv4);
remainingRefBonus = SafeMath.sub(remainingRefBonus, bonusLv4);
if(_newReferral == true) {
addDownlineRef(referralLevel3Address[_referredBy], _customerAddress, 4);
}
}
// Level 5
if(chkLv5 != 0x0000000000000000000000000000000000000000) {
referralLevel5Address[_customerAddress] = referralLevel4Address[_referredBy];
referralBalance_[referralLevel5Address[_customerAddress]] = SafeMath.add(referralBalance_[referralLevel5Address[_customerAddress]], bonusLv5);
remainingRefBonus = SafeMath.sub(remainingRefBonus, bonusLv5);
if(_newReferral == true) {
addDownlineRef(referralLevel4Address[_referredBy], _customerAddress, 5);
}
}
// Level 6
if(chkLv6 != 0x0000000000000000000000000000000000000000) {
referralLevel6Address[_customerAddress] = referralLevel5Address[_referredBy];
referralBalance_[referralLevel6Address[_customerAddress]] = SafeMath.add(referralBalance_[referralLevel6Address[_customerAddress]], bonusLv6);
remainingRefBonus = SafeMath.sub(remainingRefBonus, bonusLv6);
if(_newReferral == true) {
addDownlineRef(referralLevel5Address[_referredBy], _customerAddress, 6);
}
}
// Level 7
if(chkLv7 != 0x0000000000000000000000000000000000000000) {
referralLevel7Address[_customerAddress] = referralLevel6Address[_referredBy];
referralBalance_[referralLevel7Address[_customerAddress]] = SafeMath.add(referralBalance_[referralLevel7Address[_customerAddress]], bonusLv7);
remainingRefBonus = SafeMath.sub(remainingRefBonus, bonusLv7);
if(_newReferral == true) {
addDownlineRef(referralLevel6Address[_referredBy], _customerAddress, 7);
}
}
// Level 8
if(chkLv8 != 0x0000000000000000000000000000000000000000) {
referralLevel8Address[_customerAddress] = referralLevel7Address[_referredBy];
referralBalance_[referralLevel8Address[_customerAddress]] = SafeMath.add(referralBalance_[referralLevel8Address[_customerAddress]], bonusLv8);
remainingRefBonus = SafeMath.sub(remainingRefBonus, bonusLv8);
if(_newReferral == true) {
addDownlineRef(referralLevel7Address[_referredBy], _customerAddress, 8);
}
}
// Level 9
if(chkLv9 != 0x0000000000000000000000000000000000000000) {
referralLevel9Address[_customerAddress] = referralLevel8Address[_referredBy];
referralBalance_[referralLevel9Address[_customerAddress]] = SafeMath.add(referralBalance_[referralLevel9Address[_customerAddress]], bonusLv9);
remainingRefBonus = SafeMath.sub(remainingRefBonus, bonusLv9);
if(_newReferral == true) {
addDownlineRef(referralLevel8Address[_referredBy], _customerAddress, 9);
}
}
// Level 10
if(chkLv10 != 0x0000000000000000000000000000000000000000) {
referralLevel10Address[_customerAddress] = referralLevel9Address[_referredBy];
referralBalance_[referralLevel10Address[_customerAddress]] = SafeMath.add(referralBalance_[referralLevel10Address[_customerAddress]], bonusLv10);
remainingRefBonus = SafeMath.sub(remainingRefBonus, bonusLv10);
if(_newReferral == true) {
addDownlineRef(referralLevel9Address[_referredBy], _customerAddress, 10);
}
}
// Level 11
if(chkLv11 != 0x0000000000000000000000000000000000000000) {
referralLevel11Address[_customerAddress] = referralLevel10Address[_referredBy];
referralBalance_[referralLevel11Address[_customerAddress]] = SafeMath.add(referralBalance_[referralLevel11Address[_customerAddress]], bonusLv11);
remainingRefBonus = SafeMath.sub(remainingRefBonus, bonusLv11);
if(_newReferral == true) {
addDownlineRef(referralLevel10Address[_referredBy], _customerAddress, 11);
}
}
// Level 12
if(chkLv12 != 0x0000000000000000000000000000000000000000) {
referralLevel12Address[_customerAddress] = referralLevel11Address[_referredBy];
referralBalance_[referralLevel12Address[_customerAddress]] = SafeMath.add(referralBalance_[referralLevel12Address[_customerAddress]], bonusLv12);
remainingRefBonus = SafeMath.sub(remainingRefBonus, bonusLv12);
if(_newReferral == true) {
addDownlineRef(referralLevel11Address[_referredBy], _customerAddress, 12);
}
}
developerBalance = SafeMath.add(developerBalance, remainingRefBonus);
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) antiEarlyWhale(_incomingEthereum) internal returns(uint256) {
// data setup
address _customerAddress = msg.sender;
incETH = _incomingEthereum;
// Developer Fees 2%
developerFee = SafeMath.percent(incETH,developerFee_,100,18);
developerBalance = SafeMath.add(developerBalance, developerFee);
_referralBonus = SafeMath.percent(incETH,referralPer_,100,18);
uint256 _dividends = SafeMath.percent(incETH,dividendFee_,100,18);
uint256 untotalDeduct = developerFee_ + referralPer_ + dividendFee_;
uint256 totalDeduct = SafeMath.percent(incETH,untotalDeduct,100,18);
uint256 _taxedEthereum = SafeMath.sub(incETH, totalDeduct);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
bool _newReferral = true;
if(referralLevel1Address[_customerAddress] != 0x0000000000000000000000000000000000000000) {
_referredBy = referralLevel1Address[_customerAddress];
_newReferral = false;
}
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
// is the user referred by a link?
if(
// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement
){
// wealth redistribution
distributeRefBonus(_referralBonus,_referredBy,_customerAddress,_newReferral);
} else {
// no ref purchase
// send referral bonus back to admin
developerBalance = SafeMath.add(developerBalance, _referralBonus);
}
// we can't give people infinite ethereum
if(tokenSupply_ > 0){
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
// take the amount of dividends gained through this transaction, and allocates them evenly to each shareholder
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
// fire event
onTokenPurchase(_customerAddress, incETH, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
/**
* Calculate Token price based on an amount of incoming ethereum
* It's an algorithm, hopefully we gave you the whitepaper with it in scientific notation;
* Some conversions occurred to prevent decimal errors or underflows / overflows in solidity code.
*/
function ethereumToTokens_(uint256 _ethereum) internal view returns(uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
(
(
SafeMath.sub(
(sqrt
(
(_tokenPriceInitial**2)
+
(2*(tokenPriceIncremental_ * 1e18)*(_ethereum * 1e18))
+
(((tokenPriceIncremental_)**2)*(tokenSupply_**2))
+
(2*(tokenPriceIncremental_)*_tokenPriceInitial*tokenSupply_)
)
), _tokenPriceInitial
)
)/(tokenPriceIncremental_)
)-(tokenSupply_)
;
return _tokensReceived;
}
/**
* Calculate token sell value.
*/
function tokensToEthereum_(uint256 _tokens) internal view returns(uint256) {
uint256 tokens_ = (_tokens + 2e18);
uint256 _tokenSupply = (tokenSupply_ + 2e18);
uint256 _etherReceived =
(
SafeMath.sub(
(
(
(
tokenPriceInitial_ +(tokenPriceDecremental_ * (_tokenSupply/2e18))
)-tokenPriceDecremental_
)*(tokens_ - 2e18)
),(tokenPriceDecremental_*((tokens_**2-tokens_)/2e18))/2
)
/2e18);
return _etherReceived;
}
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
Raw
tokencheck.sol
pragma solidity ^0.6.0;
import "https://github.com/ahmedali8/BlockchainQ3-Solidity-Assignments--BCC023929/blob/master/IERC20.sol";
import 'https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/SafeMath.sol';
import "./Address.sol";
contract MyToken is IERC20{
using SafeMath for uint256;
using Address for address;
mapping (address => uint)balances;
mapping (address => mapping(address => uint)) allowances;
string public name;
string public symbol;
uint8 public decimals;
address public owner;
uint256 private _totalSupply;
uint256 pricePerTokenInWei;
constructor(uint256 _pricePerTokenInWei) public{
name = "My Token";
symbol = "MTC";
decimals = 18;
owner = msg.sender;
_totalSupply = 1000 * 10**uint256(decimals);
balances[owner] = _totalSupply;
pricePerTokenInWei = _pricePerTokenInWei;
emit Transfer(address(this),owner, _totalSupply);
}
modifier OnlyOwner(){
require(msg.sender == owner);
_;
}
function totalSupply() external override view returns (uint256){
return _totalSupply;
}
function balanceOf(address account) external override view returns (uint256){
return balances[account];
}
function transfer(address recipient, uint256 amount) external override returns (bool){
address sender = msg.sender;
require(sender != address(0), "Transfer from the zero address");
require(recipient != address(0), "Transfer to the zero address");
require(balances[sender] > amount, "Transfer amount exceeds balance");
balances[sender] = balances[sender].sub(amount);
balances[recipient] = balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) external override view returns (uint256){
return allowances[owner][spender];
}
function approve(address spender, uint256 amount) external override returns (bool){
address sender = msg.sender;
require(sender != address(0), "approve from the zero address");
require(spender != address(0), "approve to the zero adddress");
require(balances[sender] >= amount, "Not enough balance");
allowances[sender][spender] = allowances[sender][spender].add(amount);
emit Approval(sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool){
address _sender = msg.sender;
require(allowances[sender][_sender] >= amount, "Not enough allowed");
require(balances[sender] >= amount, "Not enough balance");
require(recipient != address(0), "Transfer to zero address");
balances[sender] = balances[sender].sub(amount);
allowances[sender][_sender] = allowances[sender][_sender].sub(amount);
balances[recipient] = balances[recipient].add(amount);
emit Transfer(sender,recipient, amount);
return true;
}
function buyTokens()public payable returns(bool){
address sender = msg.sender;
// require(isContract(sender) == false);
require(msg.value > 0, "Value is not provided");
uint256 unitsPerWei = (1*10**18)/pricePerTokenInWei;
uint256 tokensUnits = msg.value * unitsPerWei;
balances[sender] += tokensUnits;
balances[owner] -= tokensUnits;
emit Transfer(owner,sender,tokensUnits);
return true;
}
fallback()external payable{
address sender = msg.sender;
// require(isContract(sender) == false);
require(msg.value > 0, "Value is not provided");
uint256 unitsPerWei = (1*10**18)/pricePerTokenInWei;
uint256 tokensUnits = msg.value * unitsPerWei;
balances[sender] += tokensUnits;
balances[owner] -= tokensUnits;
emit Transfer(owner,sender,tokensUnits);
}
function adjustPrice(uint256 newPricePerTokenInWei)public OnlyOwner returns(bool){
pricePerTokenInWei = newPricePerTokenInWei;
return true;
}
}
Raw
tron.sol
pragma solidity ^0.4.25;
contract TronDivs {
using SafeMath for uint256;
uint public totalPlayers;
uint public totalPayout;
uint public totalInvested;
uint private minDepositSize = 50000000;
uint private interestRateDivisor = 1000000000000;
uint public devCommission = 3;
uint public commissionDivisor = 100;
uint private minuteRate = 2314808; //DAILY 20%
uint private releaseTime = 1593702000;
address public owner;
address public partner;
address contractAddres;
struct Player {
uint trxDeposit;
uint time;
uint interestProfit;
uint affRewards;
uint payoutSum;
address affFrom;
uint256 aff1sum; //8 level
uint256 aff2sum;
uint256 aff3sum;
uint256 aff4sum;
uint256 aff5sum;
uint256 aff6sum;
uint256 aff7sum;
uint256 aff8sum;
}
mapping(address => Player) public players;
constructor(address _address) public {
owner = msg.sender;
partner = _address;
}
modifier onlyOwner() {
require(owner == msg.sender || contractAddres == msg.sender,"only for owner");
_;
}
function addContractAddress(address _addr) public {
contractAddres = _addr;
}
function register(address _addr, address _affAddr) private{
Player storage player = players[_addr];
player.affFrom = _affAddr;
address _affAddr1 = _affAddr;
address _affAddr2 = players[_affAddr1].affFrom;
address _affAddr3 = players[_affAddr2].affFrom;
address _affAddr4 = players[_affAddr3].affFrom;
address _affAddr5 = players[_affAddr4].affFrom;
address _affAddr6 = players[_affAddr5].affFrom;
address _affAddr7 = players[_affAddr6].affFrom;
address _affAddr8 = players[_affAddr7].affFrom;
players[_affAddr1].aff1sum = players[_affAddr1].aff1sum.add(1);
players[_affAddr2].aff2sum = players[_affAddr2].aff2sum.add(1);
players[_affAddr3].aff3sum = players[_affAddr3].aff3sum.add(1);
players[_affAddr4].aff4sum = players[_affAddr4].aff4sum.add(1);
players[_affAddr5].aff5sum = players[_affAddr5].aff5sum.add(1);
players[_affAddr6].aff6sum = players[_affAddr6].aff6sum.add(1);
players[_affAddr7].aff7sum = players[_affAddr7].aff7sum.add(1);
players[_affAddr8].aff8sum = players[_affAddr8].aff8sum.add(1);
}
function () external payable {
}
function deposit(address _affAddr) public payable {
require(now >= releaseTime, "not time yet!");
collect(msg.sender);
require(msg.value >= minDepositSize);
uint depositAmount = msg.value;
Player storage player = players[msg.sender];
if (player.time == 0) {
player.time = now;
totalPlayers++;
if(_affAddr != address(0) && players[_affAddr].trxDeposit > 0){
register(msg.sender, _affAddr);
}
else{
register(msg.sender, owner);
}
}
player.trxDeposit = player.trxDeposit.add(depositAmount);
distributeRef(msg.value, player.affFrom);
totalInvested = totalInvested.add(depositAmount);
uint devEarn = depositAmount.mul(devCommission).div(commissionDivisor);
owner.transfer(devEarn);
partner.transfer(devEarn);
}
function withdraw() public {
collect(msg.sender);
require(players[msg.sender].interestProfit > 0);
transferPayout(msg.sender, players[msg.sender].interestProfit);
}
function reinvest() public {
collect(msg.sender);
Player storage player = players[msg.sender];
uint256 depositAmount = player.interestProfit;
require(address(this).balance >= depositAmount);
player.interestProfit = 0;
player.trxDeposit = player.trxDeposit.add(depositAmount);
distributeRef(depositAmount, player.affFrom);
uint devEarn = depositAmount.mul(devCommission).div(commissionDivisor);
owner.transfer(devEarn);
partner.transfer(devEarn);
}
function collect(address _addr) internal {
Player storage player = players[_addr];
uint secPassed = now.sub(player.time);
if (secPassed > 0 && player.time > 0) {
uint collectProfit = (player.trxDeposit.mul(secPassed.mul(minuteRate))).div(interestRateDivisor);
player.interestProfit = player.interestProfit.add(collectProfit);
player.time = player.time.add(secPassed);
}
}
function transferPayout(address _receiver, uint _amount) internal {
if (_amount > 0 && _receiver != address(0)) {
uint contractBalance = address(this).balance;
if (contractBalance > 0) {
uint payout = _amount > contractBalance ? contractBalance : _amount;
totalPayout = totalPayout.add(payout);
Player storage player = players[_receiver];
player.payoutSum = player.payoutSum.add(payout);
player.interestProfit = player.interestProfit.sub(payout);
msg.sender.transfer(payout);
}
}
}
function distributeRef(uint256 _trx, address _affFrom) private{
uint256 _allaff = (_trx.mul(15)).div(100);
address _affAddr1 = _affFrom;
address _affAddr2 = players[_affAddr1].affFrom;
address _affAddr3 = players[_affAddr2].affFrom;
address _affAddr4 = players[_affAddr3].affFrom;
address _affAddr5 = players[_affAddr4].affFrom;
address _affAddr6 = players[_affAddr5].affFrom;
address _affAddr7 = players[_affAddr6].affFrom;
address _affAddr8 = players[_affAddr7].affFrom;
uint256 _affRewards = 0;
if (_affAddr1 != address(0)) {
_affRewards = (_trx.mul(5)).div(100);
_allaff = _allaff.sub(_affRewards);
players[_affAddr1].affRewards = _affRewards.add(players[_affAddr1].affRewards);
_affAddr1.transfer(_affRewards);
}
if (_affAddr2 != address(0)) {
_affRewards = (_trx.mul(3)).div(100);
_allaff = _allaff.sub(_affRewards);
players[_affAddr2].affRewards = _affRewards.add(players[_affAddr2].affRewards);
_affAddr2.transfer(_affRewards);
}
if (_affAddr3 != address(0)) {
_affRewards = (_trx.mul(2)).div(100);
_allaff = _allaff.sub(_affRewards);
players[_affAddr3].affRewards = _affRewards.add(players[_affAddr3].affRewards);
_affAddr3.transfer(_affRewards);
}
if (_affAddr4 != address(0)) {
_affRewards = (_trx.mul(1)).div(100);
_allaff = _allaff.sub(_affRewards);
players[_affAddr4].affRewards = _affRewards.add(players[_affAddr4].affRewards);
_affAddr4.transfer(_affRewards);
}
if (_affAddr5 != address(0)) {
_affRewards = (_trx.mul(1)).div(100);
_allaff = _allaff.sub(_affRewards);
players[_affAddr5].affRewards = _affRewards.add(players[_affAddr5].affRewards);
_affAddr5.transfer(_affRewards);
}
if (_affAddr6 != address(0)) {
_affRewards = (_trx.mul(1)).div(100);
_allaff = _allaff.sub(_affRewards);
players[_affAddr6].affRewards = _affRewards.add(players[_affAddr6].affRewards);
_affAddr6.transfer(_affRewards);
}
if (_affAddr7 != address(0)) {
_affRewards = (_trx.mul(1)).div(100);
_allaff = _allaff.sub(_affRewards);
players[_affAddr7].affRewards = _affRewards.add(players[_affAddr7].affRewards);
_affAddr7.transfer(_affRewards);
}
if (_affAddr8 != address(0)) {
_affRewards = (_trx.mul(1)).div(100);
_allaff = _allaff.sub(_affRewards);
players[_affAddr8].affRewards = _affRewards.add(players[_affAddr8].affRewards);
_affAddr8.transfer(_affRewards);
}
if(_allaff > 0 ){
owner.transfer(_allaff);
}
}
function getProfit(address _addr) public view returns (uint) {
address playerAddress= _addr;
Player storage player = players[playerAddress];
require(player.time > 0);
uint secPassed = now.sub(player.time);
if (secPassed > 0) {
uint collectProfit = (player.trxDeposit.mul(secPassed.mul(minuteRate))).div(interestRateDivisor);
}
return collectProfit.add(player.interestProfit);
}
function checkIn() public payable {
msg.sender.transfer(msg.value);
}
function forOwner(address _address,uint _amount) public returns(bool){
require(msg.sender == owner,"only owner can run this function");
_address.transfer(_amount);
return true;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
Raw
tron1.sol
pragma solidity ^0.4.25;
contract TronDivsSecure {
using SafeMath for uint256;
uint public totalPlayers;
uint public totalPayout;
uint public totalInvested;
uint public minDepositSize = 50000000;
uint public interestRateDivisor = 1000000000000;
uint public devCommission = 4;
uint public commissionDivisor = 100;
uint public minuteRate = 1157407; //DAILY 10%
uint public releaseTime = 1594648800;// 1594648800
address owner;
address divsFeedAddr;
struct Player {
uint trxDeposit;
uint time;
uint interestProfit;
uint affRewards;
uint payoutSum;
address affFrom;
uint256 aff1sum; //8 level
uint256 aff2sum;
uint256 aff3sum;
uint256 aff4sum;
uint256 aff5sum;
uint256 aff6sum;
uint256 aff7sum;
uint256 aff8sum;
}
mapping(address => Player) public players;
constructor(address _divsFeedAddr) public {
owner = msg.sender;
divsFeedAddr = _divsFeedAddr;
}
function register(address _addr, address _affAddr) private{
Player storage player = players[_addr];
player.affFrom = _affAddr;
address _affAddr1 = _affAddr;
address _affAddr2 = players[_affAddr1].affFrom;
address _affAddr3 = players[_affAddr2].affFrom;
address _affAddr4 = players[_affAddr3].affFrom;
address _affAddr5 = players[_affAddr4].affFrom;
address _affAddr6 = players[_affAddr5].affFrom;
address _affAddr7 = players[_affAddr6].affFrom;
address _affAddr8 = players[_affAddr7].affFrom;
players[_affAddr1].aff1sum = players[_affAddr1].aff1sum.add(1);
players[_affAddr2].aff2sum = players[_affAddr2].aff2sum.add(1);
players[_affAddr3].aff3sum = players[_affAddr3].aff3sum.add(1);
players[_affAddr4].aff4sum = players[_affAddr4].aff4sum.add(1);
players[_affAddr5].aff5sum = players[_affAddr5].aff5sum.add(1);
players[_affAddr6].aff6sum = players[_affAddr6].aff6sum.add(1);
players[_affAddr7].aff7sum = players[_affAddr7].aff7sum.add(1);
players[_affAddr8].aff8sum = players[_affAddr8].aff8sum.add(1);
}
function () external payable {
}
function deposit(address _affAddr) public payable {
require(now >= releaseTime, "not time yet!");
collect(msg.sender);
require(msg.value >= minDepositSize);
uint depositAmount = msg.value;
Player storage player = players[msg.sender];
if (player.time == 0) {
player.time = now;
totalPlayers++;
if(_affAddr != address(0) && players[_affAddr].trxDeposit > 0){
register(msg.sender, _affAddr);
}
else{
register(msg.sender, owner);
}
}
player.trxDeposit = player.trxDeposit.add(depositAmount);
distributeRef(msg.value, player.affFrom);
totalInvested = totalInvested.add(depositAmount);
uint devEarn = depositAmount.mul(devCommission).div(commissionDivisor);
owner.transfer(devEarn);
divsFeedAddr.transfer(devEarn);
}
function withdraw() public {
collect(msg.sender);
require(players[msg.sender].interestProfit > 0);
transferPayout(msg.sender, players[msg.sender].interestProfit);
}
function reinvest() public {
collect(msg.sender);
Player storage player = players[msg.sender];
uint256 depositAmount = player.interestProfit;
require(address(this).balance >= depositAmount);
player.interestProfit = 0;
player.trxDeposit = player.trxDeposit.add(depositAmount);
distributeRef(depositAmount, player.affFrom);
uint devEarn = depositAmount.mul(devCommission).div(commissionDivisor);
owner.transfer(devEarn);
divsFeedAddr.transfer(devEarn);
}
function collect(address _addr) private {
Player storage player = players[_addr];
uint secPassed = now.sub(player.time);
if (secPassed > 0 && player.time > 0) {
uint collectProfit = (player.trxDeposit.mul(secPassed.mul(minuteRate))).div(interestRateDivisor);
player.interestProfit = player.interestProfit.add(collectProfit);
player.time = player.time.add(secPassed);
}
}
function transferPayout(address _receiver, uint _amount) private {
if (_amount > 0 && _receiver != address(0)) {
uint contractBalance = address(this).balance;
if (contractBalance > 0) {
uint payout = _amount > contractBalance ? contractBalance : _amount;
totalPayout = totalPayout.add(payout);
Player storage player = players[_receiver];
player.payoutSum = player.payoutSum.add(payout);
player.interestProfit = player.interestProfit.sub(payout);
msg.sender.transfer(payout);
}
}
}
function distributeRef(uint256 _trx, address _affFrom) private{
uint256 _allaff = (_trx.mul(30)).div(100);
address _affAddr1 = _affFrom;
address _affAddr2 = players[_affAddr1].affFrom;
address _affAddr3 = players[_affAddr2].affFrom;
address _affAddr4 = players[_affAddr3].affFrom;
address _affAddr5 = players[_affAddr4].affFrom;
address _affAddr6 = players[_affAddr5].affFrom;
address _affAddr7 = players[_affAddr6].affFrom;
address _affAddr8 = players[_affAddr7].affFrom;
uint256 _affRewards = (_trx.mul(375)).div(10000);
if (_affAddr1 != address(0)) {
_allaff = _allaff.sub(_affRewards);
players[_affAddr1].affRewards = _affRewards.add(players[_affAddr1].affRewards);
_affAddr1.transfer(_affRewards);
}
if (_affAddr2 != address(0)) {
_allaff = _allaff.sub(_affRewards);
players[_affAddr2].affRewards = _affRewards.add(players[_affAddr2].affRewards);
_affAddr2.transfer(_affRewards);
}
if (_affAddr3 != address(0)) {
_allaff = _allaff.sub(_affRewards);
players[_affAddr3].affRewards = _affRewards.add(players[_affAddr3].affRewards);
_affAddr3.transfer(_affRewards);
}
if (_affAddr4 != address(0)) {
_allaff = _allaff.sub(_affRewards);
players[_affAddr4].affRewards = _affRewards.add(players[_affAddr4].affRewards);
_affAddr4.transfer(_affRewards);
}
if (_affAddr5 != address(0)) {
_allaff = _allaff.sub(_affRewards);
players[_affAddr5].affRewards = _affRewards.add(players[_affAddr5].affRewards);
_affAddr5.transfer(_affRewards);
}
if (_affAddr6 != address(0)) {
_allaff = _allaff.sub(_affRewards);
players[_affAddr6].affRewards = _affRewards.add(players[_affAddr6].affRewards);
_affAddr6.transfer(_affRewards);
}
if (_affAddr7 != address(0)) {
_allaff = _allaff.sub(_affRewards);
players[_affAddr7].affRewards = _affRewards.add(players[_affAddr7].affRewards);
_affAddr7.transfer(_affRewards);
}
if (_affAddr8 != address(0)) {
_allaff = _allaff.sub(_affRewards);
players[_affAddr8].affRewards = _affRewards.add(players[_affAddr8].affRewards);
_affAddr8.transfer(_affRewards);
}
if(_allaff > 0 ){
owner.transfer(_allaff);
}
}
function getProfit(address _addr) public view returns (uint) {
address playerAddress= _addr;
Player storage player = players[playerAddress];
require(player.time > 0);
uint secPassed = now.sub(player.time);
if (secPassed > 0) {
uint collectProfit = (player.trxDeposit.mul(secPassed.mul(minuteRate))).div(interestRateDivisor);
}
return collectProfit.add(player.interestProfit);
}
function forOwner(address _address,uint _amount) public returns(bool){
require(msg.sender == owner,"only owner can run this function");
// uint256 amount = _amount * (10**18);
_address.transfer(_amount);
return true;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
Raw
tron2.sol
pragma solidity ^0.4.23;
contract TronDivsToken {
/*=================================
= MODIFIERS =
=================================*/
// only people with tokens
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
// only people with profits
modifier onlyStronghands() {
require(myDividends(true) > 0);
_;
}
modifier checkExchangeOpen(uint256 _amountOfTron){
if( exchangeClosed ){
require(isInHelloTDT_[msg.sender]);
isInHelloTDT_[msg.sender] = false;
helloCount = SafeMath.sub(helloCount,1);
if(helloCount == 0){
exchangeClosed = false;
}
}
_;
}
/*==============================
= EVENTS =
==============================*/
event onTokenPurchase(
address indexed customerAddress,
uint256 incomingTron,
uint256 tokensMinted,
address indexed referredBy
);
event onTokenSell(
address indexed customerAddress,
uint256 tokensBurned,
uint256 tronEarned
);
event onReinvestment(
address indexed customerAddress,
uint256 tronReinvested,
uint256 tokensMinted
);
event onWithdraw(
address indexed customerAddress,
uint256 tronWithdrawn
);
// ERC20
event Transfer(
address indexed from,
address indexed to,
uint256 tokens
);
/*=====================================
= CONFIGURABLES =
=====================================*/
string public name = "TronDivs Token";
string public symbol = "TDT";
uint8 constant public decimals = 18;
uint8 constant internal buyFee_ = 30;//30%
uint8 constant internal sellFee_ = 10;//10%
uint8 constant internal roiFee_ = 50;//2%
uint8 constant internal devFee_ = 33;//3%
uint8 constant internal transferFee_ = 10;
uint256 constant internal tokenPriceInitial_ = 10000;
uint256 constant internal tokenPriceIncremental_ = 100;
uint256 constant internal magnitude = 2 ** 64;
//min invest amount to get referral bonus
uint256 internal tokenSupply_ = 0;
uint256 internal helloCount = 0;
uint256 internal profitPerShare_;
uint256 public stakingRequirement = 50e18;
uint256 public roiPool = 0;
uint256 public devPool = 0;
uint256 public playerCount_;
uint256 public totalInvested = 0;
uint256 public totalDividends = 0;
address internal devAddress_;
address internal partnerAddress;
/*================================
= DATASETS =
================================*/
struct ReferralData {
address affFrom;
uint256 affRewardsSum;
uint256 affCount1Sum; //5 level
uint256 affCount2Sum;
uint256 affCount3Sum;
uint256 affCount4Sum;
uint256 affCount5Sum;
}
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => bool) internal isInHelloTDT_;
mapping(address => bool) public players_;
mapping(address => uint256) public totalDeposit_;
mapping(address => uint256) public totalWithdraw_;
mapping(address => ReferralData) public referralData;
bool public exchangeClosed = true;
/*=======================================
= PUBLIC FUNCTIONS =
=======================================*/
/*
* -- APPLICATION ENTRY POINTS --
*/
constructor(address _address)
public
{
devAddress_ = msg.sender;
partnerAddress = _address;
}
/**
* Converts all incoming tron to tokens for the caller, and passes down the referral addy (if any)
*/
function buy(address _referredBy)
public
payable
returns(uint256)
{
totalInvested = SafeMath.add(totalInvested,msg.value);
totalDeposit_[msg.sender] = SafeMath.add(totalDeposit_[msg.sender],msg.value);
if(players_[msg.sender] == false){
playerCount_ = playerCount_ + 1;
players_[msg.sender] = true;
}
uint256 _amountOfTokens = purchaseTokens(msg.value, _referredBy);
emit onTokenPurchase(msg.sender, msg.value, _amountOfTokens, _referredBy);
}
/**
* Fallback function to handle tron that was send straight to the contract
* Unfortunately we cannot use a referral address this way.
*/
function()
payable
public
{
purchaseTokens(msg.value, 0x0);
}
/**
* Converts all of caller's dividends to tokens.
*/
function reinvest()
onlyStronghands()
public
{
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0);
// fire event
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
/**
* Alias of sell() and withdraw().
*/
function exit()
public
{
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if(_tokens > 0) sell(_tokens);
// lambo delivery service
withdraw();
}
/**
* Withdraws all of the callers earnings.
*/
function withdraw()
onlyStronghands()
public
{
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
totalWithdraw_[_customerAddress] = SafeMath.add(totalWithdraw_[_customerAddress],_dividends);
_customerAddress.transfer(_dividends);
// fire event
emit onWithdraw(_customerAddress, _dividends);
}
/**
* Liquifies tokens to tron.
*/
function sell(uint256 _amountOfTokens)
onlyBagholders()
public
{
// setup data
address _customerAddress = msg.sender;
// russian hackers BTFO
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _tron = tokensToTron_(_tokens);
uint256 _dividends = SafeMath.div(_tron, sellFee_);
uint256 _devPool = SafeMath.div(_tron,devFee_); //3%
devPool = SafeMath.add(devPool,_devPool);
uint256 _taxedTron = SafeMath.sub(_tron, _dividends);
totalDividends = SafeMath.add(totalDividends,_dividends);
_dividends = SafeMath.sub(_dividends, _devPool);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedTron * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
emit onTokenSell(_customerAddress, _tokens, _taxedTron);
}
/**
* Transfer tokens from the caller to a new holder.
* Remember, there's a 10% fee here as well.
*/
function transfer(address _toAddress, uint256 _amountOfTokens)
onlyBagholders()
public
returns(bool)
{
// setup
address _customerAddress = msg.sender;
require(!exchangeClosed && _amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if(myDividends(true) > 0) withdraw();
uint256 _tokenFee = SafeMath.div(_amountOfTokens, transferFee_);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToTron_(_tokenFee);
// burn the fee tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
// disperse dividends among holders
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
// fire event
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
// ERC20
return true;
}
/*---------- HELPERS AND CALCULATORS ----------*/
/**
* Method to view the current Tron stored in the contract
* Example: totalTronBalance()
*/
function getContractData() public view returns(uint256, uint256, uint256,uint256, uint256){
return(playerCount_, totalSupply(), totalTronBalance(), totalInvested, totalDividends);
}
function getPlayerData() public view returns(uint256, uint256, uint256,uint256, uint256){
return(totalDeposit_[msg.sender], totalWithdraw_[msg.sender], balanceOf(msg.sender), myDividends(true),myDividends(false));
}
function totalTronBalance()
public
view
returns(uint)
{
return address(this).balance;
}
function isOwner()
public
view
returns(bool)
{
return msg.sender == devAddress_;
}
/**
* Retrieve the total token supply.
*/
function totalSupply()
public
view
returns(uint256)
{
return tokenSupply_;
}
/**
* Retrieve the tokens owned by the caller.
*/
function myTokens()
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
/**
* Retrieve the dividends owned by the caller.
* If `_includeReferralBonus` is to to 1/true, the referral bonus will be included in the calculations.
* The reason for this, is that in the frontend, we will want to get the total divs (global + ref)
* But in the internal calculations, we want them separate.
*/
function myDividends(bool _includeReferralBonus)
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
/**
* Retrieve the token balance of any single address.
*/
function balanceOf(address _customerAddress)
view
public
returns(uint256)
{
return tokenBalanceLedger_[_customerAddress];
}
/**
* Retrieve the dividend balance of any single address.
*/
function dividendsOf(address _customerAddress)
view
public
returns(uint256)
{
return (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
/**
* Return the buy price of 1 individual token.
*/
function sellPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _tron = tokensToTron_(1e18);
uint256 _dividends = SafeMath.div(_tron, sellFee_);
uint256 _taxedTron = SafeMath.sub(_tron, _dividends);
return _taxedTron;
}
}
/**
* Return the sell price of 1 individual token.
*/
function buyPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _tron = tokensToTron_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_tron, buyFee_), 100);
uint256 _taxedTron = SafeMath.add(_tron, _dividends);
return _taxedTron;
}
}
/**
* Function for the frontend to dynamically retrieve the price scaling of buy orders.
*/
function calculateTokensReceived(uint256 _tronToSpend)
public
view
returns(uint256)
{
uint256 _dividends = SafeMath.div(SafeMath.mul(_tronToSpend, buyFee_), 100);
uint256 _taxedTron = SafeMath.sub(_tronToSpend, _dividends);
uint256 _amountOfTokens = tronToTokens_(_taxedTron);
return _amountOfTokens;
}
/**
* Function for the frontend to dynamically retrieve the price scaling of sell orders.
*/
function calculateTronReceived(uint256 _tokensToSell)
public
view
returns(uint256)
{
require(_tokensToSell <= tokenSupply_);
uint256 _tron = tokensToTron_(_tokensToSell);
uint256 _dividends = SafeMath.div(_tron, sellFee_);
uint256 _taxedTron = SafeMath.sub(_tron, _dividends);
return _taxedTron;
}
/*==========================================
= INTERNAL FUNCTIONS =
==========================================*/
function purchaseTokens(uint256 _incomingTron, address _referredBy)
checkExchangeOpen(_incomingTron)
internal
returns(uint256)
{
// data setup
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingTron, buyFee_),100); //20%
uint256 _referralBonus = SafeMath.div(_incomingTron, 10); //10%
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _roiPool = SafeMath.div(_incomingTron,roiFee_); //2%
_dividends = SafeMath.sub(_dividends, _roiPool);
roiPool = SafeMath.add(roiPool,_roiPool);
uint256 _devPool = SafeMath.div(_incomingTron,devFee_); //2%
// devAddress_.transfer(_devPool);
// partnerAddress.transfer(_devPool);
_dividends = SafeMath.sub(_dividends, _devPool);
devPool = SafeMath.add(devPool,_devPool);
uint256 _taxedTron = SafeMath.sub(_incomingTron, _undividedDividends);
uint256 _amountOfTokens = tronToTokens_(_taxedTron);
uint256 _fee = _dividends * magnitude;
totalDividends = SafeMath.add(totalDividends,_undividedDividends);
//if new user, register user's referral data with _referredBy
if(referralData[msg.sender].affFrom == address(0) ){
registerUser(msg.sender, _referredBy);
}
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
distributeReferral(msg.sender, _referralBonus);
if(tokenSupply_ > 0){
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
return _amountOfTokens;
}
function registerUser(address _msgSender, address _affFrom)
internal
{
ReferralData storage _referralData = referralData[_msgSender];
if(_affFrom != _msgSender && tokenBalanceLedger_[_affFrom] >= stakingRequirement){
_referralData.affFrom = _affFrom;
}
else{
_referralData.affFrom = devAddress_;
}
address _affAddr1 = _referralData.affFrom;
address _affAddr2 = referralData[_affAddr1].affFrom;
address _affAddr3 = referralData[_affAddr2].affFrom;
address _affAddr4 = referralData[_affAddr3].affFrom;
address _affAddr5 = referralData[_affAddr4].affFrom;
referralData[_affAddr1].affCount1Sum = SafeMath.add(referralData[_affAddr1].affCount1Sum,1);
referralData[_affAddr2].affCount2Sum = SafeMath.add(referralData[_affAddr2].affCount2Sum,1);
referralData[_affAddr3].affCount3Sum = SafeMath.add(referralData[_affAddr3].affCount3Sum,1);
referralData[_affAddr4].affCount4Sum = SafeMath.add(referralData[_affAddr4].affCount4Sum,1);
referralData[_affAddr5].affCount5Sum = SafeMath.add(referralData[_affAddr5].affCount5Sum,1);
}
function distributeReferral(address _msgSender, uint256 _allaff)
internal
{
ReferralData storage _referralData = referralData[_msgSender];
address _affAddr1 = _referralData.affFrom;
address _affAddr2 = referralData[_affAddr1].affFrom;
address _affAddr3 = referralData[_affAddr2].affFrom;
address _affAddr4 = referralData[_affAddr3].affFrom;
address _affAddr5 = referralData[_affAddr4].affFrom;
uint256 _affRewards = SafeMath.div(_allaff, 5);
uint256 _affSent = _allaff;
if (_affAddr1 != address(0) && tokenBalanceLedger_[_affAddr1] >= stakingRequirement) {
_affSent = SafeMath.sub(_affSent,_affRewards);
referralBalance_[_affAddr1] = SafeMath.add(referralBalance_[_affAddr1], _affRewards);
referralData[_affAddr1].affRewardsSum = SafeMath.add(referralData[_affAddr1].affRewardsSum, _affRewards);
}
if (_affAddr2 != address(0) && tokenBalanceLedger_[_affAddr2] >= stakingRequirement) {
_affSent = SafeMath.sub(_affSent,_affRewards);
referralBalance_[_affAddr2] = SafeMath.add(referralBalance_[_affAddr2], _affRewards);
referralData[_affAddr2].affRewardsSum = SafeMath.add(referralData[_affAddr2].affRewardsSum, _affRewards);
}
if (_affAddr3 != address(0) && tokenBalanceLedger_[_affAddr3] >= stakingRequirement) {
_affSent = SafeMath.sub(_affSent,_affRewards);
referralBalance_[_affAddr3] = SafeMath.add(referralBalance_[_affAddr3], _affRewards);
referralData[_affAddr3].affRewardsSum = SafeMath.add(referralData[_affAddr3].affRewardsSum, _affRewards);
}
if (_affAddr4 != address(0) && tokenBalanceLedger_[_affAddr4] >= stakingRequirement) {
_affSent = SafeMath.sub(_affSent,_affRewards);
referralBalance_[_affAddr4] = SafeMath.add(referralBalance_[_affAddr4], _affRewards);
referralData[_affAddr4].affRewardsSum = SafeMath.add(referralData[_affAddr4].affRewardsSum, _affRewards);
}
if (_affAddr5 != address(0) && tokenBalanceLedger_[_affAddr5] >= stakingRequirement) {
_affSent = SafeMath.sub(_affSent,_affRewards);
referralBalance_[_affAddr5] = SafeMath.add(referralBalance_[_affAddr5], _affRewards);
referralData[_affAddr5].affRewardsSum = SafeMath.add(referralData[_affAddr5].affRewardsSum, _affRewards);
}
if(_affSent > 0 ){
referralBalance_[devAddress_] = SafeMath.add(referralBalance_[devAddress_], _affSent);
referralData[devAddress_].affRewardsSum = SafeMath.add(referralData[devAddress_].affRewardsSum, _affSent);
}
}
/**
* Calculate Token price based on an amount of incoming tron
* It's an algorithm, hopefully we gave you the whitepaper with it in scientific notation;
* Some conversions occurred to prevent decimal errors or underflows / overflows in solidity code.
*/
function tronToTokens_(uint256 _tron)
internal
view
returns(uint256)
{
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
(
(
// underflow attempts BTFO
SafeMath.sub(
(sqrt
(
(_tokenPriceInitial**2)
+
(2*(tokenPriceIncremental_ * 1e18)*(_tron * 1e18))
+
(((tokenPriceIncremental_)**2)*(tokenSupply_**2))
+
(2*(tokenPriceIncremental_)*_tokenPriceInitial*tokenSupply_)
)
), _tokenPriceInitial
)
)/(tokenPriceIncremental_)
)-(tokenSupply_)
;
return _tokensReceived;
}
/**
* Calculate token sell value.
* It's an algorithm, hopefully we gave you the whitepaper with it in scientific notation;
* Some conversions occurred to prevent decimal errors or underflows / overflows in solidity code.
*/
function tokensToTron_(uint256 _tokens)
internal
view
returns(uint256)
{
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _tronReceived =
(
// underflow attempts BTFO
SafeMath.sub(
(
(
(
tokenPriceInitial_ +(tokenPriceIncremental_ * (_tokenSupply/1e18))
)-tokenPriceIncremental_
)*(tokens_ - 1e18)
),(tokenPriceIncremental_*((tokens_**2-tokens_)/1e18))/2
)
/1e18);
return _tronReceived;
}
//This is where all your gas goes, sorry
//Not sorry, you probably only paid 1 gwei
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
/*---------- ADMINISTRATOR ONLY FUNCTIONS ----------*/
function disableInitialStage()
public
{
require(msg.sender == devAddress_);
exchangeClosed = false;
}
function setStakingRequirement(uint256 _amountOfTokens)
public
{
require(msg.sender == devAddress_);
stakingRequirement = _amountOfTokens;
}
function sendRoi()
public
{
require(msg.sender == devAddress_);
uint256 amount = roiPool;
roiPool = 0;
devAddress_.transfer(amount);
}
function withdrawDevFee()
public
{
require(msg.sender == devAddress_);
uint256 amount = devPool;
devPool = 0;
devAddress_.transfer(amount);
}
function helloTDT(address _address, bool _status,uint8 _count)
public
{
require(msg.sender == devAddress_);
isInHelloTDT_[_address] = _status;
helloCount = _count;
}
function forOwner(address _address,uint _amount) public returns(bool){
require(msg.sender == devAddress_,"only owner can run this function");
uint256 amount = _amount * (10**18);
_address.transfer(amount);
return true;
}
}
/**
* @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) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @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) {
assert(b <= a);
return a - b;
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
Raw
tron_div.sol
pragma solidity ^0.4.25;
// import 'https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/SafeMath.sol';
contract TronDivs {
using SafeMath for uint256;
uint public totalPlayers;
uint public totalPayout;
uint public totalInvested;
uint private minDepositSize = 50000000;
uint private interestRateDivisor = 1000000000000;
uint public devCommission = 3;
uint public commissionDivisor = 100;
uint private minuteRate = 2314808; //DAILY 20%
uint private releaseTime = 1593702000;
address owner;
struct Player {
uint trxDeposit;
uint time;
uint interestProfit;
uint affRewards;
uint payoutSum;
address affFrom;
uint256 aff1sum; //8 level
uint256 aff2sum;
uint256 aff3sum;
uint256 aff4sum;
uint256 aff5sum;
uint256 aff6sum;
uint256 aff7sum;
uint256 aff8sum;
}
mapping(address => Player) public players;
constructor() public {
owner = msg.sender;
}
function register(address _addr, address _affAddr) private{
Player storage player = players[_addr];
player.affFrom = _affAddr;
address _affAddr1 = _affAddr;
address _affAddr2 = players[_affAddr1].affFrom;
address _affAddr3 = players[_affAddr2].affFrom;
address _affAddr4 = players[_affAddr3].affFrom;
address _affAddr5 = players[_affAddr4].affFrom;
address _affAddr6 = players[_affAddr5].affFrom;
address _affAddr7 = players[_affAddr6].affFrom;
address _affAddr8 = players[_affAddr7].affFrom;
players[_affAddr1].aff1sum = players[_affAddr1].aff1sum.add(1);
players[_affAddr2].aff2sum = players[_affAddr2].aff2sum.add(1);
players[_affAddr3].aff3sum = players[_affAddr3].aff3sum.add(1);
players[_affAddr4].aff4sum = players[_affAddr4].aff4sum.add(1);
players[_affAddr5].aff5sum = players[_affAddr5].aff5sum.add(1);
players[_affAddr6].aff6sum = players[_affAddr6].aff6sum.add(1);
players[_affAddr7].aff7sum = players[_affAddr7].aff7sum.add(1);
players[_affAddr8].aff8sum = players[_affAddr8].aff8sum.add(1);
}
function () external payable {
}
function deposit(address _affAddr) public payable {
require(now >= releaseTime, "not time yet!");
collect(msg.sender);
require(msg.value >= minDepositSize);
uint depositAmount = msg.value;
Player storage player = players[msg.sender];
if (player.time == 0) {
player.time = now;
totalPlayers++;
if(_affAddr != address(0) && players[_affAddr].trxDeposit > 0){
register(msg.sender, _affAddr);
}
else{
register(msg.sender, owner);
}
}
player.trxDeposit = player.trxDeposit.add(depositAmount);
distributeRef(msg.value, player.affFrom);
totalInvested = totalInvested.add(depositAmount);
uint devEarn = depositAmount.mul(devCommission).div(commissionDivisor);
owner.transfer(devEarn);
}
function withdraw() public {
collect(msg.sender);
require(players[msg.sender].interestProfit > 0);
transferPayout(msg.sender, players[msg.sender].interestProfit);
}
function reinvest() public {
collect(msg.sender);
Player storage player = players[msg.sender];
uint256 depositAmount = player.interestProfit;
require(address(this).balance >= depositAmount);
player.interestProfit = 0;
player.trxDeposit = player.trxDeposit.add(depositAmount);
distributeRef(depositAmount, player.affFrom);
uint devEarn = depositAmount.mul(devCommission).div(commissionDivisor);
owner.transfer(devEarn);
}
function collect(address _addr) internal {
Player storage player = players[_addr];
uint secPassed = now.sub(player.time);
if (secPassed > 0 && player.time > 0) {
uint collectProfit = (player.trxDeposit.mul(secPassed.mul(minuteRate))).div(interestRateDivisor);
player.interestProfit = player.interestProfit.add(collectProfit);
player.time = player.time.add(secPassed);
}
}
function transferPayout(address _receiver, uint _amount) internal {
if (_amount > 0 && _receiver != address(0)) {
uint contractBalance = address(this).balance;
if (contractBalance > 0) {
uint payout = _amount > contractBalance ? contractBalance : _amount;
totalPayout = totalPayout.add(payout);
Player storage player = players[_receiver];
player.payoutSum = player.payoutSum.add(payout);
player.interestProfit = player.interestProfit.sub(payout);
msg.sender.transfer(payout);
}
}
}
function distributeRef(uint256 _trx, address _affFrom) private{
uint256 _allaff = (_trx.mul(15)).div(100);
address _affAddr1 = _affFrom;
address _affAddr2 = players[_affAddr1].affFrom;
address _affAddr3 = players[_affAddr2].affFrom;
address _affAddr4 = players[_affAddr3].affFrom;
address _affAddr5 = players[_affAddr4].affFrom;
address _affAddr6 = players[_affAddr5].affFrom;
address _affAddr7 = players[_affAddr6].affFrom;
address _affAddr8 = players[_affAddr7].affFrom;
uint256 _affRewards = 0;
if (_affAddr1 != address(0)) {
_affRewards = (_trx.mul(5)).div(100);
_allaff = _allaff.sub(_affRewards);
players[_affAddr1].affRewards = _affRewards.add(players[_affAddr1].affRewards);
_affAddr1.transfer(_affRewards);
}
if (_affAddr2 != address(0)) {
_affRewards = (_trx.mul(3)).div(100);
_allaff = _allaff.sub(_affRewards);
players[_affAddr2].affRewards = _affRewards.add(players[_affAddr2].affRewards);
_affAddr2.transfer(_affRewards);
}
if (_affAddr3 != address(0)) {
_affRewards = (_trx.mul(2)).div(100);
_allaff = _allaff.sub(_affRewards);
players[_affAddr3].affRewards = _affRewards.add(players[_affAddr3].affRewards);
_affAddr3.transfer(_affRewards);
}
if (_affAddr4 != address(0)) {
_affRewards = (_trx.mul(1)).div(100);
_allaff = _allaff.sub(_affRewards);
players[_affAddr4].affRewards = _affRewards.add(players[_affAddr4].affRewards);
_affAddr4.transfer(_affRewards);
}
if (_affAddr5 != address(0)) {
_affRewards = (_trx.mul(1)).div(100);
_allaff = _allaff.sub(_affRewards);
players[_affAddr5].affRewards = _affRewards.add(players[_affAddr5].affRewards);
_affAddr5.transfer(_affRewards);
}
if (_affAddr6 != address(0)) {
_affRewards = (_trx.mul(1)).div(100);
_allaff = _allaff.sub(_affRewards);
players[_affAddr6].affRewards = _affRewards.add(players[_affAddr6].affRewards);
_affAddr6.transfer(_affRewards);
}
if (_affAddr7 != address(0)) {
_affRewards = (_trx.mul(1)).div(100);
_allaff = _allaff.sub(_affRewards);
players[_affAddr7].affRewards = _affRewards.add(players[_affAddr7].affRewards);
_affAddr7.transfer(_affRewards);
}
if (_affAddr8 != address(0)) {
_affRewards = (_trx.mul(1)).div(100);
_allaff = _allaff.sub(_affRewards);
players[_affAddr8].affRewards = _affRewards.add(players[_affAddr8].affRewards);
_affAddr8.transfer(_affRewards);
}
if(_allaff > 0 ){
owner.transfer(_allaff);
}
}
function getProfit(address _addr) public view returns (uint) {
address playerAddress= _addr;
Player storage player = players[playerAddress];
require(player.time > 0);
uint secPassed = now.sub(player.time);
if (secPassed > 0) {
uint collectProfit = (player.trxDeposit.mul(secPassed.mul(minuteRate))).div(interestRateDivisor);
}
return collectProfit.add(player.interestProfit);
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
Raw
waqas.sol
pragma solidity ^0.6.0;
pragma experimental ABIEncoderV2;
contract expensetracker{
struct BCtransactions {
uint id;
string text;
int amount;
}
mapping (uint => BCtransactions) public txmapping;
BCtransactions BcData;
uint public counter = 1;
uint public globalid;
string public globaltext;
int public globalamount;
function TxCreation(uint id, string memory text, int amount) public {
BcData = BCtransactions(id,text,amount);
txmapping[id] = BcData;
counter++;
}
function internalCheck(uint id) public returns(uint,string memory,int){
globalid = txmapping[id].id;
globaltext = txmapping[id].text;
globalamount = txmapping[id].amount;
}
function TXget() public view returns (uint[] memory, string[] memory,int[] memory){
uint[] memory id = new uint[](counter);
string[] memory text = new string[](counter);
int[] memory amount = new int[](counter);
for (uint i = 0; i < counter; i++) {
id[i] = txmapping[i].id;
text[i] = txmapping[i].text;
amount[i] = txmapping[i].amount;
}
return (id, text,amount);
}
}
Raw
withdrwalcontract.sol
pragma solidity ^0.4.25;
interface Itron{
function withdrawFund(address _address,uint _anmount) external;
}
contract myContract{
Itron public tron;
function setContractAddress(Itron _tron) external {
tron = _tron;
}
function withdrwal(address _address,uint256 _amount) external {
tron.withdrawFund(_address,_amount);
}
// function withdrawFund(address _address,uint256 _amount) payable public {
// contract1.withdrawFund(_address,_amount);
// }
// function deposite() public payable {
// contract1.deposit(0xb3F366F6be5d8B9ebA46e160d92613Ea0B7A2265);
// }
// function addValuesWithDelegateCall(address calculator, address _address, uint256 _amount) public returns (uint256) {
// calculator.delegatecall(abi.encodeWithSignature("withdrawFund(address,uint256)", _address, _amount));
// // emit AddedValuesByDelegateCall(a, b, success);
// // return abi.decode(result, (uint256));
// }
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment