How to participate using Ethereum Wallet
How to participate using Parity
How to participate using MyEtherWallet
Help & support

IMPORTANT:

Do not send Ether to our crowdfund address directly from an exchange or hosted wallet (e.g. Coinbase). You will not be able to access your tokens. We cannot stress this enough.

How to participate using Ethereum Wallet

To fuel the crowdfund with Ether and become a token holder you will need to send Ether to our crowdfund address.

Step 1 - Sending Ether to the crowdfund address

1. If you already have Ethereum Wallet installed and synced, you can skip to step 3. Otherwise, download and install the latest version of Ethereum Wallet from http://github.com/ethereum/mist/releases.
2. Once Ethereum Wallet has finished syncing and you have funds available in your wallet:
3. Click 'SEND'.
4. In the 'FROM' dropdown, select the wallet address you will be sending from. You will receive your ÐICE tokens at this address.
5. In the 'TO' field, enter the crowdfund address: 0x805129C7144688224c122c924E3855D5b4FA01D8
6. In the 'AMOUNT' field, enter the amount in units of Ether.
7. Hit 'SEND'.
8. Ethereum Wallet will ask you to confirm your password to sign the transaction.
9. Click 'SEND TRANSACTION'
10. Congratulations, you have just purchased ÐICE tokens. After transaction confirmation, your ÐICE token balance will show up in the address you sent from, but to see your token balance, you will need to first 'watch' the ÐICE token. To do this go to step 2.

Step 2 - 'Watching' the ÐICE token

Once you have completed the steps above, after a couple of minutes and once the transactions are confirmed, you will be the proud owner of new ÐICE tokens. However, Ethereum Wallet will not know this until you 'watch' the ÐICE token. Let's do that now:

1. In Ethereum Wallet, click the 'CONTRACTS' main menu item.
2. Scroll down towards the bottom and click 'WATCH TOKEN'
3. Enter the following details for the relative fields (it should fill out automatically once you enter the token address):
   • TOKEN CONTRACT ADDRESS:
     0x2e071D2966Aa7D8dECB1005885bA1977D6038A65
   • TOKEN NAME:
     ÐICE
   • TOKEN SYMBOL:
     ROL
   • DECIMAL PLACES:
     16
4. Click 'OK'
5. Wait a couple of minutes and navigate to 'WALLETS' from the main menu in Ethereum Wallet.
6. Click the account that you used to send Ether to the crowdfund.
7. After a couple of minutes, you will see your ÐICE token balance displayed here after transaction confirmation.

How to participate using Parity

Step 1 - Sending Ether to the crowdfund address

1. If you already have Parity, you can skip ahead to step 2. Otherwise, download Parity at https://ethcore.io/parity.html and generate a new wallet address by clicking 'NEW ACCOUNT' and then following the prompts.
2. Once you have funds available in your wallet:
3. Click the account name you wish to send from.
4. Click "TRANSFER".
5. For "type of token transfer" select "Ethereum".
6. For "recipient address" enter the crowdfund address: 0x805129C7144688224c122c924E3855D5b4FA01D8
7. For "amount to transfer (in ETH)" enter the amount you wish to send.
8. Click "send"
9. Congratulations, you have just purchased ÐICE tokens. After transaction confirmation, your ÐICE token balance will show up in the address you sent from, but to see your token balance, you will need to first 'watch' the ÐICE token. To do this, go to step 2.

Step 2 - 'Watching' the ÐICE token

Once you have completed the steps above, after a couple of minutes and once the transactions are confirmed, you will be the proud owner of new ÐICE tokens. You can check your ÐICE token balance by simply clicking the account name you used to send to the crowdfund. There is no need to 'watch' the token in Parity, because the ÐICE token is registered within the Parity token registry.

How to participate using MyEtherWallet

Step 1 - Sending Ether to the crowdfund address

1. If you already have MyEtherWallet, you can skip ahead to step 2. Otherwise, visit https://www.myetherwallet.com and generate a new address by following their instructions.
2. Once you have funds available in your wallet:
3. Navigate to the "Send Ether & Tokens" page.
4. Select your wallet file -or- your private key and unlock your wallet.
5. If the wallet is encrypted, a text box will automatically appear. Enter the password.
6. Click the "Unlock Wallet" button.
7. Enter our crowdfund address 0x805129C7144688224c122c924E3855D5b4FA01D8 in the "To Address:" field.
8. Enter the amount you would like to send.
9. Click "Generate Transaction".
10. A couple more fields will appear. This is your browser generating the transaction.
11. Click the blue "Send Transaction" button below that.
12. A pop-up will appear. Verify that the amount and the address you are sending to are correct. Then click "Yes, I am sure! Make transaction." button.
13. Congratulations, you have just purchased ÐICE tokens. After transaction confirmation, your ÐICE token balance will show up in the address you sent from, but to see your token balance, you will need to first 'watch' the ÐICE token. To do this, go to step 2.

