Hydro

0xebbdf302c940c6bfd49c6b165f457fdb324649bc

transferOwnership keyboard_arrow_up

    function transferOwnership(address newOwner) public onlyOwner {
        require(newOwner != address(0));
        emit OwnershipTransferred(owner, newOwner);
        owner = newOwner;
    }

transfer keyboard_arrow_up

    function transfer(address _to, uint256 _amount) public returns (bool success) {
        doTransfer(msg.sender, _to, _amount);
        return true;
    }

transferFrom keyboard_arrow_up

    function transferFrom(address _from, address _to, uint256 _amount
    ) public returns (bool success) {
        // The standard ERC 20 transferFrom functionality
        require(allowed[_from][msg.sender] >= _amount);
        allowed[_from][msg.sender] -= _amount;
        doTransfer(_from, _to, _amount);
        return true;
    }

balanceOf keyboard_arrow_up

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

approve keyboard_arrow_up

    function approve(address _spender, uint256 _amount) public returns (bool success) {
        // To change the approve amount you first have to reduce the addresses`
        //  allowance to zero by calling `approve(_spender,0)` if it is not
        //  already 0 to mitigate the race condition described here:
        //  https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
        require((_amount == 0) || (allowed[msg.sender][_spender] == 0));

        allowed[msg.sender][_spender] = _amount;
        emit Approval(msg.sender, _spender, _amount);
        return true;
    }

approveAndCall keyboard_arrow_up

    function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
        tokenRecipient spender = tokenRecipient(_spender);
        if (approve(_spender, _value)) {
            spender.receiveApproval(msg.sender, _value, this, _extraData);
            return true;
        }
    }

burn keyboard_arrow_up

    function burn(uint256 _value) public onlyOwner {
        require(balances[msg.sender] >= _value);
        balances[msg.sender] = balances[msg.sender].sub(_value);
        totalSupply = totalSupply.sub(_value);
    }

allowance keyboard_arrow_up

    function allowance(address _owner, address _spender
    ) public constant returns (uint256 remaining) {
        return allowed[_owner][_spender];
    }

totalSupply keyboard_arrow_up

    function totalSupply() public constant returns (uint) {
        return totalSupply;
    }

setRaindropAddress keyboard_arrow_up

    function setRaindropAddress(address _raindrop) public onlyOwner {
        raindropAddress = _raindrop;
    }

authenticate keyboard_arrow_up

    function authenticate(uint _value, uint _challenge, uint _partnerId) public {
        Raindrop raindrop = Raindrop(raindropAddress);
        raindrop.authenticate(msg.sender, _value, _challenge, _partnerId);
        doTransfer(msg.sender, owner, _value);
    }

setBalances keyboard_arrow_up

    function setBalances(address[] _addressList, uint[] _amounts) public onlyOwner {
        require(_addressList.length == _amounts.length);
        for (uint i = 0; i < _addressList.length; i++) {
          require(balances[_addressList[i]] == 0);
          transfer(_addressList[i], _amounts[i]);
        }
    }