Open Ecosystem Token

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity 0.8.7;

import { IERC20 } from "./interfaces/IERC20.sol";

/*
    ███████╗██████╗  ██████╗    ██████╗  ██████╗
    ██╔════╝██╔══██╗██╔════╝    ╚════██╗██╔═████╗
    █████╗  ██████╔╝██║          █████╔╝██║██╔██║
    ██╔══╝  ██╔══██╗██║         ██╔═══╝ ████╔╝██║
    ███████╗██║  ██║╚██████╗    ███████╗╚██████╔╝
    ╚══════╝╚═╝  ╚═╝ ╚═════╝    ╚══════╝ ╚═════╝
*/

/**
 *  @title Modern ERC-20 implementation.
 *  @dev   Acknowledgements to Solmate, OpenZeppelin, and DSS for inspiring this code.
 */
contract ERC20 is IERC20 {

    /**************/
    /*** ERC-20 ***/
    /**************/

    string public override name;
    string public override symbol;

    uint8 public immutable override decimals;

    uint256 public override totalSupply;

    mapping(address => uint256) public override balanceOf;

    mapping(address => mapping(address => uint256)) public override allowance;

    /****************/
    /*** ERC-2612 ***/
    /****************/

    // PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
    bytes32 private constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;

    uint256 internal immutable initialChainId;

    bytes32 internal immutable initialDomainSeparator;

    mapping(address => uint256) public override nonces;

    /**
     *  @param name_     The name of the token.
     *  @param symbol_   The symbol of the token.
     *  @param decimals_ The decimal precision used by the token.
     */
    constructor(string memory name_, string memory symbol_, uint8 decimals_) {
        name     = name_;
        symbol   = symbol_;
        decimals = decimals_;
        initialChainId = block.chainid;
        initialDomainSeparator = _computeDomainSeparator();
    }

    /**************************/
    /*** External Functions ***/
    /**************************/

    function approve(address spender_, uint256 amount_) external override returns (bool success_) {
        _approve(msg.sender, spender_, amount_);
        return true;
    }

    function decreaseAllowance(address spender_, uint256 subtractedAmount_) external override returns (bool success_) {
        _decreaseAllowance(msg.sender, spender_, subtractedAmount_);
        return true;
    }

    function increaseAllowance(address spender_, uint256 addedAmount_) external override returns (bool success_) {
        _approve(msg.sender, spender_, allowance[msg.sender][spender_] + addedAmount_);
        return true;
    }

    function permit(address owner_, address spender_, uint256 amount_, uint256 deadline_, uint8 v_, bytes32 r_, bytes32 s_) external override {
        require(deadline_ >= block.timestamp, "ERC20:P:EXPIRED");

        // 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}.
        require(
            uint256(s_) <= uint256(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) &&
            (v_ == 27 || v_ == 28),
            "ERC20:P:MALLEABLE"
        );

        // Nonce realistically cannot overflow.
        unchecked {
            bytes32 digest = keccak256(
                abi.encodePacked(
                    "\x19\x01",
                    DOMAIN_SEPARATOR(),
                    keccak256(abi.encode(PERMIT_TYPEHASH, owner_, spender_, amount_, nonces[owner_]++, deadline_))
                )
            );

            address recoveredAddress = ecrecover(digest, v_, r_, s_);

            require(recoveredAddress == owner_ && owner_ != address(0), "ERC20:P:INVALID_SIGNATURE");
        }

        _approve(owner_, spender_, amount_);
    }

    function transfer(address recipient_, uint256 amount_) external override returns (bool success_) {
        _transfer(msg.sender, recipient_, amount_);
        return true;
    }

    function transferFrom(address owner_, address recipient_, uint256 amount_) external override returns (bool success_) {
        _decreaseAllowance(owner_, msg.sender, amount_);
        _transfer(owner_, recipient_, amount_);
        return true;
    }

    /**********************/
    /*** View Functions ***/
    /**********************/

    function DOMAIN_SEPARATOR() public view virtual override returns (bytes32 domainSeparator_) {
        return block.chainid == initialChainId ? initialDomainSeparator : _computeDomainSeparator();
    }

    /**************************/
    /*** Internal Functions ***/
    /**************************/

    function _approve(address owner_, address spender_, uint256 amount_) internal {
        emit Approval(owner_, spender_, allowance[owner_][spender_] = amount_);
    }

    function _burn(address owner_, uint256 amount_) internal virtual {
        balanceOf[owner_] -= amount_;

        // Cannot underflow because a user's balance will never be larger than the total supply.
        unchecked { totalSupply -= amount_; }

        emit Transfer(owner_, address(0), amount_);
    }

    function _computeDomainSeparator() internal view virtual returns (bytes32 domainSeparator_) {
        return keccak256(
            abi.encode(
                keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
                keccak256(bytes(name)),
                keccak256(bytes("1")),
                block.chainid,
                address(this)
            )
        );
    }

    function _decreaseAllowance(address owner_, address spender_, uint256 subtractedAmount_) internal {
        uint256 spenderAllowance = allowance[owner_][spender_];  // Cache to memory.

        if (spenderAllowance != type(uint256).max) {
            _approve(owner_, spender_, spenderAllowance - subtractedAmount_);
        }
    }

    function _mint(address recipient_, uint256 amount_) internal virtual {
        totalSupply += amount_;

        // Cannot overflow because totalSupply would first overflow in the statement above.
        unchecked { balanceOf[recipient_] += amount_; }

        emit Transfer(address(0), recipient_, amount_);
    }

    function _transfer(address owner_, address recipient_, uint256 amount_) internal virtual {
        balanceOf[owner_] -= amount_;

        // Cannot overflow because minting prevents overflow of totalSupply, and sum of user balances == totalSupply.
        unchecked { balanceOf[recipient_] += amount_; }

        emit Transfer(owner_, recipient_, amount_);
    }

}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity 0.8.7;

