ETH Price: $3,156.25 (+2.78%)

Token

BOB (BOB)
 

Overview

Max Total Supply

0 BOB

Holders

0

Total Transfers

-

Market

Price

$0.00 @ 0.000000 ETH

Onchain Market Cap

$0.00

Circulating Supply Market Cap

-

Other Info

Token Contract (WITH 18 Decimals)

Loading...
Loading
Loading...
Loading
Loading...
Loading

Click here to update the token information / general information

Contract Source Code Verified (Exact Match)

Contract Name:
BobToken

Compiler Version
v0.8.15+commit.e14f2714

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion

Contract Source Code (Solidity Standard Json-Input format)

File 1 of 23 : BobToken.sol
// SPDX-License-Identifier: CC0-1.0

pragma solidity 0.8.15;

import "./proxy/EIP1967Admin.sol";
import "./token/ERC677.sol";
import "./token/ERC20Permit.sol";
import "./token/ERC20MintBurn.sol";
import "./token/ERC20Recovery.sol";
import "./token/ERC20Blocklist.sol";
import "./utils/Claimable.sol";

/**
 * @title BobToken
 */
contract BobToken is
    EIP1967Admin,
    BaseERC20,
    ERC677,
    ERC20Permit,
    ERC20MintBurn,
    ERC20Recovery,
    ERC20Blocklist,
    Claimable
{
    /**
     * @dev Creates a proxy implementation for BobToken.
     * @param _self address of the proxy contract, linked to the deployed implementation,
     * required for correct EIP712 domain derivation.
     */
    constructor(address _self) ERC20Permit(_self) {}

    /**
     * @dev Returns the name of the token.
     */
    function name() public view override returns (string memory) {
        return "BOB";
    }

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() public view override returns (string memory) {
        return "BOB";
    }

    /**
     * @dev Tells if caller is the contract owner.
     * Gives ownership rights to the proxy admin as well.
     * @return true, if caller is the contract owner or proxy admin.
     */
    function _isOwner() internal view override returns (bool) {
        return super._isOwner() || _admin() == _msgSender();
    }
}

File 2 of 23 : EIP1967Admin.sol
// SPDX-License-Identifier: CC0-1.0

pragma solidity 0.8.15;

/**
 * @title EIP1967Admin
 * @dev Upgradeable proxy pattern implementation according to minimalistic EIP1967.
 */
contract EIP1967Admin {
    // EIP 1967
    // bytes32(uint256(keccak256('eip1967.proxy.admin')) - 1)
    uint256 internal constant EIP1967_ADMIN_STORAGE = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;

    modifier onlyAdmin() {
        require(msg.sender == _admin(), "EIP1967Admin: not an admin");
        _;
    }

    function _admin() internal view returns (address res) {
        assembly {
            res := sload(EIP1967_ADMIN_STORAGE)
        }
    }
}

File 3 of 23 : ERC677.sol
// SPDX-License-Identifier: CC0-1.0

pragma solidity 0.8.15;

import "../interfaces/IERC677.sol";
import "../interfaces/IERC677Receiver.sol";
import "./BaseERC20.sol";

/**
 * @title ERC677
 */
abstract contract ERC677 is IERC677, BaseERC20 {
    /**
     * @dev ERC677 extension to ERC20 transfer. Will notify receiver after transfer completion.
     * @param _to address of the tokens receiver.
     * @param _amount amount of tokens to mint.
     * @param _data extra data to pass in the notification callback.
     */
    function transferAndCall(address _to, uint256 _amount, bytes calldata _data) external override {
        _transfer(msg.sender, _to, _amount);
        require(IERC677Receiver(_to).onTokenTransfer(msg.sender, _amount, _data), "ERC677: callback failed");
    }
}

File 4 of 23 : ERC20Permit.sol
// SPDX-License-Identifier: CC0-1.0

pragma solidity 0.8.15;

import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "../interfaces/IERC20Permit.sol";
import "./BaseERC20.sol";
import "../utils/EIP712.sol";

/**
 * @title ERC20Permit
 */
