op-e2e: Rearrange fault proof tests

Moves fault proof tests to their own package and splits them into separate files based on the game type.

op-e2e/bridge_test.go

@@ -36,7 +36,7 @@ func TestERC20BridgeDeposits(t *testing.T) {
 	l1Client := sys.Clients["l1"]
 	l2Client := sys.Clients["sequencer"]
 
-	opts, err := bind.NewKeyedTransactorWithChainID(sys.cfg.Secrets.Alice, cfg.L1ChainIDBig())
+	opts, err := bind.NewKeyedTransactorWithChainID(sys.Cfg.Secrets.Alice, cfg.L1ChainIDBig())
 	require.Nil(t, err)
 
 	// Deploy WETH9
@@ -57,7 +57,7 @@ func TestERC20BridgeDeposits(t *testing.T) {
 	require.Equal(t, big.NewInt(params.Ether), wethBalance)
 
 	// Deploy L2 WETH9
-	l2Opts, err := bind.NewKeyedTransactorWithChainID(sys.cfg.Secrets.Alice, cfg.L2ChainIDBig())
+	l2Opts, err := bind.NewKeyedTransactorWithChainID(sys.Cfg.Secrets.Alice, cfg.L2ChainIDBig())
 	require.NoError(t, err)
 	optimismMintableTokenFactory, err := bindings.NewOptimismMintableERC20Factory(predeploys.OptimismMintableERC20FactoryAddr, l2Client)
 	require.NoError(t, err)

op-e2e/e2eutils/challenger/helper.go

@@ -94,9 +94,9 @@ func applyCannonConfig(
 ) {
 	require := require.New(t)
 	c.CannonL2 = l2Endpoint
-	c.CannonBin = "../cannon/bin/cannon"
-	c.CannonServer = "../op-program/bin/op-program"
-	c.CannonAbsolutePreState = "../op-program/bin/prestate.json"
+	c.CannonBin = "../../cannon/bin/cannon"
+	c.CannonServer = "../../op-program/bin/op-program"
+	c.CannonAbsolutePreState = "../../op-program/bin/prestate.json"
 	c.CannonSnapshotFreq = 10_000_000
 
 	genesisBytes, err := json.Marshal(l2Genesis)

op-e2e/faultproofs/alphabet_test.go

+package faultproofs
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	op_e2e "github.com/ethereum-optimism/optimism/op-e2e"
+	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/challenger"
+	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/disputegame"
+	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/wait"
+	"github.com/stretchr/testify/require"
+)
+
+func TestChallengerCompleteDisputeGame(t *testing.T) {
+	op_e2e.InitParallel(t, op_e2e.UseExecutor(1))
+
+	tests := []struct {
+		name              string
+		rootClaimAlphabet string
+		otherAlphabet     string
+		expectedResult    disputegame.Status
+		expectStep        bool
+	}{
+		{
+			name:              "ChallengerWins_DefenseStep",
+			rootClaimAlphabet: "abcdexyz",
+			otherAlphabet:     disputegame.CorrectAlphabet,
+			expectedResult:    disputegame.StatusChallengerWins,
+			expectStep:        true,
+		},
+		{
+			name:              "DefenderWins_DefenseStep",
+			rootClaimAlphabet: disputegame.CorrectAlphabet,
+			otherAlphabet:     "abcdexyz",
+			expectedResult:    disputegame.StatusDefenderWins,
+			expectStep:        false,
+		},
+		{
+			name:              "ChallengerWins_AttackStep",
+			rootClaimAlphabet: "abcdefghzyx",
+			otherAlphabet:     disputegame.CorrectAlphabet,
+			expectedResult:    disputegame.StatusChallengerWins,
+			expectStep:        true,
+		},
+		{
+			name:              "DefenderWins_AttackStep",
+			rootClaimAlphabet: disputegame.CorrectAlphabet,
+			otherAlphabet:     "abcdexyz",
+			expectedResult:    disputegame.StatusDefenderWins,
+			expectStep:        false,
+		},
+		{
+			name:              "DefenderIncorrectAtTraceZero",
+			rootClaimAlphabet: "zyxwvut",
+			otherAlphabet:     disputegame.CorrectAlphabet,
+			expectedResult:    disputegame.StatusChallengerWins,
+			expectStep:        true,
+		},
+		{
+			name:              "ChallengerIncorrectAtTraceZero",
+			rootClaimAlphabet: disputegame.CorrectAlphabet,
+			otherAlphabet:     "zyxwvut",
+			expectedResult:    disputegame.StatusDefenderWins,
+			expectStep:        false,
+		},
+		{
+			name:              "DefenderIncorrectAtLastTraceIndex",
+			rootClaimAlphabet: "abcdefghijklmnoz",
+			otherAlphabet:     disputegame.CorrectAlphabet,
+			expectedResult:    disputegame.StatusChallengerWins,
+			expectStep:        true,
+		},
+		{
+			name:              "ChallengerIncorrectAtLastTraceIndex",
+			rootClaimAlphabet: disputegame.CorrectAlphabet,
+			otherAlphabet:     "abcdefghijklmnoz",
+			expectedResult:    disputegame.StatusDefenderWins,
+			expectStep:        false,
+		},
+	}
+	for _, test := range tests {
+		test := test
+		t.Run(test.name, func(t *testing.T) {
+			op_e2e.InitParallel(t, op_e2e.UseExecutor(1))
+
+			ctx := context.Background()
+			sys, l1Client := startFaultDisputeSystem(t)
+			t.Cleanup(sys.Close)
+
+			disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys.Cfg.L1Deployments, l1Client)
+			game := disputeGameFactory.StartAlphabetGame(ctx, test.rootClaimAlphabet)
+			require.NotNil(t, game)
+			gameDuration := game.GameDuration(ctx)
+
+			game.StartChallenger(ctx, sys.NodeEndpoint("l1"), "Defender",
+				challenger.WithAgreeProposedOutput(false),
+				challenger.WithPrivKey(sys.Cfg.Secrets.Mallory),
+			)
+
+			game.StartChallenger(ctx, sys.NodeEndpoint("l1"), "Challenger",
+				// Agree with the proposed output, so disagree with the root claim
+				challenger.WithAgreeProposedOutput(true),
+				challenger.WithAlphabet(test.otherAlphabet),
+				challenger.WithPrivKey(sys.Cfg.Secrets.Alice),
+			)
+
+			// Wait for a claim at the maximum depth that has been countered to indicate we're ready to resolve the game
+			game.WaitForClaimAtMaxDepth(ctx, test.expectStep)
+
+			sys.TimeTravelClock.AdvanceTime(gameDuration)
+			require.NoError(t, wait.ForNextBlock(ctx, l1Client))
+
+			game.WaitForInactivity(ctx, 10, true)
+			game.LogGameData(ctx)
+			require.EqualValues(t, test.expectedResult, game.Status(ctx))
+		})
+	}
+}
+
+func TestChallengerCompleteExhaustiveDisputeGame(t *testing.T) {
+	op_e2e.InitParallel(t, op_e2e.UseExecutor(1))
+
+	testCase := func(t *testing.T, isRootCorrect bool) {
+		ctx := context.Background()
+		sys, l1Client := startFaultDisputeSystem(t)
+		t.Cleanup(sys.Close)
+
+		disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys.Cfg.L1Deployments, l1Client)
+		rootClaimedAlphabet := disputegame.CorrectAlphabet
+		if !isRootCorrect {
+			rootClaimedAlphabet = "abcdexyz"
+		}
+		game := disputeGameFactory.StartAlphabetGame(ctx, rootClaimedAlphabet)
+		require.NotNil(t, game)
+		gameDuration := game.GameDuration(ctx)
+
+		// Start honest challenger
+		game.StartChallenger(ctx, sys.NodeEndpoint("l1"), "Challenger",
+			challenger.WithAgreeProposedOutput(!isRootCorrect),
+			challenger.WithAlphabet(disputegame.CorrectAlphabet),
+			challenger.WithPrivKey(sys.Cfg.Secrets.Alice),
+			// Ensures the challenger responds to all claims before test timeout
+			challenger.WithPollInterval(time.Millisecond*400),
+		)
+
+		// Start dishonest challenger
+		dishonestHelper := game.CreateDishonestHelper(disputegame.CorrectAlphabet, 4, !isRootCorrect)
+		dishonestHelper.ExhaustDishonestClaims(ctx)
+
+		// Wait until we've reached max depth before checking for inactivity
+		game.WaitForClaimAtDepth(ctx, int(game.MaxDepth(ctx)))
+
+		// Wait for 4 blocks of no challenger responses. The challenger may still be stepping on invalid claims at max depth
+		game.WaitForInactivity(ctx, 4, false)
+
+		sys.TimeTravelClock.AdvanceTime(gameDuration)
+		require.NoError(t, wait.ForNextBlock(ctx, l1Client))
+
+		expectedStatus := disputegame.StatusChallengerWins
+		if isRootCorrect {
+			expectedStatus = disputegame.StatusDefenderWins
+		}
+		game.WaitForInactivity(ctx, 10, true)
+		game.LogGameData(ctx)
+		require.EqualValues(t, expectedStatus, game.Status(ctx))
+	}
+
+	t.Run("RootCorrect", func(t *testing.T) {
+		op_e2e.InitParallel(t, op_e2e.UseExecutor(1))
+		testCase(t, true)
+	})
+	t.Run("RootIncorrect", func(t *testing.T) {
+		op_e2e.InitParallel(t, op_e2e.UseExecutor(1))
+		testCase(t, false)
+	})
+}

