Async Art

0xb6dae651468e9593e4581705a09c10a76ac1e0c8

owner keyboard_arrow_up

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

renounceOwnership keyboard_arrow_up

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

transferOwnership keyboard_arrow_up

    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(
            newOwner != address(0),
            "Ownable: new owner is the zero address"
        );
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }

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

totalSupply keyboard_arrow_up

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

balanceOf keyboard_arrow_up

    function balanceOf(address account) public override view returns (uint256) {
        return _balances[account];
    }

transfer keyboard_arrow_up

    function transfer(address recipient, uint256 amount)
        public
        virtual
        override
        returns (bool)
    {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

allowance keyboard_arrow_up

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

approve keyboard_arrow_up

    function approve(address spender, uint256 amount)
        public
        virtual
        override
        returns (bool)
    {
        _approve(_msgSender(), spender, amount);
        return true;
    }

transferFrom keyboard_arrow_up

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(
            sender,
            _msgSender(),
            _allowances[sender][_msgSender()].sub(
                amount,
                "ERC20: transfer amount exceeds allowance"
            )
        );
        return true;
    }

increaseAllowance keyboard_arrow_up

    function increaseAllowance(address spender, uint256 addedValue)
        public
        virtual
        returns (bool)
    {
        _approve(
            _msgSender(),
            spender,
            _allowances[_msgSender()][spender].add(addedValue)
        );
        return true;
    }

decreaseAllowance keyboard_arrow_up

    function decreaseAllowance(address spender, uint256 subtractedValue)
        public
        virtual
        returns (bool)
    {
        _approve(
            _msgSender(),
            spender,
            _allowances[_msgSender()][spender].sub(
                subtractedValue,
                "ERC20: decreased allowance below zero"
            )
        );
        return true;
    }

registerLockableAccount keyboard_arrow_up

    function registerLockableAccount(address newMemberAddress, uint _lockedUntilDate) external onlyOwner{
        require(newMemberAddress != address(0), "ERC20Lockable: Registered account cannot be from address(0)");
        _lockableAccounts[newMemberAddress] = Account(_lockedUntilDate,true);

        emit RegisteredNewLockableAccount(newMemberAddress);

    }

registerUnlockableAccount keyboard_arrow_up

    function registerUnlockableAccount(address newUnlockableAddress) external onlyOwner {
        require(newUnlockableAddress != address(0), "ERC20Lockable: Registered account cannot be from address(0)");
        _unlockableAddresses[newUnlockableAddress] = true;

        emit RegisteredNewUnlockableAccount(newUnlockableAddress);
    }

getLockDateForAccount keyboard_arrow_up

    function getLockDateForAccount(address lockedAccountAddress) external view returns (uint) {
        require(_lockableAccounts[lockedAccountAddress].exists, "ERC20Lockable: This address does not exist.");
        return _lockableAccounts[lockedAccountAddress].lockedUntilDate;
    }

disableUnlockableAccount keyboard_arrow_up

    function disableUnlockableAccount(address unlockableAddress) external onlyOwner {
        require(_unlockableAddresses[unlockableAddress], "ERC20Lockable: This address does not exists or it is already disabled.");
        _unlockableAddresses[unlockableAddress] = false;

        emit DisabledUnlockableAccount(unlockableAddress);
    }

token keyboard_arrow_up

    function token() public view returns (IERC20) {
        return _token;
    }

beneficiary keyboard_arrow_up

    function beneficiary() public view returns (address) {
        return _beneficiary;
    }

releaseTime keyboard_arrow_up

    function releaseTime() public view returns (uint256) {
        return _releaseTime;
    }

release keyboard_arrow_up

    function release() public virtual {
        // solhint-disable-next-line not-rely-on-time
        require(
            block.timestamp >= _releaseTime,
            "TokenTimelock: current time is before release time"
        );

        uint256 amount = _token.balanceOf(address(this));
        require(amount > 0, "TokenTimelock: no tokens to release");

        _token.safeTransfer(_beneficiary, amount);
    }

cap keyboard_arrow_up

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

paused keyboard_arrow_up

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

burn keyboard_arrow_up

    function burn(uint256 amount) public virtual {
        _burn(_msgSender(), amount);
    }

burnFrom keyboard_arrow_up

    function burnFrom(address account, uint256 amount) public virtual {
        uint256 decreasedAllowance = allowance(account, _msgSender()).sub(
            amount,
            "ERC20: burn amount exceeds allowance"
        );

        _approve(account, _msgSender(), decreasedAllowance);
        _burn(account, amount);
    }

hasRole keyboard_arrow_up

    function hasRole(bytes32 role, address account) public view returns (bool) {
        return _roles[role].members.contains(account);
    }

getRoleMemberCount keyboard_arrow_up

    function getRoleMemberCount(bytes32 role) public view returns (uint256) {
        return _roles[role].members.length();
    }

getRoleMember keyboard_arrow_up

    function getRoleMember(bytes32 role, uint256 index)
        public
        view
        returns (address)
    {
        return _roles[role].members.at(index);
    }

getRoleAdmin keyboard_arrow_up

    function getRoleAdmin(bytes32 role) public view returns (bytes32) {
        return _roles[role].adminRole;
    }

grantRole keyboard_arrow_up

    function grantRole(bytes32 role, address account) public virtual {
        require(
            hasRole(_roles[role].adminRole, _msgSender()),
            "AccessControl: sender must be an admin to grant"
        );

        _grantRole(role, account);
    }

revokeRole keyboard_arrow_up

    function revokeRole(bytes32 role, address account) public virtual {
        require(
            hasRole(_roles[role].adminRole, _msgSender()),
            "AccessControl: sender must be an admin to revoke"
        );

        _revokeRole(role, account);
    }

renounceRole keyboard_arrow_up

    function renounceRole(bytes32 role, address account) public virtual {
        require(
            account == _msgSender(),
            "AccessControl: can only renounce roles for self"
        );

        _revokeRole(role, account);
    }

initialize keyboard_arrow_up

    function initialize(string memory name, string memory symbol, uint cap) public override {
        super.initialize(name, symbol, cap);
        __ERC20UpgradeBase_init();
    }

mint keyboard_arrow_up

    function mint(address to, uint256 amount) public {
        require(
            hasRole(MINTER_ROLE, _msgSender()),
            "ERC20PresetMinterPauser: must have minter role to mint"
        );
        _mint(to, amount);
    }

pause keyboard_arrow_up

    function pause() public {
        require(
            hasRole(PAUSER_ROLE, _msgSender()),
            "ERC20PresetMinterPauser: must have pauser role to pause"
        );
        _pause();
    }

unpause keyboard_arrow_up

    function unpause() public {
        require(
            hasRole(PAUSER_ROLE, _msgSender()),
            "ERC20PresetMinterPauser: must have pauser role to unpause"
        );
        _unpause();
    }

__ERC20UpgradeBase_init keyboard_arrow_up

    function __ERC20UpgradeBase_init() public initializer {
        __Ownable_init_unchained();
        __ERC20Lockable_init_unchained();
        // add more initializers here...
    }

initialize keyboard_arrow_up

    function initialize() public initializer {
        ERC20UpgradeBase.initialize("Next Innovation", "NIN", 1000000000 * (10**uint256(decimals())));
        _setupDecimals(6);
        mint(msg.sender, 1000000000 * (10**uint256(decimals())));
    }