abstract contract ERC20Permit is IERC20Permit, BaseERC20, EIP712 {
    // EIP2612 permit typehash
    bytes32 public constant PERMIT_TYPEHASH =
        keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
    // Custom "salted" permit typehash
    // Works exactly the same as EIP2612 permit, except that includes an additional salt,
    // which should be explicitly signed by the user, as part of the permit message.
    bytes32 public constant SALTED_PERMIT_TYPEHASH =
        keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline,bytes32 salt)");

    mapping(address => uint256) public nonces;

    constructor(address _self) EIP712(_self, name(), "1") {}

    function DOMAIN_SEPARATOR() external view override returns (bytes32) {
        return _domainSeparatorV4();
    }

    /**
     * @dev Allows to spend holder's unlimited amount by the specified spender according to EIP2612.
     * The function can be called by anyone, but requires having allowance parameters
     * signed by the holder according to EIP712.
     * @param _holder The holder's address.
     * @param _spender The spender's address.
     * @param _value Allowance value to set as a result of the call.
     * @param _deadline The deadline timestamp to call the permit function. Must be a timestamp in the future.
     * Note that timestamps are not precise, malicious miner/validator can manipulate them to some extend.
     * Assume that there can be a 900 seconds time delta between the desired timestamp and the actual expiration.
     * @param _v A final byte of signature (ECDSA component).
     * @param _r The first 32 bytes of signature (ECDSA component).
     * @param _s The second 32 bytes of signature (ECDSA component).
     */
    function permit(
        address _holder,
        address _spender,
        uint256 _value,
        uint256 _deadline,
        uint8 _v,
        bytes32 _r,
        bytes32 _s
    )
        external
    {
        _checkPermit(_holder, _spender, _value, _deadline, _v, _r, _s);
        _approve(_holder, _spender, _value);
    }

    /**
     * @dev Cheap shortcut for making sequential calls to permit() + transferFrom() functions.
     */
    function receiveWithPermit(
        address _holder,
        uint256 _value,
        uint256 _deadline,
        uint8 _v,
        bytes32 _r,
        bytes32 _s
    )
        public
        virtual
    {
        _checkPermit(_holder, msg.sender, _value, _deadline, _v, _r, _s);

        // we don't make calls to _approve to avoid unnecessary storage writes
        // however, emitting ERC20 events is still desired
        emit Approval(_holder, msg.sender, _value);
        emit Approval(_holder, msg.sender, 0);

        _transfer(_holder, msg.sender, _value);
    }

    /**
     * @dev Salted permit modification.
     */
    function saltedPermit(
        address _holder,
        address _spender,
        uint256 _value,
        uint256 _deadline,
        bytes32 _salt,
        uint8 _v,
        bytes32 _r,
        bytes32 _s
    )
        external
    {
        _checkSaltedPermit(_holder, _spender, _value, _deadline, _salt, _v, _r, _s);
        _approve(_holder, _spender, _value);
    }

    /**
     * @dev Cheap shortcut for making sequential calls to saltedPermit() + transferFrom() functions.
     */
    function receiveWithSaltedPermit(
        address _holder,
        uint256 _value,
        uint256 _deadline,
        bytes32 _salt,
        uint8 _v,
        bytes32 _r,
        bytes32 _s
    )
        public
        virtual
    {
        _checkSaltedPermit(_holder, msg.sender, _value, _deadline, _salt, _v, _r, _s);

        // we don't make calls to _approve to avoid unnecessary storage writes
        // however, emitting ERC20 events is still desired
        emit Approval(_holder, msg.sender, _value);
        emit Approval(_holder, msg.sender, 0);

        _transfer(_holder, msg.sender, _value);
    }

    function _checkPermit(
        address _holder,
        address _spender,
        uint256 _value,
        uint256 _deadline,
        uint8 _v,
        bytes32 _r,
        bytes32 _s
    )
        private
    {
        require(block.timestamp <= _deadline, "ERC20Permit: expired permit");

        uint256 nonce = nonces[_holder]++;
        bytes32 digest = ECDSA.toTypedDataHash(
            _domainSeparatorV4(), keccak256(abi.encode(PERMIT_TYPEHASH, _holder, _spender, _value, nonce, _deadline))
        );

        require(_holder == ECDSA.recover(digest, _v, _r, _s), "ERC20Permit: invalid ERC2612 signature");
    }

    function _checkSaltedPermit(
        address _holder,
        address _spender,
        uint256 _value,
        uint256 _deadline,
        bytes32 _salt,
        uint8 _v,
        bytes32 _r,
        bytes32 _s
    )
        private
    {
        require(block.timestamp <= _deadline, "ERC20Permit: expired permit");

        uint256 nonce = nonces[_holder]++;
        bytes32 digest = ECDSA.toTypedDataHash(
            _domainSeparatorV4(),
            keccak256(abi.encode(SALTED_PERMIT_TYPEHASH, _holder, _spender, _value, nonce, _deadline, _salt))
        );

        require(_holder == ECDSA.recover(digest, _v, _r, _s), "ERC20Permit: invalid signature");
    }
}