op-e2e/faultproofs/multi_test.go

+package faultproofs
+
+import (
+	"context"
+	"math/big"
+	"testing"
+
+	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/alphabet"
+	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
+	op_e2e "github.com/ethereum-optimism/optimism/op-e2e"
+	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/challenger"
+	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/disputegame"
+	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/wait"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/stretchr/testify/require"
+)
+
+func TestMultipleCannonGames(t *testing.T) {
+	op_e2e.InitParallel(t, op_e2e.UsesCannon, op_e2e.UseExecutor(0))
+
+	ctx := context.Background()
+	sys, l1Client := startFaultDisputeSystem(t)
+	t.Cleanup(sys.Close)
+
+	gameFactory := disputegame.NewFactoryHelper(t, ctx, sys.Cfg.L1Deployments, l1Client)
+	// Start a challenger with the correct alphabet trace
+	challenger := gameFactory.StartChallenger(ctx, sys.NodeEndpoint("l1"), "TowerDefense",
+		challenger.WithCannon(t, sys.RollupConfig, sys.L2GenesisCfg, sys.NodeEndpoint("sequencer")),
+		challenger.WithPrivKey(sys.Cfg.Secrets.Alice),
+		challenger.WithAgreeProposedOutput(true),
+	)
+
+	game1 := gameFactory.StartCannonGame(ctx, common.Hash{0x01, 0xaa})
+	game2 := gameFactory.StartCannonGame(ctx, common.Hash{0x01, 0xbb})
+
+	game1.WaitForClaimCount(ctx, 2)
+	game2.WaitForClaimCount(ctx, 2)
+
+	game1Claim := game1.GetClaimValue(ctx, 1)
+	game2Claim := game2.GetClaimValue(ctx, 1)
+	require.NotEqual(t, game1Claim, game2Claim, "games should have different cannon traces")
+
+	// Check that the helper finds the game directories correctly
+	challenger.VerifyGameDataExists(game1, game2)
+
+	// Push both games down to the step function
+	maxDepth := game1.MaxDepth(ctx)
+	for claimCount := int64(1); claimCount <= maxDepth; {
+		// Challenger should respond to both games
+		claimCount++
+		game1.WaitForClaimCount(ctx, claimCount)
+		game2.WaitForClaimCount(ctx, claimCount)
+
+		// Progress both games
+		game1.Defend(ctx, claimCount-1, common.Hash{0xaa})
+		game2.Defend(ctx, claimCount-1, common.Hash{0xaa})
+		claimCount++
+	}
+
+	game1.WaitForClaimAtMaxDepth(ctx, true)
+	game2.WaitForClaimAtMaxDepth(ctx, true)
+
+	gameDuration := game1.GameDuration(ctx)
+	sys.TimeTravelClock.AdvanceTime(gameDuration)
+	require.NoError(t, wait.ForNextBlock(ctx, l1Client))
+
+	game1.WaitForInactivity(ctx, 10, true)
+	game2.WaitForInactivity(ctx, 10, true)
+	game1.LogGameData(ctx)
+	game2.LogGameData(ctx)
+	require.EqualValues(t, disputegame.StatusChallengerWins, game1.Status(ctx))
+	require.EqualValues(t, disputegame.StatusChallengerWins, game2.Status(ctx))
+
+	// Check that the game directories are removed
+	challenger.WaitForGameDataDeletion(ctx, game1, game2)
+}
+
+func TestMultipleGameTypes(t *testing.T) {
+	op_e2e.InitParallel(t, op_e2e.UsesCannon, op_e2e.UseExecutor(0))
+
+	ctx := context.Background()
+	sys, l1Client := startFaultDisputeSystem(t)
+	t.Cleanup(sys.Close)
+
+	gameFactory := disputegame.NewFactoryHelper(t, ctx, sys.Cfg.L1Deployments, l1Client)
+	// Start a challenger with both cannon and alphabet support
+	gameFactory.StartChallenger(ctx, sys.NodeEndpoint("l1"), "TowerDefense",
+		challenger.WithCannon(t, sys.RollupConfig, sys.L2GenesisCfg, sys.NodeEndpoint("sequencer")),
+		challenger.WithAlphabet(disputegame.CorrectAlphabet),
+		challenger.WithPrivKey(sys.Cfg.Secrets.Alice),
+		challenger.WithAgreeProposedOutput(true),
+	)
+
+	game1 := gameFactory.StartCannonGame(ctx, common.Hash{0x01, 0xaa})
+	game2 := gameFactory.StartAlphabetGame(ctx, "xyzabc")
+
+	// Wait for the challenger to respond to both games
+	game1.WaitForClaimCount(ctx, 2)
+	game2.WaitForClaimCount(ctx, 2)
+	game1Response := game1.GetClaimValue(ctx, 1)
+	game2Response := game2.GetClaimValue(ctx, 1)
+	// The alphabet game always posts the same traces, so if they're different they can't both be from the alphabet.
+	require.NotEqual(t, game1Response, game2Response, "should have posted different claims")
+	// Now check they aren't both just from different cannon games by confirming the alphabet value.
+	correctAlphabet := alphabet.NewTraceProvider(disputegame.CorrectAlphabet, uint64(game2.MaxDepth(ctx)))
+	expectedClaim, err := correctAlphabet.Get(ctx, types.NewPositionFromGIndex(big.NewInt(1)).Attack())
+	require.NoError(t, err)
+	require.Equal(t, expectedClaim, game2Response)
+	// We don't confirm the cannon value because generating the correct claim is expensive
+	// Just being different is enough to confirm the challenger isn't just playing two alphabet games incorrectly
+}

