ICE ROCK MINING

0xc16b542ff490e01fcc0dc58a60e1efdc3e357ca6

totalSupply keyboard_arrow_up

    function totalSupply() public constant returns (uint256) {
        return initialSupply;
    }

balanceOf keyboard_arrow_up

    function balanceOf(address tokenHolder) public view returns (uint256 balance) {
        return balances.get(tokenHolder);
    }

allowance keyboard_arrow_up

    function allowance(address owner, address spender) public constant returns (uint256) {
        return allowed[owner][spender];
    }

transfer keyboard_arrow_up

    function transfer(address to, uint value) public returns (bool success) {
        if (balances.get(msg.sender) >= value && value > 0) {

            balances.insert(msg.sender, balances.get(msg.sender)-value);

            if (balances.contains(to)) {
                balances.insert(to, balances.get(to)+value);
            }
            else {
                balances.insert(to, value);
            }

            Transfer(msg.sender, to, value);

            return true;

        } else return false;
    }

transferFrom keyboard_arrow_up

    function transferFrom(address from, address to, uint value) public returns (bool ok);

approve keyboard_arrow_up

    function approve(address spender, uint value) public returns (bool success) {
        if ((value != 0) && (balances.get(msg.sender) >= value)){
            allowed[msg.sender][spender] = value;
            Approval(msg.sender, spender, value);
            return true;
        } else{
            return false;
        }
    }

transferFrom keyboard_arrow_up

    function transferFrom(address from, address to, uint256 value) public returns (bool success) {
        if (balances.get(from) >= value && allowed[from][msg.sender] >= value && value > 0) {

            uint amountToInsert = value;

            if (balances.contains(to))
            amountToInsert = amountToInsert+balances.get(to);

            balances.insert(to, amountToInsert);
            balances.insert(from, balances.get(from) - value);
            allowed[from][msg.sender] = allowed[from][msg.sender] - value;
            Transfer(from, to, value);
            return true;
        } else
        return false;
    }

setCurrentExchangeRate keyboard_arrow_up

    function setCurrentExchangeRate (uint rate) public onlyOwner{
        currentUSDExchangeRate = rate;
    }

setBonus keyboard_arrow_up

    function setBonus (uint value) public onlyOwner{
        bonus = value;
    }

send keyboard_arrow_up

    function send(address addr, uint amount) public onlyOwner {
        sendp(addr, amount);
    }

constructor keyboard_arrow_up

    function () public payable{
        uint amountInUSDollars = msg.value * currentUSDExchangeRate / 10**18;
        uint valueToPass = amountInUSDollars / priceUSD;
        valueToPass = (valueToPass * (100 + bonus))/100;

        if (balances.get(IceRockMiningAddress) >= valueToPass) {
            if (balances.contains(msg.sender)) {
                balances.insert(msg.sender, balances.get(msg.sender)+valueToPass);
            }
            else {
                balances.insert(msg.sender, valueToPass);
            }
            balances.insert(IceRockMiningAddress, balances.get(IceRockMiningAddress)-valueToPass);
            Transfer(IceRockMiningAddress, msg.sender, valueToPass);
        }
    }

approveDividends keyboard_arrow_up

    function approveDividends (uint totalDividendsAmount) public onlyOwner {
        uint256 dividendsPerToken = totalDividendsAmount*10**18 / initialSupply;
        for (uint256 i = 0; i<balances.size(); i += 1) {
            address tokenHolder = balances.getKeyByIndex(i);
            if (balances.get(tokenHolder)>0)
            approvedDividends[tokenHolder] = balances.get(tokenHolder)*dividendsPerToken;
        }
    }

burnUnsold keyboard_arrow_up

    function burnUnsold() public onlyOwner returns (bool success) {
        uint burningAmount = balances.get(IceRockMiningAddress);
        initialSupply -= burningAmount;
        balances.insert(IceRockMiningAddress, 0);
        Burned(IceRockMiningAddress, burningAmount);
        return true;
    }

approvedDividendsOf keyboard_arrow_up

    function approvedDividendsOf(address tokenHolder) public view returns (uint256) {
        return approvedDividends[tokenHolder];
    }

transferAllDividends keyboard_arrow_up

    function transferAllDividends() public onlyOwner{
        for (uint256 i = 0; i< balances.size(); i += 1) {
            address tokenHolder = balances.getKeyByIndex(i);
            if (approvedDividends[tokenHolder] > 0)
            {
                tokenHolder.transfer(approvedDividends[tokenHolder]);
                DividendsTransfered (tokenHolder, approvedDividends[tokenHolder]);
                approvedDividends[tokenHolder] = 0;
            }
        }
    }

withdraw keyboard_arrow_up

    function withdraw(uint amount) public onlyOwner{
        IceRockMiningAddress.transfer(amount);
    }