Pundi X Token

0xa15c7ebe1f07caf6bff097d8a589fb8ac49ae5b3

transferOwnership keyboard_arrow_up

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

pause keyboard_arrow_up

    function pause() onlyOwner whenNotPaused public {
        super.pause();
    }

unpause keyboard_arrow_up

    function unpause() onlyOwner whenPaused public {
        super.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) public whenNotPaused returns (bool) {
        require(!stopReceive[_to]);
        bool result = super.transfer(_to, _value);
        return result;
    }

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) public whenNotPaused returns (bool) {
        bool result = super.transferFrom(_from, _to, _value);
        return result;
    }

approve keyboard_arrow_up

  function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
    return super.approve(_spender, _value);
  }

increaseApproval keyboard_arrow_up

  function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
    return super.increaseApproval(_spender, _addedValue);
  }

decreaseApproval keyboard_arrow_up

  function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
    return super.decreaseApproval(_spender, _subtractedValue);
  }

burn keyboard_arrow_up

    function burn(uint _value)
        public
    {
        require(_value > 0);

        address burner = msg.sender;
        balances[burner] = balances[burner].sub(_value);
        totalSupply = totalSupply.sub(_value);
        Burn(burner, _value);
    }

mint keyboard_arrow_up

    function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
        bool result = super.mint(_to, _amount);
        return result;
    }

finishMinting keyboard_arrow_up

  function finishMinting() onlyOwner returns (bool) {
    mintingFinished = true;
    MintFinished();
    return true;
  }

setStopReceive keyboard_arrow_up

    function setStopReceive(bool stop) {
        stopReceive[msg.sender] = stop;
    }

getStopReceive keyboard_arrow_up

    function getStopReceive() constant public returns (bool) {
        return stopReceive[msg.sender];
    }

burn keyboard_arrow_up

    function burn(uint256 _value) public {
        super.burn(_value);
    }

transferAndCall keyboard_arrow_up

    function transferAndCall(address _recipient, uint256 _amount, bytes _data) {
        require(_recipient != address(0));
        require(_amount <= balances[msg.sender]);

        balances[msg.sender] = balances[msg.sender].sub(_amount);
        balances[_recipient] = balances[_recipient].add(_amount);

        require(TokenRecipient(_recipient).tokenFallback(msg.sender, _amount, _data));
        Transfer(msg.sender, _recipient, _amount);
    }