op-e2e/faultproofs/output_cannon_test.go

+package faultproofs
+
+import (
+	"context"
+	"testing"
+
+	op_e2e "github.com/ethereum-optimism/optimism/op-e2e"
+	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/challenger"
+	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/disputegame"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/stretchr/testify/require"
+)
+
+func TestOutputCannonGame(t *testing.T) {
+	op_e2e.InitParallel(t, op_e2e.UsesCannon, op_e2e.UseExecutor(0))
+	ctx := context.Background()
+	sys, l1Client := startFaultDisputeSystem(t)
+	t.Cleanup(sys.Close)
+
+	rollupEndpoint := sys.RollupNodes["sequencer"].HTTPEndpoint()
+	l1Endpoint := sys.NodeEndpoint("l1")
+	l2Endpoint := sys.NodeEndpoint("sequencer")
+	require.NotEqual(t, rollupEndpoint, l2Endpoint)
+
+	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys.Cfg.L1Deployments, l1Client)
+	game := disputeGameFactory.StartOutputCannonGame(ctx, rollupEndpoint, common.Hash{0x01})
+	game.LogGameData(ctx)
+
+	game.StartChallenger(ctx, sys.RollupConfig, sys.L2GenesisCfg, rollupEndpoint, l1Endpoint, l2Endpoint, "Challenger",
+		// Agree with the proposed output, so disagree with the root claim
+		challenger.WithAgreeProposedOutput(true),
+		challenger.WithPrivKey(sys.Cfg.Secrets.Alice),
+	)
+
+	game.LogGameData(ctx)
+	maxDepth := game.MaxDepth(ctx)
+	// Challenger should post an output root to counter claims down to the leaf level of the top game
+	// TODO(client-pod#43): Load the depth of the top game from the contract instead of deriving it
+	for i := int64(1); i <= maxDepth/2+1; i += 2 {
+		game.WaitForCorrectOutputRoot(ctx, i)
+		game.Attack(ctx, i, common.Hash{0xaa})
+		game.LogGameData(ctx)
+	}
+}

