Test Fraud Proof Game Compatibility with Espresso (#170)

* add init version on dispute game test

* more comment and DRY

* Update espresso/environment/13_dispute_game_test.go

Co-authored-by: Phil <[email protected]>

* make sure caff node can make progress

* simplify caff node wait logic

* clean up

---------

Co-authored-by: Phil <[email protected]>

Author: 2 people

espresso/environment/13_dispute_game_test.go

@@ -0,0 +1,119 @@
+package environment_test
+
+import (
+	"context"
+	"testing"
+
+	env "github.com/ethereum-optimism/optimism/espresso/environment"
+	"github.com/stretchr/testify/require"
+
+	"github.com/ethereum-optimism/optimism/op-challenger/game/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"
+)
+
+// TestOutputAlphabetGameWithEspresso_ChallengerWins verifies that fraud proof challenges work correctly
+// with Espresso integration enabled. It ensures a challenger can successfully detect and win
+// against a malicious proposer, validating that the dispute resolution process remains intact
+// when using Espresso for transaction finalization.
+//
+// This test mirrors the logic from TestOutputAlphabetGame_ChallengerWins in the non-Espresso
+// implementation (op-e2e/faultproofs/output_alphabet_test.go), but runs with the Espresso-mode
+// batcher enabled.
+//
+// Test structure:
+//   - Setup: Initialize Sequencer and Batcher in Espresso mode
+//   - Action: Deploy fault dispute system and trigger challenger response
+//   - Assert: Verify challenger successfully wins the dispute game
+func TestOutputAlphabetGameWithEspresso_ChallengerWins(t *testing.T) {
+	op_e2e.InitParallel(t)
+	ctx := context.Background()
+
+	// Start a Espresso Dev Node
+	launcher := new(env.EspressoDevNodeLauncherDocker)
+
+	// Start a Fault Dispute System with Espresso Dev Node
+	sys, espressoDevNode, err := launcher.StartDevNetWithFaultDisputeSystem(ctx, t, env.WithL1FinalizedDistance(0), env.WithSequencerUseFinalized(true))
+
+	l1Client := sys.NodeClient("l1")
+
+	// Signal the testnet to shut down
+	if have, want := err, error(nil); have != want {
+		t.Fatalf("failed to start dev environment with espresso dev node:\nhave:\n\t\"%v\"\nwant:\n\t\"%v\"\n", have, want)
+	}
+
+	// Close the system and stop the Espresso Dev Node
+	defer sys.Close()
+	defer func() {
+		err = espressoDevNode.Stop()
+		if err != nil {
+			t.Fatalf("failed to stop espresso dev node: %v", err)
+		}
+	}()
+
+	// Launch a Caff Node and check it can still make progress
+	caffNode, err := env.LaunchCaffNode(t, sys, espressoDevNode)
+	if have, want := err, error(nil); have != want {
+		t.Fatalf("failed to start caff node:\nhave:\n\t\"%v\"\nwant:\n\t\"%v\"\n", have, want)
+	}
+
+	// Shut down the Caff Node
+	defer env.Stop(t, caffNode)
+	caffClient := sys.NodeClient(env.RoleCaffNode)
+	// Make sure Caff Node still make progress
+	require.NoError(t, wait.ForNextBlock(ctx, caffClient))
+
+	// All the following testing code is pasted from `TestOutputAlphabetGame_ChallengerWins` in `op-e2e/faultproofs/output_alphabet_test.go`
+	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys)
+	game := disputeGameFactory.StartOutputAlphabetGame(ctx, "sequencer", 3, common.Hash{0xff})
+	correctTrace := game.CreateHonestActor(ctx, "sequencer")
+	game.LogGameData(ctx)
+
+	opts := challenger.WithPrivKey(sys.Cfg.Secrets.Alice)
+	game.StartChallenger(ctx, "sequencer", "Challenger", opts)
+	game.LogGameData(ctx)
+
+	// Challenger should post an output root to counter claims down to the leaf level of the top game
+	claim := game.RootClaim(ctx)
+	for claim.IsOutputRoot(ctx) && !claim.IsOutputRootLeaf(ctx) {
+		if claim.AgreesWithOutputRoot() {
+			// If the latest claim agrees with the output root, expect the honest challenger to counter it
+			claim = claim.WaitForCounterClaim(ctx)
+			game.LogGameData(ctx)
+			claim.RequireCorrectOutputRoot(ctx)
+		} else {
+			// Otherwise we should counter
+			claim = claim.Attack(ctx, common.Hash{0xaa})
+			game.LogGameData(ctx)
+		}
+	}
+
+	// Wait for the challenger to post the first claim in the cannon trace
+	claim = claim.WaitForCounterClaim(ctx)
+	game.LogGameData(ctx)
+
+	// Attack the root of the alphabet trace subgame
+	claim = correctTrace.AttackClaim(ctx, claim)
+	for !claim.IsMaxDepth(ctx) {
+		if claim.AgreesWithOutputRoot() {
+			// If the latest claim supports the output root, wait for the honest challenger to respond
+			claim = claim.WaitForCounterClaim(ctx)
+			game.LogGameData(ctx)
+		} else {
+			// Otherwise we need to counter the honest claim
+			claim = correctTrace.AttackClaim(ctx, claim)
+			game.LogGameData(ctx)
+		}
+	}
+	// Challenger should be able to call step and counter the leaf claim.
+	claim.WaitForCountered(ctx)
+	game.LogGameData(ctx)
+
+	sys.TimeTravelClock.AdvanceTime(game.MaxClockDuration(ctx))
+	require.NoError(t, wait.ForNextBlock(ctx, l1Client))
+	game.WaitForGameStatus(ctx, types.GameStatusChallengerWon)
+	game.LogGameData(ctx)
+}

