github.com/ethereum-optimism/optimism@v1.7.2/packages/contracts-bedrock/test/L1/ProtocolVersions.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  import { EIP1967Helper } from "test/mocks/EIP1967Helper.sol";
     7  
     8  // Libraries
     9  import { Constants } from "src/libraries/Constants.sol";
    10  
    11  // Target contract dependencies
    12  import { Proxy } from "src/universal/Proxy.sol";
    13  
    14  // Target contract
    15  import { ProtocolVersions, ProtocolVersion } from "src/L1/ProtocolVersions.sol";
    16  
    17  contract ProtocolVersions_Init is CommonTest {
    18      event ConfigUpdate(uint256 indexed version, ProtocolVersions.UpdateType indexed updateType, bytes data);
    19  
    20      ProtocolVersion required;
    21      ProtocolVersion recommended;
    22  
    23      function setUp() public virtual override {
    24          super.setUp();
    25          required = ProtocolVersion.wrap(deploy.cfg().requiredProtocolVersion());
    26          recommended = ProtocolVersion.wrap(deploy.cfg().recommendedProtocolVersion());
    27      }
    28  }
    29  
    30  contract ProtocolVersions_Initialize_Test is ProtocolVersions_Init {
    31      /// @dev Tests that initialization sets the correct values.
    32      function test_initialize_values_succeeds() external {
    33          ProtocolVersions protocolVersionsImpl = ProtocolVersions(deploy.mustGetAddress("ProtocolVersions"));
    34          address owner = deploy.cfg().finalSystemOwner();
    35  
    36          assertEq(ProtocolVersion.unwrap(protocolVersions.required()), ProtocolVersion.unwrap(required));
    37          assertEq(ProtocolVersion.unwrap(protocolVersions.recommended()), ProtocolVersion.unwrap(recommended));
    38          assertEq(protocolVersions.owner(), owner);
    39  
    40          assertEq(ProtocolVersion.unwrap(protocolVersionsImpl.required()), 0);
    41          assertEq(ProtocolVersion.unwrap(protocolVersionsImpl.recommended()), 0);
    42          assertEq(protocolVersionsImpl.owner(), address(0xdEad));
    43      }
    44  
    45      /// @dev Ensures that the events are emitted during initialization.
    46      function test_initialize_events_succeeds() external {
    47          ProtocolVersions protocolVersionsImpl = ProtocolVersions(deploy.mustGetAddress("ProtocolVersions"));
    48          assertEq(protocolVersionsImpl.owner(), address(0xdEad));
    49  
    50          // Wipe out the initialized slot so the proxy can be initialized again
    51          vm.store(address(protocolVersions), bytes32(0), bytes32(0));
    52  
    53          // The order depends here
    54          vm.expectEmit(true, true, true, true, address(protocolVersions));
    55          emit ConfigUpdate(0, ProtocolVersions.UpdateType.REQUIRED_PROTOCOL_VERSION, abi.encode(required));
    56          vm.expectEmit(true, true, true, true, address(protocolVersions));
    57          emit ConfigUpdate(0, ProtocolVersions.UpdateType.RECOMMENDED_PROTOCOL_VERSION, abi.encode(recommended));
    58  
    59          vm.prank(EIP1967Helper.getAdmin(address(protocolVersions)));
    60          Proxy(payable(address(protocolVersions))).upgradeToAndCall(
    61              address(protocolVersionsImpl),
    62              abi.encodeCall(
    63                  ProtocolVersions.initialize,
    64                  (
    65                      alice, // _owner
    66                      required, // _required
    67                      recommended // recommended
    68                  )
    69              )
    70          );
    71      }
    72  }
    73  
    74  contract ProtocolVersions_Setters_TestFail is ProtocolVersions_Init {
    75      /// @dev Tests that `setRequired` reverts if the caller is not the owner.
    76      function test_setRequired_notOwner_reverts() external {
    77          vm.expectRevert("Ownable: caller is not the owner");
    78          protocolVersions.setRequired(ProtocolVersion.wrap(0));
    79      }
    80  
    81      /// @dev Tests that `setRecommended` reverts if the caller is not the owner.
    82      function test_setRecommended_notOwner_reverts() external {
    83          vm.expectRevert("Ownable: caller is not the owner");
    84          protocolVersions.setRecommended(ProtocolVersion.wrap(0));
    85      }
    86  }
    87  
    88  contract ProtocolVersions_Setters_Test is ProtocolVersions_Init {
    89      /// @dev Tests that `setRequired` updates the required protocol version successfully.
    90      function testFuzz_setRequired_succeeds(uint256 _version) external {
    91          vm.expectEmit(true, true, true, true);
    92          emit ConfigUpdate(0, ProtocolVersions.UpdateType.REQUIRED_PROTOCOL_VERSION, abi.encode(_version));
    93  
    94          vm.prank(protocolVersions.owner());
    95          protocolVersions.setRequired(ProtocolVersion.wrap(_version));
    96          assertEq(ProtocolVersion.unwrap(protocolVersions.required()), _version);
    97      }
    98  
    99      /// @dev Tests that `setRecommended` updates the recommended protocol version successfully.
   100      function testFuzz_setRecommended_succeeds(uint256 _version) external {
   101          vm.expectEmit(true, true, true, true);
   102          emit ConfigUpdate(0, ProtocolVersions.UpdateType.RECOMMENDED_PROTOCOL_VERSION, abi.encode(_version));
   103  
   104          vm.prank(protocolVersions.owner());
   105          protocolVersions.setRecommended(ProtocolVersion.wrap(_version));
   106          assertEq(ProtocolVersion.unwrap(protocolVersions.recommended()), _version);
   107      }
   108  }