op-e2e/faultproofs/util.go

+package faultproofs
+
+import (
+	"context"
+	"testing"
+
+	op_e2e "github.com/ethereum-optimism/optimism/op-e2e"
+	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/challenger"
+	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/disputegame"
+	l2oo2 "github.com/ethereum-optimism/optimism/op-e2e/e2eutils/l2oo"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/stretchr/testify/require"
+)
+
+func startFaultDisputeSystem(t *testing.T) (*op_e2e.System, *ethclient.Client) {
+	cfg := op_e2e.DefaultSystemConfig(t)
+	delete(cfg.Nodes, "verifier")
+	cfg.DeployConfig.SequencerWindowSize = 4
+	cfg.DeployConfig.FinalizationPeriodSeconds = 2
+	cfg.SupportL1TimeTravel = true
+	cfg.DeployConfig.L2OutputOracleSubmissionInterval = 1
+	cfg.NonFinalizedProposals = true // Submit output proposals asap
+	sys, err := cfg.Start(t)
+	require.Nil(t, err, "Error starting up system")
+	return sys, sys.Clients["l1"]
+}
+
+// setupDisputeGameForInvalidOutputRoot sets up an L2 chain with at least one valid output root followed by an invalid output root.
+// A cannon dispute game is started to dispute the invalid output root with the correct root claim provided.
+// An honest challenger is run to defend the root claim (ie disagree with the invalid output root).
+func setupDisputeGameForInvalidOutputRoot(t *testing.T, outputRoot common.Hash) (*op_e2e.System, *ethclient.Client, *disputegame.CannonGameHelper, *disputegame.HonestHelper) {
+	ctx := context.Background()
+	sys, l1Client := startFaultDisputeSystem(t)
+
+	l2oo := l2oo2.NewL2OOHelper(t, sys.Cfg.L1Deployments, l1Client, sys.Cfg.Secrets.Proposer, sys.RollupConfig)
+
+	// Wait for one valid output root to be submitted
+	l2oo.WaitForProposals(ctx, 1)
+
+	err := sys.L2OutputSubmitter.Driver().StopL2OutputSubmitting()
+	require.NoError(t, err)
+	sys.L2OutputSubmitter = nil
+
+	// Submit an invalid output root
+	l2oo.PublishNextOutput(ctx, outputRoot)
+
+	l1Endpoint := sys.NodeEndpoint("l1")
+	l2Endpoint := sys.NodeEndpoint("sequencer")
+
+	// Dispute the new output root by creating a new game with the correct cannon trace.
+	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys.Cfg.L1Deployments, l1Client)
+	game, correctTrace := disputeGameFactory.StartCannonGameWithCorrectRoot(ctx, sys.RollupConfig, sys.L2GenesisCfg, l1Endpoint, l2Endpoint,
+		challenger.WithPrivKey(sys.Cfg.Secrets.Mallory),
+	)
+	require.NotNil(t, game)
+
+	// Start the honest challenger
+	game.StartChallenger(ctx, sys.RollupConfig, sys.L2GenesisCfg, l1Endpoint, l2Endpoint, "Defender",
+		// Disagree with the proposed output, so agree with the (correct) root claim
+		challenger.WithAgreeProposedOutput(false),
+		challenger.WithPrivKey(sys.Cfg.Secrets.Mallory),
+	)
+	return sys, l1Client, game, correctTrace
+}

