Po.et

0x0e0989b1f9b8a38983c2ba8053269ca62ec9b195

setOwner keyboard_arrow_up

    function setOwner(address _new)
        public
        onlyOwner
    {
        NewPotentialOwner(owner, _new);
        potentialOwner = _new;
    }

confirmOwnership keyboard_arrow_up

    function confirmOwnership()
        public
        onlyPotentialOwner
    {   
        // Allow new owner to distribute tokens allocated on the icoAllocation address
        allowed[icoAllocation][potentialOwner] = balanceOf(icoAllocation);

        // Forbid old owner to distribute tokens
        allowed[icoAllocation][owner] = 0;

        // Forbid old owner to withdraw tokens from foundation reserve
        allowed[foundationReserve][owner] = 0;

        // Change owner
        super.confirmOwnership();
    }

totalSupply keyboard_arrow_up

    function totalSupply() constant returns (uint256) {}

balanceOf keyboard_arrow_up

    function balanceOf(address _owner) constant returns (uint256 balance) {
        return balances[_owner];
    }

transfer keyboard_arrow_up

    function transfer(address _to, uint256 _value) returns (bool success) {
        if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
            balances[msg.sender] -= _value;
            balances[_to] += _value;
            Transfer(msg.sender, _to, _value);
            return true;
        }
        else {
            return false;
        }
    }

transferFrom keyboard_arrow_up

    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
      if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
            balances[_to] += _value;
            balances[_from] -= _value;
            allowed[_from][msg.sender] -= _value;
            Transfer(_from, _to, _value);
            return true;
        }
        else {
            return false;
        }
    }

approve keyboard_arrow_up

    function approve(address _spender, uint256 _value) returns (bool success) {
        allowed[msg.sender][_spender] = _value;
        Approval(msg.sender, _spender, _value);
        return true;
    }

allowance keyboard_arrow_up

    function allowance(address _owner, address _spender)
        public
        constant
        returns (uint256 remaining)
    {
        if (_owner == foundationReserve && _spender == owner) {
            return availableReserve();
        }

        return allowed[_owner][_spender];
    }

transferERC20Token keyboard_arrow_up

    function transferERC20Token(address tokenAddress)
        public
        onlyOwner
        returns (bool)
    {
        uint balance = AbstractToken(tokenAddress).balanceOf(this);
        return AbstractToken(tokenAddress).transfer(owner, balance);
    }

distribute keyboard_arrow_up

    function distribute(address investor, uint amount)
        public
        onlyOwner
    {
        transferFrom(icoAllocation, investor, amount);
    }

availableReserve keyboard_arrow_up

    function availableReserve() 
        public
        constant
        returns (uint)
    {   
        // No tokens should be available for withdrawal before September 1, 2017
        if (now < Sept1_2017) {
            return 0;
        }

        // Number of days passed  since September 1, 2017
        uint daysPassed = div(sub(now, Sept1_2017), 1 days);

        // All tokens should be unlocked if reserveDelta days passed
        if (daysPassed >= reserveDelta) {
            return balanceOf(foundationReserve);
        }

        // Percentage of unlocked tokens by the current date
        uint unlockedPercentage = 0;

        uint16 _days = 0;  uint8 month = 9;
        while (_days <= daysPassed) {
            unlockedPercentage += 2;
            _days += daysInMonth[month];
            month = month % 12 + 1;
        }

        // Number of unlocked tokens by the current date
        uint unlockedTokens = div(mul(totalSupply, unlockedPercentage), 100);

        // Number of tokens that should remain locked
        uint lockedTokens = foundationTokens - unlockedTokens;

        return balanceOf(foundationReserve) - lockedTokens;
    }

withdrawFromReserve keyboard_arrow_up

    function withdrawFromReserve(uint amount)
        public
        onlyOwner
    {   
        // Allow owner to withdraw no more than this amount of tokens
        allowed[foundationReserve][owner] = availableReserve();

        // Withdraw tokens from foundation reserve to owner address
        require(transferFrom(foundationReserve, owner, amount));
    }