remove proxyAdmin inputs from opcm and sv, derive it from the sysCfg, fix tests

op-chain-ops/interopgen/deploy.go

@@ -274,7 +274,6 @@ func MigrateInterop(
 		l2Deployment := l2Deployments[l2ChainID]
 		chainConfigs[i] = manage.OPChainConfig{
 			SystemConfigProxy: l2Deployment.SystemConfigProxy,
-			ProxyAdmin:        superDeployment.ProxyAdmin,
 			AbsolutePrestate:  l2Cfgs[l2ChainID].DisputeAbsolutePrestate,
 		}
 	}

op-deployer/pkg/deployer/integration_test/apply_test.go

@@ -37,7 +37,6 @@ import (
 	"github.com/ethereum/go-ethereum/rpc"
 
 	"github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/upgrade/embedded"
-	"github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/upgrade/v2_0_0"
 	op_e2e "github.com/ethereum-optimism/optimism/op-e2e"
 
 	"github.com/holiman/uint256"
@@ -757,13 +756,12 @@ func runEndToEndBootstrapAndApplyUpgradeTest(t *testing.T, afactsFS foundry.Stat
 
 		// Then run the OPCM upgrade
 		t.Run("upgrade opcm", func(t *testing.T) {
-			upgradeConfig := v2_0_0.UpgradeOPChainInput{
+			upgradeConfig := embedded.UpgradeOPChainInput{
 				Prank: superchainProxyAdminOwner,
 				Opcm:  impls.Opcm,
-				EncodedChainConfigs: []v2_0_0.OPChainConfig{
+				EncodedChainConfigs: []embedded.OPChainConfig{
 					{
 						SystemConfigProxy: common.HexToAddress("034edD2A225f7f429A63E0f1D2084B9E0A93b538"),
-						ProxyAdmin:        implementationsConfig.SuperchainProxyAdmin,
 						AbsolutePrestate:  common.Hash{'A', 'P'},
 					},
 				},

op-deployer/pkg/deployer/manage/add_game_type.go

@@ -35,7 +35,6 @@ type AddGameTypeConfig struct {
 	L1ProxyAdminOwner       common.Address
 	OPCMImpl                common.Address
 	SystemConfigProxy       common.Address
-	OPChainProxyAdmin       common.Address
 	DelayedWETHProxy        common.Address
 	DisputeGameType         uint32
 	DisputeAbsolutePrestate common.Hash
@@ -78,10 +77,6 @@ func (c *AddGameTypeConfig) Check() error {
 		return fmt.Errorf("systemConfigProxy address must be specified")
 	}
 
-	if c.OPChainProxyAdmin == (common.Address{}) {
-		return fmt.Errorf("opChainProxyAdmin address must be specified")
-	}
-
 	if c.DisputeAbsolutePrestate == (common.Hash{}) {
 		return fmt.Errorf("disputeAbsolutePrestate must be specified")
 	}
@@ -221,7 +216,6 @@ func populateConfigFromWorkdir(cfg *AddGameTypeConfig, cliCtx *cli.Context) erro
 	}
 	cfg.OPCMImpl = *state.AppliedIntent.OPCMAddress
 	cfg.SystemConfigProxy = chainState.SystemConfigProxy
-	cfg.OPChainProxyAdmin = chainState.OpChainProxyAdminImpl
 	cfg.VM = state.ImplementationsDeployment.MipsImpl
 	return nil
 }
@@ -234,7 +228,6 @@ func populateConfigFromFlags(cfg *AddGameTypeConfig, cliCtx *cli.Context) error
 	cfg.L1ProxyAdminOwner = common.HexToAddress(cliCtx.String(L1ProxyAdminOwnerFlag.Name))
 	cfg.OPCMImpl = common.HexToAddress(cliCtx.String(OPCMImplFlag.Name))
 	cfg.SystemConfigProxy = common.HexToAddress(cliCtx.String(SystemConfigProxyFlag.Name))
-	cfg.OPChainProxyAdmin = common.HexToAddress(cliCtx.String(OPChainProxyAdminFlag.Name))
 	cfg.VM = common.HexToAddress(cliCtx.String(VMFlag.Name))
 	return nil
 }
@@ -280,7 +273,6 @@ func AddGameType(ctx context.Context, cfg AddGameTypeConfig) (opcm.AddGameTypeOu
 		L1ProxyAdminOwner:       cfg.L1ProxyAdminOwner,
 		OPCMImpl:                cfg.OPCMImpl,
 		SystemConfigProxy:       cfg.SystemConfigProxy,
-		OPChainProxyAdmin:       cfg.OPChainProxyAdmin,
 		DelayedWETHProxy:        cfg.DelayedWETHProxy,
 		DisputeGameType:         cfg.DisputeGameType,
 		DisputeAbsolutePrestate: cfg.DisputeAbsolutePrestate,

op-deployer/pkg/deployer/manage/add_game_type_test.go

@@ -6,102 +6,93 @@ import (
 	"fmt"
 	"log/slog"
 	"math/big"
-	"os"
 	"testing"
 	"time"
 
 	"github.com/ethereum-optimism/optimism/op-service/testlog"
 	"github.com/ethereum-optimism/optimism/op-service/testutils"
-	"github.com/lmittmann/w3"
-	"github.com/lmittmann/w3/module/eth"
+	"github.com/ethereum-optimism/optimism/op-service/testutils/devnet"
 
+	"github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/bootstrap"
+	"github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/integration_test/shared"
 	"github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/standard"
-	"github.com/ethereum/go-ethereum/superchain"
 
 	"github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/testutil"
-	"github.com/ethereum-optimism/superchain-registry/validation"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/superchain"
 	"github.com/stretchr/testify/require"
 	"github.com/urfave/cli/v2"
 )
 
-// getAddressesOnchain reads addresses from on-chain contracts (using chainConfig to get entrypoints)
-func getAddressesOnchain(ctx context.Context, rpcURL string, chainConfig *superchain.ChainConfig) (opChainProxyAdmin, delayedWETHProxy common.Address, err error) {
-	var proxyAdminFn = w3.MustNewFunc("proxyAdmin()", "address")
-	var gameImplsFn = w3.MustNewFunc("gameImpls(uint32)", "address")
-	var wethFn = w3.MustNewFunc("weth()", "address")
-
-	client, err := w3.Dial(rpcURL)
-	if err != nil {
-		return common.Address{}, common.Address{}, fmt.Errorf("failed to connect to RPC: %w", err)
-	}
-	defer client.Close()
-
-	systemConfigProxy := *chainConfig.Addresses.SystemConfigProxy
-	disputeGameFactoryProxy := *chainConfig.Addresses.DisputeGameFactoryProxy
-
-	// Read OPChainProxyAdmin from systemConfigProxy.proxyAdmin()
-	err = client.CallCtx(ctx, eth.CallFunc(systemConfigProxy, proxyAdminFn).Returns(&opChainProxyAdmin))
-	if err != nil {
-		return common.Address{}, common.Address{}, fmt.Errorf("failed to read proxyAdmin from SystemConfig: %w", err)
-	}
+func TestAddGameType(t *testing.T) {
+	// Since the opcm version is not yet on sepolia, we create a fork of sepolia then deploy the opcm via deploy implementations.
+	lgr := testlog.Logger(t, slog.LevelDebug)
+	forkedL1, stopL1, err := devnet.NewForkedSepolia(lgr)
+	pkHex, _, _ := shared.DefaultPrivkey(t)
+	require.NoError(t, err)
+	t.Cleanup(func() {
+		require.NoError(t, stopL1())
+	})
 
-	// Read permissionless dispute game address from disputeGameFactoryProxy.gameImpls(0)
-	// GameTypes.CANNON = 0 (permissionless)
-	var permissionlessDisputeGame common.Address
-	err = client.CallCtx(ctx, eth.CallFunc(disputeGameFactoryProxy, gameImplsFn, uint32(0)).Returns(&permissionlessDisputeGame))
-	if err != nil {
-		return common.Address{}, common.Address{}, fmt.Errorf("failed to read gameImpls(0) from DisputeGameFactory: %w", err)
-	}
+	afacts, _ := testutil.LocalArtifacts(t)
+	ctx, cancel := context.WithTimeout(context.Background(), 90*time.Second)
+	defer cancel()
+	testCacheDir := testutils.IsolatedTestDirWithAutoCleanup(t)
 
-	// Read DelayedWETHProxy from permissionlessDisputeGame.weth()
-	err = client.CallCtx(ctx, eth.CallFunc(permissionlessDisputeGame, wethFn).Returns(&delayedWETHProxy))
-	if err != nil {
-		return common.Address{}, common.Address{}, fmt.Errorf("failed to read weth from permissionless dispute game: %w", err)
-	}
+	sChain, err := standard.SuperchainFor(11155111)
+	require.NoError(t, err)
 
-	return opChainProxyAdmin, delayedWETHProxy, nil
-}
+	superchainProxyAdmin, err := standard.SuperchainProxyAdminAddrFor(11155111)
+	require.NoError(t, err)
 
-func TestAddGameType(t *testing.T) {
-	rpcURL := os.Getenv("SEPOLIA_RPC_URL")
-	require.NotEmpty(t, rpcURL, "must specify RPC url via SEPOLIA_RPC_URL env var")
+	superchainProxyAdminOwner, err := standard.L1ProxyAdminOwner(11155111)
+	require.NoError(t, err)
 
-	afacts, _ := testutil.LocalArtifacts(t)
-	v200SepoliaAddrs := validation.StandardVersionsSepolia[standard.ContractsV200Tag]
-	testCacheDir := testutils.IsolatedTestDirWithAutoCleanup(t)
+	impls, err := bootstrap.Implementations(ctx, bootstrap.ImplementationsConfig{
+		L1RPCUrl:                        forkedL1.RPCUrl(),
+		PrivateKey:                      pkHex,
+		ArtifactsLocator:                afacts,
+		MIPSVersion:                     int(standard.MIPSVersion),
+		WithdrawalDelaySeconds:          standard.WithdrawalDelaySeconds,
+		MinProposalSizeBytes:            standard.MinProposalSizeBytes,
+		ChallengePeriodSeconds:          standard.ChallengePeriodSeconds,
+		ProofMaturityDelaySeconds:       standard.ProofMaturityDelaySeconds,
+		DisputeGameFinalityDelaySeconds: standard.DisputeGameFinalityDelaySeconds,
+		DevFeatureBitmap:                common.Hash{},
+		SuperchainConfigProxy:           sChain.SuperchainConfigAddr,
+		ProtocolVersionsProxy:           sChain.ProtocolVersionsAddr,
+		L1ProxyAdminOwner:               superchainProxyAdminOwner,
+		SuperchainProxyAdmin:            superchainProxyAdmin,
+		CacheDir:                        testCacheDir,
+		Logger:                          lgr,
+		Challenger:                      common.Address{'C'},
+	})
+	require.NoError(t, err)
 
 	chain, err := superchain.GetChain(11155420)
 	require.NoError(t, err)
 	chainConfig, err := chain.Config()
 	require.NoError(t, err)
 
-	readCtx, readCancel := context.WithTimeout(context.Background(), 10*time.Second)
-	defer readCancel()
-
-	opChainProxyAdmin, delayedWETHProxy, err := getAddressesOnchain(readCtx, rpcURL, chainConfig)
-	require.NoError(t, err, "failed to read addresses from chain")
-
 	cfg := AddGameTypeConfig{
-		L1RPCUrl:         rpcURL,
+		L1RPCUrl:         forkedL1.RPCUrl(),
 		Logger:           testlog.Logger(t, slog.LevelInfo),
 		ArtifactsLocator: afacts,
 		SaltMixer:        "foo",
 		// The values below were pulled from the Superchain Registry for OP Sepolia.
 		SystemConfigProxy:       *chainConfig.Addresses.SystemConfigProxy,
-		OPChainProxyAdmin:       opChainProxyAdmin,
-		DelayedWETHProxy:        delayedWETHProxy,
-		DisputeGameType:         999,
+		DelayedWETHProxy:        common.Address{}, // Let the OPCM create a new one.
+		DisputeGameType:         0,
 		DisputeAbsolutePrestate: common.HexToHash("0x1234"),
 		DisputeMaxGameDepth:     big.NewInt(73),
 		DisputeSplitDepth:       big.NewInt(30),
 		DisputeClockExtension:   10800,
 		DisputeMaxClockDuration: 302400,
 		InitialBond:             big.NewInt(1),
-		VM:                      common.Address(*v200SepoliaAddrs.Mips.Address),
-		Permissionless:          false,
-		L1ProxyAdminOwner:       *chainConfig.Roles.ProxyAdminOwner,
-		OPCMImpl:                common.Address(*v200SepoliaAddrs.OPContractsManager.Address),
+		VM:                      impls.MipsSingleton,
+		Permissionless:          true,
+		L1ProxyAdminOwner:       superchainProxyAdminOwner,
+		OPCMImpl:                impls.Opcm,
 		CacheDir:                testCacheDir,
 	}
 
@@ -113,7 +104,8 @@ func TestAddGameType(t *testing.T) {
 
 	require.Equal(t, 1, len(broadcasts))
 	// Selector for addGameType
-	require.EqualValues(t, []byte{0x16, 0x61, 0xa2, 0xe9}, broadcasts[0].Data[0:4])
+	// Gotten from `cast sig "addGameType((string,address,address,uint32,bytes32,uint256,uint256,uint64,uint64,uint256,address,bool)[])"`
+	require.EqualValues(t, []byte{0x60, 0x4a, 0xa6, 0x28}, broadcasts[0].Data[0:4])
 
 	require.NotEqual(t, common.Address{}, output.DelayedWETHProxy)
 	require.NotEqual(t, common.Address{}, output.FaultDisputeGameProxy)
@@ -127,7 +119,6 @@ func TestAddGameType_CLI(t *testing.T) {
 		{L1ProxyAdminOwnerFlag, common.Address{0x01}.String()},
 		{OPCMImplFlag, common.Address{0x02}.String()},
 		{SystemConfigProxyFlag, common.Address{0x03}.String()},
-		{OPChainProxyAdminFlag, common.Address{0x04}.String()},
 		{VMFlag, common.Address{0x05}.String()},
 	}
 
@@ -175,7 +166,6 @@ func TestAddGameType_CLI(t *testing.T) {
 
 		require.Equal(t, common.HexToAddress("0x1eb2ffc903729a0f03966b917003800b145f56e2"), cfg.L1ProxyAdminOwner)
 		require.Equal(t, common.HexToAddress("0xfbceed4de885645fbded164910e10f52febfab35"), cfg.OPCMImpl)
-		require.Equal(t, common.HexToAddress("0x7bd8879acf1e74547455c7ddc07f5c3f4a3c133d"), cfg.OPChainProxyAdmin)
 		require.Equal(t, common.HexToAddress("0x02f909cf91c2134e70a67950b7f27db7c8ee55d6"), cfg.SystemConfigProxy)
 		require.Equal(t, common.HexToAddress("0x0000000000000000000000000000000000000001"), cfg.VM)
 	})
@@ -186,7 +176,6 @@ func TestAddGameType_CLI(t *testing.T) {
 
 		flagSet.String(L1ProxyAdminOwnerFlag.Name, "0x1eb2ffc903729a0f03966b917003800b145f56e2", "doc")
 		flagSet.String(OPCMImplFlag.Name, "0xfbceed4de885645fbded164910e10f52febfab35", "doc")
-		flagSet.String(OPChainProxyAdminFlag.Name, "0x7bd8879acf1e74547455c7ddc07f5c3f4a3c133d", "doc")
 		flagSet.String(SystemConfigProxyFlag.Name, "0x02f909cf91c2134e70a67950b7f27db7c8ee55d6", "doc")
 		flagSet.String(VMFlag.Name, "0x0000000000000000000000000000000000000001", "doc")
 
@@ -197,7 +186,6 @@ func TestAddGameType_CLI(t *testing.T) {
 
 		require.Equal(t, common.HexToAddress("0x1eb2ffc903729a0f03966b917003800b145f56e2"), cfg.L1ProxyAdminOwner)
 		require.Equal(t, common.HexToAddress("0xfbceed4de885645fbded164910e10f52febfab35"), cfg.OPCMImpl)
-		require.Equal(t, common.HexToAddress("0x7bd8879acf1e74547455c7ddc07f5c3f4a3c133d"), cfg.OPChainProxyAdmin)
 		require.Equal(t, common.HexToAddress("0x02f909cf91c2134e70a67950b7f27db7c8ee55d6"), cfg.SystemConfigProxy)
 		require.Equal(t, common.HexToAddress("0x0000000000000000000000000000000000000001"), cfg.VM)
 	})

op-deployer/pkg/deployer/manage/migrate.go

@@ -54,7 +54,6 @@ func (u *InteropMigrationInput) OpChainConfigs() ([]byte, error) {
 
 type OPChainConfig struct {
 	SystemConfigProxy common.Address `json:"systemConfigProxy"`
-	ProxyAdmin        common.Address `json:"proxyAdmin"`
 	AbsolutePrestate  common.Hash    `json:"absolutePrestate"`
 }
 
@@ -66,7 +65,7 @@ func (output *InteropMigrationOutput) CheckOutput(input common.Address) error {
 	return nil
 }
 
-var opChainConfigEncoder = w3.MustNewFunc("dummy((address systemConfigProxy,address proxyAdmin,bytes32 absolutePrestate)[])", "")
+var opChainConfigEncoder = w3.MustNewFunc("dummy((address systemConfigProxy,bytes32 absolutePrestate)[])", "")
 
 type InteropMigration struct {
 	Run func(input common.Address)
@@ -112,7 +111,6 @@ func MigrateCLI(cliCtx *cli.Context) error {
 		EncodedChainConfigs: []OPChainConfig{
 			{
 				SystemConfigProxy: common.HexToAddress(cliCtx.String(SystemConfigProxyFlag.Name)),
-				ProxyAdmin:        common.HexToAddress(cliCtx.String(OPChainProxyAdminFlag.Name)),
 				AbsolutePrestate:  common.HexToHash(cliCtx.String(DisputeAbsolutePrestateFlag.Name)),
 			},
 		},

op-deployer/pkg/deployer/manage/migrate_test.go

@@ -64,7 +64,6 @@ func TestInteropMigration(t *testing.T) {
 		EncodedChainConfigs: []OPChainConfig{
 			{
 				SystemConfigProxy: common.HexToAddress("0x034edD2A225f7f429A63E0f1D2084B9E0A93b538"),
-				ProxyAdmin:        common.HexToAddress("0x189aBAAaa82DfC015A588A7dbaD6F13b1D3485Bc"),
 				AbsolutePrestate:  common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000abc"),
 			},
 		},

op-deployer/pkg/deployer/opcm/add_game_type.go

@@ -13,7 +13,6 @@ type AddGameTypeInput struct {
 	L1ProxyAdminOwner       common.Address `abi:"prank"`
 	OPCMImpl                common.Address `abi:"opcmImpl"`
 	SystemConfigProxy       common.Address
-	OPChainProxyAdmin       common.Address `abi:"opChainProxyAdmin"`
 	DelayedWETHProxy        common.Address
 	DisputeGameType         uint32
 	DisputeAbsolutePrestate common.Hash
@@ -31,7 +30,6 @@ type addGameTypeInputJSON struct {
 	Prank                   common.Address `json:"prank"`
 	OPCMImpl                common.Address `json:"opcmimpl"`
 	SystemConfigProxy       common.Address `json:"systemConfigProxy"`
-	OPChainProxyAdmin       common.Address `json:"opChainProxyAdmin"`
 	DelayedWETHProxy        common.Address `json:"delayedWETHProxy"`
 	DisputeGameType         uint32         `json:"disputeGameType"`
 	DisputeAbsolutePrestate common.Hash    `json:"disputeAbsolutePrestate"`
@@ -54,7 +52,6 @@ func (a *AddGameTypeInput) UnmarshalJSON(b []byte) error {
 	a.L1ProxyAdminOwner = alias.Prank
 	a.OPCMImpl = alias.OPCMImpl
 	a.SystemConfigProxy = alias.SystemConfigProxy
-	a.OPChainProxyAdmin = alias.OPChainProxyAdmin
 	a.DelayedWETHProxy = alias.DelayedWETHProxy
 	a.DisputeGameType = alias.DisputeGameType
 	a.DisputeAbsolutePrestate = alias.DisputeAbsolutePrestate
@@ -86,7 +83,6 @@ func (a AddGameTypeInput) MarshalJSON() ([]byte, error) {
 		Prank:                   a.L1ProxyAdminOwner,
 		OPCMImpl:                a.OPCMImpl,
 		SystemConfigProxy:       a.SystemConfigProxy,
-		OPChainProxyAdmin:       a.OPChainProxyAdmin,
 		DelayedWETHProxy:        a.DelayedWETHProxy,
 		DisputeGameType:         a.DisputeGameType,
 		DisputeAbsolutePrestate: a.DisputeAbsolutePrestate,

op-deployer/pkg/deployer/opcm/add_game_type_test.go

@@ -26,7 +26,6 @@ func compareAddGameTypeInputs(t *testing.T, expected, actual AddGameTypeInput) {
 	require.Equal(t, expected.L1ProxyAdminOwner, actual.L1ProxyAdminOwner)
 	require.Equal(t, expected.OPCMImpl, actual.OPCMImpl)
 	require.Equal(t, expected.SystemConfigProxy, actual.SystemConfigProxy)
-	require.Equal(t, expected.OPChainProxyAdmin, actual.OPChainProxyAdmin)
 	require.Equal(t, expected.DelayedWETHProxy, actual.DelayedWETHProxy)
 	require.Equal(t, expected.DisputeGameType, actual.DisputeGameType)
 	require.Equal(t, expected.DisputeAbsolutePrestate, actual.DisputeAbsolutePrestate)
@@ -54,7 +53,6 @@ func TestAddGameTypeInput_MarshalUnmarshalJSON(t *testing.T) {
 				L1ProxyAdminOwner:       common.HexToAddress("0x1111111111111111111111111111111111111111"),
 				OPCMImpl:                common.HexToAddress("0x2222222222222222222222222222222222222222"),
 				SystemConfigProxy:       common.HexToAddress("0x3333333333333333333333333333333333333333"),
-				OPChainProxyAdmin:       common.HexToAddress("0x4444444444444444444444444444444444444444"),
 				DelayedWETHProxy:        common.HexToAddress("0x5555555555555555555555555555555555555555"),
 				DisputeGameType:         1,
 				DisputeAbsolutePrestate: common.HexToHash("0x6666666666666666666666666666666666666666666666666666666666666666"),
@@ -74,7 +72,6 @@ func TestAddGameTypeInput_MarshalUnmarshalJSON(t *testing.T) {
 				L1ProxyAdminOwner:       common.HexToAddress("0x1111111111111111111111111111111111111111"),
 				OPCMImpl:                common.HexToAddress("0x2222222222222222222222222222222222222222"),
 				SystemConfigProxy:       common.HexToAddress("0x3333333333333333333333333333333333333333"),
-				OPChainProxyAdmin:       common.HexToAddress("0x4444444444444444444444444444444444444444"),
 				DelayedWETHProxy:        common.HexToAddress("0x5555555555555555555555555555555555555555"),
 				DisputeGameType:         1,
 				DisputeAbsolutePrestate: common.HexToHash("0x6666666666666666666666666666666666666666666666666666666666666666"),