File 5 of 23 : ERC20MintBurn.sol
// SPDX-License-Identifier: CC0-1.0

pragma solidity 0.8.15;

import "../utils/Ownable.sol";
import "../interfaces/IMintableERC20.sol";
import "./BaseERC20.sol";
import "../interfaces/IMintableERC20.sol";
import "../interfaces/IBurnableERC20.sol";

/**
 * @title ERC20MintBurn
 */
abstract contract ERC20MintBurn is IMintableERC20, IBurnableERC20, Ownable, BaseERC20 {
    mapping(address => uint256) internal permissions;

    event UpdateMinter(address indexed minter, bool canMint, bool canBurn);

    function isMinter(address _account) public view returns (bool) {
        return permissions[_account] & 2 > 0;
    }

    function isBurner(address _account) public view returns (bool) {
        return permissions[_account] & 1 > 0;
    }

    /**
     * @dev Updates mint/burn permissions of the specific account.
     * Callable only by the contract owner.
     * @param _account address of the new minter EOA or contract.
     * @param _canMint true if minting is allowed.
     * @param _canBurn true if burning is allowed.
     */
    function updateMinter(address _account, bool _canMint, bool _canBurn) external onlyOwner {
        permissions[_account] = (_canMint ? 2 : 0) + (_canBurn ? 1 : 0);
        emit UpdateMinter(_account, _canMint, _canBurn);
    }

    /**
     * @dev Mints the specified amount of tokens.
     * Callable only by one of the minter addresses.
     * @param _to address of the tokens receiver.
     * @param _amount amount of tokens to mint.
     */
    function mint(address _to, uint256 _amount) external {
        require(isMinter(msg.sender), "ERC20MintBurn: not a minter");

        _mint(_to, _amount);
    }

    /**
     * @dev Burns tokens from the caller.
     * Callable only by one of the burner addresses.
     * @param _value amount of tokens to burn. Should be less than or equal to caller balance.
     */
    function burn(uint256 _value) external virtual {
        require(isBurner(msg.sender), "ERC20MintBurn: not a burner");

        _burn(msg.sender, _value);
    }
}

File 6 of 23 : ERC20Recovery.sol
// SPDX-License-Identifier: CC0-1.0

pragma solidity 0.8.15;

import "@openzeppelin/contracts/utils/Address.sol";
import "../utils/Ownable.sol";
import "../interfaces/IERC677Receiver.sol";
import "./BaseERC20.sol";

/**
 * @title ERC20Recovery
 */
