OceanToken

0x985dd3d42de1e256d09e1c10f112bccb8015ad41

isMinter keyboard_arrow_up

    function isMinter(address account) public view returns (bool) {
        return _minters.has(account);
    }

addMinter keyboard_arrow_up

    function addMinter(address account) public onlyMinter {
        _addMinter(account);
    }

renounceMinter keyboard_arrow_up

    function renounceMinter() public {
        _removeMinter(msg.sender);
    }

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

allowance keyboard_arrow_up

    function allowance(address owner, address spender) public view returns (uint256) {
        return _allowed[owner][spender];
    }

transfer keyboard_arrow_up

    function transfer(
        address _to,
        uint256 _value
    )
    public
    returns (bool)
    {
        bool success = super.transfer(_to, _value);
        if (success) {
            updateTokenHolders(msg.sender, _to);
        }
        return success;
    }

approve keyboard_arrow_up

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

transferFrom keyboard_arrow_up

    function transferFrom(
        address _from,
        address _to,
        uint256 _value
    )
    public
    returns (bool)
    {
        bool success = super.transferFrom(_from, _to, _value);
        if (success) {
            updateTokenHolders(_from, _to);
        }
        return success;
    }

increaseAllowance keyboard_arrow_up

    function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
        require(spender != address(0));

        _allowed[msg.sender][spender] = _allowed[msg.sender][spender].add(addedValue);
        emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
        return true;
    }

decreaseAllowance keyboard_arrow_up

    function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
        require(spender != address(0));

        _allowed[msg.sender][spender] = _allowed[msg.sender][spender].sub(subtractedValue);
        emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
        return true;
    }

mint keyboard_arrow_up

    function mint(address to, uint256 value) public onlyMinter returns (bool) {
        _mint(to, value);
        return true;
    }

cap keyboard_arrow_up

    function cap() public view returns (uint256) {
        return _cap;
    }

name keyboard_arrow_up

    function name() public view returns (string memory) {
        return _name;
    }

symbol keyboard_arrow_up

    function symbol() public view returns (string memory) {
        return _symbol;
    }

decimals keyboard_arrow_up

    function decimals() public view returns (uint8) {
        return _decimals;
    }

isPauser keyboard_arrow_up

    function isPauser(address account) public view returns (bool) {
        return _pausers.has(account);
    }

addPauser keyboard_arrow_up

    function addPauser(address account) public onlyPauser {
        _addPauser(account);
    }

renouncePauser keyboard_arrow_up

    function renouncePauser() public {
        _removePauser(msg.sender);
    }

paused keyboard_arrow_up

    function paused() public view returns (bool) {
        return _paused;
    }

pause keyboard_arrow_up

    function pause() public onlyPauser whenNotPaused {
        _paused = true;
        emit Paused(msg.sender);
    }

unpause keyboard_arrow_up

    function unpause() public onlyPauser whenPaused {
        _paused = false;
        emit Unpaused(msg.sender);
    }

increaseAllowance keyboard_arrow_up

    function increaseAllowance(address spender, uint addedValue) public whenNotPaused returns (bool success) {
        return super.increaseAllowance(spender, addedValue);
    }

decreaseAllowance keyboard_arrow_up

    function decreaseAllowance(address spender, uint subtractedValue) public whenNotPaused returns (bool success) {
        return super.decreaseAllowance(spender, subtractedValue);
    }

owner keyboard_arrow_up

    function owner() public view returns (address) {
        return _owner;
    }

isOwner keyboard_arrow_up

    function isOwner() public view returns (bool) {
        return msg.sender == _owner;
    }

renounceOwnership keyboard_arrow_up

    function renounceOwnership() public onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

transferOwnership keyboard_arrow_up

    function transferOwnership(address newOwner) public onlyOwner {
        _transferOwnership(newOwner);
    }

getAccounts keyboard_arrow_up

    function getAccounts(
        uint256 _start,
        uint256 _end
    )
    external
    view
    onlyOwner
    returns (address[] memory, uint256[] memory)
    {
        require(
            _start <= _end && _end < accounts.length,
            'Array index out of bounds'
        );
        
        uint256 length = _end.sub(_start).add(1);
        
        address[] memory _tokenHolders = new address[](length);
        uint256[] memory _tokenBalances = new uint256[](length);
        
        for (uint256 i = _start; i <= _end; i++)
        {
            address account = accounts[i];
            uint256 accountBalance = super.balanceOf(account);
            if (accountBalance > 0)
            {
                _tokenBalances[i] = accountBalance;
                _tokenHolders[i] = account;
            }
        }
        
        return (_tokenHolders, _tokenBalances);
    }

getAccountsLength keyboard_arrow_up

    function getAccountsLength()
    external
    view
    onlyOwner
    returns (uint256)
    {
        return accounts.length;
    }

kill keyboard_arrow_up

    function kill()
    external
    onlyOwner
    {
        selfdestruct(address(uint160(owner())));
    }

constructor keyboard_arrow_up

    function()
    external
    payable
    {
        revert('Invalid ether transfer');
    }