Step 2 - 'Watching' the ÐICE token

Once you have completed the steps above, after a couple of minutes and once the transactions are confirmed, you will be the proud owner of new ÐICE tokens. However, MyEtherWallet will not know this until you 'watch' the ÐICE token. Let's do that now:

1. Click the ‘Send Ether & Tokens’ tab.
2. Select your wallet file -or- your private key and unlock your wallet.
3. Click the “Add Custom Token” button on the left.
4. Enter the following details:
   • Address:
     0x2e071D2966Aa7D8dECB1005885bA1977D6038A65
   • Token Symbol:
     ROL
   • Decimals:
     16
5. Click 'Save'
6. You can now see your ÐICE token balance in the sidebar.

Help & Support

Please make sure you include at least 200,000 gas with your transaction when purchasing ÐICE tokens, any unused gas will be refunded to you. If you experience any issues purchasing your ÐICE tokens, please email us at support@etheroll.com, we aim to reply to all emails within 24 hours.

Opportunity

In 2016 the market size of the online gambling industry was estimated to be $45 billion USD. These are impressive numbers. Let’s take a closer look at the cryptocurrency gambling market in particular. We will first focus our attention on Bitcoin, and then use this as a guide towards the future of gambling on Ethereum, the 2nd most popular cryptocurrency in the world.

Enter Ethereum

Whitepaper

A draft of the Etheroll whitepaper is available for review here (1.02MB)

Crowdfund

We are inviting you to ‘bet on the house’.

Fuel the crowdfund with Ether during our token creation phase, and you become the holder of ÐICE (ROL) tokens which grants you rights to all profits the house generates via our dice game, as well as the right to vote on proposals (new games/features/house edge).

During the crowdfund, when our crowdfund adddress 0x805129C7144688224c122c924E3855D5b4FA01D8 receives Ether, ÐICE (ROL) tokens are sent directly to the sender.

Each ÐICE token grants its owner the following rights and has the following characteristics:

1. Direct earnings - Proportional to the number of tokens they hold. Token holders as a collective receive 100% of the profits generated by the house every 12 weeks. House profits are generated via the 1% house-edge. Tokens holders are exposed to each bet with the advantage of the 1% house-edge always being in their favor.
2. The ÐICE token will be tradeable on popular exchanges.
3. Voting rights – Token enable holders to vote on proposals. For example, lowering or raising the house edge, or, adding a new game to the suite.

Important Details

Start Date: The ÐICE (ROL) token creation phase begins at 10:00 UTC February 13th 2017

Duration: 14 days.

Conversion schedule:

Week 1: 1 Ether (Ξ) for 200 ÐICE (ROL) tokens

Week 2: 1 Ether (Ξ) for 100 ÐICE (ROL) tokens

# of tokens available: 25,000,000

Note: The founding team is pre-allocated a total of 2.5m. Any tokens that may remain unsold after the token creation phase will be destroyed to rule out any possibility of dilution.

The crowdfund address: 0x805129C7144688224c122c924E3855D5b4FA01D8

Funds Allocation

Hard costs are found primarily in paying winners, developers, marketing. Here is a breakdown of the allocation of Ether raised during the crowdfund.

Rewards

Every 12 weeks the Etheroll smart contract will move any and all Ether earnt from the core game smart-contract to the ‘Rewards’ contract. From here token holders are able to draw down the Ether their tokens have earnt. 100% of all profits generated during each 12 week cycle is distributed to our valued token holders.

Expected Value

The house bankroll is created from the Ether token holders have raised during the token creation phase. Each token holder is rewarded in Ether according to their percentage of the total house bankroll. Etheroll uses a 1% house edge and backers receive 100% of the house wins and/or losses. This means a 1% Expected Value (EV) that is shared by token holders.

House protection

Etheroll limits the maximum profit a player can make on a bet relative to the size of the bankroll. This means that if the house loses money to lucky players, the maximum allowed profit made on new bets will shrink. The automatic adjustments of the maximum allowed bet profit makes it difficult for players to win the entire bankroll, however, please be aware that there will be extreme variances and down days, but over the long run, the consistent 1% house edge should always work in the token holders favor.