op-e2e/op_geth_test.go

@@ -53,7 +53,7 @@ func TestTxGasSameAsBlockGasLimit(t *testing.T) {
 	require.Nil(t, err, "Error starting up system")
 	defer sys.Close()
 
-	ethPrivKey := sys.cfg.Secrets.Alice
+	ethPrivKey := sys.Cfg.Secrets.Alice
 	tx := types.MustSignNewTx(ethPrivKey, types.LatestSignerForChainID(cfg.L2ChainIDBig()), &types.DynamicFeeTx{
 		ChainID: cfg.L2ChainIDBig(),
 		Gas:     29_999_999,

op-e2e/setup.go

@@ -248,7 +248,7 @@ type EthInstance interface {
 }
 
 type System struct {
-	cfg SystemConfig
+	Cfg SystemConfig
 
 	RollupConfig *rollup.Config
 
@@ -335,7 +335,7 @@ func (cfg SystemConfig) Start(t *testing.T, _opts ...SystemConfigOption) (*Syste
 	}
 
 	sys := &System{
-		cfg:          cfg,
+		Cfg:          cfg,
 		EthInstances: make(map[string]EthInstance),
 		Clients:      make(map[string]*ethclient.Client),
 		RawClients:   make(map[string]*rpc.Client),
@@ -690,7 +690,7 @@ func (cfg SystemConfig) Start(t *testing.T, _opts ...SystemConfigOption) (*Syste
 			Format: oplog.FormatText,
 		},
 	}
-	proposer, err := l2os.ProposerServiceFromCLIConfig(context.Background(), "0.0.1", proposerCLIConfig, sys.cfg.Loggers["proposer"])
+	proposer, err := l2os.ProposerServiceFromCLIConfig(context.Background(), "0.0.1", proposerCLIConfig, sys.Cfg.Loggers["proposer"])
 	if err != nil {
 		return nil, fmt.Errorf("unable to setup l2 output submitter: %w", err)
 	}
@@ -726,11 +726,11 @@ func (cfg SystemConfig) Start(t *testing.T, _opts ...SystemConfigOption) (*Syste
 			Level:  log.LvlInfo,
 			Format: oplog.FormatText,
 		},
-		Stopped:   sys.cfg.DisableBatcher, // Batch submitter may be enabled later
+		Stopped:   sys.Cfg.DisableBatcher, // Batch submitter may be enabled later
 		BatchType: batchType,
 	}
 	// Batch Submitter
-	batcher, err := bss.BatcherServiceFromCLIConfig(context.Background(), "0.0.1", batcherCLIConfig, sys.cfg.Loggers["batcher"])
+	batcher, err := bss.BatcherServiceFromCLIConfig(context.Background(), "0.0.1", batcherCLIConfig, sys.Cfg.Loggers["batcher"])
 	if err != nil {
 		return nil, fmt.Errorf("failed to setup batch submitter: %w", err)
 	}

op-e2e/system_test.go

@@ -192,10 +192,10 @@ func runE2ESystemTest(t *testing.T, sys *System) {
 	l2Verif := sys.Clients["verifier"]
 
 	// Transactor Account
-	ethPrivKey := sys.cfg.Secrets.Alice
+	ethPrivKey := sys.Cfg.Secrets.Alice
 
 	// Send Transaction & wait for success
-	fromAddr := sys.cfg.Secrets.Addresses().Alice
+	fromAddr := sys.Cfg.Secrets.Addresses().Alice
 
 	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
 	defer cancel()
@@ -203,11 +203,11 @@ func runE2ESystemTest(t *testing.T, sys *System) {
 	require.Nil(t, err)
 
 	// Send deposit transaction
-	opts, err := bind.NewKeyedTransactorWithChainID(ethPrivKey, sys.cfg.L1ChainIDBig())
+	opts, err := bind.NewKeyedTransactorWithChainID(ethPrivKey, sys.Cfg.L1ChainIDBig())
 	require.Nil(t, err)
 	mintAmount := big.NewInt(1_000_000_000_000)
 	opts.Value = mintAmount
-	SendDepositTx(t, sys.cfg, l1Client, l2Verif, opts, func(l2Opts *DepositTxOpts) {})
+	SendDepositTx(t, sys.Cfg, l1Client, l2Verif, opts, func(l2Opts *DepositTxOpts) {})
 
 	// Confirm balance
 	ctx, cancel = context.WithTimeout(context.Background(), 15*time.Second)
@@ -220,7 +220,7 @@ func runE2ESystemTest(t *testing.T, sys *System) {
 	require.Equal(t, mintAmount, diff, "Did not get expected balance change")
 
 	// Submit TX to L2 sequencer node
-	receipt := SendL2Tx(t, sys.cfg, l2Seq, ethPrivKey, func(opts *TxOpts) {
+	receipt := SendL2Tx(t, sys.Cfg, l2Seq, ethPrivKey, func(opts *TxOpts) {
 		opts.Value = big.NewInt(1_000_000_000)
 		opts.Nonce = 1 // Already have deposit
 		opts.ToAddr = &common.Address{0xff, 0xff}

op-e2e/system_tob_test.go

@@ -132,7 +132,7 @@ func TestL2SequencerRPCDepositTx(t *testing.T) {
 	// Obtain our sequencer, verifier, and transactor keypair.
 	l2Seq := sys.Clients["sequencer"]
 	l2Verif := sys.Clients["verifier"]
-	txSigningKey := sys.cfg.Secrets.Alice
+	txSigningKey := sys.Cfg.Secrets.Alice
 	require.Nil(t, err)
 
 	// Create a deposit tx to send over RPC.