test: alphabet game e2etest for MSFDG

op-e2e2/e2eutils/challenger/helper.go

@@ -19,8 +19,8 @@ import (
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/log"
 
-	challenger "github.com/ethereum-optimism/optimism/op-challenger"
-	"github.com/ethereum-optimism/optimism/op-challenger/config"
+	challenger "github.com/ethereum-optimism/optimism/op-challenger2"
+	"github.com/ethereum-optimism/optimism/op-challenger2/config"
 	"github.com/ethereum-optimism/optimism/op-e2e2/e2eutils"
 	"github.com/ethereum-optimism/optimism/op-e2e2/e2eutils/wait"
 	"github.com/ethereum-optimism/optimism/op-node/rollup"
@@ -80,6 +80,12 @@ func WithPollInterval(pollInterval time.Duration) Option {
 	}
 }
 
+func WithDaType(datype int64) Option {
+	return func(c *config.Config) {
+		c.DAType = datype
+	}
+}
+
 // FindMonorepoRoot finds the relative path to the monorepo root
 // Different tests might be nested in subdirectories of the op-e2e dir.
 func FindMonorepoRoot(t *testing.T) string {
@@ -150,7 +156,8 @@ func NewChallengerConfig(t *testing.T, sys EndpointProvider, l2NodeName string,
 	// Use the NewConfig method to ensure we pick up any defaults that are set.
 	l1Endpoint := sys.NodeEndpoint("l1")
 	l1Beacon := sys.L1BeaconEndpoint()
-	cfg := config.NewConfig(common.Address{}, l1Endpoint, l1Beacon, sys.RollupEndpoint(l2NodeName), sys.NodeEndpoint(l2NodeName), t.TempDir())
+	datype := config.DACalldata
+	cfg := config.NewConfig(common.Address{}, l1Endpoint, l1Beacon, sys.RollupEndpoint(l2NodeName), sys.NodeEndpoint(l2NodeName), t.TempDir(), datype)
 	// The devnet can't set the absolute prestate output root because the contracts are deployed in L1 genesis
 	// before the L2 genesis is known.
 	cfg.AllowInvalidPrestate = true

op-e2e2/e2eutils/challenger/metrics.go

@@ -3,7 +3,7 @@ package challenger
 import (
 	"sync/atomic"
 
-	"github.com/ethereum-optimism/optimism/op-challenger/metrics"
+	"github.com/ethereum-optimism/optimism/op-challenger2/metrics"
 )
 
 type CapturingMetrics struct {

op-e2e2/e2eutils/disputegame/claim_helper.go

@@ -6,7 +6,8 @@ import (
 	"slices"
 	"time"
 
-	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
+	"github.com/ethereum-optimism/optimism/op-challenger2/game/fault/contracts"
+	"github.com/ethereum-optimism/optimism/op-challenger2/game/fault/types"
 	"github.com/ethereum-optimism/optimism/op-e2e2/e2eutils/wait"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/stretchr/testify/require"
@@ -33,7 +34,7 @@ func newClaimHelper(game *OutputGameHelper, idx int64, claim types.Claim) *Claim
 }
 
 func (c *ClaimHelper) AgreesWithOutputRoot() bool {
-	return c.Position.Depth()%2 == 0
+	return c.Position.Depth()%(types.Depth(2*c.game.Nbits)) == 0
 }
 
 func (c *ClaimHelper) IsRootClaim() bool {
@@ -52,7 +53,7 @@ func (c *ClaimHelper) IsOutputRootLeaf(ctx context.Context) bool {
 
 func (c *ClaimHelper) IsBottomGameRoot(ctx context.Context) bool {
 	splitDepth := c.game.SplitDepth(ctx)
-	return c.Position.Depth() == splitDepth+1
+	return c.Position.Depth() == splitDepth+types.Depth(c.game.Nbits)
 }
 
 func (c *ClaimHelper) IsMaxDepth(ctx context.Context) bool {
@@ -93,8 +94,13 @@ func (c *ClaimHelper) WaitForCountered(ctx context.Context) {
 
 func (c *ClaimHelper) RequireCorrectOutputRoot(ctx context.Context) {
 	c.require.True(c.IsOutputRoot(ctx), "Should not expect a valid output root in the bottom game")
-	expected, err := c.game.CorrectOutputProvider.Get(ctx, c.Position)
-	c.require.NoError(err, "Failed to get correct output root")
+	subValues := []common.Hash{}
+	for i := uint64(0); i < (1<<c.game.Nbits - 1); i++ {
+		value, err := c.game.CorrectOutputProvider.Get(ctx, c.Position.MoveRightN(i))
+		c.require.NoError(err, fmt.Errorf("Failed to get correct output root at pos %v", c.Position))
+		subValues = append(subValues, value)
+	}
+	expected := contracts.SubValuesHash(subValues)
 	c.require.Equalf(expected, c.claim, "Should have correct output root in claim %v and position %v", c.Index, c.Position)
 }
 
@@ -103,11 +109,15 @@ func (c *ClaimHelper) Attack(ctx context.Context, value common.Hash, opts ...Mov
 	return c.WaitForCounterClaim(ctx)
 }
 
-func (c *ClaimHelper) Defend(ctx context.Context, value common.Hash, opts ...MoveOpt) *ClaimHelper {
-	c.game.Defend(ctx, c.Index, value, opts...)
+func (c *ClaimHelper) Attack2(ctx context.Context, attackBranch uint64, subValues []common.Hash, opts ...MoveOpt) *ClaimHelper {
+	c.game.Attack2(ctx, c.Index, attackBranch, subValues, opts...)
 	return c.WaitForCounterClaim(ctx)
 }
 
+func (c *ClaimHelper) Defend(ctx context.Context, value common.Hash, opts ...MoveOpt) *ClaimHelper {
+	panic("Depreacated, use attack2 instead!")
+}
+
 func (c *ClaimHelper) RequireDifferentClaimValue(other *ClaimHelper) {
 	c.require.NotEqual(c.claim, other.claim, "should have posted different claims")
 }

op-e2e2/e2eutils/disputegame/dishonest_helper.go

@@ -5,7 +5,7 @@ import (
 	"errors"
 	"time"
 
-	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
+	"github.com/ethereum-optimism/optimism/op-challenger2/game/fault/types"
 	"github.com/ethereum/go-ethereum/common"
 )
 
@@ -39,16 +39,21 @@ func (d *DishonestHelper) ExhaustDishonestClaims(ctx context.Context, rootClaim
 
 		d.LogGameData(ctx)
 		d.OutputGameHelper.T.Logf("Dishonest moves against claimIndex %d", claimIndex)
-		agreeWithLevel := d.defender == (claimData.Depth()%2 == 0)
+		agreeWithLevel := d.defender == (claimData.Depth()%(types.Depth(2*d.Nbits)) == 0)
+		maxAttackBranch := 1<<d.Nbits - 1
 		if !agreeWithLevel {
-			d.OutputHonestHelper.Attack(ctx, claimIndex, WithIgnoreDuplicates())
-			if claimIndex != 0 && claimData.Depth() != splitDepth+1 {
-				d.OutputHonestHelper.Defend(ctx, claimIndex, WithIgnoreDuplicates())
+			d.OutputHonestHelper.Attack2(ctx, claimIndex, 0, WithIgnoreDuplicates())
+			if claimIndex != 0 && claimData.Depth() != splitDepth+types.Depth(d.Nbits) {
+				d.OutputHonestHelper.Attack2(ctx, claimIndex, uint64(maxAttackBranch), WithIgnoreDuplicates())
 			}
 		}
-		d.OutputGameHelper.Attack(ctx, claimIndex, common.Hash{byte(claimIndex)}, WithIgnoreDuplicates())
-		if claimIndex != 0 && claimData.Depth() != splitDepth+1 {
-			d.OutputGameHelper.Defend(ctx, claimIndex, common.Hash{byte(claimIndex)}, WithIgnoreDuplicates())
+		incorresctSubValues := []common.Hash{}
+		for i := 0; i < maxAttackBranch; i++ {
+			incorresctSubValues = append(incorresctSubValues, common.Hash{byte(claimIndex)})
+		}
+		d.OutputGameHelper.Attack2(ctx, claimIndex, 0, incorresctSubValues, WithIgnoreDuplicates())
+		if claimIndex != 0 && claimData.Depth() != splitDepth+types.Depth(d.Nbits) {
+			d.OutputGameHelper.Attack2(ctx, claimIndex, uint64(maxAttackBranch), incorresctSubValues, WithIgnoreDuplicates())
 		}
 	}
 

op-e2e2/e2eutils/disputegame/helper.go

@@ -8,9 +8,9 @@ import (
 	"time"
 
 	"github.com/ethereum-optimism/optimism/op-chain-ops/genesis"
-	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/contracts"
-	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/contracts/metrics"
-	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/outputs"
+	"github.com/ethereum-optimism/optimism/op-challenger2/game/fault/contracts"
+	"github.com/ethereum-optimism/optimism/op-challenger2/game/fault/contracts/metrics"
+	"github.com/ethereum-optimism/optimism/op-challenger2/game/fault/trace/outputs"
 	"github.com/ethereum-optimism/optimism/op-e2e2/bindings"
 	"github.com/ethereum-optimism/optimism/op-e2e2/e2eutils/challenger"
 	"github.com/ethereum-optimism/optimism/op-e2e2/e2eutils/disputegame/preimage"
@@ -90,9 +90,10 @@ type FactoryHelper struct {
 	Opts        *bind.TransactOpts
 	FactoryAddr common.Address
 	Factory     *bindings.DisputeGameFactory
+	DaType      int64
 }
 
-func NewFactoryHelper(t *testing.T, ctx context.Context, system DisputeSystem) *FactoryHelper {
+func NewFactoryHelper(t *testing.T, ctx context.Context, system DisputeSystem, daType int64) *FactoryHelper {
 	require := require.New(t)
 	client := system.NodeClient("l1")
 	chainID, err := client.ChainID(ctx)
@@ -113,6 +114,7 @@ func NewFactoryHelper(t *testing.T, ctx context.Context, system DisputeSystem) *
 		Opts:        opts,
 		Factory:     factory,
 		FactoryAddr: factoryAddr,
+		DaType:      daType,
 	}
 }
 
@@ -167,7 +169,7 @@ func (h *FactoryHelper) StartOutputCannonGame(ctx context.Context, l2Node string
 	h.Require.Len(rcpt.Logs, 2, "should have emitted a single DisputeGameCreated event")
 	createdEvent, err := h.Factory.ParseDisputeGameCreated(*rcpt.Logs[1])
 	h.Require.NoError(err)
-	gameBindings, err := bindings.NewFaultDisputeGame(createdEvent.DisputeProxy, h.Client)
+	gameBindings, err := bindings.NewFaultDisputeGameN(createdEvent.DisputeProxy, h.Client)
 	h.Require.NoError(err)
 	game, err := contracts.NewFaultDisputeGameContract(ctx, metrics.NoopContractMetrics, createdEvent.DisputeProxy, batching.NewMultiCaller(h.Client.Client(), batching.DefaultBatchSize))
 	h.Require.NoError(err)
@@ -182,7 +184,7 @@ func (h *FactoryHelper) StartOutputCannonGame(ctx context.Context, l2Node string
 	provider := outputs.NewTraceProvider(logger, prestateProvider, rollupClient, l2Client, l1Head, splitDepth, prestateBlock, poststateBlock)
 
 	return &OutputCannonGameHelper{
-		OutputGameHelper: *NewOutputGameHelper(h.T, h.Require, h.Client, h.Opts, game, gameBindings, h.FactoryAddr, createdEvent.DisputeProxy, provider, h.System),
+		OutputGameHelper: *NewOutputGameHelper(h.T, h.Require, h.Client, h.Opts, game, gameBindings, h.FactoryAddr, createdEvent.DisputeProxy, provider, h.System, h.DaType),
 	}
 }
 
@@ -223,7 +225,7 @@ func (h *FactoryHelper) StartOutputAlphabetGame(ctx context.Context, l2Node stri
 	h.Require.Len(rcpt.Logs, 2, "should have emitted a single DisputeGameCreated event")
 	createdEvent, err := h.Factory.ParseDisputeGameCreated(*rcpt.Logs[1])
 	h.Require.NoError(err)
-	gameBindings, err := bindings.NewFaultDisputeGame(createdEvent.DisputeProxy, h.Client)
+	gameBindings, err := bindings.NewFaultDisputeGameN(createdEvent.DisputeProxy, h.Client)
 	h.Require.NoError(err)
 	game, err := contracts.NewFaultDisputeGameContract(ctx, metrics.NoopContractMetrics, createdEvent.DisputeProxy, batching.NewMultiCaller(h.Client.Client(), batching.DefaultBatchSize))
 	h.Require.NoError(err)
@@ -238,7 +240,7 @@ func (h *FactoryHelper) StartOutputAlphabetGame(ctx context.Context, l2Node stri
 	provider := outputs.NewTraceProvider(logger, prestateProvider, rollupClient, l2Client, l1Head, splitDepth, prestateBlock, poststateBlock)
 
 	return &OutputAlphabetGameHelper{
-		OutputGameHelper: *NewOutputGameHelper(h.T, h.Require, h.Client, h.Opts, game, gameBindings, h.FactoryAddr, createdEvent.DisputeProxy, provider, h.System),
+		OutputGameHelper: *NewOutputGameHelper(h.T, h.Require, h.Client, h.Opts, game, gameBindings, h.FactoryAddr, createdEvent.DisputeProxy, provider, h.System, h.DaType),
 	}
 }
 

op-e2e2/e2eutils/disputegame/output_alphabet_helper.go

@@ -3,8 +3,8 @@ package disputegame
 import (
 	"context"
 
-	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/outputs"
-	"github.com/ethereum-optimism/optimism/op-challenger/metrics"
+	"github.com/ethereum-optimism/optimism/op-challenger2/game/fault/trace/outputs"
+	"github.com/ethereum-optimism/optimism/op-challenger2/metrics"
 	"github.com/ethereum-optimism/optimism/op-e2e2/e2eutils/challenger"
 	"github.com/ethereum-optimism/optimism/op-service/testlog"
 	"github.com/ethereum/go-ethereum/log"

op-e2e2/e2eutils/disputegame/output_cannon_helper.go

@@ -9,13 +9,13 @@ import (
 	"path/filepath"
 	"time"
 
-	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace"
-	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/cannon"
-	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/outputs"
-	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/split"
-	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/utils"
-	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
-	"github.com/ethereum-optimism/optimism/op-challenger/metrics"
+	"github.com/ethereum-optimism/optimism/op-challenger2/game/fault/trace"
+	"github.com/ethereum-optimism/optimism/op-challenger2/game/fault/trace/cannon"
+	"github.com/ethereum-optimism/optimism/op-challenger2/game/fault/trace/outputs"
+	"github.com/ethereum-optimism/optimism/op-challenger2/game/fault/trace/split"
+	"github.com/ethereum-optimism/optimism/op-challenger2/game/fault/trace/utils"
+	"github.com/ethereum-optimism/optimism/op-challenger2/game/fault/types"
+	"github.com/ethereum-optimism/optimism/op-challenger2/metrics"
 	"github.com/ethereum-optimism/optimism/op-e2e2/bindings"
 	"github.com/ethereum-optimism/optimism/op-e2e2/e2eutils/challenger"
 	"github.com/ethereum-optimism/optimism/op-e2e2/e2eutils/wait"
@@ -233,10 +233,10 @@ func (g *OutputCannonGameHelper) VerifyPreimage(ctx context.Context, outputRootC
 		g.Require.NotNil(oracleData, "Should have had required preimage oracle data")
 		g.Require.Equal(common.Hash(preimageKey.PreimageKey()).Bytes(), oracleData.OracleKey, "Must have correct preimage key")
 
-		tx, err := g.GameBindings.AddLocalData(g.Opts,
+		tx, err := g.GameBindings.AddLocalData2(g.Opts,
 			oracleData.GetIdent(),
 			big.NewInt(outputRootClaim.Index),
-			new(big.Int).SetUint64(uint64(oracleData.OracleOffset)))
+			new(big.Int).SetUint64(uint64(oracleData.OracleOffset)), bindings.LibDADAItem{})
 		g.Require.NoError(err)
 		_, err = wait.ForReceiptOK(ctx, g.Client, tx.Hash())
 		g.Require.NoError(err)

op-e2e2/e2eutils/disputegame/output_game_helper.go

@@ -123,6 +123,7 @@ func (g *OutputGameHelper) DisputeBlock(ctx context.Context, disputeBlockNum uin
 	dishonestValue := g.GetClaimValue(ctx, 0)
 	correctRootClaim := g.correctOutputRoot(ctx, types.NewPositionFromGIndex(big.NewInt(1)))
 	rootIsValid := dishonestValue == correctRootClaim
+	nbits := g.Nbits
 	if rootIsValid {
 		// Ensure that the dishonest actor is actually posting invalid roots.
 		// Otherwise, the honest challenger will defend our counter and ruin everything.
@@ -151,15 +152,20 @@ func (g *OutputGameHelper) DisputeBlock(ctx context.Context, disputeBlockNum uin
 		parentClaimBlockNum, err := g.CorrectOutputProvider.ClaimedBlockNumber(pos)
 		g.Require.NoError(err, "failed to calculate parent claim block number")
 		if parentClaimBlockNum >= disputeBlockNum {
-			pos = pos.Attack()
+			pos = pos.MoveN(nbits, 0)
 			subValues := []common.Hash{}
 			for i := 0; i < 1<<g.Nbits-1; i++ {
 				subValues = append(subValues, getClaimValue(claim, pos.MoveRightN(uint64(i))))
 			}
 			claim = claim.Attack2(ctx, 0, subValues)
 		} else {
-			pos = pos.Defend()
-			claim = claim.Defend(ctx, getClaimValue(claim, pos))
+			maxAttackBranch := uint64(1<<nbits - 1)
+			pos = pos.MoveN(nbits, maxAttackBranch)
+			subValues := []common.Hash{}
+			for i := uint64(0); i < maxAttackBranch; i++ {
+				subValues = append(subValues, getClaimValue(claim, pos.MoveRightN(uint64(i))))
+			}
+			claim = claim.Attack2(ctx, maxAttackBranch, subValues)
 		}
 	}
 	return claim

op-e2e2/e2eutils/disputegame/output_honest_helper.go

@@ -5,9 +5,9 @@ import (
 	"testing"
 	"time"
 
-	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/contracts"
-	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
-	"github.com/ethereum-optimism/optimism/op-service/sources/batching/rpcblock"
+	"github.com/ethereum-optimism/optimism/op-challenger2/game/fault/contracts"
+	"github.com/ethereum-optimism/optimism/op-challenger2/game/fault/types"
+	"github.com/ethereum/go-ethereum/common"
 	"github.com/stretchr/testify/require"
 )
 
@@ -35,15 +35,16 @@ func (h *OutputHonestHelper) CounterClaim(ctx context.Context, claim *ClaimHelpe
 	game, target := h.loadState(ctx, claim.Index)
 	value, err := h.correctTrace.Get(ctx, game, target, target.Position)
 	h.require.NoErrorf(err, "Failed to determine correct claim at position %v with g index %v", target.Position, target.Position.ToGIndex())
+
 	if value == claim.claim {
-		return h.DefendClaim(ctx, claim, opts...)
+		return h.AttackClaim(ctx, claim, 1<<h.game.Nbits-1, opts...)
 	} else {
-		return h.AttackClaim(ctx, claim, opts...)
+		return h.AttackClaim(ctx, claim, 0, opts...)
 	}
 }
 
-func (h *OutputHonestHelper) AttackClaim(ctx context.Context, claim *ClaimHelper, opts ...MoveOpt) *ClaimHelper {
-	h.Attack(ctx, claim.Index, opts...)
+func (h *OutputHonestHelper) AttackClaim(ctx context.Context, claim *ClaimHelper, attackBranch uint64, opts ...MoveOpt) *ClaimHelper {
+	h.Attack2(ctx, claim.Index, attackBranch, opts...)
 	return claim.WaitForCounterClaim(ctx)
 }
 
@@ -52,34 +53,33 @@ func (h *OutputHonestHelper) DefendClaim(ctx context.Context, claim *ClaimHelper
 	return claim.WaitForCounterClaim(ctx)
 }
 
-func (h *OutputHonestHelper) Attack(ctx context.Context, claimIdx int64, opts ...MoveOpt) {
+func (h *OutputHonestHelper) Attack2(ctx context.Context, claimIdx int64, attackBranch uint64, opts ...MoveOpt) {
 	// Ensure the claim exists
 	h.game.WaitForClaimCount(ctx, claimIdx+1)
 
 	ctx, cancel := context.WithTimeout(ctx, getTraceTimeout)
 	defer cancel()
 
 	game, claim := h.loadState(ctx, claimIdx)
-	attackPos := claim.Position.Attack()
+	attackPos := claim.Position.MoveN(h.game.Nbits, attackBranch)
 	h.t.Logf("Attacking claim %v at position %v with g index %v", claimIdx, attackPos, attackPos.ToGIndex())
-	value, err := h.correctTrace.Get(ctx, game, claim, attackPos)
-	h.require.NoErrorf(err, "Get correct claim at position %v with g index %v", attackPos, attackPos.ToGIndex())
+	subValues := []common.Hash{}
+	for i := uint64(0); i < 1<<h.game.Nbits-1; i++ {
+		value, err := h.correctTrace.Get(ctx, game, claim, attackPos.MoveRightN(i))
+		h.require.NoErrorf(err, "Get correct claim at position %v with g index %v", attackPos, attackPos.ToGIndex())
+		subValues = append(subValues, value)
+	}
 	h.t.Log("Performing attack")
-	h.game.Attack(ctx, claimIdx, value, opts...)
+	h.game.Attack2(ctx, claimIdx, attackBranch, subValues, opts...)
 	h.t.Log("Attack complete")
 }
 
-func (h *OutputHonestHelper) Defend(ctx context.Context, claimIdx int64, opts ...MoveOpt) {
-	// Ensure the claim exists
-	h.game.WaitForClaimCount(ctx, claimIdx+1)
+func (h *OutputHonestHelper) Attack(ctx context.Context, claimIdx int64, opts ...MoveOpt) {
+	panic("unimplemented, use attack2 instead")
+}
 
-	ctx, cancel := context.WithTimeout(ctx, getTraceTimeout)
-	defer cancel()
-	game, claim := h.loadState(ctx, claimIdx)
-	defendPos := claim.Position.Defend()
-	value, err := h.correctTrace.Get(ctx, game, claim, defendPos)
-	h.game.Require.NoErrorf(err, "Get correct claim at position %v with g index %v", defendPos, defendPos.ToGIndex())
-	h.game.Defend(ctx, claimIdx, value, opts...)
+func (h *OutputHonestHelper) Defend(ctx context.Context, claimIdx int64, opts ...MoveOpt) {
+	panic("unimplemented, use attack2 instead")
 }
 
 func (h *OutputHonestHelper) StepClaimFails(ctx context.Context, claim *ClaimHelper, isAttack bool) {
@@ -105,9 +105,9 @@ func (h *OutputHonestHelper) StepFails(ctx context.Context, claimIdx int64, isAt
 }
 
 func (h *OutputHonestHelper) loadState(ctx context.Context, claimIdx int64) (types.Game, types.Claim) {
-	claims, err := h.contract.GetAllClaims(ctx, rpcblock.Latest)
+	claims, err := h.contract.GetAllClaimsWithSubValues(ctx)
 	h.require.NoError(err, "Failed to load claims from game")
-	game := types.NewGameState(claims, h.game.MaxDepth(ctx))
+	game := types.NewGameState2(claims, h.game.MaxDepth(ctx), h.game.Nbits, h.game.SplitDepth(ctx))
 
 	claim := game.Claims()[claimIdx]
 	return game, claim

op-e2e2/e2eutils/disputegame/preimage/preimage_helper.go

@@ -11,10 +11,10 @@ import (
 	"testing"
 	"time"
 
-	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/contracts"
-	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/preimages"
-	"github.com/ethereum-optimism/optimism/op-challenger/game/keccak/matrix"
-	"github.com/ethereum-optimism/optimism/op-challenger/game/keccak/types"
+	"github.com/ethereum-optimism/optimism/op-challenger2/game/fault/contracts"
+	"github.com/ethereum-optimism/optimism/op-challenger2/game/fault/preimages"
+	"github.com/ethereum-optimism/optimism/op-challenger2/game/keccak/matrix"
+	"github.com/ethereum-optimism/optimism/op-challenger2/game/keccak/types"
 	"github.com/ethereum-optimism/optimism/op-e2e2/bindings"
 	"github.com/ethereum-optimism/optimism/op-e2e2/e2eutils/wait"
 	"github.com/ethereum-optimism/optimism/op-service/sources/batching"