github.com/ethereum-optimism/optimism@v1.7.2/packages/contracts-bedrock/test/governance/MintManager.t.sol (about)

     1  // SPDX-License-Identifier: MIT
     2  pragma solidity 0.8.15;
     3  
     4  // Testing utilities
     5  import { CommonTest } from "test/setup/CommonTest.sol";
     6  
     7  // Target contract dependencies
     8  import { GovernanceToken } from "src/governance/GovernanceToken.sol";
     9  
    10  // Target contract
    11  import { MintManager } from "src/governance/MintManager.sol";
    12  
    13  contract MintManager_Initializer is CommonTest {
    14      address constant owner = address(0x1234);
    15      address constant rando = address(0x5678);
    16      GovernanceToken internal gov;
    17      MintManager internal manager;
    18  
    19      /// @dev Sets up the test suite.
    20      function setUp() public virtual override {
    21          super.setUp();
    22  
    23          vm.prank(owner);
    24          gov = new GovernanceToken();
    25  
    26          vm.prank(owner);
    27          manager = new MintManager(owner, address(gov));
    28  
    29          vm.prank(owner);
    30          gov.transferOwnership(address(manager));
    31      }
    32  }
    33  
    34  contract MintManager_constructor_Test is MintManager_Initializer {
    35      /// @dev Tests that the constructor properly configures the contract.
    36      function test_constructor_succeeds() external {
    37          assertEq(manager.owner(), owner);
    38          assertEq(address(manager.governanceToken()), address(gov));
    39      }
    40  }
    41  
    42  contract MintManager_mint_Test is MintManager_Initializer {
    43      /// @dev Tests that the mint function properly mints tokens when called by the owner.
    44      function test_mint_fromOwner_succeeds() external {
    45          // Mint once.
    46          vm.prank(owner);
    47          manager.mint(owner, 100);
    48  
    49          // Token balance increases.
    50          assertEq(gov.balanceOf(owner), 100);
    51      }
    52  
    53      /// @dev Tests that the mint function reverts when called by a non-owner.
    54      function test_mint_fromNotOwner_reverts() external {
    55          // Mint from rando fails.
    56          vm.prank(rando);
    57          vm.expectRevert("Ownable: caller is not the owner");
    58          manager.mint(owner, 100);
    59      }
    60  
    61      /// @dev Tests that the mint function properly mints tokens when called by the owner a second
    62      ///      time after the mint period has elapsed.
    63      function test_mint_afterPeriodElapsed_succeeds() external {
    64          // Mint once.
    65          vm.prank(owner);
    66          manager.mint(owner, 100);
    67  
    68          // Token balance increases.
    69          assertEq(gov.balanceOf(owner), 100);
    70  
    71          // Mint again after period elapsed (2% max).
    72          vm.warp(block.timestamp + manager.MINT_PERIOD() + 1);
    73          vm.prank(owner);
    74          manager.mint(owner, 2);
    75  
    76          // Token balance increases.
    77          assertEq(gov.balanceOf(owner), 102);
    78      }
    79  
    80      /// @dev Tests that the mint function always reverts when called before the mint period has
    81      ///      elapsed, even if the caller is the owner.
    82      function test_mint_beforePeriodElapsed_reverts() external {
    83          // Mint once.
    84          vm.prank(owner);
    85          manager.mint(owner, 100);
    86  
    87          // Token balance increases.
    88          assertEq(gov.balanceOf(owner), 100);
    89  
    90          // Mint again.
    91          vm.prank(owner);
    92          vm.expectRevert("MintManager: minting not permitted yet");
    93          manager.mint(owner, 100);
    94  
    95          // Token balance does not increase.
    96          assertEq(gov.balanceOf(owner), 100);
    97      }
    98  
    99      /// @dev Tests that the owner cannot mint more than the mint cap.
   100      function test_mint_moreThanCap_reverts() external {
   101          // Mint once.
   102          vm.prank(owner);
   103          manager.mint(owner, 100);
   104  
   105          // Token balance increases.
   106          assertEq(gov.balanceOf(owner), 100);
   107  
   108          // Mint again (greater than 2% max).
   109          vm.warp(block.timestamp + manager.MINT_PERIOD() + 1);
   110          vm.prank(owner);
   111          vm.expectRevert("MintManager: mint amount exceeds cap");
   112          manager.mint(owner, 3);
   113  
   114          // Token balance does not increase.
   115          assertEq(gov.balanceOf(owner), 100);
   116      }
   117  }
   118  
   119  contract MintManager_upgrade_Test is MintManager_Initializer {
   120      /// @dev Tests that the owner can upgrade the mint manager.
   121      function test_upgrade_fromOwner_succeeds() external {
   122          // Upgrade to new manager.
   123          vm.prank(owner);
   124          manager.upgrade(rando);
   125  
   126          // New manager is rando.
   127          assertEq(gov.owner(), rando);
   128      }
   129  
   130      /// @dev Tests that the upgrade function reverts when called by a non-owner.
   131      function test_upgrade_fromNotOwner_reverts() external {
   132          // Upgrade from rando fails.
   133          vm.prank(rando);
   134          vm.expectRevert("Ownable: caller is not the owner");
   135          manager.upgrade(rando);
   136      }
   137  
   138      /// @dev Tests that the upgrade function reverts when attempting to update to the zero
   139      ///      address, even if the caller is the owner.
   140      function test_upgrade_toZeroAddress_reverts() external {
   141          // Upgrade to zero address fails.
   142          vm.prank(owner);
   143          vm.expectRevert("MintManager: mint manager cannot be the zero address");
   144          manager.upgrade(address(0));
   145      }
   146  }