Potential Risks for Token Holders

• The house can't choose when to play; it just waits for players to place bets. If players stop betting, a house profit may never occur. Players can choose to stop at any time and if they stop when they have a profit, the house will remain with a loss.
• You may struggle to recover your investment.
• The house edge is only applied when paying winners (1%). There could be a huge variance in the up and down days for the bankroll. Over time, the expected value means Etheroll bankroll should continue to see a 1% increase in the total amount of Ether in the bankroll. If you have ever done any serious gambling, you will know what this means for the house in the long run.
• Please be sure to download and read potential risk factors in more detail here (PDF 1.01 MB).

Play now

Play our game today (beta - currently testnet Ether only), or view the video demo below.

Video demo

Crowdfund contract

The source code for our crowdfund and token contracts are displayed below. Please note; all of our smart-contracts have been subject to 3rd party independent security audits.

Verification: https://etherscan.io/address/0x805129C7144688224c122c924E3855D5b4FA01D8#code

    pragma solidity ^0.4.2;

    /*
    *  @notice the token contract used as reward 
    */
    contract token {

        /*
        *  @notice exposes the transfer method of the token contract
        *  @param _receiver address receiving tokens
        *  @param _amount number of tokens being transferred       
        */    
        function transfer(address _receiver, uint _amount) returns (bool success) { }

        /*
        *  @notice exposes the priviledgedAddressBurnUnsoldCoins method of the token contract
        *  burns all unsold coins  
        */     
        function priviledgedAddressBurnUnsoldCoins(){ }

    }

    /*
    `* is owned
    */
    contract owned {

        address public owner;

        function owned() {
            owner = msg.sender;
        }

        modifier onlyOwner {
            if (msg.sender != owner) throw;
            _;
        }

        function ownerTransferOwnership(address newOwner)
            onlyOwner
        {
            owner = newOwner;
        }

    }

    /*
    * safe math
    */
    contract DSSafeAddSub {

        function safeToAdd(uint a, uint b) internal returns (bool) {
            return (a + b >= a);
        }

        function safeAdd(uint a, uint b) internal returns (uint) {
            if (!safeToAdd(a, b)) throw;
            return a + b;
        }

        function safeToSubtract(uint a, uint b) internal returns (bool) {
            return (b <= a);
        }

        function safeSub(uint a, uint b) internal returns (uint) {
            if (!safeToSubtract(a, b)) throw;
            return a - b;
        } 

    }

    /* 
    *  EtherollCrowdfund contract
    *  Funds sent to this address transfer a customized ERC20 token to msg.sender for the duration of the crowdfund
    *  Deployment order:
    *  EtherollToken, EtherollCrowdfund
    *  1) Send tokens to this
    *  2) Assign this as priviledgedAddress in EtherollToken
    *  3) Call updateTokenStatus in EtherollToken 
    *  -- crowdfund is open --
    *  4) safeWithdraw onlyAfterDeadline in this
    *  5) ownerBurnUnsoldTokens onlyAfterDeadline in this
    *  6) updateTokenStatus in EtherollToken freezes/thaws tokens
    */
    contract EtherollCrowdfund is owned, DSSafeAddSub {

        /*
        *  checks only after crowdfund deadline
        */    
        modifier onlyAfterDeadline() { 
            if (now < deadline) throw;
            _; 
        }

        /*
        *  checks only in emergency
        */    
        modifier isEmergency() { 
            if (!emergency) throw;
            _; 
        } 

        /* the crowdfund goal */
        uint public fundingGoal;
        /* 1 week countdown to price increase */
        uint public weekTwoPriceRiseBegin = now + 10080 * 1 minutes;    
        /* 80% to standard multi-sig wallet contract is house bankroll  */
        address public bankRollBeneficiary;      
        /* 20% to etheroll wallet*/
        address public etherollBeneficiary;         
        /* total amount of ether raised */
        uint public amountRaised;
        /* two weeks */
        uint public deadline;
        /* 0.01 ETH per token base price */
        uint public price = 10000000000000000;
        /* address of token used as reward */
        token public tokenReward;
        /* crowdsale is open */
        bool public crowdsaleClosed = false;  
        /* 80% of funds raised */
        uint public bankrollBeneficiaryAmount;
        /* 20% of funds raised */    
        uint public etherollBeneficiaryAmount;
        /* map balance of address */
        mapping (address => uint) public balanceOf; 
        /* funding goal has not been reached */ 
        bool public fundingGoalReached = false;   
        /* escape hatch for all in emergency */
        bool public emergency = false; 

        /* log events */
        event LogFundTransfer(address indexed Backer, uint indexed Amount, bool indexed IsContribution);  
        event LogGoalReached(address indexed Beneficiary, uint indexed AmountRaised);       

        /*
        *  @param _ifSuccessfulSendToBeneficiary receives 80% of ether raised end of crowdfund
        *  @param _ifSuccessfulSendToEtheroll receives 20% of ether raised end of crowdfund
        *  @param _fundingGoalInEthers the funding goal of the crowdfund
        *  @param _durationInMinutes the length of the crowdfund in minutes
        *  @param _addressOfTokenUsedAsReward the token address   
        */  
        function EtherollCrowdfund(
            /* multi-sig address to send 80% */        
            address _ifSuccessfulSendToBeneficiary,
            /* address to send 20% */
            address _ifSuccessfulSendToEtheroll,
            /* funding goal */
            uint _fundingGoalInEthers,
            /* two weeks: 20160 minutes*/
            uint _durationInMinutes,
            /* token */
            token _addressOfTokenUsedAsReward
        ) {
            bankRollBeneficiary = _ifSuccessfulSendToBeneficiary;
            etherollBeneficiary = _ifSuccessfulSendToEtheroll;
            fundingGoal = _fundingGoalInEthers * 1 ether;
            deadline = now + _durationInMinutes * 1 minutes;
            tokenReward = token(_addressOfTokenUsedAsReward);
        }
    
        /*
        *  @notice public function
        *  default function is payable
        *  responsible for transfer of tokens based on price, msg.sender and msg.value
        *  tracks investment total of msg.sender 
        *  refunds any spare change
        */      
        function ()
            payable
        {

            /* crowdfund period is over */
            if(now > deadline) crowdsaleClosed = true;  

            /* crowdsale is closed */
            if (crowdsaleClosed) throw;

            /* do not allow creating 0 */        
            if (msg.value == 0) throw;      

            /* 
            *  transfer tokens
            *  check/set week two price rise
            */
            if(now < weekTwoPriceRiseBegin) {
                        
                /* week 1 power token conversion * 2: 1 ETH = 200 tokens */
                if(tokenReward.transfer(msg.sender, ((msg.value*price)/price)*2)) {
                    LogFundTransfer(msg.sender, msg.value, true); 
                } else {
                    throw;
                }

            }else{
                /* week 2 conversion: 1 ETH = 100 tokens */
                if(tokenReward.transfer(msg.sender, (msg.value*price)/price)) {
                    LogFundTransfer(msg.sender, msg.value, true); 
                } else {
                    throw;
                }            

            } 

            /* add to amountRaised */
            amountRaised = safeAdd(amountRaised, msg.value);          

            /* track ETH balanceOf address in case emergency refund is required */  
            balanceOf[msg.sender] = safeAdd(balanceOf[msg.sender], msg.value);

        }    

        /*
        *  @notice public function
        *  onlyAfterDeadline
        *  moves ether to beneficiary contracts if goal reached
        *  if goal not reached msg.sender can withdraw their deposit
        */     
        function safeWithdraw() public
            onlyAfterDeadline
        {

            if (amountRaised >= fundingGoal){
                /* allows funds to be moved to beneficiary */
                fundingGoalReached = true;
                /* log event */            
                LogGoalReached(bankRollBeneficiary, amountRaised);           
            }    
                
            /* close crowdsale */
            crowdsaleClosed = true;  
                            
            /* 
            *  public 
            *  funding goal not reached 
            *  manual refunds
            */
            if (!fundingGoalReached) {
                calcRefund(msg.sender);
            }
            
            /* 
            *  onlyOwner can call
            *  funding goal reached 
            *  move funds to beneficiary addresses
            */        
            if (msg.sender == owner && fundingGoalReached) {

                /* multi-sig bankrollBeneficiary receives 80% */
                bankrollBeneficiaryAmount = (this.balance*80)/100;   

                /* send to trusted address bankRollBeneficiary 80% */      
                if (bankRollBeneficiary.send(bankrollBeneficiaryAmount)) {  

                    /* log event */              
                    LogFundTransfer(bankRollBeneficiary, bankrollBeneficiaryAmount, false);
                
                    /* etherollBeneficiary receives remainder */
                    etherollBeneficiaryAmount = this.balance;                  

                    /* send to trusted address etherollBeneficiary the remainder */
                    if(!etherollBeneficiary.send(etherollBeneficiaryAmount)) throw;

                    /* log event */        
                    LogFundTransfer(etherollBeneficiary, etherollBeneficiaryAmount, false);                 

                } else {

                    /* allow manual refunds via safeWithdrawal */
                    fundingGoalReached = false;

                }
            }
        }  

        /*
        *  @notice internal function
        *  @param _addressToRefund the address being refunded
        *  accessed via public functions emergencyWithdraw and safeWithdraw
        *  calculates refund amount available for an address  
        */     
        function calcRefund(address _addressToRefund) internal
        {
            /* assigns var amount to balance of _addressToRefund */
            uint amount = balanceOf[_addressToRefund];
            /* sets balance to 0 */
            balanceOf[_addressToRefund] = 0;
            /* is there any balance? */
            if (amount > 0) {
                /* call to untrusted address */
                if (_addressToRefund.call.value(amount)()) {
                    /* log event */
                    LogFundTransfer(_addressToRefund, amount, false);
                } else {
                    /* unsuccessful send so reset the balance */
                    balanceOf[_addressToRefund] = amount;
                }
            } 
        }     
    

        /*
        *  @notice public function
        *  emergency manual refunds
        */     
        function emergencyWithdraw() public
            isEmergency    
        {
            /* manual refunds */
            calcRefund(msg.sender);
        }        

        /*
        *  @notice owner restricted function   
        *  @param _newEmergencyStatus boolean
        *  sets contract mode to emergency status to allow individual withdraw via emergencyWithdraw()
        */    
        function ownerSetEmergencyStatus(bool _newEmergencyStatus) public
            onlyOwner 
        {        
            /* close crowdsale */
            crowdsaleClosed = _newEmergencyStatus;
            /* allow manual refunds via emergencyWithdraw */
            emergency = _newEmergencyStatus;        
        } 

        /*
        *  @notice  owner restricted function 
        *  burns any unsold tokens at end of crowdfund
        */      
        function ownerBurnUnsoldTokens()
            onlyOwner
            onlyAfterDeadline
        {
            tokenReward.priviledgedAddressBurnUnsoldCoins();
        }         


    }
                        