espresso/environment/optitmism_espresso_test_helpers.go

@@ -25,6 +25,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-batcher/flags"
 	"github.com/ethereum-optimism/optimism/op-e2e/config"
 	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/geth"
+	"github.com/ethereum-optimism/optimism/op-e2e/faultproofs"
 	"github.com/ethereum-optimism/optimism/op-e2e/system/e2esys"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
@@ -246,8 +247,8 @@ func (e EspressoDevNodeContainerInfo) Stop() error {
 // is meant to be.
 var ErrUnableToDetermineEspressoDevNodeSequencerHost = errors.New("unable to determine the host for the espresso-dev-node sequencer api")
 
-func (l *EspressoDevNodeLauncherDocker) StartDevNet(ctx context.Context, t *testing.T, options ...DevNetLauncherOption) (*e2esys.System, EspressoDevNode, error) {
-	originalCtx := ctx
+// GetDevNetConfig returns a configuration for a devnet
+func (l *EspressoDevNodeLauncherDocker) GetDevNetSysConfig(ctx context.Context, t *testing.T, options ...DevNetLauncherOption) e2esys.SystemConfig {
 
 	var allocOpt e2esys.SystemConfigOpt
 	if l.EnclaveBatcher {
@@ -289,6 +290,57 @@ func (l *EspressoDevNodeLauncherDocker) StartDevNet(ctx context.Context, t *test
 		sysConfig.L1Allocs[address] = account.State
 	}
 
+	return sysConfig
+}
+
+// GetDevNetWithFaultDisputeSysConfig returns a configuration for a devnet with a Fault Dispute System
+func (l *EspressoDevNodeLauncherDocker) GetDevNetWithFaultDisputeSysConfig(ctx context.Context, t *testing.T, options ...DevNetLauncherOption) e2esys.SystemConfig {
+	var allocOpt e2esys.SystemConfigOpt
+	if l.EnclaveBatcher {
+		allocOpt = e2esys.WithAllocType(config.AllocTypeEspressoWithEnclave)
+	} else {
+		allocOpt = e2esys.WithAllocType(config.AllocTypeEspressoWithoutEnclave)
+	}
+
+	// Get a Fault Dispute System configuration with Espresso Dev Node allocation
+	sysConfig := faultproofs.GetFaultDisputeSystemConfigForEspresso(t, []e2esys.SystemConfigOpt{allocOpt})
+
+	if l.AltDa {
+		sysConfig.DeployConfig.UseAltDA = true
+		sysConfig.DeployConfig.DACommitmentType = "KeccakCommitment"
+		sysConfig.DeployConfig.DAChallengeWindow = 16
+		sysConfig.DeployConfig.DAResolveWindow = 16
+		sysConfig.DeployConfig.DABondSize = 1000000
+		sysConfig.DeployConfig.DAResolverRefundPercentage = 0
+		sysConfig.BatcherMaxPendingTransactions = 0
+		sysConfig.BatcherBatchType = 0
+		sysConfig.DataAvailabilityType = flags.CalldataType
+	}
+
+	// Set a short L1 block time and finalized distance to make tests faster and reach finality sooner
+	sysConfig.DeployConfig.L1BlockTime = 2
+
+	sysConfig.DeployConfig.DeployCeloContracts = true
+
+	// Ensure that we fund the dev accounts
+	sysConfig.DeployConfig.FundDevAccounts = true
+
+	espressoPremine := new(big.Int).Mul(new(big.Int).SetUint64(1_000_000), new(big.Int).SetUint64(params.Ether))
+	sysConfig.L1Allocs[ESPRESSO_CONTRACT_ACCOUNT] = types.Account{
+		Nonce:   100000,          // Set the nonce to avoid collisions with predeployed contracts
+		Balance: espressoPremine, // Pre-fund Espresso deployer acount with 1M Ether
+	}
+
+	//Set up the L1Allocs in the system config
+	for address, account := range ESPRESSO_ALLOCS {
+		sysConfig.L1Allocs[address] = account.State
+	}
+
+	return sysConfig
+}
+
+// GetDevNetStartOptions returns the start options for the devnet
+func (l *EspressoDevNodeLauncherDocker) GetDevNetStartOptions(originalCtx context.Context, t *testing.T, sysConfig *e2esys.SystemConfig, options ...DevNetLauncherOption) ([]e2esys.StartOption, *DevNetLauncherContext) {
 	initialOptions := []DevNetLauncherOption{
 		allowHostDockerInternalVirtualHost(),
 		launchEspressoDevNodeDocker(),
@@ -300,12 +352,11 @@ func (l *EspressoDevNodeLauncherDocker) StartDevNet(ctx context.Context, t *test
 
 	launchContext := DevNetLauncherContext{
 		Ctx:       originalCtx,
-		SystemCfg: &sysConfig,
+		SystemCfg: sysConfig,
 	}
 
 	allOptions := append(initialOptions, options...)
 
-	// getOptions := map[string][]geth.GethOption{}
 	startOptions := []e2esys.StartOption{}
 
 	for _, opt := range allOptions {
@@ -322,10 +373,20 @@ func (l *EspressoDevNodeLauncherDocker) StartDevNet(ctx context.Context, t *test
 		}
 
 		if sysConfigOption := options.SysConfigOption; sysConfigOption != nil {
-			sysConfigOption(&sysConfig)
+			sysConfigOption(sysConfig)
 		}
 	}
 
+	return startOptions, &launchContext
+}
+
+func (l *EspressoDevNodeLauncherDocker) StartDevNet(ctx context.Context, t *testing.T, options ...DevNetLauncherOption) (*e2esys.System, EspressoDevNode, error) {
+
+	sysConfig := l.GetDevNetSysConfig(ctx, t, options...)
+
+	originalCtx := ctx
+	startOptions, launchContext := l.GetDevNetStartOptions(originalCtx, t, &sysConfig, options...)
+
 	// We want to run the espresso-dev-node.  But we need it to be able to
 	// access the L1 node.
 
@@ -334,7 +395,47 @@ func (l *EspressoDevNodeLauncherDocker) StartDevNet(ctx context.Context, t *test
 
 		startOptions...,
 	)
-	launchContext.System = system
+
+	if err != nil {
+		if system != nil {
+			// We don't want the system running in a partial / incomplete
+			// state. So we'll tell it to stop here, just in case.
+			system.Close()
+		}
+
+		return system, nil, err
+	}
+
+	// Auto System Cleanup tied to the passed in context.
+	{
+		// We want to ensure that the lifecycle of the system node is tied to
+		// the context we were given, just like the espresso-dev-node.  So if
+		// the context is canceled, or otherwise closed, it will automatically
+		// clean up the system.
+		go (func(ctx context.Context) {
+			<-ctx.Done()
+
+			// The system is guaranteed to not be null here.
+			system.Close()
+		})(originalCtx)
+	}
+
+	return system, launchContext.EspressoDevNode, launchContext.Error
+}
+
+// StartDevNetWithFaultDisputeSystem starts a Fault Dispute System with an Espresso Dev Node
+func (l *EspressoDevNodeLauncherDocker) StartDevNetWithFaultDisputeSystem(ctx context.Context, t *testing.T, options ...DevNetLauncherOption) (*e2esys.System, EspressoDevNode, error) {
+
+	sysConfig := l.GetDevNetWithFaultDisputeSysConfig(ctx, t, options...)
+
+	originalCtx := ctx
+	startOptions, launchContext := l.GetDevNetStartOptions(originalCtx, t, &sysConfig, options...)
+
+	system, err := sysConfig.Start(
+		t,
+
+		startOptions...,
+	)
 
 	if err != nil {
 		if system != nil {

justfile

@@ -26,7 +26,7 @@ build-batcher-enclave-image:
 run-test4: compile-contracts
  go test ./espresso/environment/4_confirmation_integrity_with_reorgs_test.go -v
 
-espresso_tests_timeout := "30m"
+espresso_tests_timeout := "35m"
 espresso-tests timeout=espresso_tests_timeout: compile-contracts
  go test -timeout={{timeout}} -p=1 -count=1 ./espresso/environment
 

op-e2e/faultproofs/util.go

@@ -108,6 +108,32 @@ func StartFaultDisputeSystem(t *testing.T, opts ...faultDisputeConfigOpts) (*e2e
 	return sys, sys.NodeClient("l1")
 }
 
+// GetFaultDisputeSystemConfigForEspresso returns a Fault Dispute System configuration with another set of options
+func GetFaultDisputeSystemConfigForEspresso(t *testing.T, original_opts []e2esys.SystemConfigOpt, opts ...faultDisputeConfigOpts) e2esys.SystemConfig {
+	fdc := new(faultDisputeConfig)
+	for _, opt := range opts {
+		opt(fdc)
+	}
+
+	// merge two sets of options
+	cfg := e2esys.DefaultSystemConfig(t, append(original_opts, fdc.sysOpts...)...)
+
+	// all the following options are specific to Fault Dispute System
+	// they're pasted from `StartFaultDisputeSystem` in `op-e2e/faultproofs/util.go`(same file)
+	// and we remove the line `delete(cfg.Nodes, "verifier")`
+	cfg.Nodes["sequencer"].SafeDBPath = t.TempDir()
+	cfg.DeployConfig.SequencerWindowSize = 30
+	cfg.DeployConfig.FinalizationPeriodSeconds = 2
+	cfg.SupportL1TimeTravel = true
+	// Disable proposer creating fast games automatically - required games are manually created
+	cfg.DisableProposer = true
+	for _, opt := range fdc.cfgModifiers {
+		opt(&cfg)
+	}
+
+	return cfg
+}
+
 func SendKZGPointEvaluationTx(t *testing.T, sys *e2esys.System, l2Node string, privateKey *ecdsa.PrivateKey) *types.Receipt {
 	return helpers.SendL2Tx(t, sys.Cfg, sys.NodeClient(l2Node), privateKey, func(opts *helpers.TxOpts) {
 		precompile := common.BytesToAddress([]byte{0x0a})