op-challenger: Add actor based tests for game solver (#9637)

Includes rules to confirm that every move performed by the challenger would succeed as a call to contracts
Verifies that the game resolves correctly and the challenger is paid for every move it makes.

op-challenger/game/fault/solver/actors.go

+package solver
+
+import (
+	"testing"
+
+	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/test"
+	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
+	"github.com/ethereum/go-ethereum/common"
+)
+
+type actor interface {
+	Apply(t *testing.T, game types.Game, correctTrace types.TraceProvider) (types.Game, bool)
+}
+
+type actorFn func(t *testing.T, game types.Game, correctTrace types.TraceProvider) (types.Game, bool)
+
+func (a actorFn) Apply(t *testing.T, game types.Game, correctTrace types.TraceProvider) (types.Game, bool) {
+	return a(t, game, correctTrace)
+}
+
+type builderFn func(builder *test.GameBuilder) bool
+
+func (a builderFn) Apply(t *testing.T, game types.Game, correctTrace types.TraceProvider) (types.Game, bool) {
+	builder := test.NewGameBuilderFromGame(t, correctTrace, game)
+	done := a(builder)
+	return builder.Game, done
+}
+
+func combineActors(actors ...actor) actor {
+	return actorFn(func(t *testing.T, game types.Game, correctTrace types.TraceProvider) (types.Game, bool) {
+		done := true
+		for _, actor := range actors {
+			newGame, actorDone := actor.Apply(t, game, correctTrace)
+			game = newGame
+			done = done && actorDone
+		}
+		return game, done
+	})
+}
+
+var doNothingActor builderFn = func(builder *test.GameBuilder) bool {
+	return true
+}
+
+var correctAttackLastClaim = respondLastClaim(func(seq *test.GameBuilderSeq) {
+	seq.Attack()
+})
+
+var correctDefendLastClaim = respondLastClaim(func(seq *test.GameBuilderSeq) {
+	if seq.IsRoot() {
+		// Must attack the root
+		seq.Attack()
+	} else {
+		seq.Defend()
+	}
+})
+
+var incorrectAttackLastClaim = respondLastClaim(func(seq *test.GameBuilderSeq) {
+	seq.Attack(test.WithValue(common.Hash{0xaa}))
+})
+
+var incorrectDefendLastClaim = respondLastClaim(func(seq *test.GameBuilderSeq) {
+	if seq.IsRoot() {
+		// Must attack the root
+		seq.Attack(test.WithValue(common.Hash{0xdd}))
+	} else {
+		seq.Defend(test.WithValue(common.Hash{0xdd}))
+	}
+})
+
+var attackEverythingCorrect = respondAllClaims(func(seq *test.GameBuilderSeq) {
+	seq.Attack()
+})
+
+var defendEverythingCorrect = respondAllClaims(func(seq *test.GameBuilderSeq) {
+	if seq.IsRoot() {
+		// Must attack root
+		seq.Attack()
+	} else {
+		seq.Defend()
+	}
+})
+
+var attackEverythingIncorrect = respondAllClaims(func(seq *test.GameBuilderSeq) {
+	seq.Attack(test.WithValue(common.Hash{0xaa}))
+})
+
+var defendEverythingIncorrect = respondAllClaims(func(seq *test.GameBuilderSeq) {
+	if seq.IsRoot() {
+		// Must attack root
+		seq.Attack(test.WithValue(common.Hash{0xbb}))
+	} else {
+		seq.Defend(test.WithValue(common.Hash{0xbb}))
+	}
+})
+
+var exhaustive = respondAllClaims(func(seq *test.GameBuilderSeq) {
+	seq.Attack()
+	seq.Attack(test.WithValue(common.Hash{0xaa}))
+	if !seq.IsRoot() {
+		seq.Defend()
+		seq.Defend(test.WithValue(common.Hash{0xdd}))
+	}
+})
+
+func respondLastClaim(respond func(seq *test.GameBuilderSeq)) builderFn {
+	return func(builder *test.GameBuilder) bool {
+		seq := seqFromLastClaim(builder)
+		if seq.IsMaxDepth() {
+			// Can't counter the leaf claim
+			return true
+		}
+		respond(seq)
+		return false
+	}
+}
+
+func respondAllClaims(respond func(seq *test.GameBuilderSeq)) builderFn {
+	return func(builder *test.GameBuilder) bool {
+		startingCount := len(builder.Game.Claims())
+		for _, claim := range builder.Game.Claims() {
+			if claim.Depth() == builder.Game.MaxDepth() {
+				continue
+			}
+			respond(builder.SeqFrom(claim))
+		}
+		finalCount := len(builder.Game.Claims())
+		return finalCount == startingCount
+	}
+}
+
+func seqFromLastClaim(builder *test.GameBuilder) *test.GameBuilderSeq {
+	claims := builder.Game.Claims()
+	claim := claims[len(claims)-1]
+	return builder.SeqFrom(claim)
+}

op-challenger/game/fault/solver/game_rules_test.go

+package solver
+
+import (
+	"testing"
+
+	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
+	gameTypes "github.com/ethereum-optimism/optimism/op-challenger/game/types"
+	"github.com/ethereum-optimism/optimism/op-dispute-mon/mon/resolution"
+	"github.com/ethereum-optimism/optimism/op-dispute-mon/mon/transform"
+	disputeTypes "github.com/ethereum-optimism/optimism/op-dispute-mon/mon/types"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/stretchr/testify/require"
+)
+
+func verifyGameRules(t *testing.T, game types.Game, rootClaimCorrect bool) {
+	actualResult, claimTree, resolvedGame := gameResult(game)
+	t.Log("Resolved game:")
+	logClaims(t, resolvedGame)
+
+	verifyExpectedGameResult(t, rootClaimCorrect, actualResult)
+
+	verifyNoChallengerClaimsWereSuccessfullyCountered(t, resolvedGame)
+	verifyChallengerAlwaysWinsParentBond(t, resolvedGame)
+	verifyChallengerNeverCountersAClaimTwice(t, claimTree)
+}
+
+// verifyExpectedGameResult verifies that valid output roots are successfully defended and invalid roots are challenged
+// Rationale: Ensures the game always and only allows valid output roots to be finalized.
+func verifyExpectedGameResult(t *testing.T, rootClaimCorrect bool, actualResult gameTypes.GameStatus) {
+	expectedResult := gameTypes.GameStatusChallengerWon
+	if rootClaimCorrect {
+		expectedResult = gameTypes.GameStatusDefenderWon
+	}
+	require.Equalf(t, expectedResult, actualResult, "Game should resolve correctly expected %v but was %v", expectedResult, actualResult)
+}
+
+// verifyNoChallengerClaimsWereSuccessfullyCountered verifies the challenger didn't lose any of its bonds
+// Note that this also forbids the challenger losing a bond to itself since it shouldn't challenge its own claims
+// Rationale: If honest actors lose their bond, it indicates that incentive compatibility is broken because honest actors
+// lose money.
+func verifyNoChallengerClaimsWereSuccessfullyCountered(t *testing.T, resolvedGame types.Game) {
+	for _, claim := range resolvedGame.Claims() {
+		if claim.Claimant != challengerAddr {
+			continue
+		}
+		if claim.CounteredBy != (common.Address{}) {
+			t.Fatalf("Challenger posted claim %v but it was countered by someone else:\n%v", claim.ContractIndex, printClaim(claim, resolvedGame))
+		}
+	}
+}
+
+// verifyChallengerAlwaysWinsParentBond verifies that the challenger is always allocated the bond of any parent claim it
+// counters.
+// Rationale: If an honest action does not win the bond for countering a claim, incentive compatibility is broken because
+// honest actors are not being paid to perform their job (or the challenger is posting unnecessary claims)
+func verifyChallengerAlwaysWinsParentBond(t *testing.T, resolvedGame types.Game) {
+	for _, claim := range resolvedGame.Claims() {
+		if claim.Claimant != challengerAddr {
+			continue
+		}
+		parent, err := resolvedGame.GetParent(claim)
+		require.NoErrorf(t, err, "Failed to get parent of claim %v", claim.ContractIndex)
+		require.Equal(t, challengerAddr, parent.CounteredBy,
+			"Expected claim %v to have challenger as its claimant because of counter claim %v", parent.ContractIndex, claim.ContractIndex)
+	}
+}
+
+// verifyChallengerNeverCountersAClaimTwice verifies that the challenger never posts more than one counter to a claim
+// Rationale: The parent claim bond is only intended to cover costs of a single counter claim so incentive compatibility
+// is broken if the challenger needs to post multiple claims. Or if the claim wasn't required, the challenger is just
+// wasting money posting unnecessary claims.
+func verifyChallengerNeverCountersAClaimTwice(t *testing.T, tree *disputeTypes.BidirectionalTree) {
+	for _, claim := range tree.Claims {
+		challengerCounterCount := 0
+		for _, child := range claim.Children {
+			if child.Claim.Claimant != challengerAddr {
+				continue
+			}
+			challengerCounterCount++
+		}
+		require.LessOrEqualf(t, challengerCounterCount, 1, "Found multiple honest counters to claim %v", claim.Claim.ContractIndex)
+	}
+}
+
+func gameResult(game types.Game) (gameTypes.GameStatus, *disputeTypes.BidirectionalTree, types.Game) {
+	tree := transform.CreateBidirectionalTree(game.Claims())
+	result := resolution.Resolve(tree)
+	resolvedClaims := make([]types.Claim, 0, len(tree.Claims))
+	for _, claim := range tree.Claims {
+		resolvedClaims = append(resolvedClaims, *claim.Claim)
+	}
+	return result, tree, types.NewGameState(resolvedClaims, game.MaxDepth())
+}
+
+func logClaims(t *testing.T, game types.Game) {
+	for _, claim := range game.Claims() {
+		t.Log(printClaim(claim, game))
+	}
+}

op-challenger/game/fault/solver/game_solver_test.go

@@ -10,9 +10,6 @@ import (
 	faulttest "github.com/ethereum-optimism/optimism/op-challenger/game/fault/test"
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace"
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
-	gameTypes "github.com/ethereum-optimism/optimism/op-challenger/game/types"
-	"github.com/ethereum-optimism/optimism/op-dispute-mon/mon/resolution"
-	"github.com/ethereum-optimism/optimism/op-dispute-mon/mon/transform"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/stretchr/testify/require"
 )
@@ -199,31 +196,14 @@ func TestCalculateNextActions(t *testing.T) {
 	for _, test := range tests {
 		test := test
 		t.Run(test.name, func(t *testing.T) {
-			switch test.runCondition {
-			case RunAlways:
-			case RunFreeloadersCountered:
-				if !expectFreeloaderCounters {
-					t.Skip("Freeloader countering not enabled")
-				}
-			case RunFreeloadersNotCountered:
-				if expectFreeloaderCounters {
-					t.Skip("Freeloader countering enabled")
-				}
-			}
+			enforceRunConditions(t, test.runCondition)
 			builder := claimBuilder.GameBuilder(faulttest.WithInvalidValue(!test.rootClaimCorrect))
 			test.setupGame(builder)
 			game := builder.Game
 			logClaims(t, game)
 
 			solver := NewGameSolver(maxDepth, trace.NewSimpleTraceAccessor(claimBuilder.CorrectTraceProvider()))
-			actions, err := solver.CalculateNextActions(context.Background(), game)
-			require.NoError(t, err)
-			for i, action := range actions {
-				t.Logf("Move %v: Type: %v, ParentIdx: %v, Attack: %v, Value: %v, PreState: %v, ProofData: %v",
-					i, action.Type, action.ParentIdx, action.IsAttack, action.Value, hex.EncodeToString(action.PreState), hex.EncodeToString(action.ProofData))
-				// Check that every move the solver returns meets the generic validation rules
-				require.NoError(t, checkRules(game, action), "Attempting to perform invalid action")
-			}
+			postState, actions := runStep(t, solver, game, claimBuilder.CorrectTraceProvider())
 			for i, action := range builder.ExpectedActions {
 				t.Logf("Expect %v: Type: %v, ParentIdx: %v, Attack: %v, Value: %v, PreState: %v, ProofData: %v",
 					i, action.Type, action.ParentIdx, action.IsAttack, action.Value, hex.EncodeToString(action.PreState), hex.EncodeToString(action.ProofData))
@@ -231,24 +211,126 @@ func TestCalculateNextActions(t *testing.T) {
 			}
 			require.Len(t, actions, len(builder.ExpectedActions), "Incorrect number of actions")
 
-			challengerAddr := common.Address{0xaa, 0xbb, 0xcc, 0xdd}
-			postState := applyActions(game, challengerAddr, actions)
-			t.Log("Post game state:")
-			logClaims(t, postState)
-			actualResult := gameResult(postState)
-			expectedResult := gameTypes.GameStatusChallengerWon
-			if test.rootClaimCorrect {
-				expectedResult = gameTypes.GameStatusDefenderWon
-			}
-			require.Equalf(t, expectedResult, actualResult, "Game should resolve correctly expected %v but was %v", expectedResult, actualResult)
+			verifyGameRules(t, postState, test.rootClaimCorrect)
 		})
 	}
 }
 
-func logClaims(t *testing.T, game types.Game) {
-	for i, claim := range game.Claims() {
-		t.Logf("Claim %v: Pos: %v TraceIdx: %v Depth: %v IndexAtDepth: %v ParentIdx: %v Value: %v Claimant: %v CounteredBy: %v",
-			i, claim.Position.ToGIndex(), claim.Position.TraceIndex(game.MaxDepth()), claim.Position.Depth(), claim.Position.IndexAtDepth(), claim.ParentContractIndex, claim.Value, claim.Claimant, claim.CounteredBy)
+func runStep(t *testing.T, solver *GameSolver, game types.Game, correctTraceProvider types.TraceProvider) (types.Game, []types.Action) {
+	actions, err := solver.CalculateNextActions(context.Background(), game)
+	require.NoError(t, err)
+
+	postState := applyActions(game, challengerAddr, actions)
+	t.Log("Post state:")
+	logClaims(t, postState)
+
+	for i, action := range actions {
+		t.Logf("Move %v: Type: %v, ParentIdx: %v, Attack: %v, Value: %v, PreState: %v, ProofData: %v",
+			i, action.Type, action.ParentIdx, action.IsAttack, action.Value, hex.EncodeToString(action.PreState), hex.EncodeToString(action.ProofData))
+		// Check that every move the solver returns meets the generic validation rules
+		require.NoError(t, checkRules(game, action, correctTraceProvider), "Attempting to perform invalid action")
+	}
+	return postState, actions
+}
+
+func TestMultipleRounds(t *testing.T) {
+	t.Parallel()
+	tests := []struct {
+		name         string
+		actor        actor
+		runCondition RunCondition
+	}{
+		{
+			name:  "SingleRoot",
+			actor: doNothingActor,
+		},
+		{
+			name:  "LinearAttackCorrect",
+			actor: correctAttackLastClaim,
+		},
+		{
+			name:  "LinearDefendCorrect",
+			actor: correctDefendLastClaim,
+		},
+		{
+			name:  "LinearAttackIncorrect",
+			actor: incorrectAttackLastClaim,
+		},
+		{
+			name:  "LinearDefendInorrect",
+			actor: incorrectDefendLastClaim,
+		},
+		{
+			name:  "LinearDefendIncorrectDefendCorrect",
+			actor: combineActors(incorrectDefendLastClaim, correctDefendLastClaim),
+		},
+		{
+			name:  "LinearAttackIncorrectDefendCorrect",
+			actor: combineActors(incorrectAttackLastClaim, correctDefendLastClaim),
+		},
+		{
+			name:  "LinearDefendIncorrectDefendIncorrect",
+			actor: combineActors(incorrectDefendLastClaim, incorrectDefendLastClaim),
+		},
+		{
+			name:  "LinearAttackIncorrectDefendIncorrect",
+			actor: combineActors(incorrectAttackLastClaim, incorrectDefendLastClaim),
+		},
+		{
+			name:         "AttackEverythingCorrect",
+			actor:        attackEverythingCorrect,
+			runCondition: RunFreeloadersCountered,
+		},
+		{
+			name:  "DefendEverythingCorrect",
+			actor: defendEverythingCorrect,
+		},
+		{
+			name:  "AttackEverythingIncorrect",
+			actor: attackEverythingIncorrect,
+		},
+		{
+			name:  "DefendEverythingIncorrect",
+			actor: defendEverythingIncorrect,
+		},
+		{
+			name:  "Exhaustive",
+			actor: exhaustive,
+			// TODO(client-pod#611): We attempt to step even though the prestate is invalid
+			// The step call would fail to estimate gas so not even send, but the challenger shouldn't try
+			runCondition: RunFreeloadersCountered,
+		},
+	}
+	for _, test := range tests {
+		test := test
+		for _, rootClaimCorrect := range []bool{true, false} {
+			rootClaimCorrect := rootClaimCorrect
+			t.Run(fmt.Sprintf("%v-%v", test.name, rootClaimCorrect), func(t *testing.T) {
+				t.Parallel()
+				enforceRunConditions(t, test.runCondition)
+
+				maxDepth := types.Depth(6)
+				startingL2BlockNumber := big.NewInt(50)
+				claimBuilder := faulttest.NewAlphabetClaimBuilder(t, startingL2BlockNumber, maxDepth)
+				builder := claimBuilder.GameBuilder(faulttest.WithInvalidValue(!rootClaimCorrect))
+				game := builder.Game
+				logClaims(t, game)
+
+				correctTrace := claimBuilder.CorrectTraceProvider()
+				solver := NewGameSolver(maxDepth, trace.NewSimpleTraceAccessor(correctTrace))
+
+				roundNum := 0
+				done := false
+				for !done {
+					t.Logf("------ ROUND %v ------", roundNum)
+					game, _ = runStep(t, solver, game, correctTrace)
+					verifyGameRules(t, game, rootClaimCorrect)
+
+					game, done = test.actor.Apply(t, game, correctTrace)
+					roundNum++
+				}
+			})
+		}
 	}
 }
 
@@ -284,7 +366,16 @@ func applyActions(game types.Game, claimant common.Address, actions []types.Acti
 	return types.NewGameState(claims, game.MaxDepth())
 }
 
-func gameResult(game types.Game) gameTypes.GameStatus {
-	tree := transform.CreateBidirectionalTree(game.Claims())
-	return resolution.Resolve(tree)
+func enforceRunConditions(t *testing.T, runCondition RunCondition) {
+	switch runCondition {
+	case RunAlways:
+	case RunFreeloadersCountered:
+		if !expectFreeloaderCounters {
+			t.Skip("Freeloader countering not enabled")
+		}
+	case RunFreeloadersNotCountered:
+		if expectFreeloaderCounters {
+			t.Skip("Freeloader countering enabled")
+		}
+	}
 }

op-challenger/game/fault/test/claim_builder.go

@@ -10,7 +10,7 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-var DefaultClaimant = common.Address{0x09, 0x23, 0x34, 0x45, 0x13, 0xb3}
+var DefaultClaimant = common.Address{0xba, 0xdb, 0xad, 0xba, 0xdb, 0xad}
 
 type claimCfg struct {
 	value        common.Hash

op-challenger/game/fault/test/game_builder.go

@@ -2,6 +2,7 @@ package test
 
 import (
 	"math/big"
+	"testing"
 
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
 	"github.com/ethereum/go-ethereum/common"
@@ -13,6 +14,14 @@ type GameBuilder struct {
 	ExpectedActions []types.Action
 }
 
+func NewGameBuilderFromGame(t *testing.T, provider types.TraceProvider, game types.Game) *GameBuilder {
+	claimBuilder := NewClaimBuilder(t, game.MaxDepth(), provider)
+	return &GameBuilder{
+		builder: claimBuilder,
+		Game:    types.NewGameState(game.Claims(), game.MaxDepth()),
+	}
+}
+
 func (c *ClaimBuilder) GameBuilder(rootOpts ...ClaimOpt) *GameBuilder {
 	return &GameBuilder{
 		builder: c,
@@ -38,9 +47,21 @@ func (g *GameBuilder) SeqFrom(claim types.Claim) *GameBuilderSeq {
 	}
 }
 
+func (g *GameBuilderSeq) IsMaxDepth() bool {
+	return g.lastClaim.Depth() == g.gameBuilder.Game.MaxDepth()
+}
+
+func (g *GameBuilderSeq) IsRoot() bool {
+	return g.lastClaim.IsRoot()
+}
+
 // addClaimToGame replaces the game being built with a new instance that has claim as the latest claim.
 // The ContractIndex in claim is updated with its position in the game's claim array.
+// Does nothing if the claim already exists
 func (s *GameBuilderSeq) addClaimToGame(claim *types.Claim) {
+	if s.gameBuilder.Game.IsDuplicate(*claim) {
+		return
+	}
 	claim.ContractIndex = len(s.gameBuilder.Game.Claims())
 	claims := append(s.gameBuilder.Game.Claims(), *claim)
 	s.gameBuilder.Game = types.NewGameState(claims, s.builder.maxDepth)