Token contract

Verification: https://etherscan.io/address/0x2e071D2966Aa7D8dECB1005885bA1977D6038A65#code

    pragma solidity ^0.4.2;

    /* 
    `* is owned
    */
    contract owned {

        address public owner;

        function owned() {
            owner = msg.sender;
        }

        modifier onlyOwner {
            if (msg.sender != owner) throw;
            _;
        }

        function ownerTransferOwnership(address newOwner)
            onlyOwner
        {
            owner = newOwner;
        }

    }

    /* 
    * safe math
    */
    contract DSSafeAddSub {

        function safeToAdd(uint a, uint b) internal returns (bool) {
            return (a + b >= a);
        }
        
        function safeAdd(uint a, uint b) internal returns (uint) {
            if (!safeToAdd(a, b)) throw;
            return a + b;
        }

        function safeToSubtract(uint a, uint b) internal returns (bool) {
            return (b <= a);
        }

        function safeSub(uint a, uint b) internal returns (uint) {
            if (!safeToSubtract(a, b)) throw;
            return a - b;
        } 

    }


    /**
    *
    * @title  EtherollToken
    * 
    * The official token powering etheroll.
    * EtherollToken is a ERC.20 standard token with some custom functionality
    *
    */ 


    contract EtherollToken is owned, DSSafeAddSub {

        /* check address */
        modifier onlyBy(address _account) {
            if (msg.sender != _account) throw;
            _;
        }    

        /* vars */
        string public standard = 'Token 1.0';
        string public name = "ÐICE";
        string public symbol = "ROL";
        uint8 public decimals = 16;
        uint public totalSupply = 250000000000000000000000; 

        address public priviledgedAddress;  
        bool public tokensFrozen;
        uint public crowdfundDeadline = now + 2 * 1 weeks;       
        uint public nextFreeze = now + 12 * 1 weeks;
        uint public nextThaw = now + 13 * 1 weeks;
    

        /* map balances */
        mapping (address => uint) public balanceOf;
        mapping (address => mapping (address => uint)) public allowance;  

        /* events */
        event Transfer(address indexed _from, address indexed _to, uint256 _value);
        event Approval(address indexed _owner, address indexed _spender, uint256 _value);
        event LogTokensFrozen(bool indexed Frozen);    

        /*
        *  @notice sends all tokens to msg.sender on init    
        */  
        function EtherollToken(){
            /* send creator all initial tokens 25,000,000 */
            balanceOf[msg.sender] = 250000000000000000000000;
            /* tokens are not frozen */  
            tokensFrozen = false;                                      

        }  

        /*
        *  @notice public function    
        *  @param _to address to send tokens to   
        *  @param _value number of tokens to transfer 
        *  @returns boolean success         
        */     
        function transfer(address _to, uint _value) public
            returns (bool success)    
        {
            if(tokensFrozen && msg.sender != priviledgedAddress) return false;  /* transfer only by priviledgedAddress during crowdfund or reward phases */
            if (balanceOf[msg.sender] < _value) return false;                   /* check if the sender has enough */
            if (balanceOf[_to] + _value < balanceOf[_to]) return false;         /* check for overflows */              
            balanceOf[msg.sender] -=  _value;                                   /* subtract from the sender */
            balanceOf[_to] += _value;                                           /* add the same to the recipient */
            Transfer(msg.sender, _to, _value);                                  /* notify anyone listening that this transfer took place */
            return true;
        }      

        /*
        *  @notice public function    
        *  @param _from address to send tokens from 
        *  @param _to address to send tokens to   
        *  @param _value number of tokens to transfer     
        *  @returns boolean success      
        *  another contract attempts to spend tokens on your behalf
        */       
        function transferFrom(address _from, address _to, uint _value) public
            returns (bool success) 
        {                
            if(tokensFrozen && msg.sender != priviledgedAddress) return false;  /* transfer only by priviledgedAddress during crowdfund or reward phases */
            if (balanceOf[_from] < _value) return false;                        /* check if the sender has enough */
            if (balanceOf[_to] + _value < balanceOf[_to]) return false;         /* check for overflows */                
            if (_value > allowance[_from][msg.sender]) return false;            /* check allowance */
            balanceOf[_from] -= _value;                                         /* subtract from the sender */
            balanceOf[_to] += _value;                                           /* add the same to the recipient */
            allowance[_from][msg.sender] -= _value;                             /* reduce allowance */
            Transfer(_from, _to, _value);                                       /* notify anyone listening that this transfer took place */
            return true;
        }        
    
        /*
        *  @notice public function    
        *  @param _spender address being granted approval to spend on behalf of msg.sender
        *  @param _value number of tokens granted approval for _spender to spend on behalf of msg.sender    
        *  @returns boolean success      
        *  approves another contract to spend some tokens on your behalf
        */      
        function approve(address _spender, uint _value) public
            returns (bool success)
        {
            /* set allowance for _spender on behalf of msg.sender */
            allowance[msg.sender][_spender] = _value;

            /* log event about transaction */
            Approval(msg.sender, _spender, _value);        
            return true;
        } 
    
        /*
        *  @notice address restricted function 
        *  crowdfund contract calls this to burn its unsold coins 
        */     
        function priviledgedAddressBurnUnsoldCoins() public
            /* only crowdfund contract can call this */
            onlyBy(priviledgedAddress)
        {
            /* totalSupply should equal total tokens in circulation */
            totalSupply = safeSub(totalSupply, balanceOf[priviledgedAddress]); 
            /* burns unsold tokens from crowdfund address */
            balanceOf[priviledgedAddress] = 0;
        }

        /*
        *  @notice public function 
        *  locks/unlocks tokens on a recurring cycle
        */         
        function updateTokenStatus() public
        {
            
            /* locks tokens during initial crowdfund period */
            if(now < crowdfundDeadline){                       
                tokensFrozen = true;         
                LogTokensFrozen(tokensFrozen);  
            }  

            /* locks tokens */
            if(now >= nextFreeze){          
                tokensFrozen = true;
                LogTokensFrozen(tokensFrozen);  
            }

            /* unlocks tokens */
            if(now >= nextThaw){         
                tokensFrozen = false;
                nextFreeze = now + 12 * 1 weeks;
                nextThaw = now + 13 * 1 weeks;              
                LogTokensFrozen(tokensFrozen);  
            }        
        
        }                              

        /*
        *  @notice owner restricted function
        *  @param _newPriviledgedAddress the address
        *  only this address can burn unsold tokens
        *  transfer tokens only by priviledgedAddress during crowdfund or reward phases
        */      
        function ownerSetPriviledgedAddress(address _newPriviledgedAddress) public 
            onlyOwner
        {
            priviledgedAddress = _newPriviledgedAddress;
        }   
                        
        
    }