/// @title Interface of the ERC20 standard as defined in the EIP, including EIP-2612 permit functionality.
interface IERC20 {

    /**************/
    /*** Events ***/
    /**************/

    /**
     *  @dev   Emitted when one account has set the allowance of another account over their tokens.
     *  @param owner_   Account that tokens are approved from.
     *  @param spender_ Account that tokens are approved for.
     *  @param amount_  Amount of tokens that have been approved.
     */
    event Approval(address indexed owner_, address indexed spender_, uint256 amount_);

    /**
     *  @dev   Emitted when tokens have moved from one account to another.
     *  @param owner_     Account that tokens have moved from.
     *  @param recipient_ Account that tokens have moved to.
     *  @param amount_    Amount of tokens that have been transferred.
     */
    event Transfer(address indexed owner_, address indexed recipient_, uint256 amount_);

    /**************************/
    /*** External Functions ***/
    /**************************/

    /**
     *  @dev    Function that allows one account to set the allowance of another account over their tokens.
     *          Emits an {Approval} event.
     *  @param  spender_ Account that tokens are approved for.
     *  @param  amount_  Amount of tokens that have been approved.
     *  @return success_ Boolean indicating whether the operation succeeded.
     */
    function approve(address spender_, uint256 amount_) external returns (bool success_);

    /**
     *  @dev    Function that allows one account to decrease the allowance of another account over their tokens.
     *          Emits an {Approval} event.
     *  @param  spender_          Account that tokens are approved for.
     *  @param  subtractedAmount_ Amount to decrease approval by.
     *  @return success_          Boolean indicating whether the operation succeeded.
     */
    function decreaseAllowance(address spender_, uint256 subtractedAmount_) external returns (bool success_);

    /**
     *  @dev    Function that allows one account to increase the allowance of another account over their tokens.
     *          Emits an {Approval} event.
     *  @param  spender_     Account that tokens are approved for.
     *  @param  addedAmount_ Amount to increase approval by.
     *  @return success_     Boolean indicating whether the operation succeeded.
     */
    function increaseAllowance(address spender_, uint256 addedAmount_) external returns (bool success_);

    /**
     *  @dev   Approve by signature.
     *  @param owner_    Owner address that signed the permit.
     *  @param spender_  Spender of the permit.
     *  @param amount_   Permit approval spend limit.
     *  @param deadline_ Deadline after which the permit is invalid.
     *  @param v_        ECDSA signature v component.
     *  @param r_        ECDSA signature r component.
     *  @param s_        ECDSA signature s component.
     */
    function permit(address owner_, address spender_, uint amount_, uint deadline_, uint8 v_, bytes32 r_, bytes32 s_) external;

    /**
     *  @dev    Moves an amount of tokens from `msg.sender` to a specified account.
     *          Emits a {Transfer} event.
     *  @param  recipient_ Account that receives tokens.
     *  @param  amount_    Amount of tokens that are transferred.
     *  @return success_   Boolean indicating whether the operation succeeded.
     */
    function transfer(address recipient_, uint256 amount_) external returns (bool success_);

