Mallcoin Token

0xc72ed4445b3fe9f0863106e344e241530d338906

isAuthorized keyboard_arrow_up

    function isAuthorized(address _addr) public constant returns(bool) {
      require(_addr != address(0));

      bool result = bool(authorizers[_addr]);
      return result;
    }

addAuthorized keyboard_arrow_up

    function addAuthorized(address _addr) external onlyAuthorized {
      require(_addr != address(0));

      authorizers[_addr] = true;
    }

delAuthorized keyboard_arrow_up

    function delAuthorized(address _addr) external onlyAuthorized {
      require(_addr != address(0));
      require(_addr != msg.sender);

      //authorizers[_addr] = false;
      delete authorizers[_addr];
    }

transferOwnership keyboard_arrow_up

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

      OwnershipTransferred(owner, newOwner);
      owner = newOwner;
    }

totalSupply keyboard_arrow_up

    function totalSupply() public view returns (uint256) {
      return totalSupply_;
    }

balanceOf keyboard_arrow_up

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

transfer keyboard_arrow_up

    function transfer(address _to, uint256 _value) isNotFrozen() public returns (bool) {
      require(_to != address(0));
      require(_value <= balances[msg.sender]);

      uint256 balance = balances[msg.sender];
      uint256 frozen = frozenTokens[msg.sender];
      uint256 availableBalance = balance.sub(frozen);
      require(availableBalance >= _value);

      return super.transfer(_to, _value);
    }

allowance keyboard_arrow_up

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

transferFrom keyboard_arrow_up

    function transferFrom(address _from, address _to, uint256 _value) isNotFrozen() public returns (bool) {
      require(_to != address(0));
      require(_value <= balances[_from]);
      require(_value <= allowed[_from][msg.sender]);

      uint256 balance = balances[_from];
      uint256 frozen = frozenTokens[_from];
      uint256 availableBalance = balance.sub(frozen);
      require(availableBalance >= _value);

      return super.transferFrom(_from ,_to, _value);
    }

approve keyboard_arrow_up

    function approve(address _spender, uint256 _value) public returns (bool) {
      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) public returns (bool) {
      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) public returns (bool) {
      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;
    }

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;
        }
    }

frozenAddress keyboard_arrow_up

    function frozenAddress(address _addr) onlyOwner public returns (bool) {
      require(_addr != address(0));

      frozens[_addr] = true;
      FrozenAddress(_addr);
      return frozens[_addr];
    }

unFrozenAddress keyboard_arrow_up

    function unFrozenAddress(address _addr) onlyOwner public returns (bool) {
      require(_addr != address(0));

      delete frozens[_addr];
      //frozens[_addr] = false;
      UnFrozenAddress(_addr);
      return frozens[_addr];
    }

isFrozenByAddress keyboard_arrow_up

    function isFrozenByAddress(address _addr) public constant returns(bool) {
      require(_addr != address(0));

      bool result = bool(frozens[_addr]);
      return result;
    }

balanceFrozenTokens keyboard_arrow_up

    function balanceFrozenTokens(address _addr) public constant returns(uint256) {
      require(_addr != address(0));

      uint256 result = uint256(frozenTokens[_addr]);
      return result;
    }

balanceAvailableTokens keyboard_arrow_up

    function balanceAvailableTokens(address _addr) public constant returns(uint256) {
      require(_addr != address(0));

      uint256 frozen = uint256(frozenTokens[_addr]);
      uint256 balance = uint256(balances[_addr]);
      require(balance >= frozen);

      uint256 result = balance.sub(frozen);

      return result;
    }

frozenToken keyboard_arrow_up

    function frozenToken(address _addr, uint256 _amount) onlyOwner public returns(bool) {
      require(_addr != address(0));
      require(_amount > 0);

      uint256 balance = uint256(balances[_addr]);
      require(balance >= _amount);

      frozenTokens[_addr] = frozenTokens[_addr].add(_amount);
      FrozenTokenEvent(_addr, _amount);
      return true;
    }

unFrozenToken keyboard_arrow_up

    function unFrozenToken(address _addr, uint256 _amount) onlyOwner public returns(bool) {
      require(_addr != address(0));
      require(_amount > 0);
      require(frozenTokens[_addr] >= _amount);

      frozenTokens[_addr] = frozenTokens[_addr].sub(_amount);
      UnFrozenTokenEvent(_addr, _amount);
      return true;
    }

createToken keyboard_arrow_up

      function createToken(address _to, uint256 _amount) onlyOwnerOrAuthorized public returns (bool) {
        require(_to != address(0));
        require(_amount > 0);
        require(MAX_TOKEN_SUPPLY >= totalSupply_ + _amount);

        totalSupply_ = totalSupply_.add(_amount);
        balances[_to] = balances[_to].add(_amount);

        // KYC
        frozens[_to] = true;
        FrozenAddress(_to);

        CreateToken(_to, _amount);
        Transfer(address(0), _to, _amount);
        return true;
      }

createTokenByAtes keyboard_arrow_up

      function createTokenByAtes(address _to, uint256 _amount, string _data) onlyOwnerOrAuthorized public returns (bool) {
        require(_to != address(0));
        require(_amount > 0);
        require(bytes(_data).length > 0);
        require(MAX_TOKEN_SUPPLY >= totalSupply_ + _amount);

        totalSupply_ = totalSupply_.add(_amount);
        balances[_to] = balances[_to].add(_amount);

        // KYC
        frozens[_to] = true;
        FrozenAddress(_to);

        CreateTokenByAtes(_to, _amount, _data);
        Transfer(address(0), _to, _amount);
        return true;
      }