Merge branch 'develop' into eltociear-patch-1

bedrock-devnet/devnet/__init__.py

@@ -72,30 +72,28 @@ def main():
 
 
 def deploy_contracts(paths):
-    def internal():
-        wait_up(8545)
-        wait_for_rpc_server('127.0.0.1:8545')
-        res = eth_accounts('127.0.0.1:8545')
+    wait_up(8545)
+    wait_for_rpc_server('127.0.0.1:8545')
+    res = eth_accounts('127.0.0.1:8545')
 
-        response = json.loads(res)
-        account = response['result'][0]
+    response = json.loads(res)
+    account = response['result'][0]
 
-        fqn = 'scripts/Deploy.s.sol:Deploy'
-        run_command([
-            'forge', 'script', fqn, '--sender', account,
-            '--rpc-url', 'http://127.0.0.1:8545', '--broadcast',
-            '--unlocked'
-        ], env={}, cwd=paths.contracts_bedrock_dir)
+    fqn = 'scripts/Deploy.s.sol:Deploy'
+    run_command([
+        'forge', 'script', fqn, '--sender', account,
+        '--rpc-url', 'http://127.0.0.1:8545', '--broadcast',
+        '--unlocked'
+    ], env={}, cwd=paths.contracts_bedrock_dir)
 
-        shutil.copy(paths.l1_deployments_path, paths.addresses_json_path)
+    shutil.copy(paths.l1_deployments_path, paths.addresses_json_path)
 
-        log.info('Syncing contracts.')
-        run_command([
-            'forge', 'script', fqn, '--sig', 'sync()',
-            '--rpc-url', 'http://127.0.0.1:8545'
-        ], env={}, cwd=paths.contracts_bedrock_dir)
+    log.info('Syncing contracts.')
+    run_command([
+        'forge', 'script', fqn, '--sig', 'sync()',
+        '--rpc-url', 'http://127.0.0.1:8545'
+    ], env={}, cwd=paths.contracts_bedrock_dir)
 
-    return internal
 
 
 def devnet_l1_genesis(paths):
@@ -105,7 +103,7 @@ def devnet_l1_genesis(paths):
         '--verbosity', '4', '--gcmode', 'archive', '--dev.gaslimit', '30000000'
     ])
 
-    forge = multiprocessing.Process(target=deploy_contracts(paths))
+    forge = multiprocessing.Process(target=deploy_contracts, args=(paths,))
     forge.start()
     forge.join()
 

indexer/integration_tests/bedrock_test.go

@@ -22,6 +22,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
 	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
 	op_e2e "github.com/ethereum-optimism/optimism/op-e2e"
+	"github.com/ethereum-optimism/optimism/op-e2e/config"
 	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils"
 	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
 	"github.com/ethereum-optimism/optimism/op-node/withdrawals"
