Q DAO Governance token v1.0

0x3166c570935a7d8554c8f4ea792ff965d2efe1f2

isOwner keyboard_arrow_up

    function isOwner(address wallet) public constant returns(bool) {
        return ownersIndices[wallet] > 0;
    }

ownersCount keyboard_arrow_up

    function ownersCount() public view returns(uint) {
        return owners.length;
    }

allOperationsCount keyboard_arrow_up

    function allOperationsCount() public  view returns(uint) {
        return allOperations.length;
    }

cancelPending keyboard_arrow_up

    function cancelPending(bytes32 operation) public onlyAnyOwner {
        uint ownerIndex = ownersIndices[msg.sender] - 1;
        require((votesMaskByOperation[operation] & (2 ** ownerIndex)) != 0, "cancelPending: operation not found for this user");
        votesMaskByOperation[operation] &= ~(2 ** ownerIndex);
        uint operationVotesCount = votesCountByOperation[operation] - 1;
        votesCountByOperation[operation] = operationVotesCount;
        emit OperationDownvoted(operation, operationVotesCount, owners.length, msg.sender);
        if (operationVotesCount == 0) {
            deleteOperation(operation);
            emit OperationCancelled(operation, msg.sender);
        }
    }

transferOwnership keyboard_arrow_up

    function transferOwnership(address _newOwner, address _oldOwner) public onlyManyOwners {
        _transferOwnership(_newOwner, _oldOwner);
    }

pause keyboard_arrow_up

    function pause() public onlyManyOwners whenNotPaused {

        paused = true;
        emit Pause();
    }

unpause keyboard_arrow_up

    function unpause() public onlyManyOwners whenPaused {
        paused = false;
        emit Unpause();
    }

addAddressToGovernanceContract keyboard_arrow_up

    function addAddressToGovernanceContract(address addr) onlyManyOwners public returns(bool success) {
        if (!governanceContracts[addr]) {
            governanceContracts[addr] = true;
            emit GovernanceContractAdded(addr);
            success = true;
        }
    }

removeAddressFromGovernanceContract keyboard_arrow_up

    function removeAddressFromGovernanceContract(address addr) onlyManyOwners public returns(bool success) {
        if (governanceContracts[addr]) {
            governanceContracts[addr] = false;
            emit GovernanceContractRemoved(addr);
            success = true;
        }
    }

totalSupply keyboard_arrow_up

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

balanceOf keyboard_arrow_up

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

transfer keyboard_arrow_up

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

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,
        uint256 _addedValue
    )
    public
    returns (bool)
    {
        allowed[msg.sender][_spender] = (
        allowed[msg.sender][_spender].add(_addedValue));
        emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
        return true;
    }

decreaseApproval keyboard_arrow_up

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

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

mint keyboard_arrow_up

    function mint(address _to, uint256 _amount) external onlyGovernanceContracts() returns (bool){
        totalSupply_ = totalSupply_.add(_amount);
        balances[_to] = balances[_to].add(_amount);
        emit Mint(_to, _amount);
        emit Transfer(address(0), _to, _amount);
        return true;
    }

approveForOtherContracts keyboard_arrow_up

    function approveForOtherContracts(address _sender, address _spender, uint256 _value) external onlyGovernanceContracts() {
        allowed[_sender][_spender] = _value;
        emit Approval(_sender, _spender, _value);
    }

burnFrom keyboard_arrow_up

    function burnFrom(address _to, uint256 _amount) external onlyGovernanceContracts() returns (bool) {
        allowed[_to][msg.sender] = _amount;
        transferFrom(_to, msg.sender, _amount);
        _burn(msg.sender, _amount);
        return true;
    }

transferMany keyboard_arrow_up

    function transferMany(address[] _recipients, uint[] _values) public onlyGovernanceContracts() {
        require(_recipients.length == _values.length);
        require(_recipients.length > 0);

        for(uint i = 0; i < _recipients.length; i++) {
            address recipient = _recipients[i];
            uint value = _values[i];

            require(recipient != address(0) && value != 0);

            balances[msg.sender] = balances[msg.sender].sub(value);
            balances[recipient] = balances[recipient].add(value);
            emit Transfer(msg.sender, recipient, value);
        }
    }