Created
May 13, 2018 16:28
-
-
Save aminnagpure/f625a4eed187a6ea35af2fbf0077af47 to your computer and use it in GitHub Desktop.
Jenna Haze Coin Smart Ponzy Scheme
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
pragma solidity ^0.4.20; | |
/* | |
*A reincarnation of Mahatma Gandhi, born again to live forever on the Ethereum Blockchain | |
dddddddd | |
GGGGGGGGGGGGG d::::::dhhhhhhh iiii jjjj iiii iiii | |
GGG::::::::::::G d::::::dh:::::h i::::i j::::j i::::i i::::i | |
GG:::::::::::::::G d::::::dh:::::h iiii jjjj iiii iiii | |
G:::::GGGGGGGG::::G d:::::d h:::::h | |
G:::::G GGGGGG aaaaaaaaaaaaa nnnn nnnnnnnn ddddddddd:::::d h::::h hhhhh iiiiiiijjjjjjjiiiiiii iiiiiii ooooooooooo | |
G:::::G a::::::::::::a n:::nn::::::::nn dd::::::::::::::d h::::hh:::::hhh i:::::ij:::::ji:::::i i:::::i oo:::::::::::oo | |
G:::::G aaaaaaaaa:::::an::::::::::::::nn d::::::::::::::::d h::::::::::::::hh i::::i j::::j i::::i i::::i o:::::::::::::::o | |
G:::::G GGGGGGGGGG a::::ann:::::::::::::::nd:::::::ddddd:::::d h:::::::hhh::::::h i::::i j::::j i::::i i::::i o:::::ooooo:::::o | |
G:::::G G::::::::G aaaaaaa:::::a n:::::nnnn:::::nd::::::d d:::::d h::::::h h::::::h i::::i j::::j i::::i i::::i o::::o o::::o | |
G:::::G GGGGG::::G aa::::::::::::a n::::n n::::nd:::::d d:::::d h:::::h h:::::h i::::i j::::j i::::i i::::i o::::o o::::o | |
G:::::G G::::G a::::aaaa::::::a n::::n n::::nd:::::d d:::::d h:::::h h:::::h i::::i j::::j i::::i i::::i o::::o o::::o | |
G:::::G G::::Ga::::a a:::::a n::::n n::::nd:::::d d:::::d h:::::h h:::::h i::::i j::::j i::::i i::::i o::::o o::::o | |
G:::::GGGGGGGG::::Ga::::a a:::::a n::::n n::::nd::::::ddddd::::::dd h:::::h h:::::hi::::::ij::::ji::::::i i::::::io:::::ooooo:::::o | |
GG:::::::::::::::Ga:::::aaaa::::::a n::::n n::::n d:::::::::::::::::d h:::::h h:::::hi::::::ij::::ji::::::i ...... i::::::io:::::::::::::::o | |
GGG::::::GGG:::G a::::::::::aa:::a n::::n n::::n d:::::::::ddd::::d h:::::h h:::::hi::::::ij::::ji::::::i .::::. i::::::i oo:::::::::::oo | |
GGGGGG GGGG aaaaaaaaaa aaaa nnnnnn nnnnnn ddddddddd ddddd hhhhhhh hhhhhhhiiiiiiiij::::jiiiiiiii ...... iiiiiiii ooooooooooo | |
j::::j | |
jjjj j::::j | |
j::::jj j:::::j | |
j::::::jjj::::::j | |
jj::::::::::::j | |
jjj::::::jjj | |
jjjjjj | |
*Where there is love there is life. | |
*Happiness is when what you think, what you say, and what you do are in harmony. | |
*You must not lose faith in humanity. Humanity is an ocean; if a few drops of the ocean are dirty, the ocean does not become dirty. | |
*In a gentle way, you can shake the world. | |
*The weak can never forgive. Forgiveness is the attribute of the strong. | |
*Strength does not come from physical capacity. It comes from an indomitable will. | |
*A man is but the product of his thoughts; what he thinks, he becomes. | |
*Earth provides enough to satisfy every man's needs, but not every man's greed. | |
*Freedom is not worth having if it does not include the freedom to make mistakes. | |
*I will not let anyone walk through my mind with their dirty feet. | |
* | |
*A tribute to Mohandas Karamchand Gandhi Ji - 2 October 1869 – 30 January 1948 - Jai Hind! | |
*/ | |
contract JennaHaze { | |
/*================================= | |
= MODIFIERS = | |
=================================*/ | |
// only people with tokens | |
modifier onlybelievers () { | |
require(myTokens() > 0); | |
_; | |
} | |
// only people with profits | |
modifier onlyhodler() { | |
require(myDividends(true) > 0); | |
_; | |
} | |
// administrators can: | |
// -> change the name of the contract | |
// -> change the name of the token | |
// -> change the PoS difficulty | |
// they CANNOT: | |
// -> take funds | |
// -> disable withdrawals | |
// -> kill the contract | |
// -> change the price of tokens | |
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); | |
// execute | |
_; | |
} 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 | |
); | |
// ERC20 | |
event Transfer( | |
address indexed from, | |
address indexed to, | |
uint256 tokens | |
); | |
/*===================================== | |
= CONFIGURABLES = | |
=====================================*/ | |
string public name = "JennaHaze"; | |
string public symbol = "JenA"; | |
uint8 constant public decimals = 18; | |
uint8 constant internal dividendFee_ = 10; | |
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether; | |
uint256 constant internal tokenPriceIncremental_ = 0.00000001 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 = | |
================================*/ | |
// amount of shares for each address (scaled number) | |
mapping(address => uint256) internal tokenBalanceLedger_; | |
mapping(address => uint256) internal referralBalance_; | |
mapping(address => int256) internal payoutsTo_; | |
mapping(address => uint256) internal ambassadorAccumulatedQuota_; | |
uint256 internal tokenSupply_ = 0; | |
uint256 internal profitPerShare_; | |
// administrator list (see above on what they can do) | |
mapping(bytes32 => bool) public administrators; | |
bool public onlyAmbassadors = false; | |
/*======================================= | |
= PUBLIC FUNCTIONS = | |
=======================================*/ | |
/* | |
* -- APPLICATION ENTRY POINTS -- | |
*/ | |
function JennaHaze() | |
public | |
{ | |
// add administrators here | |
// administrators[0x9bcc16873606dc04acb98263f74c420525ddef61de0d5f18fd97d16de659131a] = true; | |
//administrators[msg.sender] = true; | |
//ambassadors_[0x0000000000000000000000000000000000000000] = true; | |
ambassadors_[msg.sender] = true; | |
// ambassadors_[0x215e3C713BADb158A457e61f99325bBB5d278E57] = 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.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 | |
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) | |
{ | |
// setup | |
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.div(_amountOfTokens, dividendFee_); | |
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); | |
// ERC20 | |
return true; | |
} | |
/*---------- ADMINISTRATOR ONLY FUNCTIONS ----------*/ | |
/** | |
* administrator can manually disable the ambassador phase. | |
*/ | |
function disableInitialStage() | |
onlyAdministrator() | |
public | |
{ | |
onlyAmbassadors = false; | |
} | |
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; | |
} | |
/*---------- 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 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]) - payoutsTo_[_customerAddress]) / magnitude; | |
} | |
/** | |
* Return the buy price of 1 individual token. | |
*/ | |
function sellPrice() | |
public | |
view | |
returns(uint256) | |
{ | |
if(tokenSupply_ == 0){ | |
return tokenPriceInitial_ - tokenPriceIncremental_; | |
} else { | |
uint256 _ethereum = tokensToEthereum_(1e18); | |
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_ ); | |
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 _dividends = SafeMath.div(_ethereum, dividendFee_ ); | |
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends); | |
return _taxedEthereum; | |
} | |
} | |
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 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) | |
antiEarlyWhale(_incomingEthereum) | |
internal | |
returns(uint256) | |
{ | |
// data setup | |
address _customerAddress = msg.sender; | |
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 karmalink? | |
if( | |
// is this a referred purchase? | |
_referredBy != 0x0000000000000000000000000000000000000000 && | |
// no cheating! | |
_referredBy != _customerAddress && | |
tokenBalanceLedger_[_referredBy] >= stakingRequirement | |
){ | |
// wealth redistribution | |
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus); | |
} else { | |
// no ref purchase | |
// add the referral bonus back to the global dividends cake | |
_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_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens); | |
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee); | |
payoutsTo_[_customerAddress] += _updatedPayouts; | |
// fire event | |
onTokenPurchase(_customerAddress, _incomingEthereum, _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 = | |
( | |
( | |
// underflow attempts BTFO | |
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 + 1e18); | |
uint256 _tokenSupply = (tokenSupply_ + 1e18); | |
uint256 _etherReceived = | |
( | |
// underflow attempts BTFO | |
SafeMath.sub( | |
( | |
( | |
( | |
tokenPriceInitial_ +(tokenPriceIncremental_ * (_tokenSupply/1e18)) | |
)-tokenPriceIncremental_ | |
)*(tokens_ - 1e18) | |
),(tokenPriceIncremental_*((tokens_**2-tokens_)/1e18))/2 | |
) | |
/1e18); | |
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; | |
} | |
} | |
} | |
/** | |
* @title SafeMath | |
* @dev Math operations with safety checks that throw on error | |
*/ | |
library SafeMath { | |
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; | |
} | |
/** | |
* Also in memory of JPK, miss you Dad. | |
*/ | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment