Everex

0xf3db5fa2c66b7af3eb0c0b782510816cbe4813b8

transferOwnership keyboard_arrow_up

  function transferOwnership(address otherOwner) onlyOwner {
    require(otherOwner != address(0));      
    newOwner = otherOwner;
  }

approveOwnership keyboard_arrow_up

  function approveOwnership() {
    require(msg.sender == newOwner);
    OwnershipTransferred(owner, newOwner);
    owner = newOwner;
    newOwner = address(0);
  }

transferModeratorship keyboard_arrow_up

  function transferModeratorship(address otherModerator) onlyModerator {
    newModerator = otherModerator;
  }

approveModeratorship keyboard_arrow_up

  function approveModeratorship() {
    require(msg.sender == newModerator);
    moderator = newModerator;
    newModerator = address(0);
  }

removeModeratorship keyboard_arrow_up

  function removeModeratorship() onlyOwner {
      moderator = address(0);
  }

hasModerator keyboard_arrow_up

  function hasModerator() constant returns(bool) {
      return (moderator != address(0));
  }

pause keyboard_arrow_up

  function pause() onlyOwnerOrModerator whenNotPaused {
    paused = true;
    Pause();
  }

unpause keyboard_arrow_up

  function unpause() onlyOwnerOrModerator whenPaused {
    paused = false;
    Unpause();
  }

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) whenNotPaused returns (bool) {
    require(!isFrozen(msg.sender));
    require(!isFrozen(_to));
    return super.transfer(_to, _value);
  }

allowance keyboard_arrow_up

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

transferFrom keyboard_arrow_up

  function transferFrom(address _from, address _to, uint256 _value) whenNotPaused returns (bool) {
    require(!isFrozen(msg.sender));
    require(!isFrozen(_from));
    require(!isFrozen(_to));
    return super.transferFrom(_from, _to, _value);
  }

approve keyboard_arrow_up

  function approve(address _spender, uint256 _value) returns (bool) {

    // 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((_value == 0) || (allowed[msg.sender][_spender] == 0));

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

increaseApproval keyboard_arrow_up

  function increaseApproval (address _spender, uint _addedValue) 
    returns (bool success) {
    allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
    Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
    return true;
  }

decreaseApproval keyboard_arrow_up

  function decreaseApproval (address _spender, uint _subtractedValue) 
    returns (bool success) {
    uint oldValue = allowed[msg.sender][_spender];
    if (_subtractedValue > oldValue) {
      allowed[msg.sender][_spender] = 0;
    } else {
      allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
    }
    Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
    return true;
  }

isFrozen keyboard_arrow_up

  function isFrozen(address _addr) constant returns (bool){
      return frozen[_addr] && hasModerator();
  }

freeze keyboard_arrow_up

  function freeze(address _addr) onlyModerator {
      frozen[_addr] = true;
  }

unfreeze keyboard_arrow_up

  function unfreeze(address _addr) onlyModerator {
      frozen[_addr] = false;
  }

moderatorTransferFrom keyboard_arrow_up

  function moderatorTransferFrom(address _from, address _to, uint256 _value) onlyModerator returns (bool) {
    balances[_to] = balances[_to].add(_value);
    balances[_from] = balances[_from].sub(_value);
    Transfer(_from, _to, _value);
    return true;
  }