    /**
     *  @dev    Moves a pre-approved amount of tokens from a sender to a specified account.
     *          Emits a {Transfer} event.
     *          Emits an {Approval} event.
     *  @param  owner_     Account that tokens are moving from.
     *  @param  recipient_ Account that receives tokens.
     *  @param  amount_    Amount of tokens that are transferred.
     *  @return success_   Boolean indicating whether the operation succeeded.
     */
    function transferFrom(address owner_, address recipient_, uint256 amount_) external returns (bool success_);

    /**********************/
    /*** View Functions ***/
    /**********************/

    /**
     *  @dev    Returns the allowance that one account has given another over their tokens.
     *  @param  owner_     Account that tokens are approved from.
     *  @param  spender_   Account that tokens are approved for.
     *  @return allowance_ Allowance that one account has given another over their tokens.
     */
    function allowance(address owner_, address spender_) external view returns (uint256 allowance_);

    /**
     *  @dev    Returns the amount of tokens owned by a given account.
     *  @param  account_ Account that owns the tokens.
     *  @return balance_ Amount of tokens owned by a given account.
     */
    function balanceOf(address account_) external view returns (uint256 balance_);

    /**
     *  @dev    Returns the decimal precision used by the token.
     *  @return decimals_ The decimal precision used by the token.
     */
    function decimals() external view returns (uint8 decimals_);

    /**
     *  @dev    Returns the signature domain separator.
     *  @return domainSeparator_ The signature domain separator.
     */
    function DOMAIN_SEPARATOR() external view returns (bytes32 domainSeparator_);

    /**
     *  @dev    Returns the name of the token.
     *  @return name_ The name of the token.
     */
    function name() external view returns (string memory name_);

    /**
      *  @dev    Returns the nonce for the given owner.
      *  @param  owner_  The address of the owner account.
      *  @return nonce_ The nonce for the given owner.
     */
    function nonces(address owner_) external view returns (uint256 nonce_);

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

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

}

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;

import {IERC20} from "erc20/interfaces/IERC20.sol";

interface IOPNToken is IERC20 {
    /// @notice Mint function only callable by the DAO
    /// @dev this function will be only callable by a DAO governance contract that can only execute functions like these after a majority vote (with quorum) has been reached
    /// @param _to Address to which tokens will be minted.
    /// @param _amount Amount of tokens to mint
    function mintTokensByDAO(address _to, uint256 _amount) external;

    /// @notice Issues tokens during the migration process.
    /// @dev This function will be only callable by a migration manager contract(burning GET and minting OPN) that will be responsible for minting tokens during the migration process. After the migration the DAO can revoke the minting rights of the migration manager.
    /// @param _to Address to which tokens will be minted.
    /// @param _amount Amount of tokens to mint.
    function issueTokensMigration(address _to, uint256 _amount) external;

    /// @notice Mints tokens for Polygon inventory.
    /// @dev As to allow GET to be migrated on Polygon this function will be used to mint a certain amount of tokens to the Polygon inventory. This is not inflationary as the tokens are already minted on Ethereum and are just being moved to Polygon.
    /// @param _to Address to which tokens will be minted.
    /// @param _amount Amount of tokens to mint.
    function mintTokenPolygonInventory(address _to, uint256 _amount) external;

    /// @notice Allows token holders to burn their tokens.
    /// @param _amount Amount of tokens to burn.
    function burn(uint256 _amount) external;

    /// @notice Finalizes the migration process
    /// @dev this function disables the migration minting and revokes the minting rights of the migration manager. This function can only be called by the DAO.
    function finalizeMigration() external;

    /// @notice Sets a new DAO controller address
    /// @param _newDaoController The address of the new DAO controller.
    function setDAOControllerAddress(address _newDaoController) external;

    /// @notice Sets a new mint manager address
    /// @param _newMigrationManager The address of the new mint manager.
    function setMintManager(address _newMigrationManager) external;

    // View functions

    /// @notice Returns the address of the mint manager.
    /// @return address of the mint manager.
    function mintManagerAddress() external view returns (address);

    /// @notice Returns the address of the DAO controller.
    /// @return address of the DAO controller.
    function daoControllerAddress() external view returns (address);

    /// @notice Returns whether the migration issuance is disabled permanently
    function migrationIssuanceDisabledPermanently()
        external
        view
        returns (bool);

    // Events

    event TokensBurned(address indexed from, uint256 amount);

    event MigrationInventoryMint(address indexed to, uint256 amount);