abstract contract ERC20Recovery is Ownable, BaseERC20 {
    event ExecutedRecovery(bytes32 indexed hash, uint256 value);
    event CancelledRecovery(bytes32 indexed hash);
    event RequestedRecovery(
        bytes32 indexed hash, uint256 requestTimestamp, uint256 executionTimestamp, address[] accounts, uint256[] values
    );

    address public recoveryAdmin;

    address public recoveredFundsReceiver;
    uint64 public recoveryLimitPercent;
    uint32 public recoveryRequestTimelockPeriod;

    uint256 public totalRecovered;

    bytes32 public recoveryRequestHash;
    uint256 public recoveryRequestExecutionTimestamp;

    /**
     * @dev Throws if called by any account other than the contract owner or recovery admin.
     */
    modifier onlyRecoveryAdmin() {
        require(_msgSender() == recoveryAdmin || _isOwner(), "Recovery: not authorized for recovery");
        _;
    }

    /**
     * @dev Updates the address of the recovery admin account.
     * Callable only by the contract owner.
     * Recovery admin is only authorized to request/execute/cancel recovery operations.
     * The availability, parameters and impact limits of recovery is controlled by the contract owner.
     * @param _recoveryAdmin address of the new recovery admin account.
     */
    function setRecoveryAdmin(address _recoveryAdmin) external onlyOwner {
        recoveryAdmin = _recoveryAdmin;
    }

    /**
     * @dev Updates the address of the recovered funds receiver.
     * Callable only by the contract owner.
     * Recovered funds receiver will receive ERC20, recovered from lost/unused accounts.
     * If receiver is a smart contract, it must correctly process a ERC677 callback, sent once on the recovery execution.
     * @param _recoveredFundsReceiver address of the new recovered funds receiver.
     */
    function setRecoveredFundsReceiver(address _recoveredFundsReceiver) external onlyOwner {
        recoveredFundsReceiver = _recoveredFundsReceiver;
    }

    /**
     * @dev Updates the max allowed percentage of total supply, which can be recovered.
     * Limits the impact that could be caused by the recovery admin.
     * Callable only by the contract owner.
     * @param _recoveryLimitPercent percentage, as a fraction of 1 ether, should be at most 100%.
     * In theory, recovery can exceed total supply, if recovered funds are then lost once again,
     * but in practice, we do not expect totalRecovered to reach such extreme values.
     */
    function setRecoveryLimitPercent(uint64 _recoveryLimitPercent) external onlyOwner {
        require(_recoveryLimitPercent <= 1 ether, "Recovery: invalid percentage");
        recoveryLimitPercent = _recoveryLimitPercent;
    }

    /**
     * @dev Updates the timelock period between submission of the recovery request and its execution.
     * Any user, who is not willing to accept the recovery, can safely withdraw his tokens within such period.
     * Callable only by the contract owner.
     * @param _recoveryRequestTimelockPeriod new timelock period in seconds.
     */
    function setRecoveryRequestTimelockPeriod(uint32 _recoveryRequestTimelockPeriod) external onlyOwner {
        require(_recoveryRequestTimelockPeriod >= 1 days, "Recovery: too low timelock period");
        require(_recoveryRequestTimelockPeriod <= 30 days, "Recovery: too high timelock period");
        recoveryRequestTimelockPeriod = _recoveryRequestTimelockPeriod;
    }

    /**
     * @dev Tells if recovery of funds is available, given the current configuration of recovery parameters.
     * @return true, if at least 1 wei of tokens could be recovered within the available limit.
     */
    function isRecoveryEnabled() external view returns (bool) {
        return _remainingRecoveryLimit() > 0;
    }

    /**
     * @dev Internal function telling the remaining available limit for recovery.
     * @return available recovery limit.
     */
    function _remainingRecoveryLimit() internal view returns (uint256) {
        if (recoveredFundsReceiver == address(0)) {
            return 0;
        }
        uint256 limit = totalSupply * recoveryLimitPercent / 1 ether;
        if (limit > totalRecovered) {
            return limit - totalRecovered;
        }
        return 0;
    }

    /**
     * @dev Creates a request to recover funds from abandoned/unused accounts.
     * Only one request could be active at a time. Any pending request would be cancelled and won't take any effect.
     * Callable only by the contract owner or recovery admin.
     * @param _accounts list of accounts to recover funds from.
     * @param _values list of max values to recover from each of the specified account.
     */
    function requestRecovery(address[] calldata _accounts, uint256[] calldata _values) external onlyRecoveryAdmin {
        require(_accounts.length == _values.length, "Recovery: different lengths");
        require(_accounts.length > 0, "Recovery: empty accounts");
        uint256 limit = _remainingRecoveryLimit();
        require(limit > 0, "Recovery: not enabled");

        bytes32 hash = recoveryRequestHash;
        if (hash != bytes32(0)) {
            emit CancelledRecovery(hash);
        }

        uint256[] memory values = new uint256[](_values.length);

        uint256 total = 0;
        for (uint256 i = 0; i < _values.length; i++) {
            uint256 balance = balanceOf(_accounts[i]);
            uint256 value = balance < _values[i] ? balance : _values[i];
            values[i] = value;
            total += value;
        }
        require(total <= limit, "Recovery: exceed recovery limit");

        uint256 executionTimestamp = block.timestamp + recoveryRequestTimelockPeriod;
        hash = keccak256(abi.encode(executionTimestamp, _accounts, values));
        recoveryRequestHash = hash;
        recoveryRequestExecutionTimestamp = executionTimestamp;

        emit RequestedRecovery(hash, block.timestamp, executionTimestamp, _accounts, values);
    }

    /**
     * @dev Executes the request to recover funds from abandoned/unused accounts.
     * Executed request should have exactly the same parameters, as emitted in the RequestedRecovery event.
     * Request could only be executed once configured timelock was surpassed.
     * After execution of the request, total amount of recovered funds should not exceed the configured percentage.
     * Callable only by the contract owner or recovery admin.
     * @param _accounts list of accounts to recover funds from.
     * @param _values list of max values to recover from each of the specified account.
     */
    function executeRecovery(address[] calldata _accounts, uint256[] calldata _values) external onlyRecoveryAdmin {
        uint256 executionTimestamp = recoveryRequestExecutionTimestamp;
        require(executionTimestamp > 0, "Recovery: no active recovery request");
        require(executionTimestamp <= block.timestamp, "Recovery: request still timelocked");
        uint256 limit = _remainingRecoveryLimit();
        require(limit > 0, "Recovery: not enabled");

        bytes32 storedHash = recoveryRequestHash;
        bytes32 receivedHash = keccak256(abi.encode(executionTimestamp, _accounts, _values));
        require(storedHash == receivedHash, "Recovery: request hashes do not match");

        uint256 value = _recoverTokens(_accounts, _values);
        totalRecovered += value;

        require(value <= limit, "Recovery: exceed recovery limit");

        delete recoveryRequestHash;
        delete recoveryRequestExecutionTimestamp;
        emit ExecutedRecovery(storedHash, value);
    }

    /**
     * @dev Cancels pending recovery request.
     * Callable only by the contract owner or recovery admin.
     */
    function cancelRecovery() external onlyRecoveryAdmin {
        bytes32 hash = recoveryRequestHash;
        require(hash != bytes32(0), "Recovery: no active recovery request");

        delete recoveryRequestHash;
        delete recoveryRequestExecutionTimestamp;

        emit CancelledRecovery(hash);
    }

    function _recoverTokens(address[] calldata _accounts, uint256[] calldata _values) internal returns (uint256) {
        uint256 total = 0;
        address receiver = recoveredFundsReceiver;

        for (uint256 i = 0; i < _accounts.length; i++) {
            uint256 balance = balanceOf(_accounts[i]);
            uint256 value = balance < _values[i] ? balance : _values[i];
            total += value;

            _decreaseBalanceUnchecked(_accounts[i], value);

            emit Transfer(_accounts[i], receiver, value);
        }

        _increaseBalance(receiver, total);

        if (Address.isContract(receiver)) {
            require(IERC677Receiver(receiver).onTokenTransfer(address(this), total, new bytes(0)));
        }

        return total;
    }
}

