Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•  contract Hourglass *
•    - function Hourglass()
•    - function buy(address _referredBy)
•    - function reinvest()
•    - function exit()
•    - function withdraw()
•    - function sell(uint256 _amountOfTokens ...
•    - function transfer(address _toAddress, ...
•    - function totalEthereumBalance()
•    - function totalSupply()
•    - function myTokens()
•    - function myDividends(bool _includeRef ...
•    - function balanceOf(address _customerA ...
•    - function dividendsOf(address _custome ...
•    - function sellPrice()
•    - function buyPrice()
•    - function calculateTokensReceived(uint ...
•    - function calculateEthereumReceived(ui ...
•    - function purchaseTokens(uint256 _inco ...
•    - function ethereumToTokens_(uint256 _e ...
•    - function tokensToEthereum_(uint256 _t ...
•    - function sqrt(uint x)
• library SafeMath
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function add(uint256 a, uint256 b)

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-07-17
*/

pragma solidity ^0.4.20;
/***
 *    ______                                                         ____  __  
 *   / ____/___  ____ ___  ____ ___  ____  ____ _      _____  ____ _/ / /_/ /_ 
 *  / /   / __ \/ __ `__ \/ __ `__ \/ __ \/ __ \ | /| / / _ \/ __ `/ / __/ __ \
 * / /___/ /_/ / / / / / / / / / / / /_/ / / / / |/ |/ /  __/ /_/ / / /_/ / / /
 *  \____/\____/_/ /_/ /_/_/ /_/ /_/\____/_/ /_/|__/|__/\___/\__,_/_/\__/_/ /_/ 
 *
 *                                                                                                                                            
 * v 1.1.0
 * eWLTH - Commonwealth.gg deployed on ETH (based on contract @ ETC:0xDe6FB6a5adbe6415CDaF143F8d90Eb01883e42ac)
 * Modifications: 
 *   -> Ticker Name and Symbol 
 *   -> dividendsOf Function
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE 
 * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

contract Hourglass {
    /*=================================
    =            MODIFIERS            =
    =================================*/
    // only people with tokens
    modifier onlyHolders() {
        require(myTokens() > 0);
        _;
    }
    
    // only people with profits
    modifier onlyStronghands() {
        require(myDividends(true) > 0);
        _;
    }
    
    /*==============================
    =            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 = "ETH-Commonwealth-1.1.0";
    string public symbol = "eWLTH";
    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;
    
   /*================================
    =            DATASETS            =
    ================================*/
    // amount of shares for each address (scaled number)
    mapping(address => uint256) internal tokenBalanceLedger_;
    mapping(address => uint256) internal referralBalance_;
    mapping(address => int256) internal payoutsTo_;
    uint256 internal tokenSupply_ = 0;
    uint256 internal profitPerShare_;
    
    /*=======================================
    =            PUBLIC FUNCTIONS            =
    =======================================*/
    /*
    * -- APPLICATION ENTRY POINTS --  
    */
    function Hourglass()
        public
    {
    }
    
     
    /**
     * Converts all incoming ethereum to tokens for the caller, and passes down the referral addy (if any)
     */
    function buy(address _referredBy)
        public
        payable
        returns(uint256)
    {
        purchaseTokens(msg.value, _referredBy);
    }
    
    /**
     * Fallback function to handle ethereum 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
        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;
        
        // lambo delivery service
        _customerAddress.transfer(_dividends);
        
        // fire event
        onWithdraw(_customerAddress, _dividends);
    }
    
    /**
     * Liquifies tokens to ethereum.
     */
    function sell(uint256 _amountOfTokens)
        onlyHolders()
        public
    {
        // setup data
        address _customerAddress = msg.sender;
        // russian hackers BTFO
        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 token to a different address. No fees.
     */
     function transfer(address _toAddress, uint256 _amountOfTokens) 
        onlyHolders() 
        public 
        returns(bool) 
    {
        // cant send to 0 address
        require(_toAddress != address(0));
        // 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
        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(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.
     * 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 dividendsOf(_customerAddress,_includeReferralBonus);
    }
    
    /**
     * 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,bool _includeReferralBonus)
        view
        public
        returns(uint256)
    {
        uint256 regularDividends = (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
        if (_includeReferralBonus){
            return regularDividends + referralBalance_[_customerAddress];
        } else {
            return regularDividends;
        }
    }
    
    /**
     * 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 _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)
    {
        // our calculation relies on the token supply, so we need supply. Doh.
        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 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)
        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;
 
        // prevents overflow
        require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
        
        if(
            // is this a referred purchase?
            _referredBy != 0x0000000000000000000000000000000000000000
        ){
            // 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 participant
            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);
        
        // 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_[_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.
     * 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 + 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;
    }
    
    
    //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;
        }
    }
}

/**
 * @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;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_ethereumToSpend","type":"uint256"}],"name":"calculateTokensReceived","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_tokensToSell","type":"uint256"}],"name":"calculateEthereumReceived","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"withdraw","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"sellPrice","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_includeReferralBonus","type":"bool"}],"name":"myDividends","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalEthereumBalance","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_customerAddress","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_customerAddress","type":"address"},{"name":"_includeReferralBonus","type":"bool"}],"name":"dividendsOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"buyPrice","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"myTokens","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_toAddress","type":"address"},{"name":"_amountOfTokens","type":"uint256"}],"name":"transfer","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_amountOfTokens","type":"uint256"}],"name":"sell","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"exit","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_referredBy","type":"address"}],"name":"buy","outputs":[{"name":"","type":"uint256"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[],"name":"reinvest","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"inputs":[],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"anonymous":false,"inputs":[{"indexed":true,"name":"customerAddress","type":"address"},{"indexed":false,"name":"incomingEthereum","type":"uint256"},{"indexed":false,"name":"tokensMinted","type":"uint256"},{"indexed":true,"name":"referredBy","type":"address"}],"name":"onTokenPurchase","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"customerAddress","type":"address"},{"indexed":false,"name":"tokensBurned","type":"uint256"},{"indexed":false,"name":"ethereumEarned","type":"uint256"}],"name":"onTokenSell","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"customerAddress","type":"address"},{"indexed":false,"name":"ethereumReinvested","type":"uint256"},{"indexed":false,"name":"tokensMinted","type":"uint256"}],"name":"onReinvestment","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"customerAddress","type":"address"},{"indexed":false,"name":"ethereumWithdrawn","type":"uint256"}],"name":"onWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"from","type":"address"},{"indexed":true,"name":"to","type":"address"},{"indexed":false,"name":"tokens","type":"uint256"}],"name":"Transfer","type":"event"}]

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

1286:17602:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4273:30;4288:9;4299:3;4273:14;:30::i;:::-;;1286:17602;2670:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;2670:45:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12450:398;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9268:122;;;;;;;;;;;;12970:414;;;;;;;;;;;;;;2759:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5625:678;;;;;;;;;;;;;;11161:543;;;;;;;;;;;;10013:238;;;;;;;;;;;;;;;;9069:128;;;;;;;;;;;;10339:169;;;;;;;;;;-1:-1:-1;;;;;10339:169:0;;;;;10599:480;;;;;;;;;;-1:-1:-1;;;;;10599:480:0;;;;;;;;;11787:542;;;;;;;;;;;;9469:182;;;;;;;;;;;;2722:30;;;;;;;;;;;;7761:1114;;;;;;;;;;-1:-1:-1;;;;;7761:1114:0;;;;;;;;;;;;;;;;;;;;;;;;6371:1297;;;;;;;;;;;;;;5232:320;;;;;;;;;;;;3879:155;;-1:-1:-1;;;;;3879:155:0;;;;;4395:767;;;;;;;;;;;;13552:2762;13659:7;13734:10;13659:7;;;;;;;13785:45;13798:17;2840:2;13785:12;:45::i;:::-;13755:75;;13866:36;13879:19;13900:1;13866:12;:36::i;:::-;13841:61;;13934:49;13947:19;13968:14;13934:12;:49::i;:::-;13913:70;;14019:52;14032:17;14051:19;14019:12;:52::i;:::-;13994:77;;14108:33;14126:14;14108:17;:33::i;:::-;14082:59;;3030:5;14167:10;:22;14152:37;;14259:1;14241:15;:19;:82;;;;-1:-1:-1;14310:12:0;;14265:42;14278:15;14310:12;14265;:42::i;:::-;:57;14241:82;14233:91;;;;;;;;-1:-1:-1;;;;;14407:57:0;;;14345:521;;-1:-1:-1;;;;;14573:29:0;;;;;;:16;:29;;;;;;14560:59;;14604:14;14560:12;:59::i;:::-;-1:-1:-1;;;;;14528:29:0;;;;;;:16;:29;;;;;:91;14345:521;;;14770:40;14783:10;14795:14;14770:12;:40::i;:::-;14757:53;;3030:5;14832:10;:22;14825:29;;14345:521;14955:1;14940:12;;:16;14937:671;;;15040:43;15053:12;;15067:15;15040:12;:43::i;:::-;15025:12;:58;;;3030:5;15245:22;;:39;;;;;;;15225:15;:60;;15245:39;;;;15225:60;;;;;15468:12;;3030:5;15442:22;;:39;;;;;;;;15423:15;:59;15417:4;:66;15409:4;:75;15402:82;;14937:671;;;15566:12;:30;;;14937:671;-1:-1:-1;;;;;15757:37:0;;;;;;:19;:37;;;;;;15744:68;;15796:15;15744:12;:68::i;:::-;-1:-1:-1;;;;;15704:37:0;;;;;;;:19;:37;;;;;;;;:108;;;;16037:15;;16090:10;:28;;;;;;;:47;;16037:33;;;16036:42;;;16090:47;;;;;16036:42;-1:-1:-1;16181:82:0;;;;;;16215:17;;16055:15;;16181:82;;;;;;;;;;;;;;;;;;;-1:-1:-1;16291:15:0;;13552:2762;-1:-1:-1;;;;;;;;;13552:2762:0:o;2670:45::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;12450:398::-;12559:7;;;;12605:44;12618:16;2840:2;12605:12;:44::i;:::-;12584:65;;12685:42;12698:16;12716:10;12685:12;:42::i;:::-;12660:67;;12764:33;12782:14;12764:17;:33::i;:::-;12738:59;12450:398;-1:-1:-1;;;;;12450:398:0:o;9268:122::-;9370:12;;9268:122;:::o;12970:414::-;13078:7;13152:17;13215:18;13284:22;13128:12;;13111:13;:29;;13103:38;;;;;;;;13172:32;13190:13;13172:17;:32::i;:::-;13152:52;-1:-1:-1;13236:37:0;13152:52;2840:2;13236:12;:37::i;:::-;13215:58;;13309:35;13322:9;13333:10;13309:12;:35::i;2759:::-;2792:2;2759:35;:::o;5625:678::-;5727:24;5775:18;1655:1;1635:17;1647:4;1635:11;:17::i;:::-;:21;1627:30;;;;;;5754:10;5727:37;;5796:18;5808:5;5796:11;:18::i;:::-;-1:-1:-1;;;;;5907:28:0;;;;;;:10;:28;;;;;;;;:66;;3030:5;5950:22;;5907:66;;;6035:16;:34;;;;;;;;6080:38;;;6021:48;;;-1:-1:-1;5907:28:0;6174:37;;;;;6021:48;;6174:37;;;;;;;;;;;;;;;;;;;;;;;;;6266:16;-1:-1:-1;;;;;6255:40:0;;6284:10;6255:40;;;;;;;;;;;;;;5625:678;;:::o;11161:543::-;11232:7;11456:17;11514:18;11589:22;11340:12;;11356:1;11340:17;11337:360;;;11380:43;;-1:-1:-1;11373:50:0;;11337:360;11476:23;11494:4;11476:17;:23::i;:::-;11456:43;-1:-1:-1;11535:39:0;11456:43;2840:2;11535:12;:39::i;:::-;11514:60;;11614:35;11627:9;11638:10;11614:12;:35::i;:::-;11589:60;;11671:14;11664:21;;11337:360;11161:543;;;;:::o;10013:238::-;10112:7;10164:10;10192:51;10164:10;10221:21;10192:11;:51::i;:::-;10185:58;;10013:238;;;;;:::o;9069:128::-;-1:-1:-1;;;;;9177:4:0;:12;;9069:128;:::o;10339:169::-;-1:-1:-1;;;;;10463:37:0;10431:7;10463:37;;;:19;:37;;;;;;;10339:169::o;10599:480::-;-1:-1:-1;;;;;10851:28:0;;10720:7;10851:28;;;:10;:28;;;;;;;;;10810:19;:37;;;;;;10792:15;;3030:5;10792:55;;10783:96;;;;10772:120;10903:169;;;;-1:-1:-1;;;;;10970:34:0;;;;;;:16;:34;;;;;;10951:53;;;-1:-1:-1;10944:60:0;;10903:169;11044:16;11037:23;;10903:169;10599:480;;;;;:::o;11787:542::-;11857:7;12081:17;12139:18;12214:22;11965:12;;11981:1;11965:17;11962:360;;;12005:43;;-1:-1:-1;11998:50:0;;11962:360;12101:23;12119:4;12101:17;:23::i;:::-;12081:43;-1:-1:-1;12160:39:0;12081:43;2840:2;12160:12;:39::i;:::-;12139:60;;12239:35;12252:9;12263:10;12239:12;:35::i;9469:182::-;9536:7;9588:10;9616:27;9588:10;9616:9;:27::i;:::-;9609:34;;9469:182;;:::o;2722:30::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7761:1114;7883:4;8003:24;1522:1;1509:10;:8;:10::i;:::-;:14;1501:23;;;;;;-1:-1:-1;;;;;7949:24:0;;;;7941:33;;;;;;-1:-1:-1;8030:10:0;-1:-1:-1;;;;;8131:37:0;;;;;;:19;:37;;;;;;8112:56;;;8104:65;;;;;;8258:1;8238:17;8250:4;8238:11;:17::i;:::-;:21;8235:36;;;8261:10;:8;:10::i;:::-;-1:-1:-1;;;;;8365:37:0;;;;;;:19;:37;;;;;;8352:68;;8404:15;8352:12;:68::i;:::-;-1:-1:-1;;;;;8312:37:0;;;;;;;:19;:37;;;;;;:108;;;;8478:31;;;;;;;8465:62;;8511:15;8465:12;:62::i;:::-;-1:-1:-1;;;;;8431:31:0;;;;;;;:19;:31;;;;;;;;:96;;;;8619:15;;;8577:28;;;;;;:10;:28;;;;;;:76;;8619:33;;;8577:76;;;;;;8700:15;;8664:22;;;;;;;:70;;8700:33;;;8664:70;;;;;8431:31;8770:55;;8619:33;;8770:55;;;;;;;;;;;;;-1:-1:-1;8863:4:0;;7761:1114;-1:-1:-1;;;7761:1114:0:o;6371:1297::-;6488:24;6645:15;6689:17;6746:18;6815:22;7148;1522:1;1509:10;:8;:10::i;:::-;:14;1501:23;;;;;;6515:10;-1:-1:-1;;;;;6596:37:0;;;;;;:19;:37;;;;;;6515:10;;-1:-1:-1;6577:56:0;;;6569:65;;;;;;6663:15;6645:33;;6709:26;6727:7;6709:17;:26::i;:::-;6689:46;-1:-1:-1;6767:37:0;6689:46;2840:2;6767:12;:37::i;:::-;6746:58;;6840:35;6853:9;6864:10;6840:12;:35::i;:::-;6815:60;;6944:35;6957:12;;6971:7;6944:12;:35::i;:::-;6929:12;:50;-1:-1:-1;;;;;7043:37:0;;;;;;:19;:37;;;;;;7030:60;;7082:7;7030:12;:60::i;:::-;-1:-1:-1;;;;;6990:37:0;;;;;;:19;:37;;;;;;;;:100;;;;7183:15;;7251:10;:28;;;;;;:47;;7183:25;;;3030:5;7212:26;;7183:56;7251:47;;;;;;7373:12;;7183:56;;-1:-1:-1;7373:16:0;;7369:194;;;7481:70;7494:15;;7538:12;;3030:5;7512:10;:22;7511:39;;;;;;;;7481:12;:70::i;:::-;7463:15;:88;7369:194;7618:16;-1:-1:-1;;;;;7606:54:0;;7636:7;7645:14;7606:54;;;;;;;;;;;;;;;;;;;;6371:1297;;;;;;;:::o;5232:320::-;5362:10;-1:-1:-1;;;;;5401:37:0;;5335:24;5401:37;;;:19;:37;;;;;;;5452:11;;5449:29;;;5465:13;5470:7;5465:4;:13::i;:::-;5534:10;:8;:10::i;:::-;5232:320;;:::o;3879:155::-;3963:7;3988:38;4003:9;4014:11;3988:14;:38::i;4395:767::-;4502:18;4647:24;5008:15;1655:1;1635:17;1647:4;1635:11;:17::i;:::-;:21;1627:30;;;;;;4523:18;4535:5;4523:11;:18::i;:::-;4674:10;-1:-1:-1;;;;;4695:28:0;;;;;;:10;:28;;;;;;;;:66;;3030:5;4738:22;;4695:66;;;4828:16;:34;;;;;;;4873:38;;;;4814:48;;;;-1:-1:-1;4674:10:0;-1:-1:-1;5026:31:0;;4814:48;;5026:14;:31::i;:::-;5008:49;;5116:16;-1:-1:-1;;;;;5101:53:0;;5134:10;5146:7;5101:53;;;;;;;;;;;;;;;;;;;;4395:767;;;:::o;19388:288::-;19446:7;19545:9;19561:1;19557;:5;;;;;;;;;19388:288;-1:-1:-1;;;;19388:288:0:o;19802:123::-;19860:7;19887:6;;;;19880:14;;;;-1:-1:-1;19912:5:0;;;19802:123::o;16610:976::-;17518:12;;16705:7;;16759:25;;16705:7;;2969:16;16910:555;16946:457;17092:52;;;17208:27;17317:1;17238:15;;17207:47;17007:248;17317:45;:58;;17007:369;17008:21;17007:369;16946:4;:457::i;:::-;17428:18;16910:12;:555::i;:::-;16847:658;;;;;;;;16832:699;;16610:976;-1:-1:-1;;;;16610:976:0:o;20000:147::-;20058:7;20090:5;;;20113:6;;;;20106:14;;;17853:722;18042:12;;17946:7;;18002:4;17992:14;;;;18042:19;;;17946:7;;18162:357;18243:147;18321:17;;;2969:16;18295:44;18243:147;18216:214;;18503:1;18002:4;-1:-1:-1;;18476:10:0;;;:18;;;;18475:25;2969:16;18451:50;18450:54;;;;;;;;18162:12;:357::i;:::-;:372;;;;;;;;;17853:722;-1:-1:-1;;;;;17853:722:0:o;18687:198::-;18761:5;18770:1;18765;18761:5;;18760:11;18798:80;18809:1;18805;:5;18798:80;;;18831:1;18827:5;;18865:1;18860;18856;18852;:5;;;;;;;;:9;18851:15;;;;;;;;18847:19;;18798:80;

bzzr://0e5612d90f9292803286ab50e33b2aa6e324eb8415fa1194f248cc3a021da5db