@@ -208,7 +209,7 @@ func TestBedrockIndexer(t *testing.T) {
 		require.Nil(t, wd.BedrockFinalizedTxHash)
 
 		// Finalize withdrawal
-		err = withdrawals.WaitForFinalizationPeriod(e2eutils.TimeoutCtx(t, 30*time.Second), l1Client, cfg.L1Deployments.OptimismPortalProxy, proveReceipt.BlockNumber)
+		err = withdrawals.WaitForFinalizationPeriod(e2eutils.TimeoutCtx(t, 30*time.Second), l1Client, proveReceipt.BlockNumber, config.L1Deployments.L2OutputOracleProxy)
 		require.Nil(t, err)
 		finReceipt := op_e2e.FinalizeWithdrawal(t, cfg, l1Client, cfg.Secrets.Alice, wdReceipt, wdParams)
 

op-e2e/system_tob_test.go

@@ -676,7 +676,7 @@ func TestMixedWithdrawalValidity(t *testing.T) {
 				// Wait for finalization and then create the Finalized Withdrawal Transaction
 				ctx, cancel = context.WithTimeout(context.Background(), 45*time.Duration(cfg.DeployConfig.L1BlockTime)*time.Second)
 				defer cancel()
-				err = withdrawals.WaitForFinalizationPeriod(ctx, l1Client, cfg.L1Deployments.OptimismPortalProxy, header.Number)
+				err = withdrawals.WaitForFinalizationPeriod(ctx, l1Client, header.Number, cfg.L1Deployments.L2OutputOracleProxy)
 				require.Nil(t, err)
 
 				// Finalize withdrawal

op-e2e/withdrawal_helper.go

@@ -145,7 +145,7 @@ func FinalizeWithdrawal(t *testing.T, cfg SystemConfig, l1Client *ethclient.Clie
 	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Duration(cfg.DeployConfig.L1BlockTime)*time.Second)
 	defer cancel()
 
-	err := withdrawals.WaitForFinalizationPeriod(ctx, l1Client, config.L1Deployments.OptimismPortalProxy, withdrawalProofReceipt.BlockNumber)
+	err := withdrawals.WaitForFinalizationPeriod(ctx, l1Client, withdrawalProofReceipt.BlockNumber, config.L1Deployments.L2OutputOracleProxy)
 	require.Nil(t, err)
 
 	opts, err := bind.NewKeyedTransactorWithChainID(privKey, cfg.L1ChainIDBig())

op-node/withdrawals/utils.go

@@ -36,7 +36,7 @@ func WaitForOutputRootPublished(ctx context.Context, client *ethclient.Client, l
 	}
 
 	getL2BlockFromLatestOutput := func() (*big.Int, error) { return l2OO.LatestBlockNumber(opts) }
-	outputBlockNum, err := utils.WaitAndGet[*big.Int](ctx, time.Second, getL2BlockFromLatestOutput, func(latest *big.Int) bool {
+	outputBlockNum, err := utils.WaitAndGet(ctx, time.Second, getL2BlockFromLatestOutput, func(latest *big.Int) bool {
 		return latest.Cmp(l2BlockNumber) >= 0
 	})
 	if err != nil {
@@ -48,12 +48,12 @@ func WaitForOutputRootPublished(ctx context.Context, client *ethclient.Client, l
 // WaitForFinalizationPeriod waits until the L1 chain has progressed far enough that l1ProvingBlockNum has completed
 // the finalization period.
 // This functions polls and can block for a very long time if used on mainnet.
-func WaitForFinalizationPeriod(ctx context.Context, client *ethclient.Client, portalAddr common.Address, l1ProvingBlockNum *big.Int) error {
+func WaitForFinalizationPeriod(ctx context.Context, client *ethclient.Client, l1ProvingBlockNum *big.Int, l2OutputOracleAddr common.Address) error {
 	l1ProvingBlockNum = new(big.Int).Set(l1ProvingBlockNum) // Don't clobber caller owned l1ProvingBlockNum
 	opts := &bind.CallOpts{Context: ctx}
 
 	// Load finalization period
-	l2OO, err := createL2OOCaller(ctx, client, portalAddr)
+	l2OO, err := bindings.NewL2OutputOracleCaller(l2OutputOracleAddr, client)
 	if err != nil {
 		return fmt.Errorf("create L2OOCaller: %w", err)
 	}
@@ -81,18 +81,6 @@ func WaitForFinalizationPeriod(ctx context.Context, client *ethclient.Client, po
 	})
 }
 
-func createL2OOCaller(ctx context.Context, client *ethclient.Client, portalAddr common.Address) (*bindings.L2OutputOracleCaller, error) {
-	portal, err := bindings.NewOptimismPortalCaller(portalAddr, client)
-	if err != nil {
-		return nil, fmt.Errorf("create OptimismPortalCaller: %w", err)
-	}
-	l2OOAddress, err := portal.L2ORACLE(&bind.CallOpts{Context: ctx})
-	if err != nil {
-		return nil, fmt.Errorf("create L2ORACLE: %w", err)
-	}
-	return bindings.NewL2OutputOracleCaller(l2OOAddress, client)
-}
-
 type ProofClient interface {
 	GetProof(context.Context, common.Address, []string, *big.Int) (*gethclient.AccountResult, error)
 }

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

@@ -109,6 +109,14 @@ contract Deploy is Deployer {
         vm.stopBroadcast();
     }
 
+    /// @notice Modifier that will only allow a function to be called on devnet.
+    modifier onlyDevnet() {
+        uint256 chainid = block.chainid;
+        if (chainid == Chains.LocalDevnet || chainid == Chains.GethDevnet) {
+            _;
+        }
+    }
+
     /// @notice Deploy the AddressManager
     function deployAddressManager() broadcast() public returns (address) {
         AddressManager manager = new AddressManager();
@@ -250,22 +258,19 @@ contract Deploy is Deployer {
     }
 
     /// @notice Deploy the DisputeGameFactoryProxy
-    function deployDisputeGameFactoryProxy() broadcast() public returns (address) {
-        if (block.chainid == Chains.LocalDevnet || block.chainid == Chains.GethDevnet) {
-            address proxyAdmin = mustGetAddress("ProxyAdmin");
-            Proxy proxy = new Proxy({
-                _admin: proxyAdmin
-            });
+    function deployDisputeGameFactoryProxy() onlyDevnet broadcast() public returns (address) {
+        address proxyAdmin = mustGetAddress("ProxyAdmin");
+        Proxy proxy = new Proxy({
+            _admin: proxyAdmin
+        });
 
-            address admin = address(uint160(uint256(vm.load(address(proxy), OWNER_KEY))));
-            require(admin == proxyAdmin);
+        address admin = address(uint160(uint256(vm.load(address(proxy), OWNER_KEY))));
+        require(admin == proxyAdmin);
 
-            save("DisputeGameFactoryProxy", address(proxy));
-            console.log("DisputeGameFactoryProxy deployed at %s", address(proxy));
+        save("DisputeGameFactoryProxy", address(proxy));
+        console.log("DisputeGameFactoryProxy deployed at %s", address(proxy));
 
-            return address(proxy);
-        }
-        return address(0);
+        return address(proxy);
     }
 
     /// @notice Deploy the L1CrossDomainMessenger
@@ -351,39 +356,30 @@ contract Deploy is Deployer {
     }
 
     /// @notice Deploy the DisputeGameFactory
-    function deployDisputeGameFactory() broadcast() public returns (address) {
-        if (block.chainid == Chains.LocalDevnet || block.chainid == Chains.GethDevnet) {
-            DisputeGameFactory factory = new DisputeGameFactory();
-            save("DisputeGameFactory", address(factory));
-            console.log("DisputeGameFactory deployed at %s", address(factory));
+    function deployDisputeGameFactory() onlyDevnet broadcast() public returns (address) {
+        DisputeGameFactory factory = new DisputeGameFactory();
+        save("DisputeGameFactory", address(factory));
+        console.log("DisputeGameFactory deployed at %s", address(factory));
 
-            return address(factory);
-        }
-        return address(0);
+        return address(factory);
     }
 
     /// @notice Deploy the PreimageOracle
-    function deployPreimageOracle() broadcast() public returns (address) {
-        if (block.chainid == 900) {
-            PreimageOracle preimageOracle = new PreimageOracle();
-            save("PreimageOracle", address(preimageOracle));
-            console.log("PreimageOracle deployed at %s", address(preimageOracle));
+    function deployPreimageOracle() onlyDevnet broadcast() public returns (address) {
+        PreimageOracle preimageOracle = new PreimageOracle();
+        save("PreimageOracle", address(preimageOracle));
+        console.log("PreimageOracle deployed at %s", address(preimageOracle));
 
-            return address(preimageOracle);
-        }
-        return address(0);
+        return address(preimageOracle);
     }
 
     /// @notice Deploy Mips
-    function deployMips() broadcast() public returns (address) {
-        if (block.chainid == 900) {
-            MIPS mips = new MIPS();
-            save("Mips", address(mips));
-            console.log("Mips deployed at %s", address(mips));
+    function deployMips() onlyDevnet broadcast() public returns (address) {
+        MIPS mips = new MIPS();
+        save("Mips", address(mips));
+        console.log("MIPS deployed at %s", address(mips));
 
-            return address(mips);
-        }
-        return address(0);
+        return address(mips);
     }
 
     /// @notice Deploy the SystemConfig
@@ -470,24 +466,22 @@ contract Deploy is Deployer {
     }
 
     /// @notice Initialize the DisputeGameFactory
-    function initializeDisputeGameFactory() broadcast() public {
-        if (block.chainid == Chains.LocalDevnet || block.chainid == Chains.GethDevnet) {
-            ProxyAdmin proxyAdmin = ProxyAdmin(mustGetAddress("ProxyAdmin"));
-            address disputeGameFactoryProxy = mustGetAddress("DisputeGameFactoryProxy");
-            address disputeGameFactory = mustGetAddress("DisputeGameFactory");
-
-            proxyAdmin.upgradeAndCall({
-                _proxy: payable(disputeGameFactoryProxy),
-                _implementation: disputeGameFactory,
-                _data: abi.encodeCall(
-                    DisputeGameFactory.initialize,
-                    (msg.sender)
-                )
-            });
+    function initializeDisputeGameFactory() onlyDevnet broadcast() public {
+        ProxyAdmin proxyAdmin = ProxyAdmin(mustGetAddress("ProxyAdmin"));
+        address disputeGameFactoryProxy = mustGetAddress("DisputeGameFactoryProxy");
+        address disputeGameFactory = mustGetAddress("DisputeGameFactory");
 
-            string memory version = DisputeGameFactory(disputeGameFactoryProxy).version();
-            console.log("DisputeGameFactory version: %s", version);
-        }
+        proxyAdmin.upgradeAndCall({
+            _proxy: payable(disputeGameFactoryProxy),
+            _implementation: disputeGameFactory,
+            _data: abi.encodeCall(
+                DisputeGameFactory.initialize,
+                (msg.sender)
+            )
+        });
+
+        string memory version = DisputeGameFactory(disputeGameFactoryProxy).version();
+        console.log("DisputeGameFactory version: %s", version);
     }
 
     /// @notice Initialize the SystemConfig
@@ -704,34 +698,30 @@ contract Deploy is Deployer {
     }
 
     /// @notice Transfer ownership of the DisputeGameFactory contract to the final system owner
-    function transferDisputeGameFactoryOwnership() broadcast() public {
-        if (block.chainid == Chains.LocalDevnet || block.chainid == Chains.GethDevnet) {
-            DisputeGameFactory disputeGameFactory = DisputeGameFactory(mustGetAddress("DisputeGameFactoryProxy"));
-            address owner = disputeGameFactory.owner();
-            address finalSystemOwner = cfg.finalSystemOwner();
-            if (owner != finalSystemOwner) {
-                disputeGameFactory.transferOwnership(finalSystemOwner);
-                console.log("DisputeGameFactory ownership transferred to: %s", finalSystemOwner);
-            }
+    function transferDisputeGameFactoryOwnership() onlyDevnet broadcast() public {
+        DisputeGameFactory disputeGameFactory = DisputeGameFactory(mustGetAddress("DisputeGameFactoryProxy"));
+        address owner = disputeGameFactory.owner();
+        address finalSystemOwner = cfg.finalSystemOwner();
+        if (owner != finalSystemOwner) {
+            disputeGameFactory.transferOwnership(finalSystemOwner);
+            console.log("DisputeGameFactory ownership transferred to: %s", finalSystemOwner);
         }
     }
 
     /// @notice Sets the implementation for the `FAULT` game type in the `DisputeGameFactory`
-    function setFaultGameImplementation() broadcast() public {
-        if (block.chainid == Chains.LocalDevnet || block.chainid == Chains.GethDevnet) {
-            DisputeGameFactory factory = DisputeGameFactory(mustGetAddress("DisputeGameFactoryProxy"));
-            Claim absolutePrestate = Claim.wrap(bytes32(cfg.faultGameAbsolutePrestate()));
-            IBigStepper faultVm = IBigStepper(new AlphabetVM(absolutePrestate));
-            if (address(factory.gameImpls(GameTypes.FAULT)) == address(0)) {
-                factory.setImplementation(GameTypes.FAULT, new FaultDisputeGame({
-                    _absolutePrestate: absolutePrestate,
-                    _maxGameDepth: cfg.faultGameMaxDepth(),
-                    _gameDuration: Duration.wrap(uint64(cfg.faultGameMaxDuration())),
-                    _vm: faultVm,
-                    _l2oo: L2OutputOracle(mustGetAddress("L2OutputOracleProxy"))
-                }));
-                console.log("DisputeGameFactory: set `FaultDisputeGame` implementation");
-            }
+    function setFaultGameImplementation() onlyDevnet broadcast() public {
+        DisputeGameFactory factory = DisputeGameFactory(mustGetAddress("DisputeGameFactoryProxy"));
+        Claim absolutePrestate = Claim.wrap(bytes32(cfg.faultGameAbsolutePrestate()));
+        IBigStepper faultVm = IBigStepper(new AlphabetVM(absolutePrestate));
+        if (address(factory.gameImpls(GameTypes.FAULT)) == address(0)) {
+            factory.setImplementation(GameTypes.FAULT, new FaultDisputeGame({
+                _absolutePrestate: absolutePrestate,
+                _maxGameDepth: cfg.faultGameMaxDepth(),
+                _gameDuration: Duration.wrap(uint64(cfg.faultGameMaxDuration())),
+                _vm: faultVm,
+                _l2oo: L2OutputOracle(mustGetAddress("L2OutputOracleProxy"))
+            }));
+            console.log("DisputeGameFactory: set `FaultDisputeGame` implementation");
         }
     }
 }