File 7 of 23 : ERC20Blocklist.sol
// SPDX-License-Identifier: CC0-1.0

pragma solidity 0.8.15;

import "../utils/Ownable.sol";
import "./BaseERC20.sol";

/**
 * @title ERC20Blocklist
 */
abstract contract ERC20Blocklist is Ownable, BaseERC20 {
    address public blocklister;

    event Blocked(address indexed account);
    event Unblocked(address indexed account);
    event BlocklisterChanged(address indexed account);

    /**
     * @dev Throws if called by any account other than the blocklister.
     */
    modifier onlyBlocklister() {
        require(msg.sender == blocklister, "Blocklist: caller is not the blocklister");
        _;
    }

    /**
     * @dev Checks if account is blocked.
     * @param _account The address to check.
     */
    function isBlocked(address _account) external view returns (bool) {
        return _isFrozen(_account);
    }

    /**
     * @dev Adds account to blocklist.
     * @param _account The address to blocklist.
     */
    function blockAccount(address _account) external onlyBlocklister {
        _freezeBalance(_account);
        emit Blocked(_account);
    }

    /**
     * @dev Removes account from blocklist.
     * @param _account The address to remove from the blocklist.
     */
    function unblockAccount(address _account) external onlyBlocklister {
        _unfreezeBalance(_account);
        emit Unblocked(_account);
    }

    /**
     * @dev Updates address of the blocklister account.
     * Callable only by the contract owner.
     * @param _newBlocklister address of new blocklister account.
     */
    function updateBlocklister(address _newBlocklister) external onlyOwner {
        blocklister = _newBlocklister;
        emit BlocklisterChanged(_newBlocklister);
    }
}

File 8 of 23 : Claimable.sol
// SPDX-License-Identifier: CC0-1.0

pragma solidity 0.8.15;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./Ownable.sol";

/**
 * @title Claimable
 */
contract Claimable is Ownable {
    address claimingAdmin;

    /**
     * @dev Throws if called by any account other than the contract owner or claiming admin.
     */
    modifier onlyClaimingAdmin() {
        require(_msgSender() == claimingAdmin || _isOwner(), "Claimable: not authorized for claiming");
        _;
    }

    /**
     * @dev Updates the address of the claiming admin account.
     * Callable only by the contract owner.
     * Claiming admin is only authorized to claim ERC20 tokens or native tokens mistakenly sent to the token contract address.
     * @param _claimingAdmin address of the new claiming admin account.
     */
    function setClaimingAdmin(address _claimingAdmin) external onlyOwner {
        claimingAdmin = _claimingAdmin;
    }

    /**
     * @dev Allows to transfer any locked token from this contract.
     * Callable only by the contract owner or claiming admin.
     * @param _token address of the token contract, or 0x00..00 for transferring native coins.
     * @param _to locked tokens receiver address.
     */
    function claimTokens(address _token, address _to) external virtual onlyClaimingAdmin {
        if (_token == address(0)) {
            payable(_to).transfer(address(this).balance);
        } else {
            uint256 balance = IERC20(_token).balanceOf(address(this));
            IERC20(_token).transfer(_to, balance);
        }
    }
}

