AION

0x4ceda7906a5ed2179785cd3a40a69ee8bc99c466

changeOwner keyboard_arrow_up

    function changeOwner(address _newOwner) onlyOwner {
        newOwner = _newOwner;
    }

acceptOwnership keyboard_arrow_up

    function acceptOwnership() {
        if (msg.sender == newOwner) {
            owner = newOwner;
        }
    }

pause keyboard_arrow_up

    function pause() onlyOwner {
        paused = true;
    }

unpause keyboard_arrow_up

    function unpause() onlyOwner {
        paused = false;
    }

claimTokens keyboard_arrow_up

    function claimTokens(address _token, address _to) onlyOwner returns (bool) {
        IToken token = IToken(_token);
        return token.transfer(_to, token.balanceOf(this));
    }

finalize keyboard_arrow_up

    function finalize() onlyOwner {
        finalized = true;
    }

setMotd keyboard_arrow_up

    function setMotd(string _m) onlyOwner {
        motd = _m;
        Motd(_m);
    }

setController keyboard_arrow_up

    function setController(address _c) onlyOwner notFinalized {
        controller = Controller(_c);
    }

balanceOf keyboard_arrow_up

    function balanceOf(address a) constant returns (uint) {
        return controller.balanceOf(a);
    }

totalSupply keyboard_arrow_up

    function totalSupply() constant returns (uint) {
        return controller.totalSupply();
    }

allowance keyboard_arrow_up

    function allowance(address _owner, address _spender) constant returns (uint) {
        return controller.allowance(_owner, _spender);
    }

transfer keyboard_arrow_up

    function transfer(address _to, uint _value) notPaused returns (bool success) {
        if (controller.transfer(msg.sender, _to, _value)) {
            Transfer(msg.sender, _to, _value);
            return true;
        }
        return false;
    }

transferFrom keyboard_arrow_up

    function transferFrom(address _from, address _to, uint _value) notPaused returns (bool success) {
        if (controller.transferFrom(msg.sender, _from, _to, _value)) {
            Transfer(_from, _to, _value);
            return true;
        }
        return false;
    }

approve keyboard_arrow_up

    function approve(address _spender, uint _value) notPaused returns (bool success) {
        // promote safe user behavior
        if (controller.approve(msg.sender, _spender, _value)) {
            Approval(msg.sender, _spender, _value);
            return true;
        }
        return false;
    }

increaseApproval keyboard_arrow_up

    function increaseApproval (address _spender, uint _addedValue) notPaused returns (bool success) {
        if (controller.increaseApproval(msg.sender, _spender, _addedValue)) {
            uint newval = controller.allowance(msg.sender, _spender);
            Approval(msg.sender, _spender, newval);
            return true;
        }
        return false;
    }

decreaseApproval keyboard_arrow_up

    function decreaseApproval (address _spender, uint _subtractedValue) notPaused returns (bool success) {
        if (controller.decreaseApproval(msg.sender, _spender, _subtractedValue)) {
            uint newval = controller.allowance(msg.sender, _spender);
            Approval(msg.sender, _spender, newval);
            return true;
        }
        return false;
    }

controllerTransfer keyboard_arrow_up

    function controllerTransfer(address _from, address _to, uint _value) onlyController {
        Transfer(_from, _to, _value);
    }

controllerApprove keyboard_arrow_up

    function controllerApprove(address _owner, address _spender, uint _value) onlyController {
        Approval(_owner, _spender, _value);
    }

controllerBurn keyboard_arrow_up

    function controllerBurn(address _from, bytes32 _to, uint256 _value) onlyController {
        Burn(_from, _to, _value);
    }

controllerClaim keyboard_arrow_up

    function controllerClaim(address _claimer, uint256 _value) onlyController {
        Claimed(_claimer, _value);
    }

setBurnAddress keyboard_arrow_up

    function setBurnAddress(address _address) onlyController {
        burnAddress = _address;
    }

enableBurning keyboard_arrow_up

    function enableBurning() onlyController {
        burnable = true;
    }

disableBurning keyboard_arrow_up

    function disableBurning() onlyController {
        burnable = false;
    }

burn keyboard_arrow_up

    function burn(bytes32 _to, uint _amount) notPaused burnEnabled returns (bool success) {
        return controller.burn(msg.sender, _to, _amount);
    }

claimByProof keyboard_arrow_up

    function claimByProof(bytes32[] data, bytes32[] proofs, uint256 number) notPaused burnEnabled returns (bool success) {
        return controller.claimByProof(msg.sender, data, proofs, number);
    }

claim keyboard_arrow_up

    function claim() notPaused burnEnabled returns (bool success) {
        return controller.claim(msg.sender);
    }