Saved Diffs

Diff history

Diff history is cleared on refresh

EthDiamond

-6 Removals
+17 Additions
/**/**
*Submitted for verification at Etherscan.io on 2020-07-04 *Submitted for verification at Etherscan.io on 2018-04-30
*/*/
pragma solidity ^0.4.20;pragma solidity ^0.4.20;
/*/*
* Trevon James Presents....
* https://potj.me/
* https://discord.gg/8FdGtS8
* Twitter: https://twitter.com/BitcoinTre
* YouTube: https://www.youtube.com/channel/UCWZbtMeOAb_qpEVUl551l7w
*
*
*
* Proof of Trevon James
* Don't Talk To Me Unless It's About Intangible Coins.
*
* -> What?* -> What?
* Incorporated the strong points of different POW{x}, best config:* Incorporated the strong points of different POW{x}, best config:
* [✓] 20% dividends for token purchase, shared among all token holders.* [✓] 20% dividends for token purchase, shared among all token holders.
* [✓] 10% dividends for token transfer, shared among all token holders.* [✓] 10% dividends for token transfer, shared among all token holders.
* [✓] 25% dividends for token selling.* [✓] 25% dividends for token selling.
* [✓] 7% dividends is given to referrer.* [✓] 7% dividends is given to referrer.
* [✓] 50 tokens to activate Masternodes.* [✓] 50 tokens to activate Masternodes.
**
*/*/
contract EtherDiamond {contract POTJ {
/*================================= /*=================================
= MODIFIERS = = MODIFIERS =
=================================*/ =================================*/
/// @dev Only people with tokens /// @dev Only people with tokens
modifier onlyBagholders { modifier onlyBagholders {
require(myTokens() > 0); require(myTokens() > 0);
_; _;
} }
/// @dev Only people with profits /// @dev Only people with profits
modifier onlyStronghands { modifier onlyStronghands {
require(myDividends(true) > 0); require(myDividends(true) > 0);
_; _;
} }
/*============================== /*==============================
= EVENTS = = EVENTS =
==============================*/ ==============================*/
event onTokenPurchase( event onTokenPurchase(
address indexed customerAddress, address indexed customerAddress,
uint256 incomingEthereum, uint256 incomingEthereum,
uint256 tokensMinted, uint256 tokensMinted,
address indexed referredBy, address indexed referredBy,
uint timestamp, uint timestamp,
uint256 price uint256 price
); );
event onTokenSell( event onTokenSell(
address indexed customerAddress, address indexed customerAddress,
uint256 tokensBurned, uint256 tokensBurned,
uint256 ethereumEarned, uint256 ethereumEarned,
uint timestamp, uint timestamp,
uint256 price uint256 price
); );
event onReinvestment( event onReinvestment(
address indexed customerAddress, address indexed customerAddress,
uint256 ethereumReinvested, uint256 ethereumReinvested,
uint256 tokensMinted uint256 tokensMinted
); );
event onWithdraw( event onWithdraw(
address indexed customerAddress, address indexed customerAddress,
uint256 ethereumWithdrawn uint256 ethereumWithdrawn
); );
// ERC20 // ERC20
event Transfer( event Transfer(
address indexed from, address indexed from,
address indexed to, address indexed to,
uint256 tokens uint256 tokens
); );
/*===================================== /*=====================================
= CONFIGURABLES = = CONFIGURABLES =
=====================================*/ =====================================*/
string public name = "Ether Diamond"; string public name = "Proof of Trevon James";
string public symbol = "ETHD"; string public symbol = "PoTJ";
uint8 constant public decimals = 18; uint8 constant public decimals = 18;
/// @dev 20% dividends for token purchase /// @dev 15% dividends for token purchase
uint8 constant internal entryFee_ = 20; uint8 constant internal entryFee_ = 20;
/// @dev 10% dividends for token transfer /// @dev 10% dividends for token transfer
uint8 constant internal transferFee_ = 10; uint8 constant internal transferFee_ = 10;
/// @dev 25% dividends for token selling /// @dev 25% dividends for token selling
uint8 constant internal exitFee_ = 25; uint8 constant internal exitFee_ = 25;
/// @dev 35% of entryFee_ (i.e. 7% dividends) is given to referrer /// @dev 35% of entryFee_ (i.e. 7% dividends) is given to referrer
uint8 constant internal refferalFee_ = 35; uint8 constant internal refferalFee_ = 35;
uint256 constant internal tokenPriceInitial_ = 0.00000001 ether; uint256 constant internal tokenPriceInitial_ = 0.00000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.000000001 ether; uint256 constant internal tokenPriceIncremental_ = 0.000000001 ether;
uint256 constant internal magnitude = 2 ** 64; uint256 constant internal magnitude = 2 ** 64;
/// @dev proof of stake (defaults at 50 tokens) /// @dev proof of stake (defaults at 50 tokens)
uint256 public stakingRequirement = 50e18; uint256 public stakingRequirement = 50e18;
/*================================= /*=================================
= DATASETS = = DATASETS =
================================*/ ================================*/
// amount of shares for each address (scaled number) // amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_; mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_; mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_; mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_; uint256 internal tokenSupply_;
uint256 internal profitPerShare_; uint256 internal profitPerShare_;
/*======================================= /*=======================================
= PUBLIC FUNCTIONS = = PUBLIC FUNCTIONS =
=======================================*/ =======================================*/
/// @dev Converts all incoming ethereum to tokens for the caller, and passes down the referral addy (if any) /// @dev Converts all incoming ethereum to tokens for the caller, and passes down the referral addy (if any)
function buy(address _referredBy) public payable returns (uint256) { function buy(address _referredBy) public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy); purchaseTokens(msg.value, _referredBy);
} }
/** /**
* @dev Fallback function to handle ethereum that was send straight to the contract * @dev Fallback function to handle ethereum that was send straight to the contract
* Unfortunately we cannot use a referral address this way. * Unfortunately we cannot use a referral address this way.
*/ */
function() payable public { function() payable public {
purchaseTokens(msg.value, 0x0); purchaseTokens(msg.value, 0x0);
} }
/// @dev Converts all of caller's dividends to tokens. /// @dev Converts all of caller's dividends to tokens.
function reinvest() onlyStronghands public { function reinvest() onlyStronghands public {
// fetch dividends // fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually // pay out the dividends virtually
address _customerAddress = msg.sender; address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude); payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus // retrieve ref. bonus
_dividends += referralBalance_[_customerAddress]; _dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0; referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends" // dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0); uint256 _tokens = purchaseTokens(_dividends, 0x0);
// fire event // fire event
onReinvestment(_customerAddress, _dividends, _tokens); onReinvestment(_customerAddress, _dividends, _tokens);
} }
/// @dev Alias of sell() and withdraw(). /// @dev Alias of sell() and withdraw().
function exit() public { function exit() public {
// get token count for caller & sell them all // get token count for caller & sell them all
address _customerAddress = msg.sender; address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress]; uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens); if (_tokens > 0) sell(_tokens);
// lambo delivery service // lambo delivery service
withdraw(); withdraw();
} }
/// @dev Withdraws all of the callers earnings. /// @dev Withdraws all of the callers earnings.
function withdraw() onlyStronghands public { function withdraw() onlyStronghands public {
// setup data // setup data
address _customerAddress = msg.sender; address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker // update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude); payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus // add ref. bonus
_dividends += referralBalance_[_customerAddress]; _dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0; referralBalance_[_customerAddress] = 0;
// lambo delivery service // lambo delivery service
_customerAddress.transfer(_dividends); _customerAddress.transfer(_dividends);
// fire event // fire event
onWithdraw(_customerAddress, _dividends); onWithdraw(_customerAddress, _dividends);
} }
/// @dev Liquifies tokens to ethereum. /// @dev Liquifies tokens to ethereum.
function sell(uint256 _amountOfTokens) onlyBagholders public { function sell(uint256 _amountOfTokens) onlyBagholders public {
// setup data // setup data
address _customerAddress = msg.sender; address _customerAddress = msg.sender;
// russian hackers BTFO // russian hackers BTFO
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]); require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens; uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens); uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100); uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends); uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
// burn the sold tokens // burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens); tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens); tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker // update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude)); int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts; payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea // dividing by zero is a bad idea
if (tokenSupply_ > 0) { if (tokenSupply_ > 0) {
// update the amount of dividends per token // update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_); profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
} }
// fire event // fire event
onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice()); onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
} }
/** /**
* @dev Transfer tokens from the caller to a new holder. * @dev Transfer tokens from the caller to a new holder.
* Remember, there's a 15% fee here as well. * Remember, there's a 15% fee here as well.
*/ */
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) { function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
// setup // setup
address _customerAddress = msg.sender; address _customerAddress = msg.sender;
// make sure we have the requested tokens // make sure we have the requested tokens
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]); require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first // withdraw all outstanding dividends first
if (myDividends(true) > 0) { if (myDividends(true) > 0) {
withdraw(); withdraw();
} }
// liquify 10% of the tokens that are transfered // liquify 10% of the tokens that are transfered
// these are dispersed to shareholders // these are dispersed to shareholders
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100); uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee); uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee); uint256 _dividends = tokensToEthereum_(_tokenFee);
// burn the fee tokens // burn the fee tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee); tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
// exchange tokens // exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens); tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens); tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
// update dividend trackers // update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens); payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens); payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
// disperse dividends among holders // disperse dividends among holders
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_); profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
// fire event // fire event
Transfer(_customerAddress, _toAddress, _taxedTokens); Transfer(_customerAddress, _toAddress, _taxedTokens);
// ERC20 // ERC20
return true; return true;
} }
/*===================================== /*=====================================
= HELPERS AND CALCULATORS = = HELPERS AND CALCULATORS =
=====================================*/ =====================================*/
/** /**
* @dev Method to view the current Ethereum stored in the contract * @dev Method to view the current Ethereum stored in the contract
* Example: totalEthereumBalance() * Example: totalEthereumBalance()
*/ */
function totalEthereumBalance() public view returns (uint256) { function totalEthereumBalance() public view returns (uint256) {
return this.balance; return this.balance;
} }
/// @dev Retrieve the total token supply. /// @dev Retrieve the total token supply.
function totalSupply() public view returns (uint256) { function totalSupply() public view returns (uint256) {
return tokenSupply_; return tokenSupply_;
} }
/// @dev Retrieve the tokens owned by the caller. /// @dev Retrieve the tokens owned by the caller.
function myTokens() public view returns (uint256) { function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender; address _customerAddress = msg.sender;
return balanceOf(_customerAddress); return balanceOf(_customerAddress);
} }
/** /**
* @dev Retrieve the dividends owned by the caller. * @dev Retrieve the dividends owned by the caller.
* If `_includeReferralBonus` is to to 1/true, the referral bonus will be included in the calculations. * 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) * 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. * But in the internal calculations, we want them separate.
*/ */
function myDividends(bool _includeReferralBonus) public view returns (uint256) { function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender; address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ; return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
} }
/// @dev Retrieve the token balance of any single address. /// @dev Retrieve the token balance of any single address.
function balanceOf(address _customerAddress) public view returns (uint256) { function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress]; return tokenBalanceLedger_[_customerAddress];
} }
/// @dev Retrieve the dividend balance of any single address. /// @dev Retrieve the dividend balance of any single address.
function dividendsOf(address _customerAddress) public view returns (uint256) { function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude; return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
} }
/// @dev Return the sell price of 1 individual token. /// @dev Return the sell price of 1 individual token.
function sellPrice() public view returns (uint256) { function sellPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh. // our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) { if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_; return tokenPriceInitial_ - tokenPriceIncremental_;
} else { } else {
uint256 _ethereum = tokensToEthereum_(1e18); uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100); uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends); uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum; return _taxedEthereum;
} }
} }
/// @dev Return the buy price of 1 individual token. /// @dev Return the buy price of 1 individual token.
function buyPrice() public view returns (uint256) { function buyPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh. // our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) { if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_; return tokenPriceInitial_ + tokenPriceIncremental_;
} else { } else {
uint256 _ethereum = tokensToEthereum_(1e18); uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100); uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends); uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum; return _taxedEthereum;
} }
} }
/// @dev Function for the frontend to dynamically retrieve the price scaling of buy orders. /// @dev Function for the frontend to dynamically retrieve the price scaling of buy orders.
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) { function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100); uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends); uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum); uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens; return _amountOfTokens;
} }
/// @dev Function for the frontend to dynamically retrieve the price scaling of sell orders. /// @dev Function for the frontend to dynamically retrieve the price scaling of sell orders.
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) { function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_); require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell); uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100); uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends); uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum; return _taxedEthereum;
} }
/*========================================== /*==========================================
= INTERNAL FUNCTIONS = = INTERNAL FUNCTIONS =
==========================================*/ ==========================================*/
/// @dev Internal function to actually purchase the tokens. /// @dev Internal function to actually purchase the tokens.
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) { function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
// data setup // data setup
address _customerAddress = msg.sender; address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100); uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100); uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus); uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends); uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum); uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude; uint256 _fee = _dividends * magnitude;
// no point in continuing execution if OP is a poorfag russian hacker // no point in continuing execution if OP is a poorfag russian hacker
// prevents overflow in the case that the pyramid somehow magically starts being used by everyone in the world // prevents overflow in the case that the pyramid somehow magically starts being used by everyone in the world
// (or hackers) // (or hackers)
// and yes we know that the safemath function automatically rules out the "greater then" equasion. // and yes we know that the safemath function automatically rules out the "greater then" equasion.
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_); require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
// is the user referred by a masternode? // is the user referred by a masternode?
if ( if (
// is this a referred purchase? // is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 && _referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating! // no cheating!
_referredBy != _customerAddress && _referredBy != _customerAddress &&
// does the referrer have at least X whole tokens? // does the referrer have at least X whole tokens?
// i.e is the referrer a godly chad masternode // i.e is the referrer a godly chad masternode
tokenBalanceLedger_[_referredBy] >= stakingRequirement tokenBalanceLedger_[_referredBy] >= stakingRequirement
) { ) {
// wealth redistribution // wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus); referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else { } else {
// no ref purchase // no ref purchase
// add the referral bonus back to the global dividends cake // add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus); _dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude; _fee = _dividends * magnitude;
} }
// we can't give people infinite ethereum // we can't give people infinite ethereum
if (tokenSupply_ > 0) { if (tokenSupply_ > 0) {
// add tokens to the pool // add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens); tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
// take the amount of dividends gained through this transaction, and allocates them evenly to each shareholder // take the amount of dividends gained through this transaction, and allocates them evenly to each shareholder
profitPerShare_ += (_dividends * magnitude / tokenSupply_); profitPerShare_ += (_dividends * magnitude / tokenSupply_);
// calculate the amount of tokens the customer receives over his purchase // calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_))); _fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else { } else {
// add tokens to the pool // add tokens to the pool
tokenSupply_ = _amountOfTokens; tokenSupply_ = _amountOfTokens;
} }
// update circulating supply & the ledger address for the customer // update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens); tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
// Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them; // 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 // really i know you think you do but you don't
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee); int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts; payoutsTo_[_customerAddress] += _updatedPayouts;
// fire event // fire event
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice()); onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens; return _amountOfTokens;
} }
/** /**
* @dev Calculate Token price based on an amount of incoming ethereum * @dev 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; * 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. * Some conversions occurred to prevent decimal errors or underflows / overflows in solidity code.
*/ */
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) { function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18; uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived = uint256 _tokensReceived =
( (
( (
// underflow attempts BTFO // underflow attempts BTFO
SafeMath.sub( SafeMath.sub(
(sqrt (sqrt
( (
(_tokenPriceInitial ** 2) (_tokenPriceInitial ** 2)
+ +
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18)) (2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+ +
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2)) ((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+ +
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_) (2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_)
) )
), _tokenPriceInitial ), _tokenPriceInitial
) )
) / (tokenPriceIncremental_) ) / (tokenPriceIncremental_)
) - (tokenSupply_); ) - (tokenSupply_);
return _tokensReceived; return _tokensReceived;
} }
/** /**
* @dev Calculate token sell value. * @dev Calculate token sell value.
* It's an algorithm, hopefully we gave you the whitepaper with it in scientific notation; * 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. * Some conversions occurred to prevent decimal errors or underflows / overflows in solidity code.
*/ */
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) { function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18); uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18); uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived = uint256 _etherReceived =
( (
// underflow attempts BTFO // underflow attempts BTFO
SafeMath.sub( SafeMath.sub(
( (
( (
( (
tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18)) tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))
) - tokenPriceIncremental_ ) - tokenPriceIncremental_
) * (tokens_ - 1e18) ) * (tokens_ - 1e18)
), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2 ), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2
) )
/ 1e18); / 1e18);
return _etherReceived; return _etherReceived;
} }
/// @dev This is where all your gas goes. /// @dev This is where all your gas goes.
function sqrt(uint256 x) internal pure returns (uint256 y) { function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2; uint256 z = (x + 1) / 2;
y = x; y = x;
while (z < y) { while (z < y) {
y = z; y = z;
z = (x / z + z) / 2; z = (x / z + z) / 2;
} }
} }
}}
/**/**
* @title SafeMath * @title SafeMath
* @dev Math operations with safety checks that throw on error * @dev Math operations with safety checks that throw on error
*/ */
library SafeMath {library SafeMath {
/** /**
* @dev Multiplies two numbers, throws on overflow. * @dev Multiplies two numbers, throws on overflow.
*/ */
function mul(uint256 a, uint256 b) internal pure returns (uint256) { function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) { if (a == 0) {
return 0; return 0;
} }
uint256 c = a * b; uint256 c = a * b;
assert(c / a == b); assert(c / a == b);
return c; return c;
} }
/** /**
* @dev Integer division of two numbers, truncating the quotient. * @dev Integer division of two numbers, truncating the quotient.
*/ */
function div(uint256 a, uint256 b) internal pure returns (uint256) { function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0 // assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b; uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold // assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c; return c;
} }
/** /**
* @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend). * @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) { function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a); assert(b <= a);
return a - b; return a - b;
} }
/** /**
* @dev Adds two numbers, throws on overflow. * @dev Adds two numbers, throws on overflow.
*/ */
function add(uint256 a, uint256 b) internal pure returns (uint256) { function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b; uint256 c = a + b;
assert(c >= a); assert(c >= a);
return c; return c;
} }
}}
Editor
Clear
Export as PDF
Original Text
Changed Text