File 9 of 23 : IERC677.sol
// SPDX-License-Identifier: CC0-1.0

pragma solidity 0.8.15;

interface IERC677 {
    function transferAndCall(address to, uint256 amount, bytes calldata data) external;
}

File 10 of 23 : IERC677Receiver.sol
// SPDX-License-Identifier: CC0-1.0

pragma solidity 0.8.15;

interface IERC677Receiver {
    function onTokenTransfer(address from, uint256 value, bytes calldata data) external returns (bool);
}

File 11 of 23 : BaseERC20.sol
// SPDX-License-Identifier: MIT

pragma solidity 0.8.15;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";

/**
 * @title BaseERC20
 */
abstract contract BaseERC20 is IERC20, IERC20Metadata {
    mapping(address => uint256) internal _balances;
    mapping(address => mapping(address => uint256)) public allowance;
    uint256 public totalSupply;

    function name() public view virtual override returns (string memory);

    function symbol() public view virtual override returns (string memory);

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

    function balanceOf(address account) public view virtual override returns (uint256 _balance) {
        _balance = _balances[account];
        assembly {
            _balance := and(_balance, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
        }
    }

    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        _transfer(msg.sender, to, amount);
        return true;
    }

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

    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
        _spendAllowance(from, msg.sender, amount);
        _transfer(from, to, amount);
        return true;
    }

    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(msg.sender, spender, allowance[msg.sender][spender] + addedValue);
        return true;
    }

    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        uint256 currentAllowance = allowance[msg.sender][spender];
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(msg.sender, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    function _transfer(address from, address to, uint256 amount) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _decreaseBalance(from, amount);
        _increaseBalance(to, amount);

        emit Transfer(from, to, amount);
    }

    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        totalSupply += amount;
        _increaseBalance(account, amount);

        emit Transfer(address(0), account, amount);
    }

    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _decreaseBalance(account, amount);
        totalSupply -= amount;

        emit Transfer(account, address(0), amount);
    }

    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        allowance[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
        uint256 currentAllowance = allowance[owner][spender];
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    function _increaseBalance(address _account, uint256 _amount) internal {
        uint256 balance = _balances[_account];
        require(balance < 1 << 255, "ERC20: account frozen");
        unchecked {
            _balances[_account] = balance + _amount;
        }
    }

    function _decreaseBalance(address _account, uint256 _amount) internal {
        uint256 balance = _balances[_account];
        require(balance < 1 << 255, "ERC20: account frozen");
        require(balance >= _amount, "ERC20: amount exceeds balance");
        unchecked {
            _balances[_account] = balance - _amount;
        }
    }

    function _decreaseBalanceUnchecked(address _account, uint256 _amount) internal {
        uint256 balance = _balances[_account];
        unchecked {
            _balances[_account] = balance - _amount;
        }
    }

    function _isFrozen(address _account) internal view returns (bool) {
        return _balances[_account] >= 1 << 255;
    }

    function _freezeBalance(address _account) internal {
        _balances[_account] |= 1 << 255;
    }

    function _unfreezeBalance(address _account) internal {
        _balances[_account] &= (1 << 255) - 1;
    }
}

File 12 of 23 : ECDSA.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;

import "../Strings.sol";

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        } else if (error == RecoverError.InvalidSignatureV) {
            revert("ECDSA: invalid signature 'v' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        // Check the signature length
        // - case 65: r,s,v signature (standard)
        // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else if (signature.length == 64) {
            bytes32 r;
            bytes32 vs;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                vs := mload(add(signature, 0x40))
            }
            return tryRecover(hash, r, vs);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }
        if (v != 27 && v != 28) {
            return (address(0), RecoverError.InvalidSignatureV);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}

File 13 of 23 : IERC20Permit.sol
// SPDX-License-Identifier: CC0-1.0

pragma solidity 0.8.15;

