DOS Network Token

0x70861e862e1ac0c96f853c8231826e469ead37b1

changeManager keyboard_arrow_up

    function changeManager(address _newManager) public onlyManager {
        manager = _newManager;
    }

setOwner keyboard_arrow_up

    function setOwner(address owner_)
        public
        auth
    {
        owner = owner_;
        emit LogSetOwner(owner);
    }

setAuthority keyboard_arrow_up

    function setAuthority(DSAuthority authority_)
        public
        auth
    {
        authority = authority_;
        emit LogSetAuthority(address(authority));
    }

stop keyboard_arrow_up

    function stop() public auth note {
        stopped = true;
    }

start keyboard_arrow_up

    function start() public auth note {
        stopped = false;
    }

totalSupply keyboard_arrow_up

    function totalSupply() public view returns (uint) {
        return _supply;
    }

balanceOf keyboard_arrow_up

    function balanceOf(address src) public view returns (uint) {
        return _balances[src];
    }

allowance keyboard_arrow_up

    function allowance(address src, address guy) public view returns (uint) {
        return _approvals[src][guy];
    }

transfer keyboard_arrow_up

    function transfer(address dst, uint wad) public returns (bool) {
        return transferFrom(msg.sender, dst, wad);
    }

transferFrom keyboard_arrow_up

    function transferFrom(address src, address dst, uint wad) public stoppable returns (bool) {
        require(_balances[src] >= wad, "token-insufficient-balance");

        // Adjust token transfer amount if necessary.
        if (isContract(manager)) {
            wad = ControllerManager(manager).onTransfer(src, _balances[src], wad);
            require(wad > 0, "transfer-disabled-by-ControllerManager");
        }

        if (src != msg.sender && _approvals[src][msg.sender] != uint(-1)) {
            require(_approvals[src][msg.sender] >= wad, "token-insufficient-approval");
            _approvals[src][msg.sender] = sub(_approvals[src][msg.sender], wad);
        }

        _balances[src] = sub(_balances[src], wad);
        _balances[dst] = add(_balances[dst], wad);

        emit Transfer(src, dst, wad);

        return true;
    }

approve keyboard_arrow_up

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

        emit Approval(msg.sender, guy, wad);

        return true;
    }

approve keyboard_arrow_up

    function approve(address guy) public stoppable returns (bool) {
        return approve(guy, uint(-1));
    }

burn keyboard_arrow_up

    function burn(uint wad) public {
        burn(msg.sender, wad);
    }

mint keyboard_arrow_up

    function mint(address guy, uint wad) public auth stoppable {
        _balances[guy] = add(_balances[guy], wad);
        _supply = add(_supply, wad);
        require(_supply <= MAX_SUPPLY, "Total supply overflow");
        emit Transfer(address(0), guy, wad);
    }

burn keyboard_arrow_up

    function burn(address guy, uint wad) public auth stoppable {
        if (guy != msg.sender && _approvals[guy][msg.sender] != uint(-1)) {
            require(_approvals[guy][msg.sender] >= wad, "token-insufficient-approval");
            _approvals[guy][msg.sender] = sub(_approvals[guy][msg.sender], wad);
        }

        require(_balances[guy] >= wad, "token-insufficient-balance");
        _balances[guy] = sub(_balances[guy], wad);
        _supply = sub(_supply, wad);
        emit Transfer(guy, address(0), wad);
    }

constructor keyboard_arrow_up

    function () external payable {}

claimTokens keyboard_arrow_up

    function claimTokens(address _token, address payable _dst) public auth {
        if (_token == address(0)) {
            _dst.transfer(address(this).balance);
            return;
        }

        ERC20 token = ERC20(_token);
        uint balance = token.balanceOf(address(this));
        token.transfer(_dst, balance);
    }