    event MigrationManagerSet(address indexed newMigrationManager);

    event MigrationMint(address indexed to, uint256 amount);

    event DaoMint(address indexed to, uint256 amount);

    event DaoControllerSet(address _newDaoController);

    event MigrationConfigFinalized();
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;

import {ERC20} from "erc20/ERC20.sol";
import {IOPNToken} from "./interfaces/IOPNToken.sol";

/// @title OPNToken
/// @author The OPN Ecosystem Team
contract OPNToken is IOPNToken, ERC20 {
    string public constant NAME = "Open Ecosystem Token";
    string public constant SYMBOL = "OPN";
    uint8 public constant DECIMALS = 18;

    /// @inheritdoc IOPNToken
    address public override mintManagerAddress;

    /// @inheritdoc IOPNToken
    address public override daoControllerAddress;

    /// @inheritdoc IOPNToken
    bool public override migrationIssuanceDisabledPermanently = false;

    constructor(address _initialController) ERC20(NAME, SYMBOL, DECIMALS) {
        daoControllerAddress = _initialController;
        // mint 2 tokens for bridge registrations and testing post migration
        _mint(msg.sender, 2 * 1e18);
    }

    // Modifiers

    modifier onlyMintManager() {
        require(
            msg.sender == mintManagerAddress,
            "OPNToken: UNAUTHORIZED MINT MANAGER"
        );
        _;
    }

    modifier onlyDAOController() {
        require(
            msg.sender == daoControllerAddress,
            "OPNToken: UNAUTHORIZED DAO CONTROLLER"
        );
        _;
    }

    // Operational functions for migration

    /// @inheritdoc IOPNToken
    function issueTokensMigration(
        address _to,
        uint256 _amount
    ) external override onlyMintManager {
        require(
            !migrationIssuanceDisabledPermanently,
            "OPNToken: MIGRATION MINTING DISABLED PERMANENTLY"
        );
        _mint(_to, _amount);
        emit MigrationMint(_to, _amount);
    }

    /// @inheritdoc IOPNToken
    function mintTokenPolygonInventory(
        address _to,
        uint256 _amount
    ) external override onlyDAOController {
        require(
            !migrationIssuanceDisabledPermanently,
            "OPNToken: MIGRATION MINTING DISABLED PERMANENTLY"
        );
        _mint(_to, _amount);
        emit MigrationInventoryMint(_to, _amount);
    }

    // Operational functions for DAO post operations

    /// @inheritdoc IOPNToken
    function mintTokensByDAO(
        address _to,
        uint256 _amount
    ) external override onlyDAOController {
        _mint(_to, _amount);
        emit DaoMint(_to, _amount);
    }

    // Operational functions for token holders

    /// @inheritdoc IOPNToken
    function burn(uint256 _amount) external override {
        _burn(msg.sender, _amount);
        emit TokensBurned(msg.sender, _amount);
    }

    // Configuration functions

    /// @inheritdoc IOPNToken
    function setDAOControllerAddress(
        address _newDaoController
    ) external override onlyDAOController {
        daoControllerAddress = _newDaoController;
        emit DaoControllerSet(_newDaoController);
    }

    /// @inheritdoc IOPNToken
    function finalizeMigration() external override onlyDAOController {
        migrationIssuanceDisabledPermanently = true;
        delete mintManagerAddress;
        emit MigrationConfigFinalized();
    }

    /// @inheritdoc IOPNToken
    function setMintManager(
        address _newMigrationManager
    ) external override onlyDAOController {
        require(
            !migrationIssuanceDisabledPermanently,
            "OPNToken: MIGRATION MINTING DISABLED PERMANENTLY"
        );
        mintManagerAddress = _newMigrationManager;
        emit MigrationManagerSet(_newMigrationManager);
    }
}

{
  "compilationTarget": {
    "src/migration/OPNToken.sol": "OPNToken"
  },
  "evmVersion": "london",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": [
    ":@solmate/src/=lib/solmate/src/",
    ":contract-test-utils/=lib/erc20-helper/lib/contract-test-utils/contracts/",
    ":ds-test/=lib/forge-std/lib/ds-test/src/",
    ":erc20-helper/=lib/erc20-helper/src/",
    ":erc20/=lib/erc20/contracts/",
    ":forge-std/=lib/forge-std/src/",
    ":revenue-distribution-token/=lib/revenue-distribution-token/contracts/",
    ":solmate/=lib/solmate/src/"
  ]
}