interface IERC20Permit {
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    )
        external;

    function nonces(address owner) external view returns (uint256);

    function DOMAIN_SEPARATOR() external view returns (bytes32);

    function PERMIT_TYPEHASH() external view returns (bytes32);

    function SALTED_PERMIT_TYPEHASH() external view returns (bytes32);

    function receiveWithPermit(
        address _holder,
        uint256 _value,
        uint256 _deadline,
        uint8 _v,
        bytes32 _r,
        bytes32 _s
    )
        external;

    function saltedPermit(
        address _holder,
        address _spender,
        uint256 _value,
        uint256 _deadline,
        bytes32 _salt,
        uint8 _v,
        bytes32 _r,
        bytes32 _s
    )
        external;

    function receiveWithSaltedPermit(
        address _holder,
        uint256 _value,
        uint256 _deadline,
        bytes32 _salt,
        uint8 _v,
        bytes32 _r,
        bytes32 _s
    )
        external;
}

File 14 of 23 : EIP712.sol
// SPDX-License-Identifier: MIT

pragma solidity 0.8.15;

import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";

/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,
 * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding
 * they need in their contracts using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * Adapted from OpenZeppelin library to support address(this) overrides in proxy implementations.
 */
abstract contract EIP712 {
    /* solhint-disable var-name-mixedcase */
    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
    // invalidate the cached domain separator if the chain id changes.
    bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
    uint256 private immutable _CACHED_CHAIN_ID;
    address private immutable _CACHED_THIS;

    bytes32 private immutable _HASHED_NAME;
    bytes32 private immutable _HASHED_VERSION;
    bytes32 private immutable _TYPE_HASH;

    /* solhint-enable var-name-mixedcase */

    /**
     * @dev Initializes the domain separator and parameter caches.
     *
     * The meaning of `name` and `version` is specified in
     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
     *
     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
     * - `version`: the current major version of the signing domain.
     *
     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
     * contract upgrade].
     */
    constructor(address self, string memory name, string memory version) {
        bytes32 hashedName = keccak256(bytes(name));
        bytes32 hashedVersion = keccak256(bytes(version));
        bytes32 typeHash =
            keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
        _HASHED_NAME = hashedName;
        _HASHED_VERSION = hashedVersion;
        _CACHED_CHAIN_ID = block.chainid;
        _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion, self);
        _CACHED_THIS = self;
        _TYPE_HASH = typeHash;
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        if (address(this) == _CACHED_THIS && block.chainid == _CACHED_CHAIN_ID) {
            return _CACHED_DOMAIN_SEPARATOR;
        } else {
            return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION, address(this));
        }
    }

    function _buildDomainSeparator(
        bytes32 typeHash,
        bytes32 nameHash,
        bytes32 versionHash,
        address self
    )
        private
        view
        returns (bytes32)
    {
        return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, self));
    }

    /**
     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
     * function returns the hash of the fully encoded EIP712 message for this domain.
     *
     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
     *
     * ```solidity
     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
     *     keccak256("Mail(address to,string contents)"),
     *     mailTo,
     *     keccak256(bytes(mailContents))
     * )));
     * address signer = ECDSA.recover(digest, signature);
     * ```
     */
    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
        return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
    }
}

File 15 of 23 : Ownable.sol
// SPDX-License-Identifier: CC0-1.0

pragma solidity 0.8.15;

import "@openzeppelin/contracts/access/Ownable.sol" as OZOwnable;

/**
 * @title Ownable
 */
contract Ownable is OZOwnable.Ownable {
    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view override {
        require(_isOwner(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Tells if caller is the contract owner.
     * @return true, if caller is the contract owner.
     */
    function _isOwner() internal view virtual returns (bool) {
        return owner() == _msgSender();
    }
}

File 16 of 23 : IMintableERC20.sol
// SPDX-License-Identifier: CC0-1.0

pragma solidity 0.8.15;

interface IMintableERC20 {
    function mint(address to, uint256 amount) external;
}

File 17 of 23 : IBurnableERC20.sol
// SPDX-License-Identifier: CC0-1.0

pragma solidity 0.8.15;

interface IBurnableERC20 {
    function burn(uint256 amount) external;
}

File 18 of 23 : Address.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

File 19 of 23 : IERC20.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);
}

File 20 of 23 : IERC20Metadata.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

File 21 of 23 : Strings.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
}

File 22 of 23 : Ownable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

File 23 of 23 : Context.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

