fix(ctb): Correctly set values in constructors.

packages/contracts-bedrock/scripts/ChainAssertions.sol

@@ -17,6 +17,7 @@ import { Predeploys } from "src/libraries/Predeploys.sol";
 import { Types } from "scripts/Types.sol";
 import { Vm } from "forge-std/Vm.sol";
 import { ISystemConfigV0 } from "scripts/interfaces/ISystemConfigV0.sol";
+import { console2 as console } from "forge-std/console2.sol";
 
 library ChainAssertions {
     /// @notice Asserts the correctness of an L1 deployment
@@ -125,9 +126,18 @@ library ChainAssertions {
     /// @notice Asserts the OptimismPortal is setup correctly
     function checkOptimismPortal(Types.ContractSet memory proxies, DeployConfig cfg) internal view {
         OptimismPortal portal = OptimismPortal(payable(proxies.OptimismPortal));
+
+        address guardian = cfg.portalGuardian();
+        if (guardian.code.length == 0) {
+            console.log("Portal guardian has no code: %s", guardian);
+        }
+
         require(address(portal.L2_ORACLE()) == proxies.L2OutputOracle);
+        require(address(portal.l2Oracle()) == proxies.L2OutputOracle);
         require(portal.GUARDIAN() == cfg.portalGuardian());
+        require(portal.guardian() == cfg.portalGuardian());
         require(address(portal.SYSTEM_CONFIG()) == proxies.SystemConfig);
+        require(address(portal.systemConfig()) == proxies.SystemConfig);
         require(portal.paused() == false);
     }
 

packages/contracts-bedrock/scripts/Deploy.s.sol

@@ -389,24 +389,27 @@ contract Deploy is Deployer {
 
     /// @notice Deploy the OptimismPortal
     function deployOptimismPortal() public broadcast returns (address addr_) {
-        address l2OutputOracleProxy = mustGetAddress("L2OutputOracleProxy");
-        address systemConfigProxy = mustGetAddress("SystemConfigProxy");
-
         address guardian = cfg.portalGuardian();
         if (guardian.code.length == 0) {
             console.log("Portal guardian has no code: %s", guardian);
         }
 
+        L2OutputOracle l2OutputOracle = L2OutputOracle(mustGetAddress("L2OutputOracleProxy"));
+        SystemConfig systemConfig = SystemConfig(mustGetAddress("SystemConfigProxy"));
+
         OptimismPortal portal = new OptimismPortal{ salt: implSalt() }({
-            _l2Oracle: L2OutputOracle(l2OutputOracleProxy),
+            _l2Oracle: l2OutputOracle,
             _guardian: guardian,
             _paused: true,
-            _config: SystemConfig(systemConfigProxy)
+            _config: systemConfig
         });
 
-        require(address(portal.L2_ORACLE()) == l2OutputOracleProxy);
+        require(address(portal.L2_ORACLE()) == address(l2OutputOracle));
+        require(address(portal.l2Oracle()) == address(l2OutputOracle));
         require(portal.GUARDIAN() == guardian);
-        require(address(portal.SYSTEM_CONFIG()) == systemConfigProxy);
+        require(portal.guardian() == guardian);
+        require(address(portal.SYSTEM_CONFIG()) == address(systemConfig));
+        require(address(portal.systemConfig()) == address(systemConfig));
         require(portal.paused() == true);
 
         save("OptimismPortal", address(portal));
@@ -420,20 +423,25 @@ contract Deploy is Deployer {
         L2OutputOracle oracle = new L2OutputOracle{ salt: implSalt() }({
             _submissionInterval: cfg.l2OutputOracleSubmissionInterval(),
             _l2BlockTime: cfg.l2BlockTime(),
-            _startingBlockNumber: cfg.l2OutputOracleStartingBlockNumber(),
-            _startingTimestamp: cfg.l2OutputOracleStartingTimestamp(),
+            _startingBlockNumber: 0,
+            _startingTimestamp: 0,
             _proposer: cfg.l2OutputOracleProposer(),
             _challenger: cfg.l2OutputOracleChallenger(),
             _finalizationPeriodSeconds: cfg.finalizationPeriodSeconds()
         });
 
         require(oracle.SUBMISSION_INTERVAL() == cfg.l2OutputOracleSubmissionInterval());
+        require(oracle.submissionInterval() == cfg.l2OutputOracleSubmissionInterval());
         require(oracle.L2_BLOCK_TIME() == cfg.l2BlockTime());
+        require(oracle.l2BlockTime() == cfg.l2BlockTime());
         require(oracle.PROPOSER() == cfg.l2OutputOracleProposer());
+        require(oracle.proposer() == cfg.l2OutputOracleProposer());
         require(oracle.CHALLENGER() == cfg.l2OutputOracleChallenger());
+        require(oracle.challenger() == cfg.l2OutputOracleChallenger());
         require(oracle.FINALIZATION_PERIOD_SECONDS() == cfg.finalizationPeriodSeconds());
-        require(oracle.startingBlockNumber() == cfg.l2OutputOracleStartingBlockNumber());
-        require(oracle.startingTimestamp() == cfg.l2OutputOracleStartingTimestamp());
+        require(oracle.finalizationPeriodSeconds() == cfg.finalizationPeriodSeconds());
+        require(oracle.startingBlockNumber() == 0);
+        require(oracle.startingTimestamp() == 0);
 
         save("L2OutputOracle", address(oracle));
         console.log("L2OutputOracle deployed at %s", address(oracle));
@@ -503,32 +511,32 @@ contract Deploy is Deployer {
 
     /// @notice Deploy the SystemConfig
     function deploySystemConfig() public broadcast returns (address addr_) {
-        bytes32 batcherHash = bytes32(uint256(uint160(cfg.batchSenderAddress())));
-
+        ResourceMetering.ResourceConfig memory defaultConfig = Constants.DEFAULT_RESOURCE_CONFIG();
+        uint64 minimumGasLimit = uint64(defaultConfig.maxResourceLimit) + uint64(defaultConfig.systemTxMaxGas);
         SystemConfig config = new SystemConfig({
-            _owner: cfg.finalSystemOwner(),
-            _overhead: cfg.gasPriceOracleOverhead(),
-            _scalar: cfg.gasPriceOracleScalar(),
-            _batcherHash: batcherHash,
-            _gasLimit: uint64(cfg.l2GenesisBlockGasLimit()),
-            _unsafeBlockSigner: cfg.p2pSequencerAddress(),
-            _config: Constants.DEFAULT_RESOURCE_CONFIG()
+            _owner: address(0xdEaD),
+            _overhead: 0,
+            _scalar: 0,
+            _batcherHash: bytes32(0),
+            _gasLimit: minimumGasLimit,
+            _unsafeBlockSigner: address(0),
+            _config: defaultConfig
         });
 
-        require(config.owner() == cfg.finalSystemOwner());
-        require(config.overhead() == cfg.gasPriceOracleOverhead());
-        require(config.scalar() == cfg.gasPriceOracleScalar());
-        require(config.unsafeBlockSigner() == cfg.p2pSequencerAddress());
-        require(config.batcherHash() == batcherHash);
+        require(config.owner() == address(0xdEaD));
+        require(config.overhead() == 0);
+        require(config.scalar() == 0);
+        require(config.unsafeBlockSigner() == address(0));
+        require(config.batcherHash() == bytes32(0));
+        require(config.gasLimit() == minimumGasLimit);
 
-        ResourceMetering.ResourceConfig memory rconfig = Constants.DEFAULT_RESOURCE_CONFIG();
         ResourceMetering.ResourceConfig memory resourceConfig = config.resourceConfig();
-        require(resourceConfig.maxResourceLimit == rconfig.maxResourceLimit);
-        require(resourceConfig.elasticityMultiplier == rconfig.elasticityMultiplier);
-        require(resourceConfig.baseFeeMaxChangeDenominator == rconfig.baseFeeMaxChangeDenominator);
-        require(resourceConfig.systemTxMaxGas == rconfig.systemTxMaxGas);
-        require(resourceConfig.minimumBaseFee == rconfig.minimumBaseFee);
-        require(resourceConfig.maximumBaseFee == rconfig.maximumBaseFee);
+        require(resourceConfig.maxResourceLimit == defaultConfig.maxResourceLimit);
+        require(resourceConfig.elasticityMultiplier == defaultConfig.elasticityMultiplier);
+        require(resourceConfig.baseFeeMaxChangeDenominator == defaultConfig.baseFeeMaxChangeDenominator);
+        require(resourceConfig.systemTxMaxGas == defaultConfig.systemTxMaxGas);
+        require(resourceConfig.minimumBaseFee == defaultConfig.minimumBaseFee);
+        require(resourceConfig.maximumBaseFee == defaultConfig.maximumBaseFee);
 
         save("SystemConfig", address(config));
         console.log("SystemConfig deployed at %s", address(config));
@@ -796,11 +804,6 @@ contract Deploy is Deployer {
         address l2OutputOracleProxy = mustGetAddress("L2OutputOracleProxy");
         address systemConfigProxy = mustGetAddress("SystemConfigProxy");
 
-        address guardian = cfg.portalGuardian();
-        if (guardian.code.length == 0) {
-            console.log("Portal guardian has no code: %s", guardian);
-        }
-
         _upgradeAndCallViaSafe({
             _proxy: payable(optimismPortalProxy),
             _implementation: optimismPortal,

packages/contracts-bedrock/test/L2OutputOracle.t.sol

@@ -460,31 +460,19 @@ contract L2OutputOracleUpgradeable_Test is CommonTest {
     function test_initValuesOnImpl_succeeds() external {
         L2OutputOracle oracleImpl = L2OutputOracle(mustGetAddress("L2OutputOracle"));
 
-        address proposer = cfg.l2OutputOracleProposer();
-        address challenger = cfg.l2OutputOracleChallenger();
-        uint256 submissionInterval = cfg.l2OutputOracleSubmissionInterval();
-        uint256 startingBlockNumber = cfg.l2OutputOracleStartingBlockNumber();
-        uint256 startingTimestamp = cfg.l2OutputOracleStartingTimestamp();
-        assertEq(submissionInterval, oracleImpl.SUBMISSION_INTERVAL());
-        uint256 l2BlockTime = cfg.l2BlockTime();
-        uint256 finalizationPeriodSeconds = cfg.finalizationPeriodSeconds();
-        assertEq(l2BlockTime, oracleImpl.L2_BLOCK_TIME());
-
-        // The values that are set in the initialize function should be all
-        // zero values in the implementation contract.
-        assertEq(oracleImpl.startingBlockNumber(), startingBlockNumber);
-        assertEq(oracleImpl.startingTimestamp(), startingTimestamp);
-        assertEq(oracleImpl.SUBMISSION_INTERVAL(), submissionInterval);
-        assertEq(oracleImpl.L2_BLOCK_TIME(), l2BlockTime);
-        assertEq(oracleImpl.FINALIZATION_PERIOD_SECONDS(), finalizationPeriodSeconds);
-        assertEq(oracleImpl.PROPOSER(), proposer);
-        assertEq(oracleImpl.CHALLENGER(), challenger);
+        assertEq(oracleImpl.SUBMISSION_INTERVAL(), cfg.l2OutputOracleSubmissionInterval());
+        assertEq(oracleImpl.submissionInterval(), cfg.l2OutputOracleSubmissionInterval());
+        assertEq(oracleImpl.L2_BLOCK_TIME(), cfg.l2BlockTime());
+        assertEq(oracleImpl.l2BlockTime(), cfg.l2BlockTime());
+        assertEq(oracleImpl.FINALIZATION_PERIOD_SECONDS(), cfg.finalizationPeriodSeconds());
+        assertEq(oracleImpl.finalizationPeriodSeconds(), cfg.finalizationPeriodSeconds());
+        assertEq(oracleImpl.PROPOSER(), cfg.l2OutputOracleProposer());
+        assertEq(oracleImpl.proposer(), cfg.l2OutputOracleProposer());
+        assertEq(oracleImpl.CHALLENGER(), cfg.l2OutputOracleChallenger());
+        assertEq(oracleImpl.challenger(), cfg.l2OutputOracleChallenger());
+
         assertEq(oracleImpl.startingBlockNumber(), 0);
         assertEq(oracleImpl.startingTimestamp(), 0);
-        assertEq(oracleImpl.PROPOSER(), address(0));
-        assertEq(oracleImpl.proposer(), address(0));
-        assertEq(oracleImpl.CHALLENGER(), address(0));
-        assertEq(oracleImpl.challenger(), address(0));
     }
 
     /// @dev Tests that the proxy cannot be initialized twice.