Settings
{
  "remappings": [
    "@gnosis/=lib/@gnosis/",
    "@gnosis/auction/=lib/@gnosis/auction/contracts/",
    "@openzeppelin/=lib/@openzeppelin/contracts/",
    "@openzeppelin/contracts/=lib/@openzeppelin/contracts/contracts/",
    "@uniswap/=lib/@uniswap/",
    "ds-test/=lib/forge-std/lib/ds-test/src/",
    "forge-std/=lib/forge-std/src/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "london",
  "libraries": {}
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"_self","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"Blocked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"BlocklisterChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"hash","type":"bytes32"}],"name":"CancelledRecovery","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"hash","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"ExecutedRecovery","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"hash","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"requestTimestamp","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"executionTimestamp","type":"uint256"},{"indexed":false,"internalType":"address[]","name":"accounts","type":"address[]"},{"indexed":false,"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"RequestedRecovery","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"Unblocked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"minter","type":"address"},{"indexed":false,"internalType":"bool","name":"canMint","type":"bool"},{"indexed":false,"internalType":"bool","name":"canBurn","type":"bool"}],"name":"UpdateMinter","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERMIT_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SALTED_PERMIT_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"_balance","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"blockAccount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"blocklister","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cancelRecovery","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"address","name":"_to","type":"address"}],"name":"claimTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_accounts","type":"address[]"},{"internalType":"uint256[]","name":"_values","type":"uint256[]"}],"name":"executeRecovery","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"isBlocked","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"isBurner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"isMinter","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isRecoveryEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_holder","type":"address"},{"internalType":"address","name":"_spender","type":"address"},{"internalType":"uint256","name":"_value","type":"uint256"},{"internalType":"uint256","name":"_deadline","type":"uint256"},{"internalType":"uint8","name":"_v","type":"uint8"},{"internalType":"bytes32","name":"_r","type":"bytes32"},{"internalType":"bytes32","name":"_s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_holder","type":"address"},{"internalType":"uint256","name":"_value","type":"uint256"},{"internalType":"uint256","name":"_deadline","type":"uint256"},{"internalType":"uint8","name":"_v","type":"uint8"},{"internalType":"bytes32","name":"_r","type":"bytes32"},{"internalType":"bytes32","name":"_s","type":"bytes32"}],"name":"receiveWithPermit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_holder","type":"address"},{"internalType":"uint256","name":"_value","type":"uint256"},{"internalType":"uint256","name":"_deadline","type":"uint256"},{"internalType":"bytes32","name":"_salt","type":"bytes32"},{"internalType":"uint8","name":"_v","type":"uint8"},{"internalType":"bytes32","name":"_r","type":"bytes32"},{"internalType":"bytes32","name":"_s","type":"bytes32"}],"name":"receiveWithSaltedPermit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"recoveredFundsReceiver","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"recoveryAdmin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"recoveryLimitPercent","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"recoveryRequestExecutionTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"recoveryRequestHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"recoveryRequestTimelockPeriod","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_accounts","type":"address[]"},{"internalType":"uint256[]","name":"_values","type":"uint256[]"}],"name":"requestRecovery","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_holder","type":"address"},{"internalType":"address","name":"_spender","type":"address"},{"internalType":"uint256","name":"_value","type":"uint256"},{"internalType":"uint256","name":"_deadline","type":"uint256"},{"internalType":"bytes32","name":"_salt","type":"bytes32"},{"internalType":"uint8","name":"_v","type":"uint8"},{"internalType":"bytes32","name":"_r","type":"bytes32"},{"internalType":"bytes32","name":"_s","type":"bytes32"}],"name":"saltedPermit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_claimingAdmin","type":"address"}],"name":"setClaimingAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_recoveredFundsReceiver","type":"address"}],"name":"setRecoveredFundsReceiver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_recoveryAdmin","type":"address"}],"name":"setRecoveryAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint64","name":"_recoveryLimitPercent","type":"uint64"}],"name":"setRecoveryLimitPercent","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"_recoveryRequestTimelockPeriod","type":"uint32"}],"name":"setRecoveryRequestTimelockPeriod","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalRecovered","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"transferAndCall","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"unblockAccount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newBlocklister","type":"address"}],"name":"updateBlocklister","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"},{"internalType":"bool","name":"_canMint","type":"bool"},{"internalType":"bool","name":"_canBurn","type":"bool"}],"name":"updateMinter","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000b0b195aefa3650a6908f15cdac7d92f8a5791b0b

-----Decoded View---------------
Arg [0] : _self (address): 0xB0B195aEFA3650A6908f15CdaC7D92F8a5791B0B

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000b0b195aefa3650a6908f15cdac7d92f8a5791b0b


[ Download: CSV Export  ]

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.