diff --git a/op-challenger2/game/fault/agent.go b/op-challenger2/game/fault/agent.go
index 9a82250f59213..609e848eb9117 100644
--- a/op-challenger2/game/fault/agent.go
+++ b/op-challenger2/game/fault/agent.go
@@ -123,7 +123,7 @@ func (a *Agent) performAction(ctx context.Context, wg *sync.WaitGroup, action ty
 		containsOracleData := action.OracleData != nil
 		isLocal := containsOracleData && action.OracleData.IsLocal
 		actionLog = actionLog.New(
-			"is_attack", action.IsAttack,
+			"attackBranch", action.AttackBranch,
 			"parent", action.ParentClaim.ContractIndex,
 			"prestate", common.Bytes2Hex(action.PreState),
 			"proof", common.Bytes2Hex(action.ProofData),
@@ -133,13 +133,15 @@ func (a *Agent) performAction(ctx context.Context, wg *sync.WaitGroup, action ty
 		if action.OracleData != nil {
 			actionLog = actionLog.New("oracleKey", common.Bytes2Hex(action.OracleData.OracleKey))
 		}
-	} else if action.Type == types.ActionTypeMove {
-		actionLog = actionLog.New("is_attack", action.IsAttack, "parent", action.ParentClaim.ContractIndex, "value", action.Value)
+	} else if action.Type == types.ActionTypeAttackV2 {
+		actionLog = actionLog.New("attackBranch", action.AttackBranch, "parent", action.ParentClaim.ContractIndex, "value", action.Value)
 	}
 
 	switch action.Type {
 	case types.ActionTypeMove:
 		a.metrics.RecordGameMove()
+	case types.ActionTypeAttackV2:
+		a.metrics.RecordGameAttackV2()
 	case types.ActionTypeStep:
 		a.metrics.RecordGameStep()
 	case types.ActionTypeChallengeL2BlockNumber:
diff --git a/op-challenger2/game/fault/contracts/faultdisputegame.go b/op-challenger2/game/fault/contracts/faultdisputegame.go
index 384bb1065bf8e..28aa9f4523df8 100644
--- a/op-challenger2/game/fault/contracts/faultdisputegame.go
+++ b/op-challenger2/game/fault/contracts/faultdisputegame.go
@@ -44,7 +44,7 @@ var (
 	methodAttack                  = "attack"
 	methodDefend                  = "defend"
 	methodStep                    = "step"
-	methodAddLocalData            = "addLocalData"
+	methodAddLocalData            = "addLocalData2"
 	methodVM                      = "vm"
 	methodStartingBlockNumber     = "startingBlockNumber"
 	methodStartingRootHash        = "startingRootHash"
@@ -75,6 +75,8 @@ type FaultDisputeGameContractLatest struct {
 	metrics     metrics.ContractMetricer
 	multiCaller *batching.MultiCaller
 	contract    *batching.BoundContract
+	nbits       uint64
+	splitDepth  types.Depth
 }
 
 type Proposal struct {
@@ -130,11 +132,23 @@ func NewFaultDisputeGameContract(ctx context.Context, metrics metrics.ContractMe
 			},
 		}, nil
 	} else {
-		return &FaultDisputeGameContractLatest{
+
+		contract := &FaultDisputeGameContractLatest{
 			metrics:     metrics,
 			multiCaller: caller,
 			contract:    batching.NewBoundContract(contractAbi, addr),
-		}, nil
+		}
+		nbits, err := contract.GetNBits(ctx)
+		if err != nil {
+			return nil, err
+		}
+		splitDepth, err := contract.GetSplitDepth(ctx)
+		if err != nil {
+			return nil, err
+		}
+		contract.nbits = nbits
+		contract.splitDepth = splitDepth
+		return contract, nil
 	}
 }
 
@@ -349,6 +363,9 @@ func (f *FaultDisputeGameContractLatest) UpdateOracleTx(ctx context.Context, cla
 }
 
 func (f *FaultDisputeGameContractLatest) addLocalDataTx(claimIdx uint64, data *types.PreimageOracleData) (txmgr.TxCandidate, error) {
+	if data.OutputRootDAItem.DaType == nil {
+		return txmgr.TxCandidate{}, fmt.Errorf("DaType isn't set")
+	}
 	call := f.contract.Call(
 		methodAddLocalData,
 		data.GetIdent(),
@@ -479,6 +496,11 @@ func (f *FaultDisputeGameContractLatest) GetAllClaimsWithSubValues(ctx context.C
 		return nil, err
 	}
 	for idx, claim := range claims {
+		if claim.IsRoot() { // root claim contains no subValues in DA, we create subvalues manually
+			claim.SubValues = &[]common.Hash{claim.Value}
+			claims[idx] = claim
+			continue
+		}
 		subValues, attackBranch, err := f.getSubValuesAndAttackBranch(ctx, &claim)
 		if err != nil {
 			return nil, fmt.Errorf("failed to load subValues: %w", err)
@@ -510,7 +532,6 @@ func (f *FaultDisputeGameContractLatest) getSubValuesAndAttackBranch(ctx context
 		return nil, 0, fmt.Errorf("failed to get move event log: %w", moveIter.Error())
 	}
 	txHash := moveIter.Event.Raw.TxHash
-
 	getTxByHashCall := batching.NewTxGetByHash(f.contract.Abi(), txHash, methodAttackV2)
 	result, err := f.multiCaller.SingleCall(ctx, rpcblock.Latest, getTxByHashCall)
 	if err != nil {
@@ -535,9 +556,13 @@ func (f *FaultDisputeGameContractLatest) getSubValuesAndAttackBranch(ctx context
 		if err != nil {
 			return nil, 0, err
 		}
-		valuesBytesLen := uint(32 * maxAttackBranch)
+		nelements := maxAttackBranch
+		if aggClaim.Position.Depth() == types.Depth(f.nbits)+f.splitDepth {
+			nelements = 1
+		}
+		valuesBytesLen := uint(32 * nelements)
 		bytes := abi.ConvertType(inputMap[fieldSubValues], make([]byte, valuesBytesLen)).([]byte)
-		for i := uint64(0); i < maxAttackBranch; i++ {
+		for i := uint64(0); i < nelements; i++ {
 			hash := common.BytesToHash(bytes[i*32 : (i+1)*32])
 			subValues = append(subValues, hash)
 		}
@@ -715,17 +740,13 @@ func (f *FaultDisputeGameContractLatest) GetMaxAttackBranch(ctx context.Context)
 }
 
 func (f *FaultDisputeGameContractLatest) AttackV2Tx(ctx context.Context, parent types.Claim, attackBranch uint64, daType uint64, claims []byte) (txmgr.TxCandidate, error) {
-	nBits, err := f.GetNBits(ctx)
-	if err != nil {
-		return txmgr.TxCandidate{}, fmt.Errorf("failed to retrieve nbits: %w", err)
-	}
 	call := f.contract.Call(methodAttackV2,
 		parent.Value,
 		big.NewInt(int64(parent.ContractIndex)),
 		new(big.Int).SetUint64(attackBranch),
 		new(big.Int).SetUint64(daType),
 		claims)
-	return f.txWithBond(ctx, parent.Position.MoveN(nBits, attackBranch), call)
+	return f.txWithBond(ctx, parent.Position.MoveN(f.nbits, attackBranch), call)
 }
 
 func (f *FaultDisputeGameContractLatest) StepV2Tx(claimIdx uint64, attackBranch uint64, stateData []byte, proof types.StepProof) (txmgr.TxCandidate, error) {
diff --git a/op-challenger2/game/fault/contracts/faultdisputegame_test.go b/op-challenger2/game/fault/contracts/faultdisputegame_test.go
index ced0eb91ee1f9..e7313bd290cc9 100644
--- a/op-challenger2/game/fault/contracts/faultdisputegame_test.go
+++ b/op-challenger2/game/fault/contracts/faultdisputegame_test.go
@@ -481,20 +481,6 @@ func TestGetBlockRange(t *testing.T) {
 	}
 }
 
-func TestGetSplitDepth(t *testing.T) {
-	for _, version := range versions {
-		version := version
-		t.Run(version.version, func(t *testing.T) {
-			stubRpc, contract := setupFaultDisputeGameTest(t, version)
-			expectedSplitDepth := faultTypes.Depth(15)
-			stubRpc.SetResponse(fdgAddr, methodSplitDepth, rpcblock.Latest, nil, []interface{}{new(big.Int).SetUint64(uint64(expectedSplitDepth))})
-			splitDepth, err := contract.GetSplitDepth(context.Background())
-			require.NoError(t, err)
-			require.Equal(t, expectedSplitDepth, splitDepth)
-		})
-	}
-}
-
 func TestGetGameMetadata(t *testing.T) {
 	for _, version := range versions {
 		version := version
@@ -794,6 +780,9 @@ func setupFaultDisputeGameTest(t *testing.T, version contractVersion) (*batching
 	caller := batching.NewMultiCaller(stubRpc, batching.DefaultBatchSize)
 
 	stubRpc.SetResponse(fdgAddr, methodVersion, rpcblock.Latest, nil, []interface{}{version.version})
+	nbitOrSplitDepth := big.NewInt(2)
+	stubRpc.SetResponse(fdgAddr, methodNBits, rpcblock.Latest, nil, []interface{}{nbitOrSplitDepth})
+	stubRpc.SetResponse(fdgAddr, methodSplitDepth, rpcblock.Latest, nil, []interface{}{nbitOrSplitDepth})
 	game, err := NewFaultDisputeGameContract(context.Background(), contractMetrics.NoopContractMetrics, fdgAddr, caller)
 	require.NoError(t, err)
 	return stubRpc, game
@@ -874,6 +863,7 @@ func TestGetAllClaimsWithSubValues(t *testing.T) {
 			attackBranch := big.NewInt(0)
 			parent := faultTypes.Claim{ClaimData: faultTypes.ClaimData{Value: common.Hash{0xbb}, Position: parentPos}, ContractIndex: 111}
 			stubRpc.SetResponse(fdgAddr, methodNBits, block, nil, []interface{}{new(big.Int).SetUint64(nBits)})
+			stubRpc.SetResponse(fdgAddr, methodSplitDepth, block, nil, []interface{}{new(big.Int).SetUint64(nBits)})
 			stubRpc.SetResponse(fdgAddr, methodRequiredBond, block, []interface{}{parent.Position.MoveN(nBits, attackBranch.Uint64()).ToGIndex()}, []interface{}{bond})
 			stubRpc.SetResponse(fdgAddr, methodAttackV2, block, []interface{}{parent.Value, big.NewInt(111), attackBranch, daType, claimsBytes[:]}, nil)
 			txCandidate, err := game.AttackV2Tx(context.Background(), parent, attackBranch.Uint64(), daType.Uint64(), claimsBytes[:])
@@ -886,10 +876,8 @@ func TestGetAllClaimsWithSubValues(t *testing.T) {
 				Value:    big.NewInt(111),
 				Data:     txCandidate.TxData,
 			})
-			packed, err := tx.MarshalBinary()
-			require.NoError(t, err)
 			txHash := tx.Hash()
-			stubRpc.SetGetTxByHashResponse(txHash, packed)
+			stubRpc.SetGetTxByHashResponse(txHash, tx)
 
 			// mock eventLog
 			eventName := eventMove
@@ -915,7 +903,7 @@ func TestGetAllClaimsWithSubValues(t *testing.T) {
 				},
 			}
 
-			stubRpc.SetFilterLogResponse(topics, fdgAddr, block, out)
+			stubRpc.SetFilterLogResponse(topics, []common.Address{fdgAddr}, block, out)
 			stubRpc.SetResponse(fdgAddr, methodClaimCount, block, nil, []interface{}{big.NewInt(1)})
 			stubRpc.SetResponse(fdgAddr, methodMaxAttackBranch, block, nil, []interface{}{big.NewInt(1<<nBits - 1)})
 			claim0 := faultTypes.Claim{
diff --git a/op-challenger2/game/fault/responder/responder.go b/op-challenger2/game/fault/responder/responder.go
index d12a6b9f6558c..5d80bed69b9c5 100644
--- a/op-challenger2/game/fault/responder/responder.go
+++ b/op-challenger2/game/fault/responder/responder.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"math/big"
 
 	"github.com/ethereum-optimism/optimism/op-challenger2/game/fault/preimages"
 	"github.com/ethereum-optimism/optimism/op-challenger2/game/fault/types"
@@ -19,8 +20,10 @@ type GameContract interface {
 	CallResolveClaim(ctx context.Context, claimIdx uint64) error
 	ResolveClaimTx(claimIdx uint64) (txmgr.TxCandidate, error)
 	AttackTx(ctx context.Context, parent types.Claim, pivot common.Hash) (txmgr.TxCandidate, error)
+	AttackV2Tx(ctx context.Context, parent types.Claim, attackBranch uint64, daType uint64, claims []byte) (txmgr.TxCandidate, error)
 	DefendTx(ctx context.Context, parent types.Claim, pivot common.Hash) (txmgr.TxCandidate, error)
 	StepTx(claimIdx uint64, isAttack bool, stateData []byte, proof []byte) (txmgr.TxCandidate, error)
+	StepV2Tx(claimIdx uint64, attackBranch uint64, stateData []byte, proof types.StepProof) (txmgr.TxCandidate, error)
 	ChallengeL2BlockNumberTx(challenge *types.InvalidL2BlockNumberChallenge) (txmgr.TxCandidate, error)
 }
 
@@ -117,8 +120,20 @@ func (r *FaultResponder) PerformAction(ctx context.Context, action types.Action)
 		} else {
 			candidate, err = r.contract.DefendTx(ctx, action.ParentClaim, action.Value)
 		}
+	case types.ActionTypeAttackV2:
+		subValues := make([]byte, 0, len(*action.SubValues))
+		for _, subValue := range *action.SubValues {
+			subValues = append(subValues, subValue[:]...)
+		}
+		daTypeUint64 := (*big.Int)(action.DAType).Uint64()
+		candidate, err = r.contract.AttackV2Tx(ctx, action.ParentClaim, action.AttackBranch, daTypeUint64, subValues)
 	case types.ActionTypeStep:
-		candidate, err = r.contract.StepTx(uint64(action.ParentClaim.ContractIndex), action.IsAttack, action.PreState, action.ProofData)
+		stepProof := types.StepProof{
+			PreStateItem:  action.OracleData.VMStateDA.PreDA,
+			PostStateItem: action.OracleData.VMStateDA.PostDA,
+			VmProof:       action.ProofData,
+		}
+		candidate, err = r.contract.StepV2Tx(uint64(action.ParentClaim.ContractIndex), action.AttackBranch, action.PreState, stepProof)
 	case types.ActionTypeChallengeL2BlockNumber:
 		candidate, err = r.contract.ChallengeL2BlockNumberTx(action.InvalidL2BlockNumberChallenge)
 	}
diff --git a/op-challenger2/game/fault/responder/responder_test.go b/op-challenger2/game/fault/responder/responder_test.go
index 65517bc188fd8..2f8538118774a 100644
--- a/op-challenger2/game/fault/responder/responder_test.go
+++ b/op-challenger2/game/fault/responder/responder_test.go
@@ -146,37 +146,54 @@ func TestPerformAction(t *testing.T) {
 		require.Equal(t, ([]byte)("attack"), mockTxMgr.sent[0].TxData)
 	})
 
-	t.Run("defend", func(t *testing.T) {
+	t.Run("attackV2", func(t *testing.T) {
 		responder, mockTxMgr, contract, _, _ := newTestFaultResponder(t)
 		action := types.Action{
-			Type:        types.ActionTypeMove,
-			ParentClaim: types.Claim{ContractIndex: 123},
-			IsAttack:    false,
-			Value:       common.Hash{0xaa},
+			Type:         types.ActionTypeAttackV2,
+			ParentClaim:  types.Claim{ContractIndex: 123},
+			IsAttack:     false,
+			AttackBranch: 0,
+			DAType:       types.CallDataType,
+			SubValues:    &[]common.Hash{{0xaa}},
 		}
 		err := responder.PerformAction(context.Background(), action)
 		require.NoError(t, err)
 
 		require.Len(t, mockTxMgr.sent, 1)
-		require.EqualValues(t, []interface{}{action.ParentClaim, action.Value}, contract.defendArgs)
-		require.Equal(t, ([]byte)("defend"), mockTxMgr.sent[0].TxData)
+		daTypeUint64 := (*big.Int)(action.DAType).Uint64()
+		subValues := make([]byte, 0, len(*action.SubValues))
+		for _, subValue := range *action.SubValues {
+			subValues = append(subValues, subValue[:]...)
+		}
+		require.EqualValues(t, []interface{}{action.ParentClaim, action.AttackBranch, daTypeUint64, subValues}, contract.attackV2Args)
+		require.Equal(t, ([]byte)("attackV2"), mockTxMgr.sent[0].TxData)
 	})
 
-	t.Run("step", func(t *testing.T) {
+	t.Run("stepV2", func(t *testing.T) {
 		responder, mockTxMgr, contract, _, _ := newTestFaultResponder(t)
 		action := types.Action{
-			Type:        types.ActionTypeStep,
-			ParentClaim: types.Claim{ContractIndex: 123},
-			IsAttack:    true,
-			PreState:    []byte{1, 2, 3},
-			ProofData:   []byte{4, 5, 6},
+			Type:         types.ActionTypeStep,
+			ParentClaim:  types.Claim{ContractIndex: 123},
+			IsAttack:     true,
+			AttackBranch: 0,
+			PreState:     []byte{1, 2, 3},
+			ProofData:    []byte{4, 5, 6},
+			OracleData: &types.PreimageOracleData{
+				VMStateDA:        types.DAData{},
+				OutputRootDAItem: types.DAItem{},
+			},
+		}
+		stepProof := types.StepProof{
+			PreStateItem:  action.OracleData.VMStateDA.PreDA,
+			PostStateItem: action.OracleData.VMStateDA.PostDA,
+			VmProof:       action.ProofData,
 		}
 		err := responder.PerformAction(context.Background(), action)
 		require.NoError(t, err)
 
 		require.Len(t, mockTxMgr.sent, 1)
-		require.EqualValues(t, []interface{}{uint64(123), action.IsAttack, action.PreState, action.ProofData}, contract.stepArgs)
-		require.Equal(t, ([]byte)("step"), mockTxMgr.sent[0].TxData)
+		require.EqualValues(t, []interface{}{uint64(123), action.AttackBranch, action.PreState, stepProof}, contract.stepV2Args)
+		require.Equal(t, ([]byte)("stepV2"), mockTxMgr.sent[0].TxData)
 	})
 
 	t.Run("stepWithLocalOracleData", func(t *testing.T) {
@@ -188,7 +205,9 @@ func TestPerformAction(t *testing.T) {
 			PreState:    []byte{1, 2, 3},
 			ProofData:   []byte{4, 5, 6},
 			OracleData: &types.PreimageOracleData{
-				IsLocal: true,
+				IsLocal:          true,
+				VMStateDA:        types.DAData{},
+				OutputRootDAItem: types.DAItem{},
 			},
 		}
 		err := responder.PerformAction(context.Background(), action)
@@ -196,7 +215,7 @@ func TestPerformAction(t *testing.T) {
 
 		require.Len(t, mockTxMgr.sent, 1)
 		require.Nil(t, contract.updateOracleArgs) // mock uploader returns nil
-		require.Equal(t, ([]byte)("step"), mockTxMgr.sent[0].TxData)
+		require.Equal(t, ([]byte)("stepV2"), mockTxMgr.sent[0].TxData)
 		require.Equal(t, 1, uploader.updates)
 		require.Equal(t, 0, oracle.existCalls)
 	})
@@ -210,7 +229,9 @@ func TestPerformAction(t *testing.T) {
 			PreState:    []byte{1, 2, 3},
 			ProofData:   []byte{4, 5, 6},
 			OracleData: &types.PreimageOracleData{
-				IsLocal: false,
+				IsLocal:          false,
+				VMStateDA:        types.DAData{},
+				OutputRootDAItem: types.DAItem{},
 			},
 		}
 		err := responder.PerformAction(context.Background(), action)
@@ -218,7 +239,7 @@ func TestPerformAction(t *testing.T) {
 
 		require.Len(t, mockTxMgr.sent, 1)
 		require.Nil(t, contract.updateOracleArgs) // mock uploader returns nil
-		require.Equal(t, ([]byte)("step"), mockTxMgr.sent[0].TxData)
+		require.Equal(t, ([]byte)("stepV2"), mockTxMgr.sent[0].TxData)
 		require.Equal(t, 1, uploader.updates)
 		require.Equal(t, 1, oracle.existCalls)
 	})
@@ -370,8 +391,10 @@ type mockContract struct {
 	calls                int
 	callFails            bool
 	attackArgs           []interface{}
+	attackV2Args         []interface{}
 	defendArgs           []interface{}
 	stepArgs             []interface{}
+	stepV2Args           []interface{}
 	challengeArgs        []interface{}
 	updateOracleClaimIdx uint64
 	updateOracleArgs     *types.PreimageOracleData
@@ -411,6 +434,11 @@ func (m *mockContract) AttackTx(_ context.Context, parent types.Claim, claim com
 	return txmgr.TxCandidate{TxData: ([]byte)("attack")}, nil
 }
 
+func (m *mockContract) AttackV2Tx(ctx context.Context, parent types.Claim, attackBranch uint64, daType uint64, claims []byte) (txmgr.TxCandidate, error) {
+	m.attackV2Args = []interface{}{parent, attackBranch, daType, claims}
+	return txmgr.TxCandidate{TxData: ([]byte)("attackV2")}, nil
+}
+
 func (m *mockContract) DefendTx(_ context.Context, parent types.Claim, claim common.Hash) (txmgr.TxCandidate, error) {
 	m.defendArgs = []interface{}{parent, claim}
 	return txmgr.TxCandidate{TxData: ([]byte)("defend")}, nil
@@ -421,6 +449,11 @@ func (m *mockContract) StepTx(claimIdx uint64, isAttack bool, stateData []byte,
 	return txmgr.TxCandidate{TxData: ([]byte)("step")}, nil
 }
 
+func (m *mockContract) StepV2Tx(claimIdx uint64, attackBranch uint64, stateData []byte, proof types.StepProof) (txmgr.TxCandidate, error) {
+	m.stepV2Args = []interface{}{claimIdx, attackBranch, stateData, proof}
+	return txmgr.TxCandidate{TxData: ([]byte)("stepV2")}, nil
+}
+
 func (m *mockContract) UpdateOracleTx(_ context.Context, claimIdx uint64, data *types.PreimageOracleData) (txmgr.TxCandidate, error) {
 	m.updateOracleClaimIdx = claimIdx
 	m.updateOracleArgs = data
diff --git a/op-challenger2/game/fault/solver/actors.go b/op-challenger2/game/fault/solver/actors.go
index 38ddbbf39b393..aeef491b9493f 100644
--- a/op-challenger2/game/fault/solver/actors.go
+++ b/op-challenger2/game/fault/solver/actors.go
@@ -51,20 +51,28 @@ var correctDefendLastClaim = respondLastClaim(func(seq *test.GameBuilderSeq) {
 		// Must attack the root
 		seq.Attack2(nil, 0)
 	} else {
-		seq.Attack2(nil, 1)
+		seq.Attack2(nil, seq.MaxAttackBranch())
 	}
 })
 
 var incorrectAttackLastClaim = respondLastClaim(func(seq *test.GameBuilderSeq) {
-	seq.Attack2(nil, 0, test.WithValue(common.Hash{0xaa}))
+	incorrectSubValues := []common.Hash{}
+	for i := uint64(0); i < seq.MaxAttackBranch(); i++ {
+		incorrectSubValues = append(incorrectSubValues, common.Hash{0xaa})
+	}
+	seq.Attack2(incorrectSubValues, 0)
 })
 
 var incorrectDefendLastClaim = respondLastClaim(func(seq *test.GameBuilderSeq) {
+	incorrectSubValues := []common.Hash{}
+	for i := uint64(0); i < seq.MaxAttackBranch(); i++ {
+		incorrectSubValues = append(incorrectSubValues, common.Hash{0xdd})
+	}
 	if seq.IsRoot() {
 		// Must attack the root
-		seq.Attack2(nil, 0, test.WithValue(common.Hash{0xdd}))
+		seq.Attack2(incorrectSubValues, 0)
 	} else {
-		seq.Attack2(nil, 1, test.WithValue(common.Hash{0xdd}))
+		seq.Attack2(incorrectSubValues, seq.MaxAttackBranch())
 	}
 })
 
@@ -77,29 +85,51 @@ var defendEverythingCorrect = respondAllClaims(func(seq *test.GameBuilderSeq) {
 		// Must attack root
 		seq.Attack2(nil, 0)
 	} else {
-		seq.Attack2(nil, 1)
+		seq.Attack2(nil, seq.MaxAttackBranch())
 	}
 })
 
 var attackEverythingIncorrect = respondAllClaims(func(seq *test.GameBuilderSeq) {
-	seq.Attack2(nil, 0, test.WithValue(common.Hash{0xaa}))
+	incorrectSubValues := []common.Hash{}
+	for i := uint64(0); i < seq.MaxAttackBranch(); i++ {
+		incorrectSubValues = append(incorrectSubValues, common.Hash{0xaa})
+	}
+	seq.Attack2(incorrectSubValues, 0)
 })
 
 var defendEverythingIncorrect = respondAllClaims(func(seq *test.GameBuilderSeq) {
+	incorrectSubValues := []common.Hash{}
+	for i := uint64(0); i < seq.MaxAttackBranch(); i++ {
+		incorrectSubValues = append(incorrectSubValues, common.Hash{0xbb})
+	}
 	if seq.IsRoot() {
 		// Must attack root
-		seq.Attack2(nil, 0, test.WithValue(common.Hash{0xbb}))
+		seq.Attack2(incorrectSubValues, 0)
 	} else {
-		seq.Attack2(nil, 1, test.WithValue(common.Hash{0xbb}))
+		seq.Attack2(incorrectSubValues, seq.MaxAttackBranch())
 	}
 })
 
 var exhaustive = respondAllClaims(func(seq *test.GameBuilderSeq) {
 	seq.Attack2(nil, 0)
-	seq.Attack2(nil, 0, test.WithValue(common.Hash{0xaa}))
-	if !seq.IsRoot() {
-		seq.Attack2(nil, 1)
-		seq.Attack2(nil, 1, test.WithValue(common.Hash{0xdd}))
+	incorrectSubValues := []common.Hash{}
+	for i := uint64(0); i < seq.MaxAttackBranch(); i++ {
+		incorrectSubValues = append(incorrectSubValues, common.Hash{0xaa})
+		if seq.IsSplitDepth() {
+			// at splitDepth, there is only one subValue
+			break
+		}
+	}
+	seq.Attack2(incorrectSubValues, 0)
+	if !seq.IsRoot() && !seq.IsTraceRoot() {
+		seq.Attack2(nil, seq.MaxAttackBranch())
+		for i := uint64(0); i < seq.MaxAttackBranch(); i++ {
+			incorrectSubValues[i] = common.Hash{0xdd}
+			if seq.IsSplitDepth() {
+				break
+			}
+		}
+		seq.Attack2(incorrectSubValues, seq.MaxAttackBranch())
 	}
 })
 
diff --git a/op-challenger2/game/fault/solver/game_rules_test.go b/op-challenger2/game/fault/solver/game_rules_test.go
index af6845ccf5eb5..0d60476bfb089 100644
--- a/op-challenger2/game/fault/solver/game_rules_test.go
+++ b/op-challenger2/game/fault/solver/game_rules_test.go
@@ -15,7 +15,6 @@ import (
 
 func verifyGameRules(t *testing.T, game types.Game, rootClaimCorrect bool) {
 	actualResult, claimTree, resolvedGame := gameResult(game)
-
 	verifyExpectedGameResult(t, rootClaimCorrect, actualResult)
 
 	verifyNoChallengerClaimsWereSuccessfullyCountered(t, resolvedGame)
diff --git a/op-challenger2/game/fault/solver/game_solver.go b/op-challenger2/game/fault/solver/game_solver.go
index 75a9707d6462b..d3ebcea0310d3 100644
--- a/op-challenger2/game/fault/solver/game_solver.go
+++ b/op-challenger2/game/fault/solver/game_solver.go
@@ -20,7 +20,7 @@ func NewGameSolver(gameDepth types.Depth, trace types.TraceAccessor, daType type
 }
 
 func (s *GameSolver) AgreeWithRootClaim(ctx context.Context, game types.Game) (bool, error) {
-	return s.claimSolver.agreeWithClaim(ctx, game, game.Claims()[0])
+	return s.claimSolver.agreeWithClaimV2(ctx, game, game.Claims()[0], 0)
 }
 
 func (s *GameSolver) CalculateNextActions(ctx context.Context, game types.Game) ([]types.Action, error) {
@@ -77,39 +77,54 @@ func (s *GameSolver) calculateStep(ctx context.Context, game types.Game, claim t
 	if claim.CounteredBy != (common.Address{}) {
 		return nil, nil
 	}
-	step, err := s.claimSolver.AttemptStep(ctx, game, claim, agreedClaims)
-	if err != nil {
-		return nil, err
-	}
-	if step == nil {
-		return nil, nil
+	for branch := range *claim.SubValues {
+		step, err := s.claimSolver.AttemptStep(ctx, game, claim, agreedClaims, uint64(branch))
+		if err != nil {
+			return nil, err
+		}
+		if step == nil {
+			continue
+		}
+		return &types.Action{
+			Type:         types.ActionTypeStep,
+			ParentClaim:  step.LeafClaim,
+			AttackBranch: step.AttackBranch,
+			PreState:     step.PreState,
+			ProofData:    step.ProofData,
+			OracleData:   step.OracleData,
+		}, nil
 	}
-	return &types.Action{
-		Type:        types.ActionTypeStep,
-		ParentClaim: step.LeafClaim,
-		IsAttack:    step.IsAttack,
-		PreState:    step.PreState,
-		ProofData:   step.ProofData,
-		OracleData:  step.OracleData,
-	}, nil
+	return nil, nil
 }
 
 func (s *GameSolver) calculateMove(ctx context.Context, game types.Game, claim types.Claim, honestClaims *honestClaimTracker) (*types.Action, error) {
-	move, err := s.claimSolver.NextMove(ctx, claim, game, honestClaims)
-	if err != nil {
-		return nil, fmt.Errorf("failed to calculate next move for claim index %v: %w", claim.ContractIndex, err)
-	}
-	if move == nil {
-		return nil, nil
-	}
-	honestClaims.AddHonestClaim(claim, *move)
-	if game.IsDuplicate(*move) {
-		return nil, nil
+	for branch := range *claim.SubValues {
+		// attack branch 0 can be attacked at root or splitDepth+nbits
+		if claim.Position.Depth() == game.SplitDepth()+types.Depth(game.NBits()) && branch != 0 {
+			return nil, nil
+		}
+		if claim.IsRoot() && branch != 0 {
+			return nil, nil
+		}
+		move, err := s.claimSolver.NextMove(ctx, claim, game, honestClaims, uint64(branch))
+		if err != nil {
+			return nil, fmt.Errorf("failed to calculate next move for claim index %v: %w", claim.ContractIndex, err)
+		}
+		if move == nil {
+			continue
+		}
+		honestClaims.AddHonestClaim(claim, *move)
+		if game.IsDuplicate(*move) {
+			break
+		}
+		return &types.Action{
+			Type:         types.ActionTypeAttackV2,
+			ParentClaim:  game.Claims()[move.ParentContractIndex],
+			Value:        move.Value,
+			SubValues:    move.SubValues,
+			AttackBranch: move.AttackBranch,
+			DAType:       s.claimSolver.daType,
+		}, nil
 	}
-	return &types.Action{
-		Type:        types.ActionTypeMove,
-		IsAttack:    !game.DefendsParent(*move),
-		ParentClaim: game.Claims()[move.ParentContractIndex],
-		Value:       move.Value,
-	}, nil
+	return nil, nil
 }
diff --git a/op-challenger2/game/fault/solver/game_solver_test.go b/op-challenger2/game/fault/solver/game_solver_test.go
index 9eb9a1a41e504..7d83c31e2f779 100644
--- a/op-challenger2/game/fault/solver/game_solver_test.go
+++ b/op-challenger2/game/fault/solver/game_solver_test.go
@@ -17,12 +17,12 @@ import (
 
 func TestCalculateNextActions_ChallengeL2BlockNumber(t *testing.T) {
 	startingBlock := big.NewInt(5)
-	maxDepth := types.Depth(6)
+	maxDepth := types.Depth(8)
 	challenge := &types.InvalidL2BlockNumberChallenge{
 		Output: &eth.OutputResponse{OutputRoot: eth.Bytes32{0xbb}},
 	}
-	nbits := uint64(1)
-	splitDepth := types.Depth(3)
+	nbits := uint64(2)
+	splitDepth := types.Depth(4)
 	claimBuilder := faulttest.NewAlphabetClaimBuilder2(t, startingBlock, maxDepth, nbits, splitDepth)
 	traceProvider := faulttest.NewAlphabetWithProofProvider(t, startingBlock, maxDepth, nil, 0, faulttest.OracleDefaultKey)
 	solver := NewGameSolver(maxDepth, trace.NewSimpleTraceAccessor(traceProvider), types.CallDataType)
@@ -42,11 +42,153 @@ func TestCalculateNextActions_ChallengeL2BlockNumber(t *testing.T) {
 	require.Equal(t, challenge, action.InvalidL2BlockNumberChallenge)
 }
 
+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)
+
+	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.ParentClaim.ContractIndex, 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 TestMultipleRoundsWithNbits1(t *testing.T) {
+	t.Parallel()
+	tests := []struct {
+		name  string
+		actor actor
+	}{
+		{
+			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,
+		},
+		{
+			name:  "DefendEverythingCorrect",
+			actor: defendEverythingCorrect,
+		},
+		{
+			name:  "AttackEverythingIncorrect",
+			actor: attackEverythingIncorrect,
+		},
+		{
+			name:  "DefendEverythingIncorrect",
+			actor: defendEverythingIncorrect,
+		},
+		{
+			name:  "Exhaustive",
+			actor: exhaustive,
+		},
+	}
+	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()
+
+				maxDepth := types.Depth(6)
+				startingL2BlockNumber := big.NewInt(50)
+				nbits := uint64(1)
+				splitDepth := types.Depth(3)
+				claimBuilder := faulttest.NewAlphabetClaimBuilder2(t, startingL2BlockNumber, maxDepth, nbits, splitDepth)
+				builder := claimBuilder.GameBuilder(faulttest.WithInvalidValue(!rootClaimCorrect))
+				game := builder.Game
+
+				correctTrace := claimBuilder.CorrectTraceProvider()
+				solver := NewGameSolver(maxDepth, trace.NewSimpleTraceAccessor(correctTrace), types.CallDataType)
+
+				roundNum := 0
+				done := false
+				for !done {
+					t.Logf("------ ROUND %v ------", roundNum)
+					game, _ = runStep2(t, solver, game, correctTrace)
+					verifyGameRules(t, game, rootClaimCorrect)
+
+					game, done = test.actor.Apply(t, game, correctTrace)
+					roundNum++
+				}
+			})
+		}
+	}
+}
+
+func applyActions(game types.Game, claimant common.Address, actions []types.Action) types.Game {
+	claims := game.Claims()
+	for _, action := range actions {
+		switch action.Type {
+		case types.ActionTypeMove:
+			newPosition := action.ParentClaim.Position.Attack()
+			if !action.IsAttack {
+				newPosition = action.ParentClaim.Position.Defend()
+			}
+			claim := types.Claim{
+				ClaimData: types.ClaimData{
+					Value:    action.Value,
+					Bond:     big.NewInt(0),
+					Position: newPosition,
+				},
+				Claimant:            claimant,
+				ContractIndex:       len(claims),
+				ParentContractIndex: action.ParentClaim.ContractIndex,
+			}
+			claims = append(claims, claim)
+		case types.ActionTypeStep:
+			counteredClaim := claims[action.ParentClaim.ContractIndex]
+			counteredClaim.CounteredBy = claimant
+			claims[action.ParentClaim.ContractIndex] = counteredClaim
+		default:
+			panic(fmt.Errorf("unknown move type: %v", action.Type))
+		}
+	}
+	return types.NewGameState2(claims, game.MaxDepth(), game.NBits(), game.SplitDepth())
+}
+
 func TestCalculateNextActions(t *testing.T) {
-	maxDepth := types.Depth(6)
+	maxDepth := types.Depth(8)
 	startingL2BlockNumber := big.NewInt(0)
-	nbits := uint64(1)
-	splitDepth := types.Depth(3)
+	nbits := uint64(2)
+	splitDepth := types.Depth(4)
 	claimBuilder := faulttest.NewAlphabetClaimBuilder2(t, startingL2BlockNumber, maxDepth, nbits, splitDepth)
 
 	tests := []struct {
@@ -57,7 +199,7 @@ func TestCalculateNextActions(t *testing.T) {
 		{
 			name: "AttackRootClaim",
 			setupGame: func(builder *faulttest.GameBuilder) {
-				builder.Seq().ExpectAttack()
+				builder.Seq().ExpectAttackV2(0)
 			},
 		},
 		{
@@ -68,136 +210,230 @@ func TestCalculateNextActions(t *testing.T) {
 		{
 			name: "DoNotPerformDuplicateMoves",
 			setupGame: func(builder *faulttest.GameBuilder) {
-				// Expected move has already been made.
-				builder.Seq().Attack()
+				builder.Seq().Attack2(nil, 0)
 			},
 		},
 		{
 			name: "RespondToAllClaimsAtDisagreeingLevel",
 			setupGame: func(builder *faulttest.GameBuilder) {
-				honestClaim := builder.Seq().Attack()
-				honestClaim.Attack().ExpectDefend()
-				honestClaim.Defend().ExpectDefend()
-				honestClaim.Attack(faulttest.WithValue(common.Hash{0xaa})).ExpectAttack()
-				honestClaim.Attack(faulttest.WithValue(common.Hash{0xbb})).ExpectAttack()
-				honestClaim.Defend(faulttest.WithValue(common.Hash{0xcc})).ExpectAttack()
-				honestClaim.Defend(faulttest.WithValue(common.Hash{0xdd})).ExpectAttack()
+				honestClaim := builder.Seq().Attack2(nil, 0)
+				honestClaim.Attack2(nil, 0).ExpectAttackV2(3)
 			},
 		},
 		{
 			name: "StepAtMaxDepth",
 			setupGame: func(builder *faulttest.GameBuilder) {
+				values := []common.Hash{{0x81}, {0x82}, {0x83}}
 				lastHonestClaim := builder.Seq().
-					Attack().
-					Attack().
-					Defend().
-					Defend().
-					Defend()
-				lastHonestClaim.Attack().ExpectStepDefend()
-				lastHonestClaim.Attack(faulttest.WithValue(common.Hash{0xdd})).ExpectStepAttack()
+					Attack2(nil, 0).    // honest
+					Attack2(values, 3). // dishonest
+					Attack2(nil, 0)     // honest
+				lastHonestClaim.Attack2([]common.Hash{{0x1}, {0x2}, {0x3}}, 0).ExpectStepV2(0)
 			},
 		},
 		{
 			name: "PoisonedPreState",
 			setupGame: func(builder *faulttest.GameBuilder) {
-				// A claim hash that has no pre-image
-				maliciousStateHash := common.Hash{0x01, 0xaa}
-
-				// Dishonest actor counters their own claims to set up a situation with an invalid prestate
-				// The honest actor should ignore path created by the dishonest actor, only supporting its own attack on the root claim
-				honestMove := builder.Seq().Attack() // This expected action is the winning move.
-				dishonestMove := honestMove.Attack(faulttest.WithValue(maliciousStateHash))
-				// The expected action by the honest actor
-				dishonestMove.ExpectAttack()
-				// The honest actor will ignore this poisoned path
-				dishonestMove.
-					Defend(faulttest.WithValue(maliciousStateHash)).
-					Attack(faulttest.WithValue(maliciousStateHash))
+				values := []common.Hash{{0x81}, {0x82}, {0x83}}
+				honest := builder.Seq().Attack2(nil, 0)
+				dishonest := honest.Attack2(values, 0)
+				dishonest.ExpectAttackV2(0)
+				dishonest.Attack2(values, 0)
+				dishonest.ExpectAttackV2(0)
+			},
+		},
+		{
+			name:             "HonestRoot-OneLevelAttack",
+			rootClaimCorrect: true,
+			setupGame: func(builder *faulttest.GameBuilder) {
+				values := []common.Hash{{0x81}, {0x82}, {0x83}}
+				honest := builder.Seq()
+				honest.Attack2(nil, 0).ExpectAttackV2(3)
+				honest.Attack2(values, 0).ExpectAttackV2(0)
+				values = claimBuilder.GetCorrectClaimsAndInvalidClaimAtIndex(builder.Game.RootClaim().Position.MoveN(nbits, 0), []uint64{1})
+				honest.Attack2(values, 0).ExpectAttackV2(1)
+				values = claimBuilder.GetCorrectClaimsAndInvalidClaimAtIndex(builder.Game.RootClaim().Position.MoveN(nbits, 0), []uint64{2})
+				honest.Attack2(values, 0).ExpectAttackV2(2)
+			},
+		},
+		{
+			name: "DishonestRoot-OneLevelAttack",
+			setupGame: func(builder *faulttest.GameBuilder) {
+				values := []common.Hash{{0x81}, {0x82}, {0x83}}
+				dishonest := builder.Seq().ExpectAttackV2(0)
+				dishonest.Attack2(values, 0).ExpectAttackV2(0)
+				values = claimBuilder.GetCorrectClaimsAndInvalidClaimAtIndex(builder.Game.RootClaim().Position.MoveN(nbits, 0), []uint64{1})
+				dishonest.Attack2(values, 0).ExpectAttackV2(1)
+				values = claimBuilder.GetCorrectClaimsAndInvalidClaimAtIndex(builder.Game.RootClaim().Position.MoveN(nbits, 0), []uint64{2})
+				dishonest.Attack2(values, 0).ExpectAttackV2(2)
+			},
+		},
+		{
+			name:             "HonestRoot-TwoLevelAttack-FirstLevelCorrect-SecondLevelCorrect",
+			rootClaimCorrect: true,
+			setupGame: func(builder *faulttest.GameBuilder) {
+				dishonest := builder.Seq().Attack2(nil, 0)
+				dishonest.Attack2(nil, 0).ExpectAttackV2(3)
+				dishonest.Attack2(nil, 1).ExpectAttackV2(3)
+				dishonest.Attack2(nil, 2).ExpectAttackV2(3)
+				dishonest.Attack2(nil, 3)
+			},
+		},
+		{
+			name:             "HonestRoot-TwoLevelAttack-FirstLevelCorrect-SecondLevelIncorrect",
+			rootClaimCorrect: true,
+			setupGame: func(builder *faulttest.GameBuilder) {
+				values := []common.Hash{{0x81}, {0x82}, {0x83}}
+				dishonest := builder.Seq().Attack2(nil, 0).ExpectAttackV2(3)
+				lastPosition := builder.Game.Claims()[len(builder.Game.Claims())-1].Position
+				dishonest.Attack2(values, 0).ExpectAttackV2(0)
+				dishonest.Attack2(values, 1).ExpectAttackV2(0)
+				dishonest.Attack2(values, 2).ExpectAttackV2(0)
+				dishonest.Attack2(values, 3).ExpectAttackV2(0)
+
+				values = claimBuilder.GetCorrectClaimsAndInvalidClaimAtIndex(lastPosition.MoveN(nbits, 0), []uint64{0})
+				dishonest.Attack2(values, 0).ExpectAttackV2(0)
+				values = claimBuilder.GetCorrectClaimsAndInvalidClaimAtIndex(lastPosition.MoveN(nbits, 0), []uint64{1})
+				dishonest.Attack2(values, 0).ExpectAttackV2(1)
+				values = claimBuilder.GetCorrectClaimsAndInvalidClaimAtIndex(lastPosition.MoveN(nbits, 0), []uint64{2})
+				dishonest.Attack2(values, 0).ExpectAttackV2(2)
+
+				values = claimBuilder.GetCorrectClaimsAndInvalidClaimAtIndex(lastPosition.MoveN(nbits, 1), []uint64{0})
+				dishonest.Attack2(values, 1).ExpectAttackV2(0)
+				values = claimBuilder.GetCorrectClaimsAndInvalidClaimAtIndex(lastPosition.MoveN(nbits, 1), []uint64{1})
+				dishonest.Attack2(values, 1).ExpectAttackV2(1)
+				values = claimBuilder.GetCorrectClaimsAndInvalidClaimAtIndex(lastPosition.MoveN(nbits, 1), []uint64{2})
+				dishonest.Attack2(values, 1).ExpectAttackV2(2)
+
+				values = claimBuilder.GetCorrectClaimsAndInvalidClaimAtIndex(lastPosition.MoveN(nbits, 2), []uint64{0})
+				dishonest.Attack2(values, 2).ExpectAttackV2(0)
+				values = claimBuilder.GetCorrectClaimsAndInvalidClaimAtIndex(lastPosition.MoveN(nbits, 2), []uint64{1})
+				dishonest.Attack2(values, 2).ExpectAttackV2(1)
+				values = claimBuilder.GetCorrectClaimsAndInvalidClaimAtIndex(lastPosition.MoveN(nbits, 2), []uint64{2})
+				dishonest.Attack2(values, 2).ExpectAttackV2(2)
+
+				values = claimBuilder.GetCorrectClaimsAndInvalidClaimAtIndex(lastPosition.MoveN(nbits, 3), []uint64{0})
+				dishonest.Attack2(values, 3).ExpectAttackV2(0)
+				values = claimBuilder.GetCorrectClaimsAndInvalidClaimAtIndex(lastPosition.MoveN(nbits, 3), []uint64{1})
+				dishonest.Attack2(values, 3).ExpectAttackV2(1)
+				values = claimBuilder.GetCorrectClaimsAndInvalidClaimAtIndex(lastPosition.MoveN(nbits, 3), []uint64{2})
+				dishonest.Attack2(values, 3).ExpectAttackV2(2)
 			},
 		},
 		{
-			name: "Freeloader-ValidClaimAtInvalidAttackPosition",
+			name:             "HonestRoot-TwoLevelAttack-FirstLevelIncorrect-SecondLevelCorrect",
+			rootClaimCorrect: true,
 			setupGame: func(builder *faulttest.GameBuilder) {
-				builder.Seq().
-					Attack().                // Honest response to invalid root
-					Defend().ExpectDefend(). // Defender agrees at this point, we should defend
-					Attack().ExpectDefend()  // Freeloader attacks instead of defends
+				values := []common.Hash{{0x81}, {0x82}, {0x83}}
+				honest := builder.Seq()
+				lastPosition := builder.Game.Claims()[len(builder.Game.Claims())-1].Position
+				honest.Attack2(values, 0).Attack2(nil, 0)
+				values = claimBuilder.GetCorrectClaimsAndInvalidClaimAtIndex(lastPosition.MoveN(nbits, 0), []uint64{1})
+				honest.Attack2(values, 0).ExpectAttackV2(1).Attack2(nil, 0).ExpectAttackV2(3)
+				values = claimBuilder.GetCorrectClaimsAndInvalidClaimAtIndex(lastPosition.MoveN(nbits, 0), []uint64{2})
+				honest.Attack2(values, 0).ExpectAttackV2(2).Attack2(nil, 0).ExpectAttackV2(3)
+				values = claimBuilder.GetCorrectClaimsAndInvalidClaimAtIndex(lastPosition.MoveN(nbits, 0), []uint64{3})
+				honest.Attack2(values, 0).ExpectAttackV2(3).Attack2(nil, 0).ExpectAttackV2(3)
 			},
 		},
 		{
-			name: "Freeloader-InvalidClaimAtInvalidAttackPosition",
+			name: "StepAtMaxDepth-LeftBranch-StepBranch0",
 			setupGame: func(builder *faulttest.GameBuilder) {
-				builder.Seq().
-					Attack().                                                     // Honest response to invalid root
-					Defend().ExpectDefend().                                      // Defender agrees at this point, we should defend
-					Attack(faulttest.WithValue(common.Hash{0xbb})).ExpectAttack() // Freeloader attacks with wrong claim instead of defends
+				values := []common.Hash{{0x81}, {0x82}, {0x83}}
+				lastHonestClaim := builder.Seq().
+					Attack2(nil, 0).    // honest
+					Attack2(values, 0). // dishonest
+					Attack2(nil, 0)     // honest
+				lastHonestClaim.Attack2([]common.Hash{{0x1}, {0x2}, {0x3}}, 0).ExpectStepV2(0)
 			},
 		},
 		{
-			name: "Freeloader-InvalidClaimAtValidDefensePosition",
+			name: "StepAtMaxDepth-LeftBranch-StepBranch1",
 			setupGame: func(builder *faulttest.GameBuilder) {
-				builder.Seq().
-					Attack().                                                     // Honest response to invalid root
-					Defend().ExpectDefend().                                      // Defender agrees at this point, we should defend
-					Defend(faulttest.WithValue(common.Hash{0xbb})).ExpectAttack() // Freeloader defends with wrong claim, we should attack
+				values := []common.Hash{{0x81}, {0x82}, {0x83}}
+				lastHonestClaim := builder.Seq().
+					Attack2(nil, 0).    // honest
+					Attack2(values, 0). // dishonest
+					Attack2(nil, 0)     // honest
+				lastPosition := builder.Game.Claims()[len(builder.Game.Claims())-1].Position
+				values = claimBuilder.GetCorrectClaimsAndInvalidClaimAtIndex(lastPosition.MoveN(nbits, 0), []uint64{1})
+				lastHonestClaim.Attack2(values, 0).ExpectStepV2(1)
 			},
 		},
 		{
-			name: "Freeloader-InvalidClaimAtValidAttackPosition",
+			name: "StepAtMaxDepth-LeftBranch-StepBranch2",
 			setupGame: func(builder *faulttest.GameBuilder) {
-				builder.Seq().
-					Attack().                                                      // Honest response to invalid root
-					Defend(faulttest.WithValue(common.Hash{0xaa})).ExpectAttack(). // Defender disagrees at this point, we should attack
-					Attack(faulttest.WithValue(common.Hash{0xbb})).ExpectAttack()  // Freeloader attacks with wrong claim instead of defends
+				values := []common.Hash{{0x81}, {0x82}, {0x83}}
+				lastHonestClaim := builder.Seq().
+					Attack2(nil, 0).    // honest
+					Attack2(values, 0). // dishonest
+					Attack2(nil, 0)     // honest
+				lastPosition := builder.Game.Claims()[len(builder.Game.Claims())-1].Position
+				values = claimBuilder.GetCorrectClaimsAndInvalidClaimAtIndex(lastPosition.MoveN(nbits, 0), []uint64{2})
+				lastHonestClaim.Attack2(values, 0).ExpectStepV2(2)
 			},
 		},
 		{
-			name: "Freeloader-InvalidClaimAtInvalidDefensePosition",
+			name: "StepAtMaxDepth-LeftBranch-StepBranch3",
 			setupGame: func(builder *faulttest.GameBuilder) {
-				builder.Seq().
-					Attack().                                                      // Honest response to invalid root
-					Defend(faulttest.WithValue(common.Hash{0xaa})).ExpectAttack(). // Defender disagrees at this point, we should attack
-					Defend(faulttest.WithValue(common.Hash{0xbb}))                 // Freeloader defends with wrong claim but we must not respond to avoid poisoning
+				values := []common.Hash{{0x81}, {0x82}, {0x83}}
+				lastHonestClaim := builder.Seq().
+					Attack2(nil, 0).    // honest
+					Attack2(values, 0). // dishonest
+					Attack2(nil, 0)     // honest
+				lastPosition := builder.Game.Claims()[len(builder.Game.Claims())-1].Position
+				values = claimBuilder.GetCorrectClaimsAndInvalidClaimAtIndex(lastPosition.MoveN(nbits, 0), []uint64{})
+				lastHonestClaim.Attack2(values, 0).ExpectStepV2(3)
 			},
 		},
 		{
-			name: "Freeloader-ValidClaimAtInvalidAttackPosition-RespondingToDishonestButCorrectAttack",
+			name: "StepAtMaxDepth-MiddleBranch-StepBranch0",
 			setupGame: func(builder *faulttest.GameBuilder) {
-				builder.Seq().
-					Attack().                // Honest response to invalid root
-					Attack().ExpectDefend(). // Defender attacks with correct value, we should defend
-					Attack().ExpectDefend()  // Freeloader attacks with wrong claim, we should defend
+				values := []common.Hash{{0x81}, {0x82}, {0x83}}
+				lastHonestClaim := builder.Seq().
+					Attack2(nil, 0).    // honest
+					Attack2(values, 1). // dishonest
+					Attack2(nil, 0)     // honest
+				lastHonestClaim.Attack2([]common.Hash{{0x1}, {0x2}, {0x3}}, 0).ExpectStepV2(0)
 			},
 		},
 		{
-			name: "Freeloader-DoNotCounterOwnClaim",
+			name: "StepAtMaxDepth-MiddleBranch-StepBranch1",
 			setupGame: func(builder *faulttest.GameBuilder) {
-				builder.Seq().
-					Attack().                // Honest response to invalid root
-					Attack().ExpectDefend(). // Defender attacks with correct value, we should defend
-					Attack().                // Freeloader attacks instead, we should defend
-					Defend()                 // We do defend and we shouldn't counter our own claim
+				values := []common.Hash{{0x81}, {0x82}, {0x83}}
+				lastHonestClaim := builder.Seq().
+					Attack2(nil, 0).    // honest
+					Attack2(values, 1). // dishonest
+					Attack2(nil, 0)     // honest
+				lastPosition := builder.Game.Claims()[len(builder.Game.Claims())-1].Position
+				values = claimBuilder.GetCorrectClaimsAndInvalidClaimAtIndex(lastPosition.MoveN(nbits, 0), []uint64{1})
+				lastHonestClaim.Attack2(values, 0).ExpectStepV2(1)
 			},
 		},
 		{
-			name: "Freeloader-ContinueDefendingAgainstFreeloader",
+			name: "StepAtMaxDepth-MiddleBranch-StepBranch2",
 			setupGame: func(builder *faulttest.GameBuilder) {
-				builder.Seq(). // invalid root
-						Attack().                                       // Honest response to invalid root
-						Attack().ExpectDefend().                        // Defender attacks with correct value, we should defend
-						Attack().                                       // Freeloader attacks instead, we should defend
-						Defend().                                       // We do defend
-						Attack(faulttest.WithValue(common.Hash{0xaa})). // freeloader attacks our defense, we should attack
-						ExpectAttack()
+				values := []common.Hash{{0x81}, {0x82}, {0x83}}
+				lastHonestClaim := builder.Seq().
+					Attack2(nil, 0).    // honest
+					Attack2(values, 1). // dishonest
+					Attack2(nil, 0)     // honest
+				lastPosition := builder.Game.Claims()[len(builder.Game.Claims())-1].Position
+				values = claimBuilder.GetCorrectClaimsAndInvalidClaimAtIndex(lastPosition.MoveN(nbits, 0), []uint64{2})
+				lastHonestClaim.Attack2(values, 0).ExpectStepV2(2)
 			},
 		},
 		{
-			name: "Freeloader-FreeloaderCountersRootClaim",
+			name: "StepAtMaxDepth-MiddleBranch-StepBranch3",
 			setupGame: func(builder *faulttest.GameBuilder) {
-				builder.Seq().
-					ExpectAttack().                                 // Honest response to invalid root
-					Attack(faulttest.WithValue(common.Hash{0xaa})). // freeloader
-					ExpectAttack()                                  // Honest response to freeloader
+				values := []common.Hash{{0x81}, {0x82}, {0x83}}
+				lastHonestClaim := builder.Seq().
+					Attack2(nil, 0).    // honest
+					Attack2(values, 1). // dishonest
+					Attack2(nil, 0)     // honest
+				lastPosition := builder.Game.Claims()[len(builder.Game.Claims())-1].Position
+				values = claimBuilder.GetCorrectClaimsAndInvalidClaimAtIndex(lastPosition.MoveN(nbits, 0), []uint64{})
+				lastHonestClaim.Attack2(values, 0).ExpectStepV2(3)
 			},
 		},
 	}
@@ -208,37 +444,95 @@ func TestCalculateNextActions(t *testing.T) {
 			builder := claimBuilder.GameBuilder(faulttest.WithInvalidValue(!test.rootClaimCorrect))
 			test.setupGame(builder)
 			game := builder.Game
-
-			solver := NewGameSolver(maxDepth, trace.NewSimpleTraceAccessor(claimBuilder.CorrectTraceProvider()), types.CallDataType)
-			postState, actions := runStep(t, solver, game, claimBuilder.CorrectTraceProvider())
+			accessor := trace.NewSimpleTraceAccessor(claimBuilder.CorrectTraceProvider())
+			solver := NewGameSolver(maxDepth, accessor, types.CallDataType)
+			postState, actions := runStep2(t, solver, game, claimBuilder.CorrectTraceProvider())
+			preimage := getStepPreimage(t, builder, game, accessor)
 			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.ParentClaim.ContractIndex, action.IsAttack, action.Value, hex.EncodeToString(action.PreState), hex.EncodeToString(action.ProofData))
+				if action.Type == types.ActionTypeStep {
+					action.OracleData = preimage
+				}
+				t.Logf("Expect %v: Type: %v, Position: %v, ParentIdx: %v, Branch: %v, Value: %v, SubValues: %v, PreState: %v, ProofData: %v",
+					i, action.Type, action.ParentClaim.Position, action.ParentClaim.ContractIndex, action.AttackBranch, action.Value, action.SubValues, hex.EncodeToString(action.PreState), hex.EncodeToString(action.ProofData))
+				// Datype don't need to be compared, because it's set in solver not in getStepData2.
+				if action.OracleData != nil {
+					action.OracleData.VMStateDA.PreDA.DaType = types.CallDataType
+					action.OracleData.VMStateDA.PostDA.DaType = types.CallDataType
+					action.OracleData.OutputRootDAItem.DaType = types.CallDataType
+
+				}
 				require.Containsf(t, actions, action, "Expected claim %v missing", i)
 			}
 			require.Len(t, actions, len(builder.ExpectedActions), "Incorrect number of actions")
-
 			verifyGameRules(t, postState, test.rootClaimCorrect)
 		})
 	}
 }
 
-func runStep(t *testing.T, solver *GameSolver, game types.Game, correctTraceProvider types.TraceProvider) (types.Game, []types.Action) {
+func runStep2(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)
+	postState := applyActions2(game, challengerAddr, actions)
 
 	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.ParentClaim.ContractIndex, action.IsAttack, action.Value, hex.EncodeToString(action.PreState), hex.EncodeToString(action.ProofData))
+		t.Logf("Real %v: Type: %v, Position: %v, ParentIdx: %v, Branch: %v, Value: %v, SubValues: %v, PreState: %v, ProofData: %v",
+			i, action.Type,
+			action.ParentClaim.Position,
+			action.ParentClaim.ContractIndex,
+			action.AttackBranch, action.Value, action.SubValues, 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) {
+func applyActions2(game types.Game, claimant common.Address, actions []types.Action) types.Game {
+	claims := game.Claims()
+	for _, action := range actions {
+		switch action.Type {
+		case types.ActionTypeAttackV2:
+			newPosition := action.ParentClaim.Position.MoveN(game.NBits(), action.AttackBranch)
+			claim := types.Claim{
+				ClaimData: types.ClaimData{
+					Value:    action.Value,
+					Bond:     big.NewInt(0),
+					Position: newPosition,
+				},
+				Claimant:            claimant,
+				ContractIndex:       len(claims),
+				ParentContractIndex: action.ParentClaim.ContractIndex,
+				SubValues:           action.SubValues,
+				AttackBranch:        action.AttackBranch,
+			}
+			claims = append(claims, claim)
+		case types.ActionTypeStep:
+			counteredClaim := claims[action.ParentClaim.ContractIndex]
+			counteredClaim.CounteredBy = claimant
+			claims[action.ParentClaim.ContractIndex] = counteredClaim
+		default:
+			panic(fmt.Errorf("unknown move type: %v", action.Type))
+		}
+	}
+	return types.NewGameState2(claims, game.MaxDepth(), game.NBits(), game.SplitDepth())
+}
+
+func getStepPreimage(t *testing.T, builder *faulttest.GameBuilder, game types.Game, accessor types.TraceAccessor) *types.PreimageOracleData {
+	if len(builder.ExpectedActions) == 0 {
+		return nil
+	}
+	claims := game.Claims()
+	lastClaim := claims[len(claims)-1]
+	lastExpectedAction := builder.ExpectedActions[len(builder.ExpectedActions)-1]
+	if lastExpectedAction.Type != types.ActionTypeStep {
+		return nil
+	}
+	_, _, preimage, err := accessor.GetStepData2(context.Background(), game, lastClaim, lastClaim.MoveRightN(lastExpectedAction.AttackBranch))
+	require.NoError(t, err)
+	return preimage
+}
+
+func TestMultipleRoundsWithNbits2(t *testing.T) {
 	t.Parallel()
 	tests := []struct {
 		name  string
@@ -303,15 +597,16 @@ func TestMultipleRounds(t *testing.T) {
 	}
 	for _, test := range tests {
 		test := test
-		for _, rootClaimCorrect := range []bool{true, false} {
+		for _, rootClaimCorrect := range []bool{false} {
 			rootClaimCorrect := rootClaimCorrect
 			t.Run(fmt.Sprintf("%v-%v", test.name, rootClaimCorrect), func(t *testing.T) {
 				t.Parallel()
 
-				maxDepth := types.Depth(6)
+				maxDepth := types.Depth(10)
 				startingL2BlockNumber := big.NewInt(50)
-				nbits := uint64(1)
-				splitDepth := types.Depth(3)
+				nbits := uint64(2)
+				// splitDepth can't be 4 when maxDepth=8, because we can only attack branch 0 at claim with depth of splitDepth+nbits
+				splitDepth := types.Depth(4)
 				claimBuilder := faulttest.NewAlphabetClaimBuilder2(t, startingL2BlockNumber, maxDepth, nbits, splitDepth)
 				builder := claimBuilder.GameBuilder(faulttest.WithInvalidValue(!rootClaimCorrect))
 				game := builder.Game
@@ -323,7 +618,7 @@ func TestMultipleRounds(t *testing.T) {
 				done := false
 				for !done {
 					t.Logf("------ ROUND %v ------", roundNum)
-					game, _ = runStep(t, solver, game, correctTrace)
+					game, _ = runStep2(t, solver, game, correctTrace)
 					verifyGameRules(t, game, rootClaimCorrect)
 
 					game, done = test.actor.Apply(t, game, correctTrace)
@@ -333,34 +628,3 @@ func TestMultipleRounds(t *testing.T) {
 		}
 	}
 }
-
-func applyActions(game types.Game, claimant common.Address, actions []types.Action) types.Game {
-	claims := game.Claims()
-	for _, action := range actions {
-		switch action.Type {
-		case types.ActionTypeMove:
-			newPosition := action.ParentClaim.Position.Attack()
-			if !action.IsAttack {
-				newPosition = action.ParentClaim.Position.Defend()
-			}
-			claim := types.Claim{
-				ClaimData: types.ClaimData{
-					Value:    action.Value,
-					Bond:     big.NewInt(0),
-					Position: newPosition,
-				},
-				Claimant:            claimant,
-				ContractIndex:       len(claims),
-				ParentContractIndex: action.ParentClaim.ContractIndex,
-			}
-			claims = append(claims, claim)
-		case types.ActionTypeStep:
-			counteredClaim := claims[action.ParentClaim.ContractIndex]
-			counteredClaim.CounteredBy = claimant
-			claims[action.ParentClaim.ContractIndex] = counteredClaim
-		default:
-			panic(fmt.Errorf("unknown move type: %v", action.Type))
-		}
-	}
-	return types.NewGameState2(claims, game.MaxDepth(), game.NBits(), game.SplitDepth())
-}
diff --git a/op-challenger2/game/fault/solver/rules.go b/op-challenger2/game/fault/solver/rules.go
index 88d790296a785..45ce9af7c5c40 100644
--- a/op-challenger2/game/fault/solver/rules.go
+++ b/op-challenger2/game/fault/solver/rules.go
@@ -20,13 +20,13 @@ type actionRule func(game types.Game, action types.Action, correctTrace types.Tr
 var rules = []actionRule{
 	parentMustExist,
 	onlyStepAtMaxDepth,
-	onlyMoveBeforeMaxDepth,
+	onlyAttackBeforeMaxDepth,
 	doNotDuplicateExistingMoves,
 	doNotStepAlreadyCounteredClaims,
-	doNotDefendRootClaim,
+	onlyAttackRootClaimZeroBranch,
 	avoidPoisonedPrestate,
-	detectPoisonedStepPrestate,
-	detectFailedStep,
+	//detectPoisonedStepPrestate,
+	//detectFailedStep,
 	doNotCounterSelf,
 }
 
@@ -66,15 +66,13 @@ func onlyStepAtMaxDepth(game types.Game, action types.Action, _ types.TraceProvi
 	return nil
 }
 
-// onlyMoveBeforeMaxDepth verifies that move actions are not performed against leaf claims
-// Rationale: The action would be rejected by the contracts
-func onlyMoveBeforeMaxDepth(game types.Game, action types.Action, _ types.TraceProvider) error {
-	if action.Type == types.ActionTypeMove {
+func onlyAttackBeforeMaxDepth(game types.Game, action types.Action, _ types.TraceProvider) error {
+	if action.Type == types.ActionTypeAttackV2 {
 		return nil
 	}
 	parentDepth := game.Claims()[action.ParentClaim.ContractIndex].Position.Depth()
 	if parentDepth < game.MaxDepth() {
-		return fmt.Errorf("parent (%v) not at max depth (%v) but attempting to perform %v action instead of move",
+		return fmt.Errorf("parent (%v) not at max depth (%v) but attempting to perform %v action instead of attackV2",
 			parentDepth, game.MaxDepth(), action.Type)
 	}
 	return nil
@@ -103,11 +101,9 @@ func doNotStepAlreadyCounteredClaims(game types.Game, action types.Action, _ typ
 	return nil
 }
 
-// doNotDefendRootClaim checks the challenger doesn't attempt to defend the root claim
-// Rationale: The action would be rejected by the contracts
-func doNotDefendRootClaim(game types.Game, action types.Action, _ types.TraceProvider) error {
-	if game.Claims()[action.ParentClaim.ContractIndex].IsRootPosition() && !action.IsAttack {
-		return fmt.Errorf("defending the root claim at idx %v", action.ParentClaim.ContractIndex)
+func onlyAttackRootClaimZeroBranch(game types.Game, action types.Action, _ types.TraceProvider) error {
+	if game.Claims()[action.ParentClaim.ContractIndex].IsRootPosition() && action.AttackBranch != 0 {
+		return fmt.Errorf("attacking the root claim at idx %v with branch %v", action.ParentClaim.ContractIndex, action.AttackBranch)
 	}
 	return nil
 }
@@ -163,7 +159,8 @@ func avoidPoisonedPrestate(game types.Game, action types.Action, correctTrace ty
 	if err != nil {
 		return fmt.Errorf("failed to get correct trace at position %v: %w", preStateClaim.Position, err)
 	}
-	if correctValue != preStateClaim.Value {
+	preStateClaimValue := (*preStateClaim.SubValues)[0]
+	if correctValue != preStateClaimValue {
 		err = fmt.Errorf("prestate poisoned claim %v has invalid prestate and is left of honest claim countering %v at trace index %v", preStateClaim.ContractIndex, action.ParentClaim.ContractIndex, honestTraceIndex)
 		return err
 	}
@@ -194,10 +191,7 @@ func detectFailedStep(game types.Game, action types.Action, correctTrace types.T
 		return nil
 	}
 	honestTraceIndex := position.TraceIndex(game.MaxDepth())
-	poststateIndex := honestTraceIndex
-	if !action.IsAttack {
-		poststateIndex = new(big.Int).Add(honestTraceIndex, big.NewInt(1))
-	}
+	poststateIndex := new(big.Int).Add(honestTraceIndex, big.NewInt(int64(action.AttackBranch)))
 	// Walk back up the claims and find the claim required post state index
 	claim := game.Claims()[action.ParentClaim.ContractIndex]
 	poststateClaim, ok := game.AncestorWithTraceIndex(claim, poststateIndex)
@@ -208,7 +202,7 @@ func detectFailedStep(game types.Game, action types.Action, correctTrace types.T
 	if err != nil {
 		return fmt.Errorf("failed to get correct trace at position %v: %w", poststateClaim.Position, err)
 	}
-	validStep := correctValue == poststateClaim.Value
+	validStep := correctValue == (*poststateClaim.SubValues)[0]
 	parentPostAgree := (claim.Depth()-poststateClaim.Depth())%2 == 0
 	if parentPostAgree == validStep {
 		return fmt.Errorf("failed step against claim at %v using poststate from claim %v post state is correct? %v parentPostAgree? %v",
@@ -272,8 +266,5 @@ func resultingPosition(game types.Game, action types.Action) types.Position {
 	if action.Type == types.ActionTypeStep {
 		return parentPos
 	}
-	if action.IsAttack {
-		return parentPos.Attack()
-	}
-	return parentPos.Defend()
+	return parentPos.MoveN(uint64(game.NBits()), action.AttackBranch)
 }
diff --git a/op-challenger2/game/fault/solver/solver.go b/op-challenger2/game/fault/solver/solver.go
index a82cc5bb88a0f..392fb9b7cd595 100644
--- a/op-challenger2/game/fault/solver/solver.go
+++ b/op-challenger2/game/fault/solver/solver.go
@@ -6,7 +6,9 @@ import (
 	"errors"
 	"fmt"
 
+	"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"
 )
 
 var (
@@ -63,7 +65,7 @@ func (s *claimSolver) shouldCounter(game types.Game, claim types.Claim, honestCl
 }
 
 // NextMove returns the next move to make given the current state of the game.
-func (s *claimSolver) NextMove(ctx context.Context, claim types.Claim, game types.Game, honestClaims *honestClaimTracker) (*types.Claim, error) {
+func (s *claimSolver) NextMove(ctx context.Context, claim types.Claim, game types.Game, honestClaims *honestClaimTracker, branch uint64) (*types.Claim, error) {
 	if claim.Depth() == s.gameDepth {
 		return nil, types.ErrGameDepthReached
 	}
@@ -74,27 +76,41 @@ func (s *claimSolver) NextMove(ctx context.Context, claim types.Claim, game type
 		return nil, nil
 	}
 
-	if agree, err := s.agreeWithClaim(ctx, game, claim); err != nil {
+	agree, err := s.agreeWithClaimV2(ctx, game, claim, branch)
+	if err != nil {
 		return nil, err
-	} else if agree {
-		return s.defend(ctx, game, claim)
+	}
+	if agree {
+		if claim.Depth() == game.TraceRootDepth() && branch == 0 {
+			// Only useful in alphabet game, because the alphabet game has a constant status byte, and is not safe from someone being dishonest in
+			// output bisection and then posting a correct execution trace bisection root claim.
+			// when root claim of output bisection is dishonest,
+			// root claim of execution trace bisection is made by the dishonest actor but is honest
+			// we should counter it.
+			return s.attackV2(ctx, game, claim, branch)
+		}
+		if branch < game.MaxAttackBranch()-1 {
+			return nil, nil
+		}
+		// if we agree with all subValues, we should attack the maxAttackBranch
+		return s.attackV2(ctx, game, claim, branch+1)
 	} else {
-		return s.attack(ctx, game, claim)
+		return s.attackV2(ctx, game, claim, branch)
 	}
 }
 
 type StepData struct {
-	LeafClaim  types.Claim
-	IsAttack   bool
-	PreState   []byte
-	ProofData  []byte
-	OracleData *types.PreimageOracleData
+	LeafClaim    types.Claim
+	AttackBranch uint64
+	PreState     []byte
+	ProofData    []byte
+	OracleData   *types.PreimageOracleData
 }
 
 // AttemptStep determines what step, if any, should occur for a given leaf claim.
 // An error will be returned if the claim is not at the max depth.
 // Returns nil, nil if no step should be performed.
-func (s *claimSolver) AttemptStep(ctx context.Context, game types.Game, claim types.Claim, honestClaims *honestClaimTracker) (*StepData, error) {
+func (s *claimSolver) AttemptStep(ctx context.Context, game types.Game, claim types.Claim, honestClaims *honestClaimTracker, branch uint64) (*StepData, error) {
 	if claim.Depth() != s.gameDepth {
 		return nil, ErrStepNonLeafNode
 	}
@@ -105,66 +121,73 @@ func (s *claimSolver) AttemptStep(ctx context.Context, game types.Game, claim ty
 		return nil, nil
 	}
 
-	claimCorrect, err := s.agreeWithClaim(ctx, game, claim)
+	claimCorrect, err := s.agreeWithClaimV2(ctx, game, claim, branch)
 	if err != nil {
 		return nil, err
 	}
 
 	var position types.Position
+	attackBranch := branch
 	if !claimCorrect {
 		// Attack the claim by executing step index, so we need to get the pre-state of that index
-		position = claim.Position
+		position = claim.Position.MoveRightN(branch)
 	} else {
-		// Defend and use this claim as the starting point to execute the step after.
-		// Thus, we need the pre-state of the next step.
-		position = claim.Position.MoveRight()
-	}
-
-	preState, proofData, oracleData, err := s.trace.GetStepData(ctx, game, claim, position)
+		if branch == game.MaxAttackBranch()-1 {
+			// If we agree all subValues ,the maxAttackBranch should be stepped
+			position = claim.Position.MoveRightN(branch + 1)
+			attackBranch = branch + 1
+		} else {
+			return nil, nil
+		}
+	}
+	preState, proofData, oracleData, err := s.trace.GetStepData2(ctx, game, claim, position)
 	if err != nil {
 		return nil, err
 	}
-
+	oracleData.OutputRootDAItem.DaType = s.daType
+	oracleData.VMStateDA.PreDA.DaType = s.daType
+	oracleData.VMStateDA.PostDA.DaType = s.daType
 	return &StepData{
-		LeafClaim:  claim,
-		IsAttack:   !claimCorrect,
-		PreState:   preState,
-		ProofData:  proofData,
-		OracleData: oracleData,
+		LeafClaim:    claim,
+		AttackBranch: attackBranch,
+		PreState:     preState,
+		ProofData:    proofData,
+		OracleData:   oracleData,
 	}, nil
 }
 
-// attack returns a response that attacks the claim.
-func (s *claimSolver) attack(ctx context.Context, game types.Game, claim types.Claim) (*types.Claim, error) {
-	position := claim.Attack()
-	value, err := s.trace.Get(ctx, game, claim, position)
-	if err != nil {
-		return nil, fmt.Errorf("attack claim: %w", err)
+// agreeWithClaim returns true if the claim is correct according to the internal [TraceProvider].
+func (s *claimSolver) agreeWithClaimV2(ctx context.Context, game types.Game, claim types.Claim, branch uint64) (bool, error) {
+	if branch >= uint64(len(*claim.SubValues)) {
+		return true, fmt.Errorf("branch must be less than maxAttachBranch")
 	}
-	return &types.Claim{
-		ClaimData:           types.ClaimData{Value: value, Position: position},
-		ParentContractIndex: claim.ContractIndex,
-	}, nil
+	ourValue, err := s.trace.Get(ctx, game, claim, claim.Position.MoveRightN(branch))
+	return bytes.Equal(ourValue[:], (*claim.SubValues)[branch][:]), err
 }
 
-// defend returns a response that defends the claim.
-func (s *claimSolver) defend(ctx context.Context, game types.Game, claim types.Claim) (*types.Claim, error) {
-	if claim.IsRoot() {
-		return nil, nil
-	}
-	position := claim.Defend()
-	value, err := s.trace.Get(ctx, game, claim, position)
-	if err != nil {
-		return nil, fmt.Errorf("defend claim: %w", err)
-	}
+func (s *claimSolver) attackV2(ctx context.Context, game types.Game, claim types.Claim, branch uint64) (*types.Claim, error) {
+	var err error
+	var value common.Hash
+	var values []common.Hash
+	maxAttackBranch := game.MaxAttackBranch()
+	position := claim.MoveN(game.NBits(), branch)
+	for i := uint64(0); i < maxAttackBranch; i++ {
+		tmpPosition := position.MoveRightN(i)
+		if tmpPosition.Depth() == (game.SplitDepth()+types.Depth(game.NBits())) && i != 0 {
+			break
+		} else {
+			value, err = s.trace.Get(ctx, game, claim, tmpPosition)
+			if err != nil {
+				return nil, fmt.Errorf("attack claim: %w", err)
+			}
+			values = append(values, value)
+		}
+	}
+	hash := contracts.SubValuesHash(values)
 	return &types.Claim{
-		ClaimData:           types.ClaimData{Value: value, Position: position},
+		ClaimData:           types.ClaimData{Value: hash, Position: position},
 		ParentContractIndex: claim.ContractIndex,
+		SubValues:           &values,
+		AttackBranch:        branch,
 	}, nil
 }
-
-// agreeWithClaim returns true if the claim is correct according to the internal [TraceProvider].
-func (s *claimSolver) agreeWithClaim(ctx context.Context, game types.Game, claim types.Claim) (bool, error) {
-	ourValue, err := s.trace.Get(ctx, game, claim, claim.Position)
-	return bytes.Equal(ourValue[:], claim.Value[:]), err
-}
diff --git a/op-challenger2/game/fault/solver/solver_test.go b/op-challenger2/game/fault/solver/solver_test.go
index 4fb5723fde8eb..7ce1049419b34 100644
--- a/op-challenger2/game/fault/solver/solver_test.go
+++ b/op-challenger2/game/fault/solver/solver_test.go
@@ -5,84 +5,124 @@ import (
 	"math/big"
 	"testing"
 
+	"github.com/ethereum-optimism/optimism/op-challenger2/game/fault/contracts"
 	faulttest "github.com/ethereum-optimism/optimism/op-challenger2/game/fault/test"
 	"github.com/ethereum-optimism/optimism/op-challenger2/game/fault/trace"
+	"github.com/ethereum-optimism/optimism/op-challenger2/game/fault/trace/alphabet"
+	"github.com/ethereum-optimism/optimism/op-challenger2/game/fault/trace/split"
 	"github.com/ethereum-optimism/optimism/op-challenger2/game/fault/types"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/stretchr/testify/require"
 )
 
-func TestAttemptStep(t *testing.T) {
-	maxDepth := types.Depth(3)
+func TestAttemptStepNary2(t *testing.T) {
+	maxDepth := types.Depth(7)
 	startingL2BlockNumber := big.NewInt(0)
 	nbits := uint64(1)
 	splitDepth := types.Depth(3)
 	claimBuilder := faulttest.NewAlphabetClaimBuilder2(t, startingL2BlockNumber, maxDepth, nbits, splitDepth)
+	traceDepth := maxDepth - splitDepth - types.Depth(nbits)
 
 	// Last accessible leaf is the second last trace index
 	// The root node is used for the last trace index and can only be attacked.
-	lastLeafTraceIndex := big.NewInt(1<<maxDepth - 2)
-	lastLeafTraceIndexPlusOne := big.NewInt(1<<maxDepth - 1)
+	lastLeafTraceIndex := big.NewInt(1<<traceDepth - 2)
+	lastLeafTraceIndexPlusOne := big.NewInt(1<<traceDepth - 1)
 	ctx := context.Background()
+	absolutePrestate, err := claimBuilder.CorrectTraceProvider().AbsolutePreStateCommitment(ctx)
+	require.NoError(t, err)
 
 	tests := []struct {
 		name                string
 		agreeWithOutputRoot bool
 		expectedErr         error
 		expectNoStep        bool
-		expectAttack        bool
+		expectAttackBranch  uint64
 		expectPreState      []byte
 		expectProofData     []byte
 		expectedOracleData  *types.PreimageOracleData
+		expectedVMStateData *types.DAData
 		setupGame           func(builder *faulttest.GameBuilder)
 	}{
 		{
 			name:               "AttackFirstTraceIndex",
-			expectAttack:       true,
+			expectAttackBranch: 0,
 			expectPreState:     claimBuilder.CorrectPreState(common.Big0),
 			expectProofData:    claimBuilder.CorrectProofData(common.Big0),
 			expectedOracleData: claimBuilder.CorrectOracleData(common.Big0),
+			expectedVMStateData: &types.DAData{
+				PreDA:  types.DAItem{DaType: types.CallDataType, DataHash: absolutePrestate},
+				PostDA: types.DAItem{DaType: types.CallDataType, DataHash: common.Hash{0xbb}},
+			},
 			setupGame: func(builder *faulttest.GameBuilder) {
 				builder.Seq().
-					Attack2(nil, 0, faulttest.WithValue(common.Hash{0xaa})).
 					Attack2(nil, 0).
-					Attack2(nil, 0, faulttest.WithValue(common.Hash{0xbb}))
+					Attack2(nil, 0).
+					Attack2(nil, 0). // splitDepth
+					Attack2(nil, 0).
+					Attack2([]common.Hash{{0xaa}}, 0).
+					Attack2(nil, 0).
+					Attack2([]common.Hash{{0xbb}}, 0)
 			},
 		},
 		{
 			name:               "DefendFirstTraceIndex",
-			expectAttack:       false,
+			expectAttackBranch: 1,
 			expectPreState:     claimBuilder.CorrectPreState(big.NewInt(1)),
 			expectProofData:    claimBuilder.CorrectProofData(big.NewInt(1)),
 			expectedOracleData: claimBuilder.CorrectOracleData(big.NewInt(1)),
+			expectedVMStateData: &types.DAData{
+				PreDA:  types.DAItem{DaType: types.CallDataType, DataHash: claimBuilder.CorrectClaimAtPosition(types.NewPosition(types.Depth(7), common.Big0))},
+				PostDA: types.DAItem{DaType: types.CallDataType, DataHash: claimBuilder.CorrectClaimAtPosition(types.NewPosition(types.Depth(7), common.Big1))},
+			},
 			setupGame: func(builder *faulttest.GameBuilder) {
 				builder.Seq().
-					Attack2(nil, 0, faulttest.WithValue(common.Hash{0xaa})).
+					Attack2(nil, 0).
+					Attack2(nil, 0).
+					Attack2(nil, 0). // splitDepth
+					Attack2(nil, 0).
+					Attack2([]common.Hash{{0xaa}}, 0).
 					Attack2(nil, 0).
 					Attack2(nil, 0)
 			},
 		},
 		{
 			name:               "AttackMiddleTraceIndex",
-			expectAttack:       true,
+			expectAttackBranch: 0,
 			expectPreState:     claimBuilder.CorrectPreState(big.NewInt(4)),
 			expectProofData:    claimBuilder.CorrectProofData(big.NewInt(4)),
 			expectedOracleData: claimBuilder.CorrectOracleData(big.NewInt(4)),
+			expectedVMStateData: &types.DAData{
+				PreDA:  types.DAItem{DaType: types.CallDataType, DataHash: claimBuilder.CorrectClaimAtPosition(types.NewPosition(types.Depth(5), big.NewInt(0)))},
+				PostDA: types.DAItem{DaType: types.CallDataType, DataHash: common.Hash{0xaa}},
+			},
 			setupGame: func(builder *faulttest.GameBuilder) {
 				builder.Seq().
+					Attack2(nil, 0).
+					Attack2(nil, 0).
+					Attack2(nil, 0). // splitDepth
+					Attack2(nil, 0).
 					Attack2(nil, 0).
 					Attack2(nil, 1).
-					Attack2(nil, 0, faulttest.WithValue(common.Hash{0xaa}))
+					Attack2([]common.Hash{{0xaa}}, 0)
 			},
 		},
 		{
 			name:               "DefendMiddleTraceIndex",
-			expectAttack:       false,
+			expectAttackBranch: 1,
 			expectPreState:     claimBuilder.CorrectPreState(big.NewInt(5)),
 			expectProofData:    claimBuilder.CorrectProofData(big.NewInt(5)),
 			expectedOracleData: claimBuilder.CorrectOracleData(big.NewInt(5)),
+			expectedVMStateData: &types.DAData{
+				PreDA:  types.DAItem{DaType: types.CallDataType, DataHash: claimBuilder.CorrectClaimAtPosition(types.NewPosition(types.Depth(7), big.NewInt(4)))},
+				PostDA: types.DAItem{DaType: types.CallDataType, DataHash: claimBuilder.CorrectClaimAtPosition(types.NewPosition(types.Depth(6), big.NewInt(2)))},
+			},
 			setupGame: func(builder *faulttest.GameBuilder) {
 				builder.Seq().
+					Attack2(nil, 0).
+					Attack2(nil, 0).
+					Attack2(nil, 0). // splitDepth
+					Attack2(nil, 0).
 					Attack2(nil, 0).
 					Attack2(nil, 1).
 					Attack2(nil, 0)
@@ -90,25 +130,41 @@ func TestAttemptStep(t *testing.T) {
 		},
 		{
 			name:               "AttackLastTraceIndex",
-			expectAttack:       true,
+			expectAttackBranch: 0,
 			expectPreState:     claimBuilder.CorrectPreState(lastLeafTraceIndex),
 			expectProofData:    claimBuilder.CorrectProofData(lastLeafTraceIndex),
 			expectedOracleData: claimBuilder.CorrectOracleData(lastLeafTraceIndex),
+			expectedVMStateData: &types.DAData{
+				PreDA:  types.DAItem{DaType: types.CallDataType, DataHash: claimBuilder.CorrectClaimAtPosition(types.NewPosition(types.Depth(6), common.Big2))},
+				PostDA: types.DAItem{DaType: types.CallDataType, DataHash: common.Hash{0xaa}},
+			},
 			setupGame: func(builder *faulttest.GameBuilder) {
 				builder.Seq().
+					Attack2(nil, 0).
+					Attack2(nil, 0).
+					Attack2(nil, 0). // splitDepth
+					Attack2(nil, 0).
 					Attack2(nil, 0).
 					Attack2(nil, 1).
-					Attack2(nil, 1, faulttest.WithValue(common.Hash{0xaa}))
+					Attack2([]common.Hash{{0xaa}}, 1)
 			},
 		},
 		{
 			name:               "DefendLastTraceIndex",
-			expectAttack:       false,
+			expectAttackBranch: 1,
 			expectPreState:     claimBuilder.CorrectPreState(lastLeafTraceIndexPlusOne),
 			expectProofData:    claimBuilder.CorrectProofData(lastLeafTraceIndexPlusOne),
 			expectedOracleData: claimBuilder.CorrectOracleData(lastLeafTraceIndexPlusOne),
+			expectedVMStateData: &types.DAData{
+				PreDA:  types.DAItem{DaType: types.CallDataType, DataHash: claimBuilder.CorrectClaimAtPosition(types.NewPosition(types.Depth(7), big.NewInt(6)))},
+				PostDA: types.DAItem{DaType: types.CallDataType, DataHash: claimBuilder.CorrectClaimAtPosition(types.NewPosition(types.Depth(4), big.NewInt(0)))},
+			},
 			setupGame: func(builder *faulttest.GameBuilder) {
 				builder.Seq().
+					Attack2(nil, 0).
+					Attack2(nil, 0).
+					Attack2(nil, 0). // splitDepth
+					Attack2(nil, 0).
 					Attack2(nil, 0).
 					Attack2(nil, 1).
 					Attack2(nil, 1)
@@ -127,7 +183,11 @@ func TestAttemptStep(t *testing.T) {
 			setupGame: func(builder *faulttest.GameBuilder) {
 				builder.Seq().
 					Attack2(nil, 0).
-					Attack2(nil, 0, faulttest.WithValue(common.Hash{0xaa})).
+					Attack2(nil, 0).
+					Attack2(nil, 0). // splitDepth
+					Attack2(nil, 0).
+					Attack2(nil, 0).
+					Attack2([]common.Hash{{0xaa}}, 0).
 					Attack2(nil, 0)
 			},
 			expectNoStep:        true,
@@ -137,21 +197,29 @@ func TestAttemptStep(t *testing.T) {
 			name: "CannotStepInvalidPath",
 			setupGame: func(builder *faulttest.GameBuilder) {
 				builder.Seq().
-					Attack2(nil, 0, faulttest.WithValue(common.Hash{0xaa})).
-					Attack2(nil, 0, faulttest.WithValue(common.Hash{0xbb})).
-					Attack2(nil, 0, faulttest.WithValue(common.Hash{0xcc}))
+					Attack2(nil, 0).
+					Attack2(nil, 0).
+					Attack2(nil, 0). // splitDepth
+					Attack2(nil, 0).
+					Attack2([]common.Hash{{0xaa}}, 0).
+					Attack2([]common.Hash{{0xbb}}, 0).
+					Attack2([]common.Hash{{0xcc}}, 0)
 			},
 			expectNoStep:        true,
 			agreeWithOutputRoot: true,
 		},
 		{
 			name:               "CannotStepNearlyValidPath",
-			expectAttack:       true,
+			expectAttackBranch: 1,
 			expectPreState:     claimBuilder.CorrectPreState(big.NewInt(4)),
 			expectProofData:    claimBuilder.CorrectProofData(big.NewInt(4)),
 			expectedOracleData: claimBuilder.CorrectOracleData(big.NewInt(4)),
 			setupGame: func(builder *faulttest.GameBuilder) {
 				builder.Seq().
+					Attack2(nil, 0).
+					Attack2(nil, 0).
+					Attack2(nil, 0). // splitDepth
+					Attack2(nil, 0).
 					Attack2(nil, 0).
 					Attack2(nil, 1).
 					Attack2(nil, 1)
@@ -179,18 +247,363 @@ func TestAttemptStep(t *testing.T) {
 				grandParentClaim := claims[parentClaim.ParentContractIndex]
 				agreedClaims.AddHonestClaim(grandParentClaim, parentClaim)
 			}
-			step, err := alphabetSolver.AttemptStep(ctx, game, lastClaim, agreedClaims)
+			step, err := alphabetSolver.AttemptStep(ctx, game, lastClaim, agreedClaims, 0)
+			require.ErrorIs(t, err, tableTest.expectedErr)
+			if !tableTest.expectNoStep && tableTest.expectedErr == nil {
+				require.NotNil(t, step)
+				require.Equal(t, lastClaim, step.LeafClaim)
+				require.Equal(t, tableTest.expectAttackBranch, step.AttackBranch)
+				require.Equal(t, tableTest.expectPreState, step.PreState)
+				require.Equal(t, tableTest.expectProofData, step.ProofData)
+				require.Equal(t, tableTest.expectedOracleData.IsLocal, step.OracleData.IsLocal)
+				require.Equal(t, tableTest.expectedOracleData.OracleKey, step.OracleData.OracleKey)
+				require.Equal(t, tableTest.expectedOracleData.GetPreimageWithSize(), step.OracleData.GetPreimageWithSize())
+				require.Equal(t, tableTest.expectedOracleData.OracleOffset, step.OracleData.OracleOffset)
+				require.Equal(t, tableTest.expectedVMStateData.PreDA, step.OracleData.VMStateDA.PreDA)
+				require.Equal(t, tableTest.expectedVMStateData.PostDA, step.OracleData.VMStateDA.PostDA)
+			} else {
+				require.Nil(t, step)
+			}
+		})
+	}
+}
+
+type bottomTraceProvider struct {
+	pre  types.Claim
+	post types.Claim
+	*faulttest.AlphabetWithProofProvider
+}
+
+func TestAttemptStepNary2WithLocalData(t *testing.T) {
+	maxDepth := types.Depth(7)
+	startingL2BlockNumber := big.NewInt(0)
+	nbits := uint64(1)
+	splitDepth := types.Depth(3)
+	claimBuilder := faulttest.NewAlphabetClaimBuilder2(t, startingL2BlockNumber, maxDepth, nbits, splitDepth)
+	traceDepth := maxDepth - splitDepth - types.Depth(nbits)
+	callDataType := types.CallDataType
+	oracleKey := faulttest.OraclPostKey
+	ctx := context.Background()
+
+	top := alphabet.NewTraceProvider(big.NewInt(0), splitDepth)
+	bottomCreator := func(ctx context.Context, depth types.Depth, pre types.Claim, post types.Claim) (types.TraceProvider, error) {
+		return &bottomTraceProvider{
+			pre:  pre,
+			post: post,
+			// The oracel key is mocked, and it would be different from correct trace. So, in the following tests only oracle related
+			AlphabetWithProofProvider: faulttest.NewAlphabetWithProofProvider(t, big.NewInt(0), traceDepth, nil, splitDepth, oracleKey),
+		}, nil
+	}
+	selector := split.NewSplitProviderSelector(top, splitDepth, bottomCreator)
+	accessor := trace.NewAccessor(selector)
+
+	tests := []struct {
+		name                string
+		agreeWithOutputRoot bool
+		expectedErr         error
+		expectedOracleKey   []byte
+		expectedVMStateData *types.DAData
+		expectedLocalData   *types.DAItem
+		setupGame           func(builder *faulttest.GameBuilder)
+	}{
+		{
+			name:              "DefendFirstTraceIndex",
+			expectedOracleKey: faulttest.LocalDataOracleKeyBytes(oracleKey),
+			expectedVMStateData: &types.DAData{
+				PreDA:  types.DAItem{DaType: types.CallDataType, DataHash: claimBuilder.CorrectClaimAtPosition(types.NewPosition(types.Depth(7), common.Big0))},
+				PostDA: types.DAItem{DaType: types.CallDataType, DataHash: claimBuilder.CorrectClaimAtPosition(types.NewPosition(types.Depth(7), common.Big1))},
+			},
+			expectedLocalData: &types.DAItem{
+				DaType:   types.CallDataType,
+				DataHash: claimBuilder.CorrectClaimAtPosition(types.NewPosition(types.Depth(3), common.Big0)),
+			},
+			setupGame: func(builder *faulttest.GameBuilder) {
+				builder.Seq().
+					Attack2(nil, 0).
+					Attack2(nil, 0).
+					Attack2(nil, 0). // splitDepth
+					Attack2(nil, 0).
+					Attack2([]common.Hash{{0xaa}}, 0).
+					Attack2(nil, 0).
+					Attack2(nil, 0)
+			},
+		},
+	}
+
+	for _, tableTest := range tests {
+		tableTest := tableTest
+		claimBuilder := faulttest.NewAlphabetClaimBuilder2(t, big.NewInt(0), maxDepth, nbits, splitDepth)
+		builder := claimBuilder.GameBuilder(faulttest.WithInvalidValue(tableTest.agreeWithOutputRoot))
+		tableTest.setupGame(builder)
+		alphabetSolver := newClaimSolver(maxDepth, accessor, callDataType)
+		game := builder.Game
+		claims := game.Claims()
+		lastClaim := claims[len(claims)-1]
+		agreedClaims := newHonestClaimTracker()
+		if tableTest.agreeWithOutputRoot {
+			agreedClaims.AddHonestClaim(types.Claim{}, claims[0])
+		}
+		if (lastClaim.Depth()%2 == 0) == tableTest.agreeWithOutputRoot {
+			parentClaim := claims[lastClaim.ParentContractIndex]
+			grandParentClaim := claims[parentClaim.ParentContractIndex]
+			agreedClaims.AddHonestClaim(grandParentClaim, parentClaim)
+		}
+		step, err := alphabetSolver.AttemptStep(ctx, game, lastClaim, agreedClaims, 0)
+		require.ErrorIs(t, err, tableTest.expectedErr)
+
+		if tableTest.expectedErr == nil {
+			require.NotNil(t, step)
+			require.Equal(t, lastClaim, step.LeafClaim)
+			require.Equal(t, tableTest.expectedVMStateData.PreDA, step.OracleData.VMStateDA.PreDA)
+			require.Equal(t, tableTest.expectedVMStateData.PostDA, step.OracleData.VMStateDA.PostDA)
+			require.Equal(t, tableTest.expectedOracleKey, step.OracleData.OracleKey)
+			require.Equal(t, tableTest.expectedLocalData.DaType, step.OracleData.OutputRootDAItem.DaType)
+			require.Equal(t, tableTest.expectedLocalData.DataHash, step.OracleData.OutputRootDAItem.DataHash)
+			require.Equal(t, tableTest.expectedLocalData.Proof, step.OracleData.OutputRootDAItem.Proof)
+		} else {
+			require.Nil(t, step)
+		}
+	}
+}
+
+func TestAttemptStepNary4(t *testing.T) {
+	maxDepth := types.Depth(8)
+	startingL2BlockNumber := big.NewInt(0)
+	nbits := uint64(2)
+	splitDepth := types.Depth(2)
+	claimBuilder := faulttest.NewAlphabetClaimBuilder2(t, startingL2BlockNumber, maxDepth, nbits, splitDepth)
+
+	ctx := context.Background()
+	absolutePrestate, err := claimBuilder.CorrectTraceProvider().AbsolutePreStateCommitment(ctx)
+	require.NoError(t, err)
+
+	claimAt := claimBuilder.CorrectClaimAtPosition
+	tests := []struct {
+		name                string
+		agreeWithOutputRoot bool
+		attackBranch        uint64
+		expectedErr         error
+		expectNoStep        bool
+		expectAttackBranch  uint64
+		expectPreState      []byte
+		expectProofData     []byte
+		expectedOracleData  *types.PreimageOracleData
+		expectedVMStateData *types.DAData
+		// In alphabet game, oracleKey is always blocknumber. So, expectedLocalData is always nil.
+		expectedLocalData *types.DAItem
+		setupGame         func(builder *faulttest.GameBuilder)
+	}{
+		{
+			name:                "AttackLeftMostBranch",
+			expectAttackBranch:  0,
+			attackBranch:        0,
+			agreeWithOutputRoot: true,
+			expectPreState:      claimBuilder.CorrectPreState(common.Big0),
+			expectProofData:     claimBuilder.CorrectProofData(common.Big0),
+			expectedOracleData:  claimBuilder.CorrectOracleData(common.Big0),
+			expectedVMStateData: &types.DAData{
+				PreDA: types.DAItem{DaType: types.CallDataType, DataHash: absolutePrestate},
+				PostDA: types.DAItem{
+					DaType:   types.CallDataType,
+					DataHash: common.Hash{0x81},
+					Proof:    append(common.Hash{0x82}.Bytes(), common.Hash{0x83}.Bytes()...),
+				},
+			},
+			expectedLocalData: &types.DAItem{DaType: types.CallDataType},
+			setupGame: func(builder *faulttest.GameBuilder) {
+				builder.Seq().
+					Attack2(nil, 0). // splitDepth
+					Attack2(nil, 0).
+					Attack2(nil, 0).
+					Attack2([]common.Hash{{0x81}, {0x82}, {0x83}}, 0)
+			},
+		},
+		{
+			name:                "AttackFirstBranch",
+			expectAttackBranch:  0,
+			attackBranch:        0,
+			agreeWithOutputRoot: true,
+			expectPreState:      claimBuilder.CorrectPreState(big.NewInt(4)),
+			expectProofData:     claimBuilder.CorrectProofData(big.NewInt(4)),
+			expectedOracleData:  claimBuilder.CorrectOracleData(big.NewInt(4)),
+			expectedVMStateData: &types.DAData{
+				PreDA: types.DAItem{
+					DaType:   types.CallDataType,
+					DataHash: claimAt(types.NewPosition(types.Depth(6), common.Big0)),
+					Proof: append(
+						claimAt(types.NewPosition(types.Depth(6), common.Big1)).Bytes(),
+						claimAt(types.NewPosition(types.Depth(6), common.Big2)).Bytes()...,
+					),
+				},
+				PostDA: types.DAItem{
+					DaType:   types.CallDataType,
+					DataHash: common.Hash{0x81},
+					Proof:    append(common.Hash{0x82}.Bytes(), common.Hash{0x83}.Bytes()...),
+				},
+			},
+			expectedLocalData: &types.DAItem{DaType: types.CallDataType},
+			setupGame: func(builder *faulttest.GameBuilder) {
+				builder.Seq().
+					Attack2(nil, 0). // splitDepth
+					Attack2(nil, 0).
+					Attack2(nil, 0).
+					Attack2([]common.Hash{{0x81}, {0x82}, {0x83}}, 1)
+			},
+		},
+		{
+			name:                "AttackMidBranch",
+			expectAttackBranch:  2,
+			attackBranch:        2,
+			agreeWithOutputRoot: true,
+			expectPreState:      claimBuilder.CorrectPreState(big.NewInt(6)),
+			expectProofData:     claimBuilder.CorrectProofData(big.NewInt(6)),
+			expectedOracleData:  claimBuilder.CorrectOracleData(big.NewInt(6)),
+			expectedVMStateData: &types.DAData{
+				PreDA: types.DAItem{
+					DaType:   types.CallDataType,
+					DataHash: claimAt(types.NewPosition(types.Depth(8), big.NewInt(5))),
+					Proof:    append(claimAt(types.NewPosition(types.Depth(8), big.NewInt(4))).Bytes(), common.Hash{0x83}.Bytes()...),
+				},
+				PostDA: types.DAItem{
+					DaType:   types.CallDataType,
+					DataHash: common.Hash{0x83},
+					Proof: crypto.Keccak256(
+						claimAt(types.NewPosition(types.Depth(8), big.NewInt(4))).Bytes(),
+						claimAt(types.NewPosition(types.Depth(8), big.NewInt(5))).Bytes(),
+					),
+				},
+			},
+			expectedLocalData: &types.DAItem{DaType: types.CallDataType},
+			setupGame: func(builder *faulttest.GameBuilder) {
+				builder.Seq().
+					Attack2(nil, 0). // splitDepth
+					Attack2(nil, 0).
+					Attack2(nil, 0).
+					Attack2([]common.Hash{
+						claimAt(types.NewPosition(types.Depth(8), big.NewInt(4))),
+						claimAt(types.NewPosition(types.Depth(8), big.NewInt(5))),
+						{0x83},
+					}, 1)
+			},
+		},
+		{ // if subValues at [0, maxAttackBranck -1] are correct, step would attack the maxAttackBranck
+			name:                "AttackMaxBranch",
+			expectAttackBranch:  3,
+			attackBranch:        2,
+			agreeWithOutputRoot: true,
+			expectPreState:      claimBuilder.CorrectPreState(big.NewInt(7)),
+			expectProofData:     claimBuilder.CorrectProofData(big.NewInt(7)),
+			expectedOracleData:  claimBuilder.CorrectOracleData(big.NewInt(7)),
+			expectedVMStateData: &types.DAData{
+				PreDA: types.DAItem{
+					DaType:   types.CallDataType,
+					DataHash: claimAt(types.NewPosition(types.Depth(8), big.NewInt(6))),
+					Proof: crypto.Keccak256(
+						claimAt(types.NewPosition(types.Depth(8), big.NewInt(4))).Bytes(),
+						claimAt(types.NewPosition(types.Depth(8), big.NewInt(5))).Bytes(),
+					),
+				},
+				PostDA: types.DAItem{
+					DaType:   types.CallDataType,
+					DataHash: claimAt(types.NewPosition(types.Depth(6), common.Big1)),
+					Proof: append(
+						claimAt(types.NewPosition(types.Depth(6), common.Big0)).Bytes(),
+						claimAt(types.NewPosition(types.Depth(6), common.Big2)).Bytes()...,
+					),
+				},
+			},
+			expectedLocalData: &types.DAItem{DaType: types.CallDataType},
+			setupGame: func(builder *faulttest.GameBuilder) {
+				builder.Seq().
+					Attack2(nil, 0). // splitDepth
+					Attack2(nil, 0).
+					Attack2(nil, 0).
+					Attack2([]common.Hash{
+						claimAt(types.NewPosition(types.Depth(8), big.NewInt(4))),
+						claimAt(types.NewPosition(types.Depth(8), big.NewInt(5))),
+						claimAt(types.NewPosition(types.Depth(8), big.NewInt(6))),
+					}, 1)
+			},
+		},
+		{
+			name:                "AttackRightMost",
+			expectAttackBranch:  3,
+			attackBranch:        2,
+			agreeWithOutputRoot: true,
+			expectPreState:      claimBuilder.CorrectPreState(big.NewInt(15)),
+			expectProofData:     claimBuilder.CorrectProofData(big.NewInt(15)),
+			expectedOracleData:  claimBuilder.CorrectOracleData(big.NewInt(15)),
+			expectedVMStateData: &types.DAData{
+				PreDA: types.DAItem{
+					DaType:   types.CallDataType,
+					DataHash: claimAt(types.NewPosition(types.Depth(8), big.NewInt(14))),
+					Proof: crypto.Keccak256(
+						claimAt(types.NewPosition(types.Depth(8), big.NewInt(12))).Bytes(),
+						claimAt(types.NewPosition(types.Depth(8), big.NewInt(13))).Bytes(),
+					),
+				},
+				PostDA: types.DAItem{
+					DaType:   types.CallDataType,
+					DataHash: contracts.SubValuesHash([]common.Hash{claimAt(types.NewPosition(types.Depth(4), common.Big0))}),
+				},
+			},
+			expectedLocalData: &types.DAItem{DaType: types.CallDataType},
+			setupGame: func(builder *faulttest.GameBuilder) {
+				builder.Seq().
+					Attack2(nil, 0). // splitDepth
+					Attack2(nil, 0).
+					Attack2(nil, 0).
+					Attack2([]common.Hash{
+						claimAt(types.NewPosition(types.Depth(8), big.NewInt(12))),
+						claimAt(types.NewPosition(types.Depth(8), big.NewInt(13))),
+						claimAt(types.NewPosition(types.Depth(8), big.NewInt(14))),
+					}, 3)
+			},
+		},
+	}
+
+	for _, tableTest := range tests {
+		tableTest := tableTest
+		t.Run(tableTest.name, func(t *testing.T) {
+			builder := claimBuilder.GameBuilder(faulttest.WithInvalidValue(tableTest.agreeWithOutputRoot))
+			tableTest.setupGame(builder)
+			accessor := trace.NewSimpleTraceAccessor(claimBuilder.CorrectTraceProvider())
+			alphabetSolver := newClaimSolver(maxDepth, accessor, types.CallDataType)
+			game := builder.Game
+			claims := game.Claims()
+			lastClaim := claims[len(claims)-1]
+			agreedClaims := newHonestClaimTracker()
+			if tableTest.agreeWithOutputRoot {
+				agreedClaims.AddHonestClaim(types.Claim{}, claims[0])
+			}
+			if (lastClaim.Depth()%(types.Depth(2*nbits)) == 0) == tableTest.agreeWithOutputRoot {
+				parentClaim := claims[lastClaim.ParentContractIndex]
+				grandParentClaim := claims[parentClaim.ParentContractIndex]
+				agreedClaims.AddHonestClaim(grandParentClaim, parentClaim)
+			}
+			step, err := alphabetSolver.AttemptStep(ctx, game, lastClaim, agreedClaims, tableTest.attackBranch)
 			require.ErrorIs(t, err, tableTest.expectedErr)
+			_, _, preimage, err := accessor.GetStepData2(ctx, game, lastClaim, lastClaim.MoveRightN(tableTest.expectAttackBranch))
+			require.NoError(t, err)
+			preimage.VMStateDA.PreDA.DaType = types.CallDataType
+			preimage.VMStateDA.PostDA.DaType = types.CallDataType
 			if !tableTest.expectNoStep && tableTest.expectedErr == nil {
 				require.NotNil(t, step)
 				require.Equal(t, lastClaim, step.LeafClaim)
-				require.Equal(t, tableTest.expectAttack, step.IsAttack)
+				require.Equal(t, tableTest.expectAttackBranch, step.AttackBranch)
 				require.Equal(t, tableTest.expectPreState, step.PreState)
 				require.Equal(t, tableTest.expectProofData, step.ProofData)
 				require.Equal(t, tableTest.expectedOracleData.IsLocal, step.OracleData.IsLocal)
 				require.Equal(t, tableTest.expectedOracleData.OracleKey, step.OracleData.OracleKey)
 				require.Equal(t, tableTest.expectedOracleData.GetPreimageWithSize(), step.OracleData.GetPreimageWithSize())
 				require.Equal(t, tableTest.expectedOracleData.OracleOffset, step.OracleData.OracleOffset)
+				require.Equal(t, tableTest.expectedVMStateData.PreDA, step.OracleData.VMStateDA.PreDA)
+				require.Equal(t, tableTest.expectedVMStateData.PostDA, step.OracleData.VMStateDA.PostDA)
+				require.Equal(t, tableTest.expectedVMStateData.PreDA, preimage.VMStateDA.PreDA)
+				require.Equal(t, tableTest.expectedVMStateData.PostDA, preimage.VMStateDA.PostDA)
+				require.Equal(t, tableTest.expectedLocalData.DaType, step.OracleData.OutputRootDAItem.DaType)
+				require.Equal(t, tableTest.expectedLocalData.DataHash, step.OracleData.OutputRootDAItem.DataHash)
+				require.Equal(t, tableTest.expectedLocalData.Proof, step.OracleData.OutputRootDAItem.Proof)
 			} else {
 				require.Nil(t, step)
 			}
diff --git a/op-challenger2/game/fault/test/alphabet.go b/op-challenger2/game/fault/test/alphabet.go
index 8d998cd0cdd6b..e101755da3eab 100644
--- a/op-challenger2/game/fault/test/alphabet.go
+++ b/op-challenger2/game/fault/test/alphabet.go
@@ -9,6 +9,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-challenger2/game/fault/trace/alphabet"
 	"github.com/ethereum-optimism/optimism/op-challenger2/game/fault/types"
 	oppreimage "github.com/ethereum-optimism/optimism/op-preimage"
+	"github.com/ethereum/go-ethereum/common"
 )
 
 type OracleKeyType int
@@ -19,9 +20,25 @@ const (
 	OracleDefaultKey OracleKeyType = iota
 )
 
+func LocalDataOracleKeyBytes(oracleKey OracleKeyType) []byte {
+	var key []byte
+	switch oracleKey {
+	case OraclePreKey:
+		// localPreimageKey(1) + STARTING_OUTPUT_ROOT(2)
+		key = []byte{byte(oppreimage.LocalKeyType), types.LocalPreimageKeyStartingOutputRoot}
+	case OraclPostKey:
+		// localPreimageKey(1) + DISPUTED_OUTPUT_ROOT(3)
+		key = []byte{byte(oppreimage.LocalKeyType), types.LocalPreimageKeyDisputedOutputRoot}
+	case OracleDefaultKey:
+		panic("only OraclePreKey and OracleDefaultKey are supported!")
+	}
+	return key
+}
+
 func NewAlphabetWithProofProvider(t *testing.T, startingL2BlockNumber *big.Int, maxDepth types.Depth, oracleError error, rootDepth types.Depth, oracleKey OracleKeyType) *AlphabetWithProofProvider {
+	provider := alphabet.NewTraceProvider(startingL2BlockNumber, maxDepth)
 	return &AlphabetWithProofProvider{
-		alphabet.NewTraceProvider(startingL2BlockNumber, maxDepth),
+		provider,
 		maxDepth,
 		oracleError,
 		nil,
@@ -34,6 +51,11 @@ func NewAlphabetClaimBuilder2(t *testing.T, startingL2BlockNumber *big.Int, maxD
 	return NewClaimBuilder2(t, maxDepth, nbits, splitDepth, alphabetProvider)
 }
 
+func NewAlphabetClaimBuilderWithLocalDataOracle(t *testing.T, startingL2BlockNumber *big.Int, maxDepth types.Depth, nbits uint64, splitDepth types.Depth, oracleKey OracleKeyType) *ClaimBuilder {
+	alphabetProvider := NewAlphabetWithProofProvider(t, startingL2BlockNumber, maxDepth, nil, splitDepth+types.Depth(nbits), oracleKey)
+	return NewClaimBuilder2(t, maxDepth, nbits, splitDepth, alphabetProvider)
+}
+
 type AlphabetWithProofProvider struct {
 	*alphabet.AlphabetTraceProvider
 	depth            types.Depth
@@ -51,11 +73,8 @@ func (a *AlphabetWithProofProvider) GetStepData(ctx context.Context, i types.Pos
 	var key []byte
 	switch a.oracleKey {
 	case OraclePreKey:
-		// localPreimageKey(1) + STARTING_OUTPUT_ROOT(2)
-		key = []byte{byte(oppreimage.LocalKeyType), types.LocalPreimageKeyStartingOutputRoot}
 	case OraclPostKey:
-		// localPreimageKey(1) + DISPUTED_OUTPUT_ROOT(3)
-		key = []byte{byte(oppreimage.LocalKeyType), types.LocalPreimageKeyDisputedOutputRoot}
+		key = LocalDataOracleKeyBytes(a.oracleKey)
 	case OracleDefaultKey:
 		key = []byte{byte(traceIndex)}
 	}
@@ -63,14 +82,18 @@ func (a *AlphabetWithProofProvider) GetStepData(ctx context.Context, i types.Pos
 	return preimage, []byte{byte(traceIndex - 1)}, data, nil
 }
 
-func (ap *AlphabetWithProofProvider) GetStepData2(ctx context.Context, pos types.Position) ([]byte, []byte, *types.PreimageOracleData, error) {
+func (a *AlphabetWithProofProvider) GetStepData2(ctx context.Context, pos types.Position) ([]byte, []byte, *types.PreimageOracleData, error) {
 	return nil, nil, nil, fmt.Errorf("alphabetWithProofProvider GetStepData2 is not supported, use GetStepData instead")
 }
 
-func (c *AlphabetWithProofProvider) GetL2BlockNumberChallenge(_ context.Context) (*types.InvalidL2BlockNumberChallenge, error) {
-	if c.L2BlockChallenge != nil {
-		return c.L2BlockChallenge, nil
+func (a *AlphabetWithProofProvider) GetL2BlockNumberChallenge(_ context.Context) (*types.InvalidL2BlockNumberChallenge, error) {
+	if a.L2BlockChallenge != nil {
+		return a.L2BlockChallenge, nil
 	} else {
 		return nil, types.ErrL2BlockNumberValid
 	}
 }
+
+func (a *AlphabetWithProofProvider) AbsolutePreStateCommitment(ctx context.Context) (hash common.Hash, err error) {
+	return a.AlphabetTraceProvider.AbsolutePreStateCommitment(ctx)
+}
diff --git a/op-challenger2/game/fault/test/claim_builder.go b/op-challenger2/game/fault/test/claim_builder.go
index 91d07d6d1c0d4..ad03903ade002 100644
--- a/op-challenger2/game/fault/test/claim_builder.go
+++ b/op-challenger2/game/fault/test/claim_builder.go
@@ -164,17 +164,24 @@ func (c *ClaimBuilder) claim(pos types.Position, opts ...ClaimOpt) types.Claim {
 	if cfg.claimant != (common.Address{}) {
 		claim.Claimant = cfg.claimant
 	}
-	if cfg.value != (common.Hash{}) {
-		claim.Value = cfg.value
-	} else if cfg.invalidValue {
+	if cfg.invalidValue {
 		claim.Value = c.incorrectClaim(pos)
-	} else {
-		claim.Value = c.CorrectClaimAtPosition(pos)
-		// when nbits is 1, subValues is also filled with claim.Value
 		claim.SubValues = &[]common.Hash{claim.Value}
-	}
-	if cfg.subValues != nil {
+	} else if cfg.subValues != nil {
 		claim.SubValues = cfg.subValues
+		claim.Value = contracts.SubValuesHash(*claim.SubValues)
+	} else {
+		values := []common.Hash{}
+		if pos.IsRootPosition() || pos.Depth() == c.splitDepth+types.Depth(c.nbits) {
+			values = append(values, c.CorrectClaimAtPosition(pos))
+		} else {
+			for i := uint64(0); i < c.MaxAttackBranch(); i++ {
+				pos := pos.MoveRightN(i)
+				values = append(values, c.CorrectClaimAtPosition(pos))
+			}
+		}
+		claim.SubValues = &values
+		claim.Value = contracts.SubValuesHash(values)
 	}
 	claim.ParentContractIndex = cfg.parentIdx
 	return claim
@@ -205,3 +212,61 @@ func (c *ClaimBuilder) DefendClaim(claim types.Claim, opts ...ClaimOpt) types.Cl
 	pos := claim.Position.Defend()
 	return c.claim(pos, append([]ClaimOpt{WithParent(claim)}, opts...)...)
 }
+
+func (c *ClaimBuilder) NBits() uint64 {
+	return c.nbits
+}
+
+func (c *ClaimBuilder) MaxAttackBranch() uint64 {
+	return 1<<c.nbits - 1
+}
+
+func (c *ClaimBuilder) SplitDepth() types.Depth {
+	return c.splitDepth
+}
+
+func (c *ClaimBuilder) TraceRootDepth() types.Depth {
+	return c.splitDepth + types.Depth(c.nbits)
+}
+
+func (c *ClaimBuilder) GetCorrectClaimsAndInvalidClaimAtIndex(pos types.Position, invalidBranchList []uint64) []common.Hash {
+	values := []common.Hash{}
+	if pos.IsRootPosition() {
+		if contains(invalidBranchList, uint64(0)) {
+			values = append(values, c.incorrectClaim(pos))
+		} else {
+			values = append(values, c.CorrectClaimAtPosition(pos))
+		}
+		for i := uint64(0); i < c.MaxAttackBranch()-1; i++ {
+			values = append(values, common.Hash{})
+		}
+	} else if pos.Depth() == c.splitDepth+types.Depth(c.nbits) {
+		if contains(invalidBranchList, uint64(0)) {
+			values = append(values, c.incorrectClaim(pos))
+		} else {
+			values = append(values, c.CorrectClaimAtPosition(pos))
+		}
+		for i := uint64(0); i < c.MaxAttackBranch()-1; i++ {
+			values = append(values, common.Hash{})
+		}
+	} else {
+		for i := uint64(0); i < c.MaxAttackBranch(); i++ {
+			pos := pos.MoveRightN(i)
+			if contains(invalidBranchList, i) {
+				values = append(values, c.incorrectClaim(pos))
+			} else {
+				values = append(values, c.CorrectClaimAtPosition(pos))
+			}
+		}
+	}
+	return values
+}
+
+func contains(slice []uint64, value uint64) bool {
+	for _, v := range slice {
+		if v == value {
+			return true
+		}
+	}
+	return false
+}
diff --git a/op-challenger2/game/fault/test/game_builder.go b/op-challenger2/game/fault/test/game_builder.go
index 823a1935fb38f..9842fb3737d77 100644
--- a/op-challenger2/game/fault/test/game_builder.go
+++ b/op-challenger2/game/fault/test/game_builder.go
@@ -4,6 +4,7 @@ import (
 	"math/big"
 	"testing"
 
+	"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"
 )
@@ -55,10 +56,22 @@ func (g *GameBuilderSeq) IsRoot() bool {
 	return g.lastClaim.IsRoot()
 }
 
+func (g *GameBuilderSeq) IsTraceRoot() bool {
+	return g.lastClaim.Depth() == g.gameBuilder.Game.SplitDepth()+types.Depth(g.gameBuilder.Game.NBits())
+}
+
+func (g *GameBuilderSeq) IsSplitDepth() bool {
+	return g.lastClaim.Depth() == g.gameBuilder.Game.SplitDepth()
+}
+
 func (g *GameBuilderSeq) LastClaim() types.Claim {
 	return g.lastClaim
 }
 
+func (g *GameBuilderSeq) MaxAttackBranch() uint64 {
+	return g.gameBuilder.builder.MaxAttackBranch()
+}
+
 // 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
@@ -161,3 +174,45 @@ func (s *GameBuilderSeq) ExpectStepDefend() *GameBuilderSeq {
 	})
 	return s
 }
+
+func (s *GameBuilderSeq) ExpectAttackV2(branch uint64) *GameBuilderSeq {
+	var value common.Hash
+	var values []common.Hash
+	nBits := s.builder.NBits()
+	maxAttackBranch := s.builder.MaxAttackBranch()
+	position := s.lastClaim.Position.MoveN(nBits, branch)
+
+	for i := uint64(0); i < maxAttackBranch; i++ {
+		tmpPosition := position.MoveRightN(i)
+		if tmpPosition.Depth() == (s.builder.SplitDepth()+types.Depth(nBits)) && i != 0 {
+			break
+		} else {
+			value = s.builder.CorrectClaimAtPosition(tmpPosition)
+		}
+		values = append(values, value)
+	}
+	hash := contracts.SubValuesHash(values)
+	action := types.Action{
+		Type:         types.ActionTypeAttackV2,
+		ParentClaim:  s.lastClaim,
+		Value:        hash,
+		SubValues:    &values,
+		AttackBranch: branch,
+		DAType:       types.CallDataType,
+	}
+	s.gameBuilder.ExpectedActions = append(s.gameBuilder.ExpectedActions, action)
+	return s
+}
+
+func (s *GameBuilderSeq) ExpectStepV2(branch uint64) *GameBuilderSeq {
+	traceIdx := new(big.Int).Add(s.lastClaim.TraceIndex(s.builder.maxDepth), big.NewInt(int64(branch)))
+	s.gameBuilder.ExpectedActions = append(s.gameBuilder.ExpectedActions, types.Action{
+		Type:         types.ActionTypeStep,
+		ParentClaim:  s.lastClaim,
+		AttackBranch: branch,
+		PreState:     s.builder.CorrectPreState(traceIdx),
+		ProofData:    s.builder.CorrectProofData(traceIdx),
+		OracleData:   s.builder.CorrectOracleData(traceIdx),
+	})
+	return s
+}
diff --git a/op-challenger2/game/fault/trace/access.go b/op-challenger2/game/fault/trace/access.go
index dcb013a54245b..72dda08498486 100644
--- a/op-challenger2/game/fault/trace/access.go
+++ b/op-challenger2/game/fault/trace/access.go
@@ -63,18 +63,14 @@ func findAncestorProofAtDepth2(ctx context.Context, provider types.TraceProvider
 			return types.DAItem{}, fmt.Errorf("failed to get absolutePrestate: %w", err)
 		}
 		return types.DAItem{
-			DaType:   types.CallDataType,
 			DataHash: absolutePresate,
-			Proof:    []byte{},
 		}, nil
 	}
 
 	// If traceIdx is the right most branch, the root Claim is returned.
 	if new(big.Int).Add(relativeTraceIdx, big.NewInt(1)).Cmp(new(big.Int).Lsh(big.NewInt(1), uint(maxTraceDepth-types.Depth(game.NBits())))) == 0 {
 		return types.DAItem{
-			DaType:   types.CallDataType,
 			DataHash: splitLeaf.Value,
-			Proof:    []byte{},
 		}, nil
 	}
 
@@ -102,7 +98,6 @@ func findAncestorProofAtDepth2(ctx context.Context, provider types.TraceProvider
 	merkleProof := utils.GenerateProofForSubValues(subValues, uint32(branch))
 
 	return types.DAItem{
-		DaType:   types.CallDataType,
 		DataHash: ancestorClaim,
 		Proof:    merkleProof,
 	}, nil
@@ -157,7 +152,7 @@ func (t *Accessor) GetStepData2(ctx context.Context, game types.Game, ref types.
 	preTraceIdx := new(big.Int).Sub(postTraceIdx, big.NewInt(1))
 	preStateDaItem, err := findAncestorProofAtDepth2(ctx, provider, game, ref, preTraceIdx)
 	if err != nil {
-		return nil, nil, nil, fmt.Errorf("failed to get postStateDaItem at trace index %v: %w", preTraceIdx, err)
+		return nil, nil, nil, fmt.Errorf("failed to get preStateDaItem at trace index %v: %w", preTraceIdx, err)
 	}
 	postStateDaItem, err := findAncestorProofAtDepth2(ctx, provider, game, ref, postTraceIdx)
 	if err != nil {
@@ -169,18 +164,21 @@ func (t *Accessor) GetStepData2(ctx context.Context, game types.Game, ref types.
 	}
 
 	preimageData.VMStateDA = stateData
-
-	keyType := preimage.KeyType(preimageData.OracleKey[0])
-	if keyType == preimage.LocalKeyType {
-		ident := preimageData.GetIdent()
-		addlocalDataDaItem := types.DAItem{}
-		if ident.Cmp(big.NewInt(types.LocalPreimageKeyStartingOutputRoot)) == 0 {
-			addlocalDataDaItem = outputRootDA.PreDA
-		} else if ident.Cmp(big.NewInt(types.LocalPreimageKeyDisputedOutputRoot)) == 0 {
-			addlocalDataDaItem = outputRootDA.PostDA
+	addlocalDataDaItem := types.DAItem{}
+
+	if preimageData.OracleKey != nil {
+		keyType := preimage.KeyType(preimageData.OracleKey[0])
+		if keyType == preimage.LocalKeyType {
+			ident := preimageData.GetIdent()
+			if ident.Cmp(big.NewInt(types.LocalPreimageKeyStartingOutputRoot)) == 0 {
+				addlocalDataDaItem = outputRootDA.PreDA
+			} else if ident.Cmp(big.NewInt(types.LocalPreimageKeyDisputedOutputRoot)) == 0 {
+				addlocalDataDaItem = outputRootDA.PostDA
+			}
 		}
-		preimageData.OutputRootDAItem = addlocalDataDaItem
 	}
+	preimageData.OutputRootDAItem = addlocalDataDaItem
+
 	return prestate, proofData, preimageData, nil
 }
 
diff --git a/op-challenger2/game/fault/trace/access_test.go b/op-challenger2/game/fault/trace/access_test.go
index 71ed3e8fbcf5f..8db129d5b9bbb 100644
--- a/op-challenger2/game/fault/trace/access_test.go
+++ b/op-challenger2/game/fault/trace/access_test.go
@@ -138,12 +138,10 @@ func TestGetStepData2(t *testing.T) {
 
 	expectedStateDA := types.DAData{
 		PreDA: types.DAItem{
-			DaType:   types.CallDataType,
 			DataHash: subClaimsDep8[0],
 			Proof:    append(subClaimsDep8[1][:], subClaimsDep8[2][:]...),
 		},
 		PostDA: types.DAItem{
-			DaType:   types.CallDataType,
 			DataHash: subClaimsDep8[1],
 			Proof:    append(subClaimsDep8[0][:], subClaimsDep8[2][:]...),
 		},
@@ -190,7 +188,6 @@ func TestGetStepDataWithOutputRoot(t *testing.T) {
 	outputRootDA := types.DAData{
 		PreDA: types.DAItem{},
 		PostDA: types.DAItem{
-			DaType:   types.CallDataType,
 			DataHash: subClaimsDep2[0],
 			Proof:    append(subClaimsDep2[1][:], subClaimsDep2[2][:]...),
 		},
@@ -287,13 +284,10 @@ func attackLeftMost(t *testing.T, ctx context.Context, gameBuilder *test.GameBui
 	absolutePre, err := provider.AbsolutePreStateCommitment(ctx)
 	require.NoError(t, err)
 	expectPreDA = types.DAItem{
-		DaType:   types.CallDataType,
 		DataHash: absolutePre,
-		Proof:    []byte{},
 	}
 
 	expectPostDA = types.DAItem{
-		DaType:   types.CallDataType,
 		DataHash: subClaimsDep8[0],
 		Proof:    append(subClaimsDep8[1][:], subClaimsDep8[2][:]...),
 	}
@@ -327,13 +321,11 @@ func attackFirstBranch(t *testing.T, ctx context.Context, gameBuilder *test.Game
 	preTraceIdx = new(big.Int).Sub(postTraceIdx, big.NewInt(1))
 
 	expectPreDA = types.DAItem{
-		DaType:   types.CallDataType,
 		DataHash: subClaimsDep6[0],
 		Proof:    append(subClaimsDep6[1][:], subClaimsDep6[2][:]...),
 	}
 
 	expectPostDA = types.DAItem{
-		DaType:   types.CallDataType,
 		DataHash: subClaimsDep8[0],
 		Proof:    append(subClaimsDep8[1][:], subClaimsDep8[2][:]...),
 	}
@@ -365,13 +357,11 @@ func attackMidBranch(t *testing.T, ctx context.Context, gameBuilder *test.GameBu
 	preTraceIdx = new(big.Int).Sub(postTraceIdx, big.NewInt(1))
 
 	expectPreDA = types.DAItem{
-		DaType:   types.CallDataType,
 		DataHash: subClaimsDep8[0],
 		Proof:    append(subClaimsDep8[1][:], subClaimsDep8[2][:]...),
 	}
 
 	expectPostDA = types.DAItem{
-		DaType:   types.CallDataType,
 		DataHash: subClaimsDep8[1],
 		Proof:    append(subClaimsDep8[0][:], subClaimsDep8[2][:]...),
 	}
@@ -404,13 +394,11 @@ func attackMaxBranch(t *testing.T, ctx context.Context, gameBuilder *test.GameBu
 	preTraceIdx = new(big.Int).Sub(postTraceIdx, big.NewInt(1))
 
 	expectPreDA = types.DAItem{
-		DaType:   types.CallDataType,
 		DataHash: subClaimsDep8[2],
 		Proof:    crypto.Keccak256(subClaimsDep8[0][:], subClaimsDep8[1][:]),
 	}
 
 	expectPostDA = types.DAItem{
-		DaType:   types.CallDataType,
 		DataHash: subClaimsDep6[1],
 		Proof:    append(subClaimsDep6[0][:], subClaimsDep6[2][:]...),
 	}
@@ -442,16 +430,13 @@ func attackRightMost(t *testing.T, ctx context.Context, gameBuilder *test.GameBu
 	preTraceIdx = new(big.Int).Sub(postTraceIdx, big.NewInt(1))
 
 	expectPreDA = types.DAItem{
-		DaType:   types.CallDataType,
 		DataHash: subClaimsDep8[2],
 		Proof:    crypto.Keccak256(subClaimsDep8[0][:], subClaimsDep8[1][:]),
 	}
 
 	splitLeaf := game.Claims()[2]
 	expectPostDA = types.DAItem{
-		DaType:   types.CallDataType,
 		DataHash: splitLeaf.Value,
-		Proof:    []byte{},
 	}
 	return
 }
diff --git a/op-challenger2/game/fault/trace/utils/daproof_test.go b/op-challenger2/game/fault/trace/utils/daproof_test.go
index 5620102a0eb03..0aab86087bfa2 100644
--- a/op-challenger2/game/fault/trace/utils/daproof_test.go
+++ b/op-challenger2/game/fault/trace/utils/daproof_test.go
@@ -9,6 +9,7 @@ import (
 )
 
 func TestUnpaddingMerkelProof(t *testing.T) {
+	oneleave := []common.Hash{{0xaa}}
 	twoLeaves := []common.Hash{{0xaa}, {0xbb}}
 	fourLeaves := []common.Hash{{0xaa}, {0xbb}, {0xcc}, {0xdd}}
 	fiveLeaves := []common.Hash{{0xaa}, {0xbb}, {0xcc}, {0xdd}, {0xee}}
@@ -17,6 +18,12 @@ func TestUnpaddingMerkelProof(t *testing.T) {
 		index       uint32
 		expectProof []byte
 	}{
+		// 1 leave
+		{
+			data:        oneleave,
+			index:       0,
+			expectProof: nil,
+		},
 		// 2 leaves
 		{
 			data:        twoLeaves,
diff --git a/op-challenger2/game/fault/types/actions.go b/op-challenger2/game/fault/types/actions.go
index e5093d6ac553d..d6a22e4463a9e 100644
--- a/op-challenger2/game/fault/types/actions.go
+++ b/op-challenger2/game/fault/types/actions.go
@@ -9,6 +9,7 @@ func (a ActionType) String() string {
 }
 
 const (
+	ActionTypeAttackV2               ActionType = "attackV2"
 	ActionTypeMove                   ActionType = "move"
 	ActionTypeStep                   ActionType = "step"
 	ActionTypeChallengeL2BlockNumber ActionType = "challenge-l2-block-number"
@@ -22,7 +23,10 @@ type Action struct {
 	IsAttack    bool
 
 	// Moves
-	Value common.Hash
+	Value        common.Hash
+	SubValues    *[]common.Hash
+	AttackBranch uint64
+	DAType       DAType
 
 	// Steps
 	PreState   []byte
diff --git a/op-challenger2/game/fault/types/types.go b/op-challenger2/game/fault/types/types.go
index 72130b4388d82..f532eed7f05c2 100644
--- a/op-challenger2/game/fault/types/types.go
+++ b/op-challenger2/game/fault/types/types.go
@@ -161,6 +161,8 @@ type TraceAccessor interface {
 	// evaluated in the context of the specified claim (ref).
 	GetStepData(ctx context.Context, game Game, ref Claim, pos Position) (prestate []byte, proofData []byte, preimageData *PreimageOracleData, err error)
 
+	// GetStepData2 returns GetStepData returns and oracle proofs required for MSFDG contract's addLocalData and stepV2
+	GetStepData2(ctx context.Context, game Game, ref Claim, pos Position) (prestate []byte, proofData []byte, preimageData *PreimageOracleData, err error)
 	// GetL2BlockNumberChallenge returns the data required to prove the correct L2 block number of the root claim.
 	// Returns ErrL2BlockNumberValid if the root claim is known to come from the same block as the claimed L2 block.
 	GetL2BlockNumberChallenge(ctx context.Context, game Game) (*InvalidL2BlockNumberChallenge, error)
diff --git a/op-challenger2/metrics/metrics.go b/op-challenger2/metrics/metrics.go
index adb223c0eac7b..3b01fcf603be8 100644
--- a/op-challenger2/metrics/metrics.go
+++ b/op-challenger2/metrics/metrics.go
@@ -36,6 +36,7 @@ type Metricer interface {
 
 	RecordGameStep()
 	RecordGameMove()
+	RecordGameAttackV2()
 	RecordGameL2Challenge()
 	RecordCannonExecutionTime(t float64)
 	RecordAsteriscExecutionTime(t float64)
@@ -85,6 +86,7 @@ type Metrics struct {
 	highestActedL1Block prometheus.Gauge
 
 	moves        prometheus.Counter
+	attackV2     prometheus.Counter
 	steps        prometheus.Counter
 	l2Challenges prometheus.Counter
 
@@ -142,6 +144,11 @@ func NewMetrics() *Metrics {
 			Name:      "moves",
 			Help:      "Number of game moves made by the challenge agent",
 		}),
+		attackV2: factory.NewCounter(prometheus.CounterOpts{
+			Namespace: Namespace,
+			Name:      "attackV2",
+			Help:      "Number of game attack v2 moves made by the challenge agent",
+		}),
 		steps: factory.NewCounter(prometheus.CounterOpts{
 			Namespace: Namespace,
 			Name:      "steps",
@@ -254,6 +261,10 @@ func (m *Metrics) RecordGameMove() {
 	m.moves.Add(1)
 }
 
+func (m *Metrics) RecordGameAttackV2() {
+	m.attackV2.Add(1)
+}
+
 func (m *Metrics) RecordGameStep() {
 	m.steps.Add(1)
 }
diff --git a/op-challenger2/metrics/noop.go b/op-challenger2/metrics/noop.go
index 8519d6bab4b6f..f53cf9f4c7663 100644
--- a/op-challenger2/metrics/noop.go
+++ b/op-challenger2/metrics/noop.go
@@ -26,6 +26,7 @@ func (*NoopMetricsImpl) RecordInfo(version string) {}
 func (*NoopMetricsImpl) RecordUp()                 {}
 
 func (*NoopMetricsImpl) RecordGameMove()        {}
+func (*NoopMetricsImpl) RecordGameAttackV2()    {}
 func (*NoopMetricsImpl) RecordGameStep()        {}
 func (*NoopMetricsImpl) RecordGameL2Challenge() {}
 
diff --git a/op-e2e2/bindings/faultdiputegameN.go b/op-e2e2/bindings/faultdiputegameN.go
new file mode 100644
index 0000000000000..e2070a99f5e2b
--- /dev/null
+++ b/op-e2e2/bindings/faultdiputegameN.go
@@ -0,0 +1,2079 @@
+// Code generated - DO NOT EDIT.
+// This file is a generated binding and any manual changes will be lost.
+
+package bindings
+
+import (
+	"errors"
+	"math/big"
+	"strings"
+
+	ethereum "github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/event"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var (
+	_ = errors.New
+	_ = big.NewInt
+	_ = strings.NewReader
+	_ = ethereum.NotFound
+	_ = bind.Bind
+	_ = common.Big1
+	_ = types.BloomLookup
+	_ = event.NewSubscription
+	_ = abi.ConvertType
+)
+
+// FaultDisputeGameStepProof is an auto generated low-level Go binding around an user-defined struct.
+type FaultDisputeGameStepProof struct {
+	PreStateItem  LibDADAItem
+	PostStateItem LibDADAItem
+	VmProof       []byte
+}
+
+// LibDADAItem is an auto generated low-level Go binding around an user-defined struct.
+type LibDADAItem struct {
+	DaType   *big.Int
+	DataHash [32]byte
+	Proof    []byte
+}
+
+// FaultDisputeGameNMetaData contains all meta data concerning the FaultDisputeGameN contract.
+var FaultDisputeGameNMetaData = &bind.MetaData{
+	ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_gameType\",\"type\":\"uint32\",\"internalType\":\"GameType\"},{\"name\":\"_absolutePrestate\",\"type\":\"bytes32\",\"internalType\":\"Claim\"},{\"name\":\"_maxGameDepth\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_splitDepth\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_clockExtension\",\"type\":\"uint64\",\"internalType\":\"Duration\"},{\"name\":\"_maxClockDuration\",\"type\":\"uint64\",\"internalType\":\"Duration\"},{\"name\":\"_vm\",\"type\":\"address\",\"internalType\":\"contractIBigStepper\"},{\"name\":\"_weth\",\"type\":\"address\",\"internalType\":\"contractIDelayedWETH\"},{\"name\":\"_anchorStateRegistry\",\"type\":\"address\",\"internalType\":\"contractIAnchorStateRegistry\"},{\"name\":\"_l2ChainId\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"MAX_ATTACK_BRANCH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"N_BITS\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"absolutePrestate\",\"inputs\":[],\"outputs\":[{\"name\":\"absolutePrestate_\",\"type\":\"bytes32\",\"internalType\":\"Claim\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"addLocalData\",\"inputs\":[{\"name\":\"_ident\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_execLeafIdx\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_partOffset\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"addLocalData2\",\"inputs\":[{\"name\":\"_ident\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_execLeafIdx\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_partOffset\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_daItem\",\"type\":\"tuple\",\"internalType\":\"structLibDA.DAItem\",\"components\":[{\"name\":\"daType\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"dataHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"proof\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"outputs\":[{\"name\":\"uuid_\",\"type\":\"bytes32\",\"internalType\":\"Hash\"},{\"name\":\"value_\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"anchorStateRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"registry_\",\"type\":\"address\",\"internalType\":\"contractIAnchorStateRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"attack\",\"inputs\":[{\"name\":\"_disputed\",\"type\":\"bytes32\",\"internalType\":\"Claim\"},{\"name\":\"_parentIndex\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_claim\",\"type\":\"bytes32\",\"internalType\":\"Claim\"}],\"outputs\":[],\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"attackV2\",\"inputs\":[{\"name\":\"_disputed\",\"type\":\"bytes32\",\"internalType\":\"Claim\"},{\"name\":\"_parentIndex\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_attackBranch\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_daType\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_claims\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[],\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"challengeRootL2Block\",\"inputs\":[{\"name\":\"_outputRootProof\",\"type\":\"tuple\",\"internalType\":\"structTypes.OutputRootProof\",\"components\":[{\"name\":\"version\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"stateRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"messagePasserStorageRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"latestBlockhash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}]},{\"name\":\"_headerRLP\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"claimCredit\",\"inputs\":[{\"name\":\"_recipient\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"claimData\",\"inputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"parentIndex\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"counteredBy\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"claimant\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"bond\",\"type\":\"uint128\",\"internalType\":\"uint128\"},{\"name\":\"claim\",\"type\":\"bytes32\",\"internalType\":\"Claim\"},{\"name\":\"position\",\"type\":\"uint128\",\"internalType\":\"Position\"},{\"name\":\"clock\",\"type\":\"uint128\",\"internalType\":\"Clock\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"claimDataLen\",\"inputs\":[],\"outputs\":[{\"name\":\"len_\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"claims\",\"inputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"Hash\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"clockExtension\",\"inputs\":[],\"outputs\":[{\"name\":\"clockExtension_\",\"type\":\"uint64\",\"internalType\":\"Duration\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"createdAt\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"Timestamp\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"credit\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"defend\",\"inputs\":[{\"name\":\"_disputed\",\"type\":\"bytes32\",\"internalType\":\"Claim\"},{\"name\":\"_parentIndex\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_claim\",\"type\":\"bytes32\",\"internalType\":\"Claim\"}],\"outputs\":[],\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"extraData\",\"inputs\":[],\"outputs\":[{\"name\":\"extraData_\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"gameCreator\",\"inputs\":[],\"outputs\":[{\"name\":\"creator_\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"gameData\",\"inputs\":[],\"outputs\":[{\"name\":\"gameType_\",\"type\":\"uint32\",\"internalType\":\"GameType\"},{\"name\":\"rootClaim_\",\"type\":\"bytes32\",\"internalType\":\"Claim\"},{\"name\":\"extraData_\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"gameType\",\"inputs\":[],\"outputs\":[{\"name\":\"gameType_\",\"type\":\"uint32\",\"internalType\":\"GameType\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getChallengerDuration\",\"inputs\":[{\"name\":\"_claimIndex\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"duration_\",\"type\":\"uint64\",\"internalType\":\"Duration\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getNumToResolve\",\"inputs\":[{\"name\":\"_claimIndex\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"numRemainingChildren_\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getRequiredBond\",\"inputs\":[{\"name\":\"_position\",\"type\":\"uint128\",\"internalType\":\"Position\"}],\"outputs\":[{\"name\":\"requiredBond_\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"l1Head\",\"inputs\":[],\"outputs\":[{\"name\":\"l1Head_\",\"type\":\"bytes32\",\"internalType\":\"Hash\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"l2BlockNumber\",\"inputs\":[],\"outputs\":[{\"name\":\"l2BlockNumber_\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"l2BlockNumberChallenged\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"l2BlockNumberChallenger\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"l2ChainId\",\"inputs\":[],\"outputs\":[{\"name\":\"l2ChainId_\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"maxAttackBranch\",\"inputs\":[],\"outputs\":[{\"name\":\"maxAttackBranch_\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"maxClockDuration\",\"inputs\":[],\"outputs\":[{\"name\":\"maxClockDuration_\",\"type\":\"uint64\",\"internalType\":\"Duration\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"maxGameDepth\",\"inputs\":[],\"outputs\":[{\"name\":\"maxGameDepth_\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"move\",\"inputs\":[{\"name\":\"_disputed\",\"type\":\"bytes32\",\"internalType\":\"Claim\"},{\"name\":\"_challengeIndex\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_claim\",\"type\":\"bytes32\",\"internalType\":\"Claim\"},{\"name\":\"_isAttack\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"outputs\":[],\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"nBits\",\"inputs\":[],\"outputs\":[{\"name\":\"nBits_\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"resolutionCheckpoints\",\"inputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"initialCheckpointComplete\",\"type\":\"bool\",\"internalType\":\"bool\"},{\"name\":\"subgameIndex\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"leftmostPosition\",\"type\":\"uint128\",\"internalType\":\"Position\"},{\"name\":\"counteredBy\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"resolve\",\"inputs\":[],\"outputs\":[{\"name\":\"status_\",\"type\":\"uint8\",\"internalType\":\"enumGameStatus\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"resolveClaim\",\"inputs\":[{\"name\":\"_claimIndex\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_numToResolve\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"resolvedAt\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"Timestamp\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"resolvedSubgames\",\"inputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"rootClaim\",\"inputs\":[],\"outputs\":[{\"name\":\"rootClaim_\",\"type\":\"bytes32\",\"internalType\":\"Claim\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"splitDepth\",\"inputs\":[],\"outputs\":[{\"name\":\"splitDepth_\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"startingBlockNumber\",\"inputs\":[],\"outputs\":[{\"name\":\"startingBlockNumber_\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"startingOutputRoot\",\"inputs\":[],\"outputs\":[{\"name\":\"root\",\"type\":\"bytes32\",\"internalType\":\"Hash\"},{\"name\":\"l2BlockNumber\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"startingRootHash\",\"inputs\":[],\"outputs\":[{\"name\":\"startingRootHash_\",\"type\":\"bytes32\",\"internalType\":\"Hash\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"status\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"enumGameStatus\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"step\",\"inputs\":[{\"name\":\"_claimIndex\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_isAttack\",\"type\":\"bool\",\"internalType\":\"bool\"},{\"name\":\"_stateData\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"_proof\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"stepV2\",\"inputs\":[{\"name\":\"_claimIndex\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_attackBranch\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_stateData\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"_proof\",\"type\":\"tuple\",\"internalType\":\"structFaultDisputeGame.StepProof\",\"components\":[{\"name\":\"preStateItem\",\"type\":\"tuple\",\"internalType\":\"structLibDA.DAItem\",\"components\":[{\"name\":\"daType\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"dataHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"proof\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]},{\"name\":\"postStateItem\",\"type\":\"tuple\",\"internalType\":\"structLibDA.DAItem\",\"components\":[{\"name\":\"daType\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"dataHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"proof\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]},{\"name\":\"vmProof\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"subgames\",\"inputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"version\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"vm\",\"inputs\":[],\"outputs\":[{\"name\":\"vm_\",\"type\":\"address\",\"internalType\":\"contractIBigStepper\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"weth\",\"inputs\":[],\"outputs\":[{\"name\":\"weth_\",\"type\":\"address\",\"internalType\":\"contractIDelayedWETH\"}],\"stateMutability\":\"view\"},{\"type\":\"event\",\"name\":\"Move\",\"inputs\":[{\"name\":\"parentIndex\",\"type\":\"uint256\",\"indexed\":true,\"internalType\":\"uint256\"},{\"name\":\"claim\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"Claim\"},{\"name\":\"claimant\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Resolved\",\"inputs\":[{\"name\":\"status\",\"type\":\"uint8\",\"indexed\":true,\"internalType\":\"enumGameStatus\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"AlreadyInitialized\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"AnchorRootNotFound\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"BlockNumberMatches\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"BondTransferFailed\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"CannotDefendRootClaim\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ClaimAboveSplit\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ClaimAlreadyExists\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ClaimAlreadyResolved\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ClockNotExpired\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ClockTimeExceeded\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ContentLengthMismatch\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"DuplicateStep\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"EmptyItem\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"GameDepthExceeded\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"GameNotInProgress\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"IncorrectBondAmount\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidClockExtension\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidDataRemainder\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidDisputedClaimIndex\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidHeader\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidHeaderRLP\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidLocalIdent\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidOutputRootProof\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidParent\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidPosition\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidPrestate\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidSplitDepth\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"L2BlockNumberChallenged\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"MaxDepthTooLarge\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"NoCreditToClaim\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"NotSupported\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OutOfOrderResolution\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"UnexpectedList\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"UnexpectedRootClaim\",\"inputs\":[{\"name\":\"rootClaim\",\"type\":\"bytes32\",\"internalType\":\"Claim\"}]},{\"type\":\"error\",\"name\":\"UnexpectedString\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ValidStep\",\"inputs\":[]}]",
+}
+
+// FaultDisputeGameNABI is the input ABI used to generate the binding from.
+// Deprecated: Use FaultDisputeGameNMetaData.ABI instead.
+var FaultDisputeGameNABI = FaultDisputeGameNMetaData.ABI
+
+// FaultDisputeGameN is an auto generated Go binding around an Ethereum contract.
+type FaultDisputeGameN struct {
+	FaultDisputeGameNCaller     // Read-only binding to the contract
+	FaultDisputeGameNTransactor // Write-only binding to the contract
+	FaultDisputeGameNFilterer   // Log filterer for contract events
+}
+
+// FaultDisputeGameNCaller is an auto generated read-only Go binding around an Ethereum contract.
+type FaultDisputeGameNCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// FaultDisputeGameNTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type FaultDisputeGameNTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// FaultDisputeGameNFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type FaultDisputeGameNFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// FaultDisputeGameNSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type FaultDisputeGameNSession struct {
+	Contract     *FaultDisputeGameN // Generic contract binding to set the session for
+	CallOpts     bind.CallOpts      // Call options to use throughout this session
+	TransactOpts bind.TransactOpts  // Transaction auth options to use throughout this session
+}
+
+// FaultDisputeGameNCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type FaultDisputeGameNCallerSession struct {
+	Contract *FaultDisputeGameNCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts            // Call options to use throughout this session
+}
+
+// FaultDisputeGameNTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type FaultDisputeGameNTransactorSession struct {
+	Contract     *FaultDisputeGameNTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts            // Transaction auth options to use throughout this session
+}
+
+// FaultDisputeGameNRaw is an auto generated low-level Go binding around an Ethereum contract.
+type FaultDisputeGameNRaw struct {
+	Contract *FaultDisputeGameN // Generic contract binding to access the raw methods on
+}
+
+// FaultDisputeGameNCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type FaultDisputeGameNCallerRaw struct {
+	Contract *FaultDisputeGameNCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// FaultDisputeGameNTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type FaultDisputeGameNTransactorRaw struct {
+	Contract *FaultDisputeGameNTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewFaultDisputeGameN creates a new instance of FaultDisputeGameN, bound to a specific deployed contract.
+func NewFaultDisputeGameN(address common.Address, backend bind.ContractBackend) (*FaultDisputeGameN, error) {
+	contract, err := bindFaultDisputeGameN(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &FaultDisputeGameN{FaultDisputeGameNCaller: FaultDisputeGameNCaller{contract: contract}, FaultDisputeGameNTransactor: FaultDisputeGameNTransactor{contract: contract}, FaultDisputeGameNFilterer: FaultDisputeGameNFilterer{contract: contract}}, nil
+}
+
+// NewFaultDisputeGameNCaller creates a new read-only instance of FaultDisputeGameN, bound to a specific deployed contract.
+func NewFaultDisputeGameNCaller(address common.Address, caller bind.ContractCaller) (*FaultDisputeGameNCaller, error) {
+	contract, err := bindFaultDisputeGameN(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &FaultDisputeGameNCaller{contract: contract}, nil
+}
+
+// NewFaultDisputeGameNTransactor creates a new write-only instance of FaultDisputeGameN, bound to a specific deployed contract.
+func NewFaultDisputeGameNTransactor(address common.Address, transactor bind.ContractTransactor) (*FaultDisputeGameNTransactor, error) {
+	contract, err := bindFaultDisputeGameN(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &FaultDisputeGameNTransactor{contract: contract}, nil
+}
+
+// NewFaultDisputeGameNFilterer creates a new log filterer instance of FaultDisputeGameN, bound to a specific deployed contract.
+func NewFaultDisputeGameNFilterer(address common.Address, filterer bind.ContractFilterer) (*FaultDisputeGameNFilterer, error) {
+	contract, err := bindFaultDisputeGameN(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &FaultDisputeGameNFilterer{contract: contract}, nil
+}
+
+// bindFaultDisputeGameN binds a generic wrapper to an already deployed contract.
+func bindFaultDisputeGameN(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := FaultDisputeGameNMetaData.GetAbi()
+	if err != nil {
+		return nil, err
+	}
+	return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil
+}
+
+// Call invokes the (constant) contract method with params as input values and
+// sets the output to result. The result type might be a single field for simple
+// returns, a slice of interfaces for anonymous returns and a struct for named
+// returns.
+func (_FaultDisputeGameN *FaultDisputeGameNRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _FaultDisputeGameN.Contract.FaultDisputeGameNCaller.contract.Call(opts, result, method, params...)
+}
+
+// Transfer initiates a plain transaction to move funds to the contract, calling
+// its default method if one is available.
+func (_FaultDisputeGameN *FaultDisputeGameNRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _FaultDisputeGameN.Contract.FaultDisputeGameNTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_FaultDisputeGameN *FaultDisputeGameNRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _FaultDisputeGameN.Contract.FaultDisputeGameNTransactor.contract.Transact(opts, method, params...)
+}
+
+// Call invokes the (constant) contract method with params as input values and
+// sets the output to result. The result type might be a single field for simple
+// returns, a slice of interfaces for anonymous returns and a struct for named
+// returns.
+func (_FaultDisputeGameN *FaultDisputeGameNCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _FaultDisputeGameN.Contract.contract.Call(opts, result, method, params...)
+}
+
+// Transfer initiates a plain transaction to move funds to the contract, calling
+// its default method if one is available.
+func (_FaultDisputeGameN *FaultDisputeGameNTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _FaultDisputeGameN.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_FaultDisputeGameN *FaultDisputeGameNTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _FaultDisputeGameN.Contract.contract.Transact(opts, method, params...)
+}
+
+// MAXATTACKBRANCH is a free data retrieval call binding the contract method 0xb76e5932.
+//
+// Solidity: function MAX_ATTACK_BRANCH() view returns(uint256)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) MAXATTACKBRANCH(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "MAX_ATTACK_BRANCH")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// MAXATTACKBRANCH is a free data retrieval call binding the contract method 0xb76e5932.
+//
+// Solidity: function MAX_ATTACK_BRANCH() view returns(uint256)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) MAXATTACKBRANCH() (*big.Int, error) {
+	return _FaultDisputeGameN.Contract.MAXATTACKBRANCH(&_FaultDisputeGameN.CallOpts)
+}
+
+// MAXATTACKBRANCH is a free data retrieval call binding the contract method 0xb76e5932.
+//
+// Solidity: function MAX_ATTACK_BRANCH() view returns(uint256)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) MAXATTACKBRANCH() (*big.Int, error) {
+	return _FaultDisputeGameN.Contract.MAXATTACKBRANCH(&_FaultDisputeGameN.CallOpts)
+}
+
+// NBITS is a free data retrieval call binding the contract method 0x2a1512ac.
+//
+// Solidity: function N_BITS() view returns(uint256)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) NBITS(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "N_BITS")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// NBITS is a free data retrieval call binding the contract method 0x2a1512ac.
+//
+// Solidity: function N_BITS() view returns(uint256)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) NBITS() (*big.Int, error) {
+	return _FaultDisputeGameN.Contract.NBITS(&_FaultDisputeGameN.CallOpts)
+}
+
+// NBITS is a free data retrieval call binding the contract method 0x2a1512ac.
+//
+// Solidity: function N_BITS() view returns(uint256)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) NBITS() (*big.Int, error) {
+	return _FaultDisputeGameN.Contract.NBITS(&_FaultDisputeGameN.CallOpts)
+}
+
+// AbsolutePrestate is a free data retrieval call binding the contract method 0x8d450a95.
+//
+// Solidity: function absolutePrestate() view returns(bytes32 absolutePrestate_)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) AbsolutePrestate(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "absolutePrestate")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// AbsolutePrestate is a free data retrieval call binding the contract method 0x8d450a95.
+//
+// Solidity: function absolutePrestate() view returns(bytes32 absolutePrestate_)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) AbsolutePrestate() ([32]byte, error) {
+	return _FaultDisputeGameN.Contract.AbsolutePrestate(&_FaultDisputeGameN.CallOpts)
+}
+
+// AbsolutePrestate is a free data retrieval call binding the contract method 0x8d450a95.
+//
+// Solidity: function absolutePrestate() view returns(bytes32 absolutePrestate_)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) AbsolutePrestate() ([32]byte, error) {
+	return _FaultDisputeGameN.Contract.AbsolutePrestate(&_FaultDisputeGameN.CallOpts)
+}
+
+// AnchorStateRegistry is a free data retrieval call binding the contract method 0x5c0cba33.
+//
+// Solidity: function anchorStateRegistry() view returns(address registry_)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) AnchorStateRegistry(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "anchorStateRegistry")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// AnchorStateRegistry is a free data retrieval call binding the contract method 0x5c0cba33.
+//
+// Solidity: function anchorStateRegistry() view returns(address registry_)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) AnchorStateRegistry() (common.Address, error) {
+	return _FaultDisputeGameN.Contract.AnchorStateRegistry(&_FaultDisputeGameN.CallOpts)
+}
+
+// AnchorStateRegistry is a free data retrieval call binding the contract method 0x5c0cba33.
+//
+// Solidity: function anchorStateRegistry() view returns(address registry_)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) AnchorStateRegistry() (common.Address, error) {
+	return _FaultDisputeGameN.Contract.AnchorStateRegistry(&_FaultDisputeGameN.CallOpts)
+}
+
+// ClaimData is a free data retrieval call binding the contract method 0xc6f0308c.
+//
+// Solidity: function claimData(uint256 ) view returns(uint32 parentIndex, address counteredBy, address claimant, uint128 bond, bytes32 claim, uint128 position, uint128 clock)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) ClaimData(opts *bind.CallOpts, arg0 *big.Int) (struct {
+	ParentIndex uint32
+	CounteredBy common.Address
+	Claimant    common.Address
+	Bond        *big.Int
+	Claim       [32]byte
+	Position    *big.Int
+	Clock       *big.Int
+}, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "claimData", arg0)
+
+	outstruct := new(struct {
+		ParentIndex uint32
+		CounteredBy common.Address
+		Claimant    common.Address
+		Bond        *big.Int
+		Claim       [32]byte
+		Position    *big.Int
+		Clock       *big.Int
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.ParentIndex = *abi.ConvertType(out[0], new(uint32)).(*uint32)
+	outstruct.CounteredBy = *abi.ConvertType(out[1], new(common.Address)).(*common.Address)
+	outstruct.Claimant = *abi.ConvertType(out[2], new(common.Address)).(*common.Address)
+	outstruct.Bond = *abi.ConvertType(out[3], new(*big.Int)).(**big.Int)
+	outstruct.Claim = *abi.ConvertType(out[4], new([32]byte)).(*[32]byte)
+	outstruct.Position = *abi.ConvertType(out[5], new(*big.Int)).(**big.Int)
+	outstruct.Clock = *abi.ConvertType(out[6], new(*big.Int)).(**big.Int)
+
+	return *outstruct, err
+
+}
+
+// ClaimData is a free data retrieval call binding the contract method 0xc6f0308c.
+//
+// Solidity: function claimData(uint256 ) view returns(uint32 parentIndex, address counteredBy, address claimant, uint128 bond, bytes32 claim, uint128 position, uint128 clock)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) ClaimData(arg0 *big.Int) (struct {
+	ParentIndex uint32
+	CounteredBy common.Address
+	Claimant    common.Address
+	Bond        *big.Int
+	Claim       [32]byte
+	Position    *big.Int
+	Clock       *big.Int
+}, error) {
+	return _FaultDisputeGameN.Contract.ClaimData(&_FaultDisputeGameN.CallOpts, arg0)
+}
+
+// ClaimData is a free data retrieval call binding the contract method 0xc6f0308c.
+//
+// Solidity: function claimData(uint256 ) view returns(uint32 parentIndex, address counteredBy, address claimant, uint128 bond, bytes32 claim, uint128 position, uint128 clock)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) ClaimData(arg0 *big.Int) (struct {
+	ParentIndex uint32
+	CounteredBy common.Address
+	Claimant    common.Address
+	Bond        *big.Int
+	Claim       [32]byte
+	Position    *big.Int
+	Clock       *big.Int
+}, error) {
+	return _FaultDisputeGameN.Contract.ClaimData(&_FaultDisputeGameN.CallOpts, arg0)
+}
+
+// ClaimDataLen is a free data retrieval call binding the contract method 0x8980e0cc.
+//
+// Solidity: function claimDataLen() view returns(uint256 len_)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) ClaimDataLen(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "claimDataLen")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// ClaimDataLen is a free data retrieval call binding the contract method 0x8980e0cc.
+//
+// Solidity: function claimDataLen() view returns(uint256 len_)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) ClaimDataLen() (*big.Int, error) {
+	return _FaultDisputeGameN.Contract.ClaimDataLen(&_FaultDisputeGameN.CallOpts)
+}
+
+// ClaimDataLen is a free data retrieval call binding the contract method 0x8980e0cc.
+//
+// Solidity: function claimDataLen() view returns(uint256 len_)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) ClaimDataLen() (*big.Int, error) {
+	return _FaultDisputeGameN.Contract.ClaimDataLen(&_FaultDisputeGameN.CallOpts)
+}
+
+// Claims is a free data retrieval call binding the contract method 0xeff0f592.
+//
+// Solidity: function claims(bytes32 ) view returns(bool)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) Claims(opts *bind.CallOpts, arg0 [32]byte) (bool, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "claims", arg0)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// Claims is a free data retrieval call binding the contract method 0xeff0f592.
+//
+// Solidity: function claims(bytes32 ) view returns(bool)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) Claims(arg0 [32]byte) (bool, error) {
+	return _FaultDisputeGameN.Contract.Claims(&_FaultDisputeGameN.CallOpts, arg0)
+}
+
+// Claims is a free data retrieval call binding the contract method 0xeff0f592.
+//
+// Solidity: function claims(bytes32 ) view returns(bool)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) Claims(arg0 [32]byte) (bool, error) {
+	return _FaultDisputeGameN.Contract.Claims(&_FaultDisputeGameN.CallOpts, arg0)
+}
+
+// ClockExtension is a free data retrieval call binding the contract method 0x6b6716c0.
+//
+// Solidity: function clockExtension() view returns(uint64 clockExtension_)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) ClockExtension(opts *bind.CallOpts) (uint64, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "clockExtension")
+
+	if err != nil {
+		return *new(uint64), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64)
+
+	return out0, err
+
+}
+
+// ClockExtension is a free data retrieval call binding the contract method 0x6b6716c0.
+//
+// Solidity: function clockExtension() view returns(uint64 clockExtension_)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) ClockExtension() (uint64, error) {
+	return _FaultDisputeGameN.Contract.ClockExtension(&_FaultDisputeGameN.CallOpts)
+}
+
+// ClockExtension is a free data retrieval call binding the contract method 0x6b6716c0.
+//
+// Solidity: function clockExtension() view returns(uint64 clockExtension_)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) ClockExtension() (uint64, error) {
+	return _FaultDisputeGameN.Contract.ClockExtension(&_FaultDisputeGameN.CallOpts)
+}
+
+// CreatedAt is a free data retrieval call binding the contract method 0xcf09e0d0.
+//
+// Solidity: function createdAt() view returns(uint64)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) CreatedAt(opts *bind.CallOpts) (uint64, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "createdAt")
+
+	if err != nil {
+		return *new(uint64), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64)
+
+	return out0, err
+
+}
+
+// CreatedAt is a free data retrieval call binding the contract method 0xcf09e0d0.
+//
+// Solidity: function createdAt() view returns(uint64)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) CreatedAt() (uint64, error) {
+	return _FaultDisputeGameN.Contract.CreatedAt(&_FaultDisputeGameN.CallOpts)
+}
+
+// CreatedAt is a free data retrieval call binding the contract method 0xcf09e0d0.
+//
+// Solidity: function createdAt() view returns(uint64)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) CreatedAt() (uint64, error) {
+	return _FaultDisputeGameN.Contract.CreatedAt(&_FaultDisputeGameN.CallOpts)
+}
+
+// Credit is a free data retrieval call binding the contract method 0xd5d44d80.
+//
+// Solidity: function credit(address ) view returns(uint256)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) Credit(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "credit", arg0)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// Credit is a free data retrieval call binding the contract method 0xd5d44d80.
+//
+// Solidity: function credit(address ) view returns(uint256)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) Credit(arg0 common.Address) (*big.Int, error) {
+	return _FaultDisputeGameN.Contract.Credit(&_FaultDisputeGameN.CallOpts, arg0)
+}
+
+// Credit is a free data retrieval call binding the contract method 0xd5d44d80.
+//
+// Solidity: function credit(address ) view returns(uint256)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) Credit(arg0 common.Address) (*big.Int, error) {
+	return _FaultDisputeGameN.Contract.Credit(&_FaultDisputeGameN.CallOpts, arg0)
+}
+
+// ExtraData is a free data retrieval call binding the contract method 0x609d3334.
+//
+// Solidity: function extraData() pure returns(bytes extraData_)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) ExtraData(opts *bind.CallOpts) ([]byte, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "extraData")
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ExtraData is a free data retrieval call binding the contract method 0x609d3334.
+//
+// Solidity: function extraData() pure returns(bytes extraData_)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) ExtraData() ([]byte, error) {
+	return _FaultDisputeGameN.Contract.ExtraData(&_FaultDisputeGameN.CallOpts)
+}
+
+// ExtraData is a free data retrieval call binding the contract method 0x609d3334.
+//
+// Solidity: function extraData() pure returns(bytes extraData_)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) ExtraData() ([]byte, error) {
+	return _FaultDisputeGameN.Contract.ExtraData(&_FaultDisputeGameN.CallOpts)
+}
+
+// GameCreator is a free data retrieval call binding the contract method 0x37b1b229.
+//
+// Solidity: function gameCreator() pure returns(address creator_)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) GameCreator(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "gameCreator")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// GameCreator is a free data retrieval call binding the contract method 0x37b1b229.
+//
+// Solidity: function gameCreator() pure returns(address creator_)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) GameCreator() (common.Address, error) {
+	return _FaultDisputeGameN.Contract.GameCreator(&_FaultDisputeGameN.CallOpts)
+}
+
+// GameCreator is a free data retrieval call binding the contract method 0x37b1b229.
+//
+// Solidity: function gameCreator() pure returns(address creator_)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) GameCreator() (common.Address, error) {
+	return _FaultDisputeGameN.Contract.GameCreator(&_FaultDisputeGameN.CallOpts)
+}
+
+// GameData is a free data retrieval call binding the contract method 0xfa24f743.
+//
+// Solidity: function gameData() view returns(uint32 gameType_, bytes32 rootClaim_, bytes extraData_)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) GameData(opts *bind.CallOpts) (struct {
+	GameType  uint32
+	RootClaim [32]byte
+	ExtraData []byte
+}, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "gameData")
+
+	outstruct := new(struct {
+		GameType  uint32
+		RootClaim [32]byte
+		ExtraData []byte
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.GameType = *abi.ConvertType(out[0], new(uint32)).(*uint32)
+	outstruct.RootClaim = *abi.ConvertType(out[1], new([32]byte)).(*[32]byte)
+	outstruct.ExtraData = *abi.ConvertType(out[2], new([]byte)).(*[]byte)
+
+	return *outstruct, err
+
+}
+
+// GameData is a free data retrieval call binding the contract method 0xfa24f743.
+//
+// Solidity: function gameData() view returns(uint32 gameType_, bytes32 rootClaim_, bytes extraData_)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) GameData() (struct {
+	GameType  uint32
+	RootClaim [32]byte
+	ExtraData []byte
+}, error) {
+	return _FaultDisputeGameN.Contract.GameData(&_FaultDisputeGameN.CallOpts)
+}
+
+// GameData is a free data retrieval call binding the contract method 0xfa24f743.
+//
+// Solidity: function gameData() view returns(uint32 gameType_, bytes32 rootClaim_, bytes extraData_)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) GameData() (struct {
+	GameType  uint32
+	RootClaim [32]byte
+	ExtraData []byte
+}, error) {
+	return _FaultDisputeGameN.Contract.GameData(&_FaultDisputeGameN.CallOpts)
+}
+
+// GameType is a free data retrieval call binding the contract method 0xbbdc02db.
+//
+// Solidity: function gameType() view returns(uint32 gameType_)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) GameType(opts *bind.CallOpts) (uint32, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "gameType")
+
+	if err != nil {
+		return *new(uint32), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(uint32)).(*uint32)
+
+	return out0, err
+
+}
+
+// GameType is a free data retrieval call binding the contract method 0xbbdc02db.
+//
+// Solidity: function gameType() view returns(uint32 gameType_)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) GameType() (uint32, error) {
+	return _FaultDisputeGameN.Contract.GameType(&_FaultDisputeGameN.CallOpts)
+}
+
+// GameType is a free data retrieval call binding the contract method 0xbbdc02db.
+//
+// Solidity: function gameType() view returns(uint32 gameType_)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) GameType() (uint32, error) {
+	return _FaultDisputeGameN.Contract.GameType(&_FaultDisputeGameN.CallOpts)
+}
+
+// GetChallengerDuration is a free data retrieval call binding the contract method 0xbd8da956.
+//
+// Solidity: function getChallengerDuration(uint256 _claimIndex) view returns(uint64 duration_)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) GetChallengerDuration(opts *bind.CallOpts, _claimIndex *big.Int) (uint64, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "getChallengerDuration", _claimIndex)
+
+	if err != nil {
+		return *new(uint64), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64)
+
+	return out0, err
+
+}
+
+// GetChallengerDuration is a free data retrieval call binding the contract method 0xbd8da956.
+//
+// Solidity: function getChallengerDuration(uint256 _claimIndex) view returns(uint64 duration_)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) GetChallengerDuration(_claimIndex *big.Int) (uint64, error) {
+	return _FaultDisputeGameN.Contract.GetChallengerDuration(&_FaultDisputeGameN.CallOpts, _claimIndex)
+}
+
+// GetChallengerDuration is a free data retrieval call binding the contract method 0xbd8da956.
+//
+// Solidity: function getChallengerDuration(uint256 _claimIndex) view returns(uint64 duration_)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) GetChallengerDuration(_claimIndex *big.Int) (uint64, error) {
+	return _FaultDisputeGameN.Contract.GetChallengerDuration(&_FaultDisputeGameN.CallOpts, _claimIndex)
+}
+
+// GetNumToResolve is a free data retrieval call binding the contract method 0x5a5fa2d9.
+//
+// Solidity: function getNumToResolve(uint256 _claimIndex) view returns(uint256 numRemainingChildren_)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) GetNumToResolve(opts *bind.CallOpts, _claimIndex *big.Int) (*big.Int, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "getNumToResolve", _claimIndex)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// GetNumToResolve is a free data retrieval call binding the contract method 0x5a5fa2d9.
+//
+// Solidity: function getNumToResolve(uint256 _claimIndex) view returns(uint256 numRemainingChildren_)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) GetNumToResolve(_claimIndex *big.Int) (*big.Int, error) {
+	return _FaultDisputeGameN.Contract.GetNumToResolve(&_FaultDisputeGameN.CallOpts, _claimIndex)
+}
+
+// GetNumToResolve is a free data retrieval call binding the contract method 0x5a5fa2d9.
+//
+// Solidity: function getNumToResolve(uint256 _claimIndex) view returns(uint256 numRemainingChildren_)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) GetNumToResolve(_claimIndex *big.Int) (*big.Int, error) {
+	return _FaultDisputeGameN.Contract.GetNumToResolve(&_FaultDisputeGameN.CallOpts, _claimIndex)
+}
+
+// GetRequiredBond is a free data retrieval call binding the contract method 0xc395e1ca.
+//
+// Solidity: function getRequiredBond(uint128 _position) view returns(uint256 requiredBond_)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) GetRequiredBond(opts *bind.CallOpts, _position *big.Int) (*big.Int, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "getRequiredBond", _position)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// GetRequiredBond is a free data retrieval call binding the contract method 0xc395e1ca.
+//
+// Solidity: function getRequiredBond(uint128 _position) view returns(uint256 requiredBond_)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) GetRequiredBond(_position *big.Int) (*big.Int, error) {
+	return _FaultDisputeGameN.Contract.GetRequiredBond(&_FaultDisputeGameN.CallOpts, _position)
+}
+
+// GetRequiredBond is a free data retrieval call binding the contract method 0xc395e1ca.
+//
+// Solidity: function getRequiredBond(uint128 _position) view returns(uint256 requiredBond_)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) GetRequiredBond(_position *big.Int) (*big.Int, error) {
+	return _FaultDisputeGameN.Contract.GetRequiredBond(&_FaultDisputeGameN.CallOpts, _position)
+}
+
+// L1Head is a free data retrieval call binding the contract method 0x6361506d.
+//
+// Solidity: function l1Head() pure returns(bytes32 l1Head_)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) L1Head(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "l1Head")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// L1Head is a free data retrieval call binding the contract method 0x6361506d.
+//
+// Solidity: function l1Head() pure returns(bytes32 l1Head_)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) L1Head() ([32]byte, error) {
+	return _FaultDisputeGameN.Contract.L1Head(&_FaultDisputeGameN.CallOpts)
+}
+
+// L1Head is a free data retrieval call binding the contract method 0x6361506d.
+//
+// Solidity: function l1Head() pure returns(bytes32 l1Head_)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) L1Head() ([32]byte, error) {
+	return _FaultDisputeGameN.Contract.L1Head(&_FaultDisputeGameN.CallOpts)
+}
+
+// L2BlockNumber is a free data retrieval call binding the contract method 0x8b85902b.
+//
+// Solidity: function l2BlockNumber() pure returns(uint256 l2BlockNumber_)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) L2BlockNumber(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "l2BlockNumber")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// L2BlockNumber is a free data retrieval call binding the contract method 0x8b85902b.
+//
+// Solidity: function l2BlockNumber() pure returns(uint256 l2BlockNumber_)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) L2BlockNumber() (*big.Int, error) {
+	return _FaultDisputeGameN.Contract.L2BlockNumber(&_FaultDisputeGameN.CallOpts)
+}
+
+// L2BlockNumber is a free data retrieval call binding the contract method 0x8b85902b.
+//
+// Solidity: function l2BlockNumber() pure returns(uint256 l2BlockNumber_)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) L2BlockNumber() (*big.Int, error) {
+	return _FaultDisputeGameN.Contract.L2BlockNumber(&_FaultDisputeGameN.CallOpts)
+}
+
+// L2BlockNumberChallenged is a free data retrieval call binding the contract method 0x3e3ac912.
+//
+// Solidity: function l2BlockNumberChallenged() view returns(bool)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) L2BlockNumberChallenged(opts *bind.CallOpts) (bool, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "l2BlockNumberChallenged")
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// L2BlockNumberChallenged is a free data retrieval call binding the contract method 0x3e3ac912.
+//
+// Solidity: function l2BlockNumberChallenged() view returns(bool)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) L2BlockNumberChallenged() (bool, error) {
+	return _FaultDisputeGameN.Contract.L2BlockNumberChallenged(&_FaultDisputeGameN.CallOpts)
+}
+
+// L2BlockNumberChallenged is a free data retrieval call binding the contract method 0x3e3ac912.
+//
+// Solidity: function l2BlockNumberChallenged() view returns(bool)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) L2BlockNumberChallenged() (bool, error) {
+	return _FaultDisputeGameN.Contract.L2BlockNumberChallenged(&_FaultDisputeGameN.CallOpts)
+}
+
+// L2BlockNumberChallenger is a free data retrieval call binding the contract method 0x30dbe570.
+//
+// Solidity: function l2BlockNumberChallenger() view returns(address)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) L2BlockNumberChallenger(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "l2BlockNumberChallenger")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// L2BlockNumberChallenger is a free data retrieval call binding the contract method 0x30dbe570.
+//
+// Solidity: function l2BlockNumberChallenger() view returns(address)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) L2BlockNumberChallenger() (common.Address, error) {
+	return _FaultDisputeGameN.Contract.L2BlockNumberChallenger(&_FaultDisputeGameN.CallOpts)
+}
+
+// L2BlockNumberChallenger is a free data retrieval call binding the contract method 0x30dbe570.
+//
+// Solidity: function l2BlockNumberChallenger() view returns(address)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) L2BlockNumberChallenger() (common.Address, error) {
+	return _FaultDisputeGameN.Contract.L2BlockNumberChallenger(&_FaultDisputeGameN.CallOpts)
+}
+
+// L2ChainId is a free data retrieval call binding the contract method 0xd6ae3cd5.
+//
+// Solidity: function l2ChainId() view returns(uint256 l2ChainId_)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) L2ChainId(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "l2ChainId")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// L2ChainId is a free data retrieval call binding the contract method 0xd6ae3cd5.
+//
+// Solidity: function l2ChainId() view returns(uint256 l2ChainId_)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) L2ChainId() (*big.Int, error) {
+	return _FaultDisputeGameN.Contract.L2ChainId(&_FaultDisputeGameN.CallOpts)
+}
+
+// L2ChainId is a free data retrieval call binding the contract method 0xd6ae3cd5.
+//
+// Solidity: function l2ChainId() view returns(uint256 l2ChainId_)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) L2ChainId() (*big.Int, error) {
+	return _FaultDisputeGameN.Contract.L2ChainId(&_FaultDisputeGameN.CallOpts)
+}
+
+// MaxAttackBranch is a free data retrieval call binding the contract method 0x70b6bb0d.
+//
+// Solidity: function maxAttackBranch() view returns(uint256 maxAttackBranch_)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) MaxAttackBranch(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "maxAttackBranch")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// MaxAttackBranch is a free data retrieval call binding the contract method 0x70b6bb0d.
+//
+// Solidity: function maxAttackBranch() view returns(uint256 maxAttackBranch_)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) MaxAttackBranch() (*big.Int, error) {
+	return _FaultDisputeGameN.Contract.MaxAttackBranch(&_FaultDisputeGameN.CallOpts)
+}
+
+// MaxAttackBranch is a free data retrieval call binding the contract method 0x70b6bb0d.
+//
+// Solidity: function maxAttackBranch() view returns(uint256 maxAttackBranch_)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) MaxAttackBranch() (*big.Int, error) {
+	return _FaultDisputeGameN.Contract.MaxAttackBranch(&_FaultDisputeGameN.CallOpts)
+}
+
+// MaxClockDuration is a free data retrieval call binding the contract method 0xdabd396d.
+//
+// Solidity: function maxClockDuration() view returns(uint64 maxClockDuration_)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) MaxClockDuration(opts *bind.CallOpts) (uint64, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "maxClockDuration")
+
+	if err != nil {
+		return *new(uint64), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64)
+
+	return out0, err
+
+}
+
+// MaxClockDuration is a free data retrieval call binding the contract method 0xdabd396d.
+//
+// Solidity: function maxClockDuration() view returns(uint64 maxClockDuration_)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) MaxClockDuration() (uint64, error) {
+	return _FaultDisputeGameN.Contract.MaxClockDuration(&_FaultDisputeGameN.CallOpts)
+}
+
+// MaxClockDuration is a free data retrieval call binding the contract method 0xdabd396d.
+//
+// Solidity: function maxClockDuration() view returns(uint64 maxClockDuration_)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) MaxClockDuration() (uint64, error) {
+	return _FaultDisputeGameN.Contract.MaxClockDuration(&_FaultDisputeGameN.CallOpts)
+}
+
+// MaxGameDepth is a free data retrieval call binding the contract method 0xfa315aa9.
+//
+// Solidity: function maxGameDepth() view returns(uint256 maxGameDepth_)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) MaxGameDepth(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "maxGameDepth")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// MaxGameDepth is a free data retrieval call binding the contract method 0xfa315aa9.
+//
+// Solidity: function maxGameDepth() view returns(uint256 maxGameDepth_)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) MaxGameDepth() (*big.Int, error) {
+	return _FaultDisputeGameN.Contract.MaxGameDepth(&_FaultDisputeGameN.CallOpts)
+}
+
+// MaxGameDepth is a free data retrieval call binding the contract method 0xfa315aa9.
+//
+// Solidity: function maxGameDepth() view returns(uint256 maxGameDepth_)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) MaxGameDepth() (*big.Int, error) {
+	return _FaultDisputeGameN.Contract.MaxGameDepth(&_FaultDisputeGameN.CallOpts)
+}
+
+// NBits is a free data retrieval call binding the contract method 0x8d0e582e.
+//
+// Solidity: function nBits() view returns(uint256 nBits_)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) NBits(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "nBits")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// NBits is a free data retrieval call binding the contract method 0x8d0e582e.
+//
+// Solidity: function nBits() view returns(uint256 nBits_)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) NBits() (*big.Int, error) {
+	return _FaultDisputeGameN.Contract.NBits(&_FaultDisputeGameN.CallOpts)
+}
+
+// NBits is a free data retrieval call binding the contract method 0x8d0e582e.
+//
+// Solidity: function nBits() view returns(uint256 nBits_)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) NBits() (*big.Int, error) {
+	return _FaultDisputeGameN.Contract.NBits(&_FaultDisputeGameN.CallOpts)
+}
+
+// ResolutionCheckpoints is a free data retrieval call binding the contract method 0xa445ece6.
+//
+// Solidity: function resolutionCheckpoints(uint256 ) view returns(bool initialCheckpointComplete, uint32 subgameIndex, uint128 leftmostPosition, address counteredBy)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) ResolutionCheckpoints(opts *bind.CallOpts, arg0 *big.Int) (struct {
+	InitialCheckpointComplete bool
+	SubgameIndex              uint32
+	LeftmostPosition          *big.Int
+	CounteredBy               common.Address
+}, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "resolutionCheckpoints", arg0)
+
+	outstruct := new(struct {
+		InitialCheckpointComplete bool
+		SubgameIndex              uint32
+		LeftmostPosition          *big.Int
+		CounteredBy               common.Address
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.InitialCheckpointComplete = *abi.ConvertType(out[0], new(bool)).(*bool)
+	outstruct.SubgameIndex = *abi.ConvertType(out[1], new(uint32)).(*uint32)
+	outstruct.LeftmostPosition = *abi.ConvertType(out[2], new(*big.Int)).(**big.Int)
+	outstruct.CounteredBy = *abi.ConvertType(out[3], new(common.Address)).(*common.Address)
+
+	return *outstruct, err
+
+}
+
+// ResolutionCheckpoints is a free data retrieval call binding the contract method 0xa445ece6.
+//
+// Solidity: function resolutionCheckpoints(uint256 ) view returns(bool initialCheckpointComplete, uint32 subgameIndex, uint128 leftmostPosition, address counteredBy)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) ResolutionCheckpoints(arg0 *big.Int) (struct {
+	InitialCheckpointComplete bool
+	SubgameIndex              uint32
+	LeftmostPosition          *big.Int
+	CounteredBy               common.Address
+}, error) {
+	return _FaultDisputeGameN.Contract.ResolutionCheckpoints(&_FaultDisputeGameN.CallOpts, arg0)
+}
+
+// ResolutionCheckpoints is a free data retrieval call binding the contract method 0xa445ece6.
+//
+// Solidity: function resolutionCheckpoints(uint256 ) view returns(bool initialCheckpointComplete, uint32 subgameIndex, uint128 leftmostPosition, address counteredBy)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) ResolutionCheckpoints(arg0 *big.Int) (struct {
+	InitialCheckpointComplete bool
+	SubgameIndex              uint32
+	LeftmostPosition          *big.Int
+	CounteredBy               common.Address
+}, error) {
+	return _FaultDisputeGameN.Contract.ResolutionCheckpoints(&_FaultDisputeGameN.CallOpts, arg0)
+}
+
+// ResolvedAt is a free data retrieval call binding the contract method 0x19effeb4.
+//
+// Solidity: function resolvedAt() view returns(uint64)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) ResolvedAt(opts *bind.CallOpts) (uint64, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "resolvedAt")
+
+	if err != nil {
+		return *new(uint64), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64)
+
+	return out0, err
+
+}
+
+// ResolvedAt is a free data retrieval call binding the contract method 0x19effeb4.
+//
+// Solidity: function resolvedAt() view returns(uint64)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) ResolvedAt() (uint64, error) {
+	return _FaultDisputeGameN.Contract.ResolvedAt(&_FaultDisputeGameN.CallOpts)
+}
+
+// ResolvedAt is a free data retrieval call binding the contract method 0x19effeb4.
+//
+// Solidity: function resolvedAt() view returns(uint64)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) ResolvedAt() (uint64, error) {
+	return _FaultDisputeGameN.Contract.ResolvedAt(&_FaultDisputeGameN.CallOpts)
+}
+
+// ResolvedSubgames is a free data retrieval call binding the contract method 0xfe2bbeb2.
+//
+// Solidity: function resolvedSubgames(uint256 ) view returns(bool)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) ResolvedSubgames(opts *bind.CallOpts, arg0 *big.Int) (bool, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "resolvedSubgames", arg0)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// ResolvedSubgames is a free data retrieval call binding the contract method 0xfe2bbeb2.
+//
+// Solidity: function resolvedSubgames(uint256 ) view returns(bool)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) ResolvedSubgames(arg0 *big.Int) (bool, error) {
+	return _FaultDisputeGameN.Contract.ResolvedSubgames(&_FaultDisputeGameN.CallOpts, arg0)
+}
+
+// ResolvedSubgames is a free data retrieval call binding the contract method 0xfe2bbeb2.
+//
+// Solidity: function resolvedSubgames(uint256 ) view returns(bool)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) ResolvedSubgames(arg0 *big.Int) (bool, error) {
+	return _FaultDisputeGameN.Contract.ResolvedSubgames(&_FaultDisputeGameN.CallOpts, arg0)
+}
+
+// RootClaim is a free data retrieval call binding the contract method 0xbcef3b55.
+//
+// Solidity: function rootClaim() pure returns(bytes32 rootClaim_)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) RootClaim(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "rootClaim")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// RootClaim is a free data retrieval call binding the contract method 0xbcef3b55.
+//
+// Solidity: function rootClaim() pure returns(bytes32 rootClaim_)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) RootClaim() ([32]byte, error) {
+	return _FaultDisputeGameN.Contract.RootClaim(&_FaultDisputeGameN.CallOpts)
+}
+
+// RootClaim is a free data retrieval call binding the contract method 0xbcef3b55.
+//
+// Solidity: function rootClaim() pure returns(bytes32 rootClaim_)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) RootClaim() ([32]byte, error) {
+	return _FaultDisputeGameN.Contract.RootClaim(&_FaultDisputeGameN.CallOpts)
+}
+
+// SplitDepth is a free data retrieval call binding the contract method 0xec5e6308.
+//
+// Solidity: function splitDepth() view returns(uint256 splitDepth_)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) SplitDepth(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "splitDepth")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// SplitDepth is a free data retrieval call binding the contract method 0xec5e6308.
+//
+// Solidity: function splitDepth() view returns(uint256 splitDepth_)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) SplitDepth() (*big.Int, error) {
+	return _FaultDisputeGameN.Contract.SplitDepth(&_FaultDisputeGameN.CallOpts)
+}
+
+// SplitDepth is a free data retrieval call binding the contract method 0xec5e6308.
+//
+// Solidity: function splitDepth() view returns(uint256 splitDepth_)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) SplitDepth() (*big.Int, error) {
+	return _FaultDisputeGameN.Contract.SplitDepth(&_FaultDisputeGameN.CallOpts)
+}
+
+// StartingBlockNumber is a free data retrieval call binding the contract method 0x70872aa5.
+//
+// Solidity: function startingBlockNumber() view returns(uint256 startingBlockNumber_)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) StartingBlockNumber(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "startingBlockNumber")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// StartingBlockNumber is a free data retrieval call binding the contract method 0x70872aa5.
+//
+// Solidity: function startingBlockNumber() view returns(uint256 startingBlockNumber_)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) StartingBlockNumber() (*big.Int, error) {
+	return _FaultDisputeGameN.Contract.StartingBlockNumber(&_FaultDisputeGameN.CallOpts)
+}
+
+// StartingBlockNumber is a free data retrieval call binding the contract method 0x70872aa5.
+//
+// Solidity: function startingBlockNumber() view returns(uint256 startingBlockNumber_)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) StartingBlockNumber() (*big.Int, error) {
+	return _FaultDisputeGameN.Contract.StartingBlockNumber(&_FaultDisputeGameN.CallOpts)
+}
+
+// StartingOutputRoot is a free data retrieval call binding the contract method 0x57da950e.
+//
+// Solidity: function startingOutputRoot() view returns(bytes32 root, uint256 l2BlockNumber)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) StartingOutputRoot(opts *bind.CallOpts) (struct {
+	Root          [32]byte
+	L2BlockNumber *big.Int
+}, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "startingOutputRoot")
+
+	outstruct := new(struct {
+		Root          [32]byte
+		L2BlockNumber *big.Int
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.Root = *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+	outstruct.L2BlockNumber = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int)
+
+	return *outstruct, err
+
+}
+
+// StartingOutputRoot is a free data retrieval call binding the contract method 0x57da950e.
+//
+// Solidity: function startingOutputRoot() view returns(bytes32 root, uint256 l2BlockNumber)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) StartingOutputRoot() (struct {
+	Root          [32]byte
+	L2BlockNumber *big.Int
+}, error) {
+	return _FaultDisputeGameN.Contract.StartingOutputRoot(&_FaultDisputeGameN.CallOpts)
+}
+
+// StartingOutputRoot is a free data retrieval call binding the contract method 0x57da950e.
+//
+// Solidity: function startingOutputRoot() view returns(bytes32 root, uint256 l2BlockNumber)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) StartingOutputRoot() (struct {
+	Root          [32]byte
+	L2BlockNumber *big.Int
+}, error) {
+	return _FaultDisputeGameN.Contract.StartingOutputRoot(&_FaultDisputeGameN.CallOpts)
+}
+
+// StartingRootHash is a free data retrieval call binding the contract method 0x25fc2ace.
+//
+// Solidity: function startingRootHash() view returns(bytes32 startingRootHash_)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) StartingRootHash(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "startingRootHash")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// StartingRootHash is a free data retrieval call binding the contract method 0x25fc2ace.
+//
+// Solidity: function startingRootHash() view returns(bytes32 startingRootHash_)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) StartingRootHash() ([32]byte, error) {
+	return _FaultDisputeGameN.Contract.StartingRootHash(&_FaultDisputeGameN.CallOpts)
+}
+
+// StartingRootHash is a free data retrieval call binding the contract method 0x25fc2ace.
+//
+// Solidity: function startingRootHash() view returns(bytes32 startingRootHash_)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) StartingRootHash() ([32]byte, error) {
+	return _FaultDisputeGameN.Contract.StartingRootHash(&_FaultDisputeGameN.CallOpts)
+}
+
+// Status is a free data retrieval call binding the contract method 0x200d2ed2.
+//
+// Solidity: function status() view returns(uint8)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) Status(opts *bind.CallOpts) (uint8, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "status")
+
+	if err != nil {
+		return *new(uint8), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8)
+
+	return out0, err
+
+}
+
+// Status is a free data retrieval call binding the contract method 0x200d2ed2.
+//
+// Solidity: function status() view returns(uint8)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) Status() (uint8, error) {
+	return _FaultDisputeGameN.Contract.Status(&_FaultDisputeGameN.CallOpts)
+}
+
+// Status is a free data retrieval call binding the contract method 0x200d2ed2.
+//
+// Solidity: function status() view returns(uint8)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) Status() (uint8, error) {
+	return _FaultDisputeGameN.Contract.Status(&_FaultDisputeGameN.CallOpts)
+}
+
+// Subgames is a free data retrieval call binding the contract method 0x2ad69aeb.
+//
+// Solidity: function subgames(uint256 , uint256 ) view returns(uint256)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) Subgames(opts *bind.CallOpts, arg0 *big.Int, arg1 *big.Int) (*big.Int, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "subgames", arg0, arg1)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// Subgames is a free data retrieval call binding the contract method 0x2ad69aeb.
+//
+// Solidity: function subgames(uint256 , uint256 ) view returns(uint256)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) Subgames(arg0 *big.Int, arg1 *big.Int) (*big.Int, error) {
+	return _FaultDisputeGameN.Contract.Subgames(&_FaultDisputeGameN.CallOpts, arg0, arg1)
+}
+
+// Subgames is a free data retrieval call binding the contract method 0x2ad69aeb.
+//
+// Solidity: function subgames(uint256 , uint256 ) view returns(uint256)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) Subgames(arg0 *big.Int, arg1 *big.Int) (*big.Int, error) {
+	return _FaultDisputeGameN.Contract.Subgames(&_FaultDisputeGameN.CallOpts, arg0, arg1)
+}
+
+// Version is a free data retrieval call binding the contract method 0x54fd4d50.
+//
+// Solidity: function version() view returns(string)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) Version(opts *bind.CallOpts) (string, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "version")
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// Version is a free data retrieval call binding the contract method 0x54fd4d50.
+//
+// Solidity: function version() view returns(string)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) Version() (string, error) {
+	return _FaultDisputeGameN.Contract.Version(&_FaultDisputeGameN.CallOpts)
+}
+
+// Version is a free data retrieval call binding the contract method 0x54fd4d50.
+//
+// Solidity: function version() view returns(string)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) Version() (string, error) {
+	return _FaultDisputeGameN.Contract.Version(&_FaultDisputeGameN.CallOpts)
+}
+
+// Vm is a free data retrieval call binding the contract method 0x3a768463.
+//
+// Solidity: function vm() view returns(address vm_)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) Vm(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "vm")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// Vm is a free data retrieval call binding the contract method 0x3a768463.
+//
+// Solidity: function vm() view returns(address vm_)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) Vm() (common.Address, error) {
+	return _FaultDisputeGameN.Contract.Vm(&_FaultDisputeGameN.CallOpts)
+}
+
+// Vm is a free data retrieval call binding the contract method 0x3a768463.
+//
+// Solidity: function vm() view returns(address vm_)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) Vm() (common.Address, error) {
+	return _FaultDisputeGameN.Contract.Vm(&_FaultDisputeGameN.CallOpts)
+}
+
+// Weth is a free data retrieval call binding the contract method 0x3fc8cef3.
+//
+// Solidity: function weth() view returns(address weth_)
+func (_FaultDisputeGameN *FaultDisputeGameNCaller) Weth(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _FaultDisputeGameN.contract.Call(opts, &out, "weth")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// Weth is a free data retrieval call binding the contract method 0x3fc8cef3.
+//
+// Solidity: function weth() view returns(address weth_)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) Weth() (common.Address, error) {
+	return _FaultDisputeGameN.Contract.Weth(&_FaultDisputeGameN.CallOpts)
+}
+
+// Weth is a free data retrieval call binding the contract method 0x3fc8cef3.
+//
+// Solidity: function weth() view returns(address weth_)
+func (_FaultDisputeGameN *FaultDisputeGameNCallerSession) Weth() (common.Address, error) {
+	return _FaultDisputeGameN.Contract.Weth(&_FaultDisputeGameN.CallOpts)
+}
+
+// AddLocalData is a paid mutator transaction binding the contract method 0xf8f43ff6.
+//
+// Solidity: function addLocalData(uint256 _ident, uint256 _execLeafIdx, uint256 _partOffset) returns()
+func (_FaultDisputeGameN *FaultDisputeGameNTransactor) AddLocalData(opts *bind.TransactOpts, _ident *big.Int, _execLeafIdx *big.Int, _partOffset *big.Int) (*types.Transaction, error) {
+	return _FaultDisputeGameN.contract.Transact(opts, "addLocalData", _ident, _execLeafIdx, _partOffset)
+}
+
+// AddLocalData is a paid mutator transaction binding the contract method 0xf8f43ff6.
+//
+// Solidity: function addLocalData(uint256 _ident, uint256 _execLeafIdx, uint256 _partOffset) returns()
+func (_FaultDisputeGameN *FaultDisputeGameNSession) AddLocalData(_ident *big.Int, _execLeafIdx *big.Int, _partOffset *big.Int) (*types.Transaction, error) {
+	return _FaultDisputeGameN.Contract.AddLocalData(&_FaultDisputeGameN.TransactOpts, _ident, _execLeafIdx, _partOffset)
+}
+
+// AddLocalData is a paid mutator transaction binding the contract method 0xf8f43ff6.
+//
+// Solidity: function addLocalData(uint256 _ident, uint256 _execLeafIdx, uint256 _partOffset) returns()
+func (_FaultDisputeGameN *FaultDisputeGameNTransactorSession) AddLocalData(_ident *big.Int, _execLeafIdx *big.Int, _partOffset *big.Int) (*types.Transaction, error) {
+	return _FaultDisputeGameN.Contract.AddLocalData(&_FaultDisputeGameN.TransactOpts, _ident, _execLeafIdx, _partOffset)
+}
+
+// AddLocalData2 is a paid mutator transaction binding the contract method 0xaf6cc6a7.
+//
+// Solidity: function addLocalData2(uint256 _ident, uint256 _execLeafIdx, uint256 _partOffset, (uint256,bytes32,bytes) _daItem) returns(bytes32 uuid_, bytes32 value_)
+func (_FaultDisputeGameN *FaultDisputeGameNTransactor) AddLocalData2(opts *bind.TransactOpts, _ident *big.Int, _execLeafIdx *big.Int, _partOffset *big.Int, _daItem LibDADAItem) (*types.Transaction, error) {
+	return _FaultDisputeGameN.contract.Transact(opts, "addLocalData2", _ident, _execLeafIdx, _partOffset, _daItem)
+}
+
+// AddLocalData2 is a paid mutator transaction binding the contract method 0xaf6cc6a7.
+//
+// Solidity: function addLocalData2(uint256 _ident, uint256 _execLeafIdx, uint256 _partOffset, (uint256,bytes32,bytes) _daItem) returns(bytes32 uuid_, bytes32 value_)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) AddLocalData2(_ident *big.Int, _execLeafIdx *big.Int, _partOffset *big.Int, _daItem LibDADAItem) (*types.Transaction, error) {
+	return _FaultDisputeGameN.Contract.AddLocalData2(&_FaultDisputeGameN.TransactOpts, _ident, _execLeafIdx, _partOffset, _daItem)
+}
+
+// AddLocalData2 is a paid mutator transaction binding the contract method 0xaf6cc6a7.
+//
+// Solidity: function addLocalData2(uint256 _ident, uint256 _execLeafIdx, uint256 _partOffset, (uint256,bytes32,bytes) _daItem) returns(bytes32 uuid_, bytes32 value_)
+func (_FaultDisputeGameN *FaultDisputeGameNTransactorSession) AddLocalData2(_ident *big.Int, _execLeafIdx *big.Int, _partOffset *big.Int, _daItem LibDADAItem) (*types.Transaction, error) {
+	return _FaultDisputeGameN.Contract.AddLocalData2(&_FaultDisputeGameN.TransactOpts, _ident, _execLeafIdx, _partOffset, _daItem)
+}
+
+// Attack is a paid mutator transaction binding the contract method 0x472777c6.
+//
+// Solidity: function attack(bytes32 _disputed, uint256 _parentIndex, bytes32 _claim) payable returns()
+func (_FaultDisputeGameN *FaultDisputeGameNTransactor) Attack(opts *bind.TransactOpts, _disputed [32]byte, _parentIndex *big.Int, _claim [32]byte) (*types.Transaction, error) {
+	return _FaultDisputeGameN.contract.Transact(opts, "attack", _disputed, _parentIndex, _claim)
+}
+
+// Attack is a paid mutator transaction binding the contract method 0x472777c6.
+//
+// Solidity: function attack(bytes32 _disputed, uint256 _parentIndex, bytes32 _claim) payable returns()
+func (_FaultDisputeGameN *FaultDisputeGameNSession) Attack(_disputed [32]byte, _parentIndex *big.Int, _claim [32]byte) (*types.Transaction, error) {
+	return _FaultDisputeGameN.Contract.Attack(&_FaultDisputeGameN.TransactOpts, _disputed, _parentIndex, _claim)
+}
+
+// Attack is a paid mutator transaction binding the contract method 0x472777c6.
+//
+// Solidity: function attack(bytes32 _disputed, uint256 _parentIndex, bytes32 _claim) payable returns()
+func (_FaultDisputeGameN *FaultDisputeGameNTransactorSession) Attack(_disputed [32]byte, _parentIndex *big.Int, _claim [32]byte) (*types.Transaction, error) {
+	return _FaultDisputeGameN.Contract.Attack(&_FaultDisputeGameN.TransactOpts, _disputed, _parentIndex, _claim)
+}
+
+// AttackV2 is a paid mutator transaction binding the contract method 0x199e300e.
+//
+// Solidity: function attackV2(bytes32 _disputed, uint256 _parentIndex, uint256 _attackBranch, uint256 _daType, bytes _claims) payable returns()
+func (_FaultDisputeGameN *FaultDisputeGameNTransactor) AttackV2(opts *bind.TransactOpts, _disputed [32]byte, _parentIndex *big.Int, _attackBranch *big.Int, _daType *big.Int, _claims []byte) (*types.Transaction, error) {
+	return _FaultDisputeGameN.contract.Transact(opts, "attackV2", _disputed, _parentIndex, _attackBranch, _daType, _claims)
+}
+
+// AttackV2 is a paid mutator transaction binding the contract method 0x199e300e.
+//
+// Solidity: function attackV2(bytes32 _disputed, uint256 _parentIndex, uint256 _attackBranch, uint256 _daType, bytes _claims) payable returns()
+func (_FaultDisputeGameN *FaultDisputeGameNSession) AttackV2(_disputed [32]byte, _parentIndex *big.Int, _attackBranch *big.Int, _daType *big.Int, _claims []byte) (*types.Transaction, error) {
+	return _FaultDisputeGameN.Contract.AttackV2(&_FaultDisputeGameN.TransactOpts, _disputed, _parentIndex, _attackBranch, _daType, _claims)
+}
+
+// AttackV2 is a paid mutator transaction binding the contract method 0x199e300e.
+//
+// Solidity: function attackV2(bytes32 _disputed, uint256 _parentIndex, uint256 _attackBranch, uint256 _daType, bytes _claims) payable returns()
+func (_FaultDisputeGameN *FaultDisputeGameNTransactorSession) AttackV2(_disputed [32]byte, _parentIndex *big.Int, _attackBranch *big.Int, _daType *big.Int, _claims []byte) (*types.Transaction, error) {
+	return _FaultDisputeGameN.Contract.AttackV2(&_FaultDisputeGameN.TransactOpts, _disputed, _parentIndex, _attackBranch, _daType, _claims)
+}
+
+// ChallengeRootL2Block is a paid mutator transaction binding the contract method 0x01935130.
+//
+// Solidity: function challengeRootL2Block((bytes32,bytes32,bytes32,bytes32) _outputRootProof, bytes _headerRLP) returns()
+func (_FaultDisputeGameN *FaultDisputeGameNTransactor) ChallengeRootL2Block(opts *bind.TransactOpts, _outputRootProof TypesOutputRootProof, _headerRLP []byte) (*types.Transaction, error) {
+	return _FaultDisputeGameN.contract.Transact(opts, "challengeRootL2Block", _outputRootProof, _headerRLP)
+}
+
+// ChallengeRootL2Block is a paid mutator transaction binding the contract method 0x01935130.
+//
+// Solidity: function challengeRootL2Block((bytes32,bytes32,bytes32,bytes32) _outputRootProof, bytes _headerRLP) returns()
+func (_FaultDisputeGameN *FaultDisputeGameNSession) ChallengeRootL2Block(_outputRootProof TypesOutputRootProof, _headerRLP []byte) (*types.Transaction, error) {
+	return _FaultDisputeGameN.Contract.ChallengeRootL2Block(&_FaultDisputeGameN.TransactOpts, _outputRootProof, _headerRLP)
+}
+
+// ChallengeRootL2Block is a paid mutator transaction binding the contract method 0x01935130.
+//
+// Solidity: function challengeRootL2Block((bytes32,bytes32,bytes32,bytes32) _outputRootProof, bytes _headerRLP) returns()
+func (_FaultDisputeGameN *FaultDisputeGameNTransactorSession) ChallengeRootL2Block(_outputRootProof TypesOutputRootProof, _headerRLP []byte) (*types.Transaction, error) {
+	return _FaultDisputeGameN.Contract.ChallengeRootL2Block(&_FaultDisputeGameN.TransactOpts, _outputRootProof, _headerRLP)
+}
+
+// ClaimCredit is a paid mutator transaction binding the contract method 0x60e27464.
+//
+// Solidity: function claimCredit(address _recipient) returns()
+func (_FaultDisputeGameN *FaultDisputeGameNTransactor) ClaimCredit(opts *bind.TransactOpts, _recipient common.Address) (*types.Transaction, error) {
+	return _FaultDisputeGameN.contract.Transact(opts, "claimCredit", _recipient)
+}
+
+// ClaimCredit is a paid mutator transaction binding the contract method 0x60e27464.
+//
+// Solidity: function claimCredit(address _recipient) returns()
+func (_FaultDisputeGameN *FaultDisputeGameNSession) ClaimCredit(_recipient common.Address) (*types.Transaction, error) {
+	return _FaultDisputeGameN.Contract.ClaimCredit(&_FaultDisputeGameN.TransactOpts, _recipient)
+}
+
+// ClaimCredit is a paid mutator transaction binding the contract method 0x60e27464.
+//
+// Solidity: function claimCredit(address _recipient) returns()
+func (_FaultDisputeGameN *FaultDisputeGameNTransactorSession) ClaimCredit(_recipient common.Address) (*types.Transaction, error) {
+	return _FaultDisputeGameN.Contract.ClaimCredit(&_FaultDisputeGameN.TransactOpts, _recipient)
+}
+
+// Defend is a paid mutator transaction binding the contract method 0x7b0f0adc.
+//
+// Solidity: function defend(bytes32 _disputed, uint256 _parentIndex, bytes32 _claim) payable returns()
+func (_FaultDisputeGameN *FaultDisputeGameNTransactor) Defend(opts *bind.TransactOpts, _disputed [32]byte, _parentIndex *big.Int, _claim [32]byte) (*types.Transaction, error) {
+	return _FaultDisputeGameN.contract.Transact(opts, "defend", _disputed, _parentIndex, _claim)
+}
+
+// Defend is a paid mutator transaction binding the contract method 0x7b0f0adc.
+//
+// Solidity: function defend(bytes32 _disputed, uint256 _parentIndex, bytes32 _claim) payable returns()
+func (_FaultDisputeGameN *FaultDisputeGameNSession) Defend(_disputed [32]byte, _parentIndex *big.Int, _claim [32]byte) (*types.Transaction, error) {
+	return _FaultDisputeGameN.Contract.Defend(&_FaultDisputeGameN.TransactOpts, _disputed, _parentIndex, _claim)
+}
+
+// Defend is a paid mutator transaction binding the contract method 0x7b0f0adc.
+//
+// Solidity: function defend(bytes32 _disputed, uint256 _parentIndex, bytes32 _claim) payable returns()
+func (_FaultDisputeGameN *FaultDisputeGameNTransactorSession) Defend(_disputed [32]byte, _parentIndex *big.Int, _claim [32]byte) (*types.Transaction, error) {
+	return _FaultDisputeGameN.Contract.Defend(&_FaultDisputeGameN.TransactOpts, _disputed, _parentIndex, _claim)
+}
+
+// Initialize is a paid mutator transaction binding the contract method 0x8129fc1c.
+//
+// Solidity: function initialize() payable returns()
+func (_FaultDisputeGameN *FaultDisputeGameNTransactor) Initialize(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _FaultDisputeGameN.contract.Transact(opts, "initialize")
+}
+
+// Initialize is a paid mutator transaction binding the contract method 0x8129fc1c.
+//
+// Solidity: function initialize() payable returns()
+func (_FaultDisputeGameN *FaultDisputeGameNSession) Initialize() (*types.Transaction, error) {
+	return _FaultDisputeGameN.Contract.Initialize(&_FaultDisputeGameN.TransactOpts)
+}
+
+// Initialize is a paid mutator transaction binding the contract method 0x8129fc1c.
+//
+// Solidity: function initialize() payable returns()
+func (_FaultDisputeGameN *FaultDisputeGameNTransactorSession) Initialize() (*types.Transaction, error) {
+	return _FaultDisputeGameN.Contract.Initialize(&_FaultDisputeGameN.TransactOpts)
+}
+
+// Move is a paid mutator transaction binding the contract method 0x6f034409.
+//
+// Solidity: function move(bytes32 _disputed, uint256 _challengeIndex, bytes32 _claim, bool _isAttack) payable returns()
+func (_FaultDisputeGameN *FaultDisputeGameNTransactor) Move(opts *bind.TransactOpts, _disputed [32]byte, _challengeIndex *big.Int, _claim [32]byte, _isAttack bool) (*types.Transaction, error) {
+	return _FaultDisputeGameN.contract.Transact(opts, "move", _disputed, _challengeIndex, _claim, _isAttack)
+}
+
+// Move is a paid mutator transaction binding the contract method 0x6f034409.
+//
+// Solidity: function move(bytes32 _disputed, uint256 _challengeIndex, bytes32 _claim, bool _isAttack) payable returns()
+func (_FaultDisputeGameN *FaultDisputeGameNSession) Move(_disputed [32]byte, _challengeIndex *big.Int, _claim [32]byte, _isAttack bool) (*types.Transaction, error) {
+	return _FaultDisputeGameN.Contract.Move(&_FaultDisputeGameN.TransactOpts, _disputed, _challengeIndex, _claim, _isAttack)
+}
+
+// Move is a paid mutator transaction binding the contract method 0x6f034409.
+//
+// Solidity: function move(bytes32 _disputed, uint256 _challengeIndex, bytes32 _claim, bool _isAttack) payable returns()
+func (_FaultDisputeGameN *FaultDisputeGameNTransactorSession) Move(_disputed [32]byte, _challengeIndex *big.Int, _claim [32]byte, _isAttack bool) (*types.Transaction, error) {
+	return _FaultDisputeGameN.Contract.Move(&_FaultDisputeGameN.TransactOpts, _disputed, _challengeIndex, _claim, _isAttack)
+}
+
+// Resolve is a paid mutator transaction binding the contract method 0x2810e1d6.
+//
+// Solidity: function resolve() returns(uint8 status_)
+func (_FaultDisputeGameN *FaultDisputeGameNTransactor) Resolve(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _FaultDisputeGameN.contract.Transact(opts, "resolve")
+}
+
+// Resolve is a paid mutator transaction binding the contract method 0x2810e1d6.
+//
+// Solidity: function resolve() returns(uint8 status_)
+func (_FaultDisputeGameN *FaultDisputeGameNSession) Resolve() (*types.Transaction, error) {
+	return _FaultDisputeGameN.Contract.Resolve(&_FaultDisputeGameN.TransactOpts)
+}
+
+// Resolve is a paid mutator transaction binding the contract method 0x2810e1d6.
+//
+// Solidity: function resolve() returns(uint8 status_)
+func (_FaultDisputeGameN *FaultDisputeGameNTransactorSession) Resolve() (*types.Transaction, error) {
+	return _FaultDisputeGameN.Contract.Resolve(&_FaultDisputeGameN.TransactOpts)
+}
+
+// ResolveClaim is a paid mutator transaction binding the contract method 0x03c2924d.
+//
+// Solidity: function resolveClaim(uint256 _claimIndex, uint256 _numToResolve) returns()
+func (_FaultDisputeGameN *FaultDisputeGameNTransactor) ResolveClaim(opts *bind.TransactOpts, _claimIndex *big.Int, _numToResolve *big.Int) (*types.Transaction, error) {
+	return _FaultDisputeGameN.contract.Transact(opts, "resolveClaim", _claimIndex, _numToResolve)
+}
+
+// ResolveClaim is a paid mutator transaction binding the contract method 0x03c2924d.
+//
+// Solidity: function resolveClaim(uint256 _claimIndex, uint256 _numToResolve) returns()
+func (_FaultDisputeGameN *FaultDisputeGameNSession) ResolveClaim(_claimIndex *big.Int, _numToResolve *big.Int) (*types.Transaction, error) {
+	return _FaultDisputeGameN.Contract.ResolveClaim(&_FaultDisputeGameN.TransactOpts, _claimIndex, _numToResolve)
+}
+
+// ResolveClaim is a paid mutator transaction binding the contract method 0x03c2924d.
+//
+// Solidity: function resolveClaim(uint256 _claimIndex, uint256 _numToResolve) returns()
+func (_FaultDisputeGameN *FaultDisputeGameNTransactorSession) ResolveClaim(_claimIndex *big.Int, _numToResolve *big.Int) (*types.Transaction, error) {
+	return _FaultDisputeGameN.Contract.ResolveClaim(&_FaultDisputeGameN.TransactOpts, _claimIndex, _numToResolve)
+}
+
+// Step is a paid mutator transaction binding the contract method 0xd8cc1a3c.
+//
+// Solidity: function step(uint256 _claimIndex, bool _isAttack, bytes _stateData, bytes _proof) returns()
+func (_FaultDisputeGameN *FaultDisputeGameNTransactor) Step(opts *bind.TransactOpts, _claimIndex *big.Int, _isAttack bool, _stateData []byte, _proof []byte) (*types.Transaction, error) {
+	return _FaultDisputeGameN.contract.Transact(opts, "step", _claimIndex, _isAttack, _stateData, _proof)
+}
+
+// Step is a paid mutator transaction binding the contract method 0xd8cc1a3c.
+//
+// Solidity: function step(uint256 _claimIndex, bool _isAttack, bytes _stateData, bytes _proof) returns()
+func (_FaultDisputeGameN *FaultDisputeGameNSession) Step(_claimIndex *big.Int, _isAttack bool, _stateData []byte, _proof []byte) (*types.Transaction, error) {
+	return _FaultDisputeGameN.Contract.Step(&_FaultDisputeGameN.TransactOpts, _claimIndex, _isAttack, _stateData, _proof)
+}
+
+// Step is a paid mutator transaction binding the contract method 0xd8cc1a3c.
+//
+// Solidity: function step(uint256 _claimIndex, bool _isAttack, bytes _stateData, bytes _proof) returns()
+func (_FaultDisputeGameN *FaultDisputeGameNTransactorSession) Step(_claimIndex *big.Int, _isAttack bool, _stateData []byte, _proof []byte) (*types.Transaction, error) {
+	return _FaultDisputeGameN.Contract.Step(&_FaultDisputeGameN.TransactOpts, _claimIndex, _isAttack, _stateData, _proof)
+}
+
+// StepV2 is a paid mutator transaction binding the contract method 0x175d249c.
+//
+// Solidity: function stepV2(uint256 _claimIndex, uint256 _attackBranch, bytes _stateData, ((uint256,bytes32,bytes),(uint256,bytes32,bytes),bytes) _proof) returns()
+func (_FaultDisputeGameN *FaultDisputeGameNTransactor) StepV2(opts *bind.TransactOpts, _claimIndex *big.Int, _attackBranch *big.Int, _stateData []byte, _proof FaultDisputeGameStepProof) (*types.Transaction, error) {
+	return _FaultDisputeGameN.contract.Transact(opts, "stepV2", _claimIndex, _attackBranch, _stateData, _proof)
+}
+
+// StepV2 is a paid mutator transaction binding the contract method 0x175d249c.
+//
+// Solidity: function stepV2(uint256 _claimIndex, uint256 _attackBranch, bytes _stateData, ((uint256,bytes32,bytes),(uint256,bytes32,bytes),bytes) _proof) returns()
+func (_FaultDisputeGameN *FaultDisputeGameNSession) StepV2(_claimIndex *big.Int, _attackBranch *big.Int, _stateData []byte, _proof FaultDisputeGameStepProof) (*types.Transaction, error) {
+	return _FaultDisputeGameN.Contract.StepV2(&_FaultDisputeGameN.TransactOpts, _claimIndex, _attackBranch, _stateData, _proof)
+}
+
+// StepV2 is a paid mutator transaction binding the contract method 0x175d249c.
+//
+// Solidity: function stepV2(uint256 _claimIndex, uint256 _attackBranch, bytes _stateData, ((uint256,bytes32,bytes),(uint256,bytes32,bytes),bytes) _proof) returns()
+func (_FaultDisputeGameN *FaultDisputeGameNTransactorSession) StepV2(_claimIndex *big.Int, _attackBranch *big.Int, _stateData []byte, _proof FaultDisputeGameStepProof) (*types.Transaction, error) {
+	return _FaultDisputeGameN.Contract.StepV2(&_FaultDisputeGameN.TransactOpts, _claimIndex, _attackBranch, _stateData, _proof)
+}
+
+// FaultDisputeGameNMoveIterator is returned from FilterMove and is used to iterate over the raw logs and unpacked data for Move events raised by the FaultDisputeGameN contract.
+type FaultDisputeGameNMoveIterator struct {
+	Event *FaultDisputeGameNMove // Event containing the contract specifics and raw log
+
+	contract *bind.BoundContract // Generic contract to use for unpacking event data
+	event    string              // Event name to use for unpacking event data
+
+	logs chan types.Log        // Log channel receiving the found contract events
+	sub  ethereum.Subscription // Subscription for errors, completion and termination
+	done bool                  // Whether the subscription completed delivering logs
+	fail error                 // Occurred error to stop iteration
+}
+
+// Next advances the iterator to the subsequent event, returning whether there
+// are any more events found. In case of a retrieval or parsing error, false is
+// returned and Error() can be queried for the exact failure.
+func (it *FaultDisputeGameNMoveIterator) Next() bool {
+	// If the iterator failed, stop iterating
+	if it.fail != nil {
+		return false
+	}
+	// If the iterator completed, deliver directly whatever's available
+	if it.done {
+		select {
+		case log := <-it.logs:
+			it.Event = new(FaultDisputeGameNMove)
+			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+				it.fail = err
+				return false
+			}
+			it.Event.Raw = log
+			return true
+
+		default:
+			return false
+		}
+	}
+	// Iterator still in progress, wait for either a data or an error event
+	select {
+	case log := <-it.logs:
+		it.Event = new(FaultDisputeGameNMove)
+		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+			it.fail = err
+			return false
+		}
+		it.Event.Raw = log
+		return true
+
+	case err := <-it.sub.Err():
+		it.done = true
+		it.fail = err
+		return it.Next()
+	}
+}
+
+// Error returns any retrieval or parsing error occurred during filtering.
+func (it *FaultDisputeGameNMoveIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *FaultDisputeGameNMoveIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// FaultDisputeGameNMove represents a Move event raised by the FaultDisputeGameN contract.
+type FaultDisputeGameNMove struct {
+	ParentIndex *big.Int
+	Claim       [32]byte
+	Claimant    common.Address
+	Raw         types.Log // Blockchain specific contextual infos
+}
+
+// FilterMove is a free log retrieval operation binding the contract event 0x9b3245740ec3b155098a55be84957a4da13eaf7f14a8bc6f53126c0b9350f2be.
+//
+// Solidity: event Move(uint256 indexed parentIndex, bytes32 indexed claim, address indexed claimant)
+func (_FaultDisputeGameN *FaultDisputeGameNFilterer) FilterMove(opts *bind.FilterOpts, parentIndex []*big.Int, claim [][32]byte, claimant []common.Address) (*FaultDisputeGameNMoveIterator, error) {
+
+	var parentIndexRule []interface{}
+	for _, parentIndexItem := range parentIndex {
+		parentIndexRule = append(parentIndexRule, parentIndexItem)
+	}
+	var claimRule []interface{}
+	for _, claimItem := range claim {
+		claimRule = append(claimRule, claimItem)
+	}
+	var claimantRule []interface{}
+	for _, claimantItem := range claimant {
+		claimantRule = append(claimantRule, claimantItem)
+	}
+
+	logs, sub, err := _FaultDisputeGameN.contract.FilterLogs(opts, "Move", parentIndexRule, claimRule, claimantRule)
+	if err != nil {
+		return nil, err
+	}
+	return &FaultDisputeGameNMoveIterator{contract: _FaultDisputeGameN.contract, event: "Move", logs: logs, sub: sub}, nil
+}
+
+// WatchMove is a free log subscription operation binding the contract event 0x9b3245740ec3b155098a55be84957a4da13eaf7f14a8bc6f53126c0b9350f2be.
+//
+// Solidity: event Move(uint256 indexed parentIndex, bytes32 indexed claim, address indexed claimant)
+func (_FaultDisputeGameN *FaultDisputeGameNFilterer) WatchMove(opts *bind.WatchOpts, sink chan<- *FaultDisputeGameNMove, parentIndex []*big.Int, claim [][32]byte, claimant []common.Address) (event.Subscription, error) {
+
+	var parentIndexRule []interface{}
+	for _, parentIndexItem := range parentIndex {
+		parentIndexRule = append(parentIndexRule, parentIndexItem)
+	}
+	var claimRule []interface{}
+	for _, claimItem := range claim {
+		claimRule = append(claimRule, claimItem)
+	}
+	var claimantRule []interface{}
+	for _, claimantItem := range claimant {
+		claimantRule = append(claimantRule, claimantItem)
+	}
+
+	logs, sub, err := _FaultDisputeGameN.contract.WatchLogs(opts, "Move", parentIndexRule, claimRule, claimantRule)
+	if err != nil {
+		return nil, err
+	}
+	return event.NewSubscription(func(quit <-chan struct{}) error {
+		defer sub.Unsubscribe()
+		for {
+			select {
+			case log := <-logs:
+				// New log arrived, parse the event and forward to the user
+				event := new(FaultDisputeGameNMove)
+				if err := _FaultDisputeGameN.contract.UnpackLog(event, "Move", log); err != nil {
+					return err
+				}
+				event.Raw = log
+
+				select {
+				case sink <- event:
+				case err := <-sub.Err():
+					return err
+				case <-quit:
+					return nil
+				}
+			case err := <-sub.Err():
+				return err
+			case <-quit:
+				return nil
+			}
+		}
+	}), nil
+}
+
+// ParseMove is a log parse operation binding the contract event 0x9b3245740ec3b155098a55be84957a4da13eaf7f14a8bc6f53126c0b9350f2be.
+//
+// Solidity: event Move(uint256 indexed parentIndex, bytes32 indexed claim, address indexed claimant)
+func (_FaultDisputeGameN *FaultDisputeGameNFilterer) ParseMove(log types.Log) (*FaultDisputeGameNMove, error) {
+	event := new(FaultDisputeGameNMove)
+	if err := _FaultDisputeGameN.contract.UnpackLog(event, "Move", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// FaultDisputeGameNResolvedIterator is returned from FilterResolved and is used to iterate over the raw logs and unpacked data for Resolved events raised by the FaultDisputeGameN contract.
+type FaultDisputeGameNResolvedIterator struct {
+	Event *FaultDisputeGameNResolved // Event containing the contract specifics and raw log
+
+	contract *bind.BoundContract // Generic contract to use for unpacking event data
+	event    string              // Event name to use for unpacking event data
+
+	logs chan types.Log        // Log channel receiving the found contract events
+	sub  ethereum.Subscription // Subscription for errors, completion and termination
+	done bool                  // Whether the subscription completed delivering logs
+	fail error                 // Occurred error to stop iteration
+}
+
+// Next advances the iterator to the subsequent event, returning whether there
+// are any more events found. In case of a retrieval or parsing error, false is
+// returned and Error() can be queried for the exact failure.
+func (it *FaultDisputeGameNResolvedIterator) Next() bool {
+	// If the iterator failed, stop iterating
+	if it.fail != nil {
+		return false
+	}
+	// If the iterator completed, deliver directly whatever's available
+	if it.done {
+		select {
+		case log := <-it.logs:
+			it.Event = new(FaultDisputeGameNResolved)
+			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+				it.fail = err
+				return false
+			}
+			it.Event.Raw = log
+			return true
+
+		default:
+			return false
+		}
+	}
+	// Iterator still in progress, wait for either a data or an error event
+	select {
+	case log := <-it.logs:
+		it.Event = new(FaultDisputeGameNResolved)
+		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+			it.fail = err
+			return false
+		}
+		it.Event.Raw = log
+		return true
+
+	case err := <-it.sub.Err():
+		it.done = true
+		it.fail = err
+		return it.Next()
+	}
+}
+
+// Error returns any retrieval or parsing error occurred during filtering.
+func (it *FaultDisputeGameNResolvedIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *FaultDisputeGameNResolvedIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// FaultDisputeGameNResolved represents a Resolved event raised by the FaultDisputeGameN contract.
+type FaultDisputeGameNResolved struct {
+	Status uint8
+	Raw    types.Log // Blockchain specific contextual infos
+}
+
+// FilterResolved is a free log retrieval operation binding the contract event 0x5e186f09b9c93491f14e277eea7faa5de6a2d4bda75a79af7a3684fbfb42da60.
+//
+// Solidity: event Resolved(uint8 indexed status)
+func (_FaultDisputeGameN *FaultDisputeGameNFilterer) FilterResolved(opts *bind.FilterOpts, status []uint8) (*FaultDisputeGameNResolvedIterator, error) {
+
+	var statusRule []interface{}
+	for _, statusItem := range status {
+		statusRule = append(statusRule, statusItem)
+	}
+
+	logs, sub, err := _FaultDisputeGameN.contract.FilterLogs(opts, "Resolved", statusRule)
+	if err != nil {
+		return nil, err
+	}
+	return &FaultDisputeGameNResolvedIterator{contract: _FaultDisputeGameN.contract, event: "Resolved", logs: logs, sub: sub}, nil
+}
+
+// WatchResolved is a free log subscription operation binding the contract event 0x5e186f09b9c93491f14e277eea7faa5de6a2d4bda75a79af7a3684fbfb42da60.
+//
+// Solidity: event Resolved(uint8 indexed status)
+func (_FaultDisputeGameN *FaultDisputeGameNFilterer) WatchResolved(opts *bind.WatchOpts, sink chan<- *FaultDisputeGameNResolved, status []uint8) (event.Subscription, error) {
+
+	var statusRule []interface{}
+	for _, statusItem := range status {
+		statusRule = append(statusRule, statusItem)
+	}
+
+	logs, sub, err := _FaultDisputeGameN.contract.WatchLogs(opts, "Resolved", statusRule)
+	if err != nil {
+		return nil, err
+	}
+	return event.NewSubscription(func(quit <-chan struct{}) error {
+		defer sub.Unsubscribe()
+		for {
+			select {
+			case log := <-logs:
+				// New log arrived, parse the event and forward to the user
+				event := new(FaultDisputeGameNResolved)
+				if err := _FaultDisputeGameN.contract.UnpackLog(event, "Resolved", log); err != nil {
+					return err
+				}
+				event.Raw = log
+
+				select {
+				case sink <- event:
+				case err := <-sub.Err():
+					return err
+				case <-quit:
+					return nil
+				}
+			case err := <-sub.Err():
+				return err
+			case <-quit:
+				return nil
+			}
+		}
+	}), nil
+}
+
+// ParseResolved is a log parse operation binding the contract event 0x5e186f09b9c93491f14e277eea7faa5de6a2d4bda75a79af7a3684fbfb42da60.
+//
+// Solidity: event Resolved(uint8 indexed status)
+func (_FaultDisputeGameN *FaultDisputeGameNFilterer) ParseResolved(log types.Log) (*FaultDisputeGameNResolved, error) {
+	event := new(FaultDisputeGameNResolved)
+	if err := _FaultDisputeGameN.contract.UnpackLog(event, "Resolved", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
diff --git a/op-e2e2/e2eutils/challenger/helper.go b/op-e2e2/e2eutils/challenger/helper.go
index 7388629cef182..d5df60d57f83e 100644
--- a/op-e2e2/e2eutils/challenger/helper.go
+++ b/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
diff --git a/op-e2e2/e2eutils/challenger/metrics.go b/op-e2e2/e2eutils/challenger/metrics.go
index de95121480f19..25abaa1756907 100644
--- a/op-e2e2/e2eutils/challenger/metrics.go
+++ b/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 {
diff --git a/op-e2e2/e2eutils/disputegame/claim_helper.go b/op-e2e2/e2eutils/disputegame/claim_helper.go
index 0effe44ad8433..a44ebd72a2b8f 100644
--- a/op-e2e2/e2eutils/disputegame/claim_helper.go
+++ b/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")
 }
diff --git a/op-e2e2/e2eutils/disputegame/dishonest_helper.go b/op-e2e2/e2eutils/disputegame/dishonest_helper.go
index 015e2cd8049c5..fff4b8ed5ceb9 100644
--- a/op-e2e2/e2eutils/disputegame/dishonest_helper.go
+++ b/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())
 		}
 	}
 
diff --git a/op-e2e2/e2eutils/disputegame/helper.go b/op-e2e2/e2eutils/disputegame/helper.go
index 40c14ae482472..f94d032ff620d 100644
--- a/op-e2e2/e2eutils/disputegame/helper.go
+++ b/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),
 	}
 }
 
diff --git a/op-e2e2/e2eutils/disputegame/output_alphabet_helper.go b/op-e2e2/e2eutils/disputegame/output_alphabet_helper.go
index e452f546f0ba4..dbe7caab19630 100644
--- a/op-e2e2/e2eutils/disputegame/output_alphabet_helper.go
+++ b/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"
diff --git a/op-e2e2/e2eutils/disputegame/output_cannon_helper.go b/op-e2e2/e2eutils/disputegame/output_cannon_helper.go
index c13c20f355fa6..b6723738b9815 100644
--- a/op-e2e2/e2eutils/disputegame/output_cannon_helper.go
+++ b/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)
diff --git a/op-e2e2/e2eutils/disputegame/output_game_helper.go b/op-e2e2/e2eutils/disputegame/output_game_helper.go
index 287fb9b2f06ab..af0daab9f62b4 100644
--- a/op-e2e2/e2eutils/disputegame/output_game_helper.go
+++ b/op-e2e2/e2eutils/disputegame/output_game_helper.go
@@ -8,12 +8,12 @@ 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/fault/trace/outputs"
-	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
-	keccakTypes "github.com/ethereum-optimism/optimism/op-challenger/game/keccak/types"
-	gameTypes "github.com/ethereum-optimism/optimism/op-challenger/game/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/fault/trace/outputs"
+	"github.com/ethereum-optimism/optimism/op-challenger2/game/fault/types"
+	keccakTypes "github.com/ethereum-optimism/optimism/op-challenger2/game/keccak/types"
+	gameTypes "github.com/ethereum-optimism/optimism/op-challenger2/game/types"
 	"github.com/ethereum-optimism/optimism/op-e2e2/bindings"
 	"github.com/ethereum-optimism/optimism/op-e2e2/e2eutils/wait"
 	preimage "github.com/ethereum-optimism/optimism/op-preimage"
@@ -34,15 +34,19 @@ type OutputGameHelper struct {
 	Client                *ethclient.Client
 	Opts                  *bind.TransactOpts
 	Game                  contracts.FaultDisputeGameContract
-	GameBindings          *bindings.FaultDisputeGame
+	GameBindings          *bindings.FaultDisputeGameN
 	FactoryAddr           common.Address
 	Addr                  common.Address
 	CorrectOutputProvider *outputs.OutputTraceProvider
 	System                DisputeSystem
+	DaType                *big.Int
+	Nbits                 uint64
 }
 
 func NewOutputGameHelper(t *testing.T, require *require.Assertions, client *ethclient.Client, opts *bind.TransactOpts,
-	game contracts.FaultDisputeGameContract, gameBindings *bindings.FaultDisputeGame, factoryAddr common.Address, addr common.Address, correctOutputProvider *outputs.OutputTraceProvider, system DisputeSystem) *OutputGameHelper {
+	game contracts.FaultDisputeGameContract, gameBindings *bindings.FaultDisputeGameN, factoryAddr common.Address, addr common.Address, correctOutputProvider *outputs.OutputTraceProvider, system DisputeSystem, datype int64) *OutputGameHelper {
+	nbits, err := game.GetNBits(context.Background())
+	require.NoError(err, "fail to load nbits from contract")
 	return &OutputGameHelper{
 		T:                     t,
 		Require:               require,
@@ -54,6 +58,8 @@ func NewOutputGameHelper(t *testing.T, require *require.Assertions, client *ethc
 		Addr:                  addr,
 		CorrectOutputProvider: correctOutputProvider,
 		System:                system,
+		DaType:                big.NewInt(datype),
+		Nbits:                 nbits,
 	}
 }
 
@@ -117,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.
@@ -145,11 +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()
-			claim = claim.Attack(ctx, getClaimValue(claim, pos))
+			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
@@ -538,19 +554,28 @@ func (g *OutputGameHelper) moveCfg(Opts ...MoveOpt) *moveCfg {
 	return cfg
 }
 
-func (g *OutputGameHelper) Attack(ctx context.Context, claimIdx int64, claim common.Hash, Opts ...MoveOpt) {
-	g.T.Logf("Attacking claim %v with value %v", claimIdx, claim)
+func (g *OutputGameHelper) Attack2(ctx context.Context, claimIdx int64, attackBranch uint64, subValues []common.Hash, Opts ...MoveOpt) {
+	g.T.Logf("Attacking claim %v with subValues %v", claimIdx, subValues)
 	cfg := g.moveCfg(Opts...)
 
 	claimData, err := g.Game.GetClaim(ctx, uint64(claimIdx))
 	g.Require.NoError(err, "Failed to get claim data")
-	attackPos := claimData.Position.Attack()
-	transactOpts := g.makeBondedTransactOpts(ctx, claimData.Position.Attack().ToGIndex(), cfg.Opts)
+	attackPos := claimData.Position.MoveN(g.Nbits, attackBranch)
+	transactOpts := g.makeBondedTransactOpts(ctx, attackPos.ToGIndex(), cfg.Opts)
 
+	claims := []byte{}
+	if attackPos.Depth() == types.Depth(g.Nbits)+g.SplitDepth(ctx) {
+		// only one subValue at splitDepth+nbits Depth
+		subValues = subValues[:1]
+	}
+	for _, subValue := range subValues {
+		claims = append(claims, subValue.Bytes()...)
+	}
 	err = g.sendMove(ctx, func() (*gethtypes.Transaction, error) {
-		return g.GameBindings.Attack(transactOpts, claimData.Value, big.NewInt(claimIdx), claim)
+		return g.GameBindings.AttackV2(transactOpts, claimData.Value, big.NewInt(claimIdx), big.NewInt(int64(attackBranch)), g.DaType, claims)
 	})
 	if err != nil {
+		claim := contracts.SubValuesHash(subValues)
 		if cfg.ignoreDupes && g.hasClaim(ctx, claimIdx, attackPos, claim) {
 			return
 		}
@@ -558,24 +583,13 @@ func (g *OutputGameHelper) Attack(ctx context.Context, claimIdx int64, claim com
 	}
 }
 
-func (g *OutputGameHelper) Defend(ctx context.Context, claimIdx int64, claim common.Hash, Opts ...MoveOpt) {
-	g.T.Logf("Defending claim %v with value %v", claimIdx, claim)
-	cfg := g.moveCfg(Opts...)
-
-	claimData, err := g.Game.GetClaim(ctx, uint64(claimIdx))
-	g.Require.NoError(err, "Failed to get claim data")
-	defendPos := claimData.Position.Defend()
-	transactOpts := g.makeBondedTransactOpts(ctx, defendPos.ToGIndex(), cfg.Opts)
+// currently, this function still remains to avoid compilation errors
+func (g *OutputGameHelper) Attack(ctx context.Context, claimIdx int64, claim common.Hash, Opts ...MoveOpt) {
+	panic("unimplemented")
+}
 
-	err = g.sendMove(ctx, func() (*gethtypes.Transaction, error) {
-		return g.GameBindings.Defend(transactOpts, claimData.Value, big.NewInt(claimIdx), claim)
-	})
-	if err != nil {
-		if cfg.ignoreDupes && g.hasClaim(ctx, claimIdx, defendPos, claim) {
-			return
-		}
-		g.Require.NoErrorf(err, "Defend transaction failed. Game state: \n%v", g.GameData(ctx))
-	}
+func (g *OutputGameHelper) Defend(ctx context.Context, claimIdx int64, claim common.Hash, Opts ...MoveOpt) {
+	panic("unimplemented")
 }
 
 func (g *OutputGameHelper) hasClaim(ctx context.Context, parentIdx int64, pos types.Position, value common.Hash) bool {
@@ -725,8 +739,8 @@ func (g *OutputGameHelper) GameData(ctx context.Context) string {
 				extra = fmt.Sprintf("Block num: %v", blockNum)
 			}
 		}
-		info = info + fmt.Sprintf("%v - Position: %v, Depth: %v, IndexAtDepth: %v Trace Index: %v, ClaimHash: %v, Countered By: %v, ParentIndex: %v Claimant: %v Bond: %v %v\n",
-			i, claim.Position.ToGIndex().Int64(), pos.Depth(), pos.IndexAtDepth(), pos.TraceIndex(maxDepth), claim.Value.Hex(), claim.CounteredBy, claim.ParentContractIndex, claim.Claimant, claim.Bond, extra)
+		info = info + fmt.Sprintf("%v - Position: %v, Depth: %v, IndexAtDepth: %v Trace Index: %v, ClaimHash: %v, SubValues: %v, Countered By: %v, ParentIndex: %v Claimant: %v Bond: %v %v\n",
+			i, claim.Position.ToGIndex().Int64(), pos.Depth(), pos.IndexAtDepth(), pos.TraceIndex(maxDepth), claim.Value.Hex(), claim.SubValues, claim.CounteredBy, claim.ParentContractIndex, claim.Claimant, claim.Bond, extra)
 	}
 	l2BlockNum := g.L2BlockNum(ctx)
 	status, err := g.Game.GetStatus(ctx)
diff --git a/op-e2e2/e2eutils/disputegame/output_honest_helper.go b/op-e2e2/e2eutils/disputegame/output_honest_helper.go
index e2de7c4ec743f..e83eb7ce5a90f 100644
--- a/op-e2e2/e2eutils/disputegame/output_honest_helper.go
+++ b/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,7 +53,7 @@ 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)
 
@@ -60,26 +61,25 @@ func (h *OutputHonestHelper) Attack(ctx context.Context, claimIdx int64, opts ..
 	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
diff --git a/op-e2e2/e2eutils/disputegame/preimage/preimage_helper.go b/op-e2e2/e2eutils/disputegame/preimage/preimage_helper.go
index cdfda94c1128b..276a16c71bf61 100644
--- a/op-e2e2/e2eutils/disputegame/preimage/preimage_helper.go
+++ b/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"
diff --git a/op-e2e2/faultproofs/challenge_preimage_test.go b/op-e2e2/faultproofs/challenge_preimage_test.go
index 4ff565cd8ed8c..746a7b25c7bf0 100644
--- a/op-e2e2/faultproofs/challenge_preimage_test.go
+++ b/op-e2e2/faultproofs/challenge_preimage_test.go
@@ -18,7 +18,7 @@ func TestChallengeLargePreimages_ChallengeFirst(t *testing.T) {
 	sys, _ := StartFaultDisputeSystem(t)
 	t.Cleanup(sys.Close)
 
-	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys)
+	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys, daType)
 	disputeGameFactory.StartChallenger(ctx, "Challenger",
 		challenger.WithAlphabet(),
 		challenger.WithPrivKey(sys.Cfg.Secrets.Alice))
@@ -36,7 +36,7 @@ func TestChallengeLargePreimages_ChallengeMiddle(t *testing.T) {
 	ctx := context.Background()
 	sys, _ := StartFaultDisputeSystem(t)
 	t.Cleanup(sys.Close)
-	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys)
+	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys, daType)
 	disputeGameFactory.StartChallenger(ctx, "Challenger",
 		challenger.WithAlphabet(),
 		challenger.WithPrivKey(sys.Cfg.Secrets.Mallory))
@@ -54,7 +54,7 @@ func TestChallengeLargePreimages_ChallengeLast(t *testing.T) {
 	ctx := context.Background()
 	sys, _ := StartFaultDisputeSystem(t)
 	t.Cleanup(sys.Close)
-	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys)
+	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys, daType)
 	disputeGameFactory.StartChallenger(ctx, "Challenger",
 		challenger.WithAlphabet(),
 		challenger.WithPrivKey(sys.Cfg.Secrets.Mallory))
diff --git a/op-e2e2/faultproofs/multi_test.go b/op-e2e2/faultproofs/multi_test.go
index 7074f5cd2d632..8c1156c9e7676 100644
--- a/op-e2e2/faultproofs/multi_test.go
+++ b/op-e2e2/faultproofs/multi_test.go
@@ -17,7 +17,7 @@ func TestMultipleGameTypes(t *testing.T) {
 	sys, _ := StartFaultDisputeSystem(t)
 	t.Cleanup(sys.Close)
 
-	gameFactory := disputegame.NewFactoryHelper(t, ctx, sys)
+	gameFactory := disputegame.NewFactoryHelper(t, ctx, sys, daType)
 
 	game1 := gameFactory.StartOutputCannonGame(ctx, "sequencer", 1, common.Hash{0x01, 0xaa})
 	game2 := gameFactory.StartOutputAlphabetGame(ctx, "sequencer", 1, common.Hash{0xbb})
diff --git a/op-e2e2/faultproofs/output_alphabet_test.go b/op-e2e2/faultproofs/output_alphabet_test.go
index 14c8d42ce2744..be4e290b97d4b 100644
--- a/op-e2e2/faultproofs/output_alphabet_test.go
+++ b/op-e2e2/faultproofs/output_alphabet_test.go
@@ -6,7 +6,8 @@ import (
 	"testing"
 	"time"
 
-	"github.com/ethereum-optimism/optimism/op-challenger/game/types"
+	"github.com/ethereum-optimism/optimism/op-challenger2/config"
+	"github.com/ethereum-optimism/optimism/op-challenger2/game/types"
 	op_e2e "github.com/ethereum-optimism/optimism/op-e2e2"
 	"github.com/ethereum-optimism/optimism/op-e2e2/e2eutils/challenger"
 	"github.com/ethereum-optimism/optimism/op-e2e2/e2eutils/disputegame"
@@ -16,23 +17,28 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+const (
+	daType = config.DACalldata
+)
+
 func TestOutputAlphabetGame_ChallengerWins(t *testing.T) {
 	op_e2e.InitParallel(t)
 	ctx := context.Background()
 	sys, l1Client := StartFaultDisputeSystem(t)
 	t.Cleanup(sys.Close)
 
-	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys)
+	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys, daType)
 	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.StartChallenger(ctx, "sequencer", "Challenger", opts, challenger.WithDaType(daType))
 	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)
+	incorrectValues := setIncorrectValues(common.Hash{0xaa}, 1<<game.Nbits-1)
 	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
@@ -41,7 +47,7 @@ func TestOutputAlphabetGame_ChallengerWins(t *testing.T) {
 			claim.RequireCorrectOutputRoot(ctx)
 		} else {
 			// Otherwise we should counter
-			claim = claim.Attack(ctx, common.Hash{0xaa})
+			claim = claim.Attack2(ctx, 0, incorrectValues)
 			game.LogGameData(ctx)
 		}
 	}
@@ -49,9 +55,8 @@ func TestOutputAlphabetGame_ChallengerWins(t *testing.T) {
 	// 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)
+	claim = correctTrace.AttackClaim(ctx, claim, 0)
 	for !claim.IsMaxDepth(ctx) {
 		if claim.AgreesWithOutputRoot() {
 			// If the latest claim supports the output root, wait for the honest challenger to respond
@@ -59,7 +64,7 @@ func TestOutputAlphabetGame_ChallengerWins(t *testing.T) {
 			game.LogGameData(ctx)
 		} else {
 			// Otherwise we need to counter the honest claim
-			claim = correctTrace.AttackClaim(ctx, claim)
+			claim = correctTrace.AttackClaim(ctx, claim, 0)
 			game.LogGameData(ctx)
 		}
 	}
@@ -79,7 +84,7 @@ func TestOutputAlphabetGame_ReclaimBond(t *testing.T) {
 	sys, l1Client := StartFaultDisputeSystem(t)
 	t.Cleanup(sys.Close)
 
-	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys)
+	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys, daType)
 	game := disputeGameFactory.StartOutputAlphabetGame(ctx, "sequencer", 3, common.Hash{0xff})
 	game.LogGameData(ctx)
 
@@ -98,11 +103,14 @@ func TestOutputAlphabetGame_ReclaimBond(t *testing.T) {
 	// Perform a few moves
 	claim = claim.WaitForCounterClaim(ctx)
 	game.LogGameData(ctx)
-	claim = claim.Attack(ctx, common.Hash{})
+	incorrectValues := setIncorrectValues(common.Hash{0xaa}, 1<<game.Nbits-1)
+	claim = claim.Attack2(ctx, 0, incorrectValues)
 	claim = claim.WaitForCounterClaim(ctx)
 	game.LogGameData(ctx)
-	claim = claim.Attack(ctx, common.Hash{})
+	claim = claim.Attack2(ctx, 0, incorrectValues)
 	game.LogGameData(ctx)
+	// when nbits=2, splitDepth is 4, maxDepth is 8, the following line should be commentted,
+	// because the maxDepth is reached and we don't need to waitForCounterClaim.
 	_ = claim.WaitForCounterClaim(ctx)
 
 	// Expect posted claims so the game balance is non-zero
@@ -140,13 +148,13 @@ func TestOutputAlphabetGame_ValidOutputRoot(t *testing.T) {
 	sys, l1Client := StartFaultDisputeSystem(t)
 	t.Cleanup(sys.Close)
 
-	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys)
+	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys, daType)
 	game := disputeGameFactory.StartOutputAlphabetGameWithCorrectRoot(ctx, "sequencer", 2)
 	correctTrace := game.CreateHonestActor(ctx, "sequencer")
 	game.LogGameData(ctx)
 	claim := game.DisputeLastBlock(ctx)
 	// Invalid root claim of the alphabet game
-	claim = claim.Attack(ctx, common.Hash{0x01})
+	claim = claim.Attack2(ctx, 0, setIncorrectValues(common.Hash{0x01}, 1<<game.Nbits-1))
 
 	opts := challenger.WithPrivKey(sys.Cfg.Secrets.Alice)
 	game.StartChallenger(ctx, "sequencer", "Challenger", opts)
@@ -155,7 +163,7 @@ func TestOutputAlphabetGame_ValidOutputRoot(t *testing.T) {
 	game.LogGameData(ctx)
 	for !claim.IsMaxDepth(ctx) {
 		// Dishonest actor always attacks with the correct trace
-		claim = correctTrace.AttackClaim(ctx, claim)
+		claim = correctTrace.AttackClaim(ctx, claim, 0)
 		claim = claim.WaitForCounterClaim(ctx)
 		game.LogGameData(ctx)
 	}
@@ -173,7 +181,7 @@ func TestChallengerCompleteExhaustiveDisputeGame(t *testing.T) {
 		sys, l1Client := StartFaultDisputeSystem(t)
 		t.Cleanup(sys.Close)
 
-		disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys)
+		disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys, daType)
 		var game *disputegame.OutputAlphabetGameHelper
 		if isRootCorrect {
 			game = disputeGameFactory.StartOutputAlphabetGameWithCorrectRoot(ctx, "sequencer", 1)
@@ -194,7 +202,7 @@ func TestChallengerCompleteExhaustiveDisputeGame(t *testing.T) {
 
 		if isRootCorrect {
 			// Attack the correct output root with an invalid alphabet trace
-			claim = claim.Attack(ctx, common.Hash{0x01})
+			claim = claim.Attack2(ctx, 0, setIncorrectValues(common.Hash{0x01}, 1<<game.Nbits-1))
 		} else {
 			// Wait for the challenger to counter the invalid output root
 			claim = claim.WaitForCounterClaim(ctx)
@@ -241,13 +249,14 @@ func TestOutputAlphabetGame_FreeloaderEarnsNothing(t *testing.T) {
 	freeloaderOpts, err := bind.NewKeyedTransactorWithChainID(sys.Cfg.Secrets.Mallory, sys.Cfg.L1ChainIDBig())
 	require.Nil(t, err)
 
-	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys)
+	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys, daType)
 	game := disputeGameFactory.StartOutputAlphabetGameWithCorrectRoot(ctx, "sequencer", 2)
 	correctTrace := game.CreateHonestActor(ctx, "sequencer")
 	game.LogGameData(ctx)
 	claim := game.DisputeLastBlock(ctx)
 	// Invalid root claim of the alphabet game
-	claim = claim.Attack(ctx, common.Hash{0x01})
+	maxAttackBranch := 1<<game.Nbits - 1
+	claim = claim.Attack2(ctx, 0, setIncorrectValues(common.Hash{0x01}, maxAttackBranch))
 
 	// Chronology of claims:
 	// dishonest root claim:
@@ -259,24 +268,25 @@ func TestOutputAlphabetGame_FreeloaderEarnsNothing(t *testing.T) {
 	// The freeloader must be positioned leftmost (gindex positioning) or at the same position as honest claims.
 
 	// honest counter
-	claim = correctTrace.AttackClaim(ctx, claim)
+	claim = correctTrace.AttackClaim(ctx, claim, 0)
 
 	var freeloaders []*disputegame.ClaimHelper
 
 	// dishonest
-	dishonest := correctTrace.AttackClaim(ctx, claim)
+	dishonest := correctTrace.AttackClaim(ctx, claim, 0)
 
-	freeloaders = append(freeloaders, correctTrace.AttackClaim(ctx, dishonest, disputegame.WithTransactOpts(freeloaderOpts)))
-	freeloaders = append(freeloaders, dishonest.Attack(ctx, common.Hash{0x02}, disputegame.WithTransactOpts(freeloaderOpts)))
-	freeloaders = append(freeloaders, dishonest.Defend(ctx, common.Hash{0x03}, disputegame.WithTransactOpts(freeloaderOpts)))
+	maxAttakBranch := uint64(1<<game.Nbits - 1)
+	freeloaders = append(freeloaders, correctTrace.AttackClaim(ctx, dishonest, 0, disputegame.WithTransactOpts(freeloaderOpts)))
+	freeloaders = append(freeloaders, dishonest.Attack2(ctx, 0, setIncorrectValues(common.Hash{0x02}, maxAttackBranch), disputegame.WithTransactOpts(freeloaderOpts)))
+	freeloaders = append(freeloaders, dishonest.Attack2(ctx, maxAttakBranch, setIncorrectValues(common.Hash{0x03}, maxAttackBranch), disputegame.WithTransactOpts(freeloaderOpts)))
 
 	// Ensure freeloaders respond before the honest challenger
 	game.StartChallenger(ctx, "sequencer", "Challenger", challenger.WithPrivKey(sys.Cfg.Secrets.Alice))
 	dishonest.WaitForCounterClaim(ctx, freeloaders...)
 
 	// Freeloaders after the honest challenger
-	freeloaders = append(freeloaders, dishonest.Attack(ctx, common.Hash{0x04}, disputegame.WithTransactOpts(freeloaderOpts)))
-	freeloaders = append(freeloaders, dishonest.Defend(ctx, common.Hash{0x05}, disputegame.WithTransactOpts(freeloaderOpts)))
+	freeloaders = append(freeloaders, dishonest.Attack2(ctx, 0, setIncorrectValues(common.Hash{0x04}, maxAttackBranch), disputegame.WithTransactOpts(freeloaderOpts)))
+	freeloaders = append(freeloaders, dishonest.Attack2(ctx, maxAttakBranch, setIncorrectValues(common.Hash{0x05}, maxAttackBranch), disputegame.WithTransactOpts(freeloaderOpts)))
 
 	for _, freeloader := range freeloaders {
 		if freeloader.IsMaxDepth(ctx) {
@@ -302,7 +312,7 @@ func TestHighestActedL1BlockMetric(t *testing.T) {
 	sys, l1Client := StartFaultDisputeSystem(t)
 	t.Cleanup(sys.Close)
 
-	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys)
+	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys, daType)
 	honestChallenger := disputeGameFactory.StartChallenger(ctx, "Honest", challenger.WithAlphabet(), challenger.WithPrivKey(sys.Cfg.Secrets.Alice))
 
 	game1 := disputeGameFactory.StartOutputAlphabetGame(ctx, "sequencer", 1, common.Hash{0xaa})
@@ -319,3 +329,10 @@ func TestHighestActedL1BlockMetric(t *testing.T) {
 	require.NoError(t, wait.ForNextBlock(ctx, l1Client))
 	honestChallenger.WaitL1HeadActedOn(ctx, l1Client)
 }
+
+func setIncorrectValues(v common.Hash, nelements int) (subValues []common.Hash) {
+	for i := 0; i < nelements; i++ {
+		subValues = append(subValues, v)
+	}
+	return subValues
+}
diff --git a/op-e2e2/faultproofs/output_cannon_test.go b/op-e2e2/faultproofs/output_cannon_test.go
index c67f3bc95f2c7..4c16f19b88669 100644
--- a/op-e2e2/faultproofs/output_cannon_test.go
+++ b/op-e2e2/faultproofs/output_cannon_test.go
@@ -6,9 +6,9 @@ import (
 	"math/big"
 	"testing"
 
-	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/utils"
-	"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-challenger2/game/fault/trace/utils"
+	"github.com/ethereum-optimism/optimism/op-challenger2/game/fault/types"
+	gameTypes "github.com/ethereum-optimism/optimism/op-challenger2/game/types"
 	op_e2e "github.com/ethereum-optimism/optimism/op-e2e2"
 	"github.com/ethereum-optimism/optimism/op-e2e2/e2eutils/challenger"
 	"github.com/ethereum-optimism/optimism/op-e2e2/e2eutils/disputegame"
@@ -25,7 +25,7 @@ func TestOutputCannonGame(t *testing.T) {
 	sys, l1Client := StartFaultDisputeSystem(t)
 	t.Cleanup(sys.Close)
 
-	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys)
+	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys, daType)
 	game := disputeGameFactory.StartOutputCannonGame(ctx, "sequencer", 4, common.Hash{0x01})
 	game.LogGameData(ctx)
 
@@ -81,7 +81,7 @@ func TestOutputCannon_ChallengeAllZeroClaim(t *testing.T) {
 	sys, l1Client := StartFaultDisputeSystem(t)
 	t.Cleanup(sys.Close)
 
-	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys)
+	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys, daType)
 	game := disputeGameFactory.StartOutputCannonGame(ctx, "sequencer", 3, common.Hash{})
 	game.LogGameData(ctx)
 
@@ -119,7 +119,7 @@ func TestOutputCannon_PublishCannonRootClaim(t *testing.T) {
 			ctx := context.Background()
 			sys, _ := StartFaultDisputeSystem(t)
 
-			disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys)
+			disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys, daType)
 			game := disputeGameFactory.StartOutputCannonGame(ctx, "sequencer", test.disputeL2BlockNumber, common.Hash{0x01})
 			game.DisputeLastBlock(ctx)
 			game.LogGameData(ctx)
@@ -151,7 +151,7 @@ func TestOutputCannonDisputeGame(t *testing.T) {
 			sys, l1Client := StartFaultDisputeSystem(t)
 			t.Cleanup(sys.Close)
 
-			disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys)
+			disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys, daType)
 			game := disputeGameFactory.StartOutputCannonGame(ctx, "sequencer", 1, common.Hash{0x01, 0xaa})
 			require.NotNil(t, game)
 			game.LogGameData(ctx)
@@ -188,7 +188,7 @@ func TestOutputCannonDefendStep(t *testing.T) {
 	sys, l1Client := StartFaultDisputeSystem(t)
 	t.Cleanup(sys.Close)
 
-	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys)
+	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys, daType)
 	game := disputeGameFactory.StartOutputCannonGame(ctx, "sequencer", 1, common.Hash{0x01, 0xaa})
 	require.NotNil(t, game)
 	outputRootClaim := game.DisputeLastBlock(ctx)
@@ -205,7 +205,7 @@ func TestOutputCannonDefendStep(t *testing.T) {
 			return claim.Attack(ctx, common.Hash{0xaa})
 		} else {
 			// Post our own counter but using the correct hash in low levels to force a defense step
-			return correctTrace.AttackClaim(ctx, claim)
+			return correctTrace.AttackClaim(ctx, claim, 0)
 		}
 	})
 
@@ -234,7 +234,7 @@ func TestOutputCannonStepWithLargePreimage(t *testing.T) {
 	require.NoError(t, err, "Batcher should resume submitting valid batches")
 
 	l2BlockNumber := safeHead.NumberU64()
-	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys)
+	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys, daType)
 	// Dispute any block - it will have to read the L1 batches to see if the block is reached
 	game := disputeGameFactory.StartOutputCannonGame(ctx, "sequencer", l2BlockNumber, common.Hash{0x01, 0xaa})
 	require.NotNil(t, game)
@@ -267,7 +267,7 @@ func TestOutputCannonStepWithPreimage(t *testing.T) {
 		sys, _ := StartFaultDisputeSystem(t, WithBlobBatches())
 		t.Cleanup(sys.Close)
 
-		disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys)
+		disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys, daType)
 		game := disputeGameFactory.StartOutputCannonGame(ctx, "sequencer", 1, common.Hash{0x01, 0xaa})
 		require.NotNil(t, game)
 		outputRootClaim := game.DisputeLastBlock(ctx)
@@ -320,7 +320,7 @@ func TestOutputCannonStepWithKZGPointEvaluation(t *testing.T) {
 		precompileBlock := receipt.BlockNumber
 		t.Logf("KZG Point Evaluation block number: %d", precompileBlock)
 
-		disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys)
+		disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys, daType)
 		game := disputeGameFactory.StartOutputCannonGame(ctx, "sequencer", precompileBlock.Uint64(), common.Hash{0x01, 0xaa})
 		require.NotNil(t, game)
 		outputRootClaim := game.DisputeLastBlock(ctx)
@@ -377,7 +377,7 @@ func TestOutputCannonProposedOutputRootValid(t *testing.T) {
 				if claim.IsOutputRootLeaf(ctx) {
 					return claim.Attack(ctx, common.Hash{0x01})
 				}
-				return correctTrace.AttackClaim(ctx, claim)
+				return correctTrace.AttackClaim(ctx, claim, 0)
 			},
 			performStep: honestStepsFail,
 		},
@@ -386,7 +386,7 @@ func TestOutputCannonProposedOutputRootValid(t *testing.T) {
 			performMove: func(ctx context.Context, game *disputegame.OutputCannonGameHelper, correctTrace *disputegame.OutputHonestHelper, claim *disputegame.ClaimHelper) *disputegame.ClaimHelper {
 				// Can only attack the root claim or the first cannon claim
 				if claim.IsRootClaim() {
-					return correctTrace.AttackClaim(ctx, claim)
+					return correctTrace.AttackClaim(ctx, claim, 0)
 				}
 				// The root of the cannon game must have an invalid VM status code
 				// Attacking ensure we're running the cannon trace between two different blocks
@@ -410,7 +410,7 @@ func TestOutputCannonProposedOutputRootValid(t *testing.T) {
 			sys, l1Client := StartFaultDisputeSystem(t)
 			t.Cleanup(sys.Close)
 
-			disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys)
+			disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys, daType)
 			game := disputeGameFactory.StartOutputCannonGameWithCorrectRoot(ctx, "sequencer", 1)
 			correctTrace := game.CreateHonestActor(ctx, "sequencer", challenger.WithPrivKey(sys.Cfg.Secrets.Mallory))
 
@@ -444,13 +444,13 @@ func TestOutputCannonPoisonedPostState(t *testing.T) {
 	sys, l1Client := StartFaultDisputeSystem(t)
 	t.Cleanup(sys.Close)
 
-	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys)
+	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys, daType)
 	// Root claim is dishonest
 	game := disputeGameFactory.StartOutputCannonGame(ctx, "sequencer", 1, common.Hash{0xaa})
 	correctTrace := game.CreateHonestActor(ctx, "sequencer", challenger.WithPrivKey(sys.Cfg.Secrets.Alice))
 
 	// Honest first attack at "honest" level
-	claim := correctTrace.AttackClaim(ctx, game.RootClaim(ctx))
+	claim := correctTrace.AttackClaim(ctx, game.RootClaim(ctx), 0)
 
 	// Honest defense at "dishonest" level
 	claim = correctTrace.DefendClaim(ctx, claim)
@@ -459,7 +459,7 @@ func TestOutputCannonPoisonedPostState(t *testing.T) {
 	claimToIgnore1 := claim.Attack(ctx, common.Hash{0x03, 0xaa})
 
 	// Honest attack at "dishonest" level - honest move would be to ignore
-	claimToIgnore2 := correctTrace.AttackClaim(ctx, claimToIgnore1)
+	claimToIgnore2 := correctTrace.AttackClaim(ctx, claimToIgnore1, 0)
 	game.LogGameData(ctx)
 
 	// Start the honest challenger
@@ -508,7 +508,7 @@ func TestDisputeOutputRootBeyondProposedBlock_ValidOutputRoot(t *testing.T) {
 	sys, l1Client := StartFaultDisputeSystem(t)
 	t.Cleanup(sys.Close)
 
-	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys)
+	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys, daType)
 	// Root claim is dishonest
 	game := disputeGameFactory.StartOutputCannonGameWithCorrectRoot(ctx, "sequencer", 1)
 	correctTrace := game.CreateHonestActor(ctx, "sequencer", challenger.WithPrivKey(sys.Cfg.Secrets.Alice))
@@ -517,7 +517,7 @@ func TestDisputeOutputRootBeyondProposedBlock_ValidOutputRoot(t *testing.T) {
 
 	claim := game.RootClaim(ctx)
 	// Attack the output root
-	claim = correctTrace.AttackClaim(ctx, claim)
+	claim = correctTrace.AttackClaim(ctx, claim, 0)
 	// Wait for the challenger to respond
 	claim = claim.WaitForCounterClaim(ctx)
 	// Then defend until the split depth to force the game into the extension part of the output root bisection
@@ -558,7 +558,7 @@ func TestDisputeOutputRootBeyondProposedBlock_InvalidOutputRoot(t *testing.T) {
 	sys, l1Client := StartFaultDisputeSystem(t)
 	t.Cleanup(sys.Close)
 
-	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys)
+	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys, daType)
 	// Root claim is dishonest
 	game := disputeGameFactory.StartOutputCannonGame(ctx, "sequencer", 1, common.Hash{0xaa})
 	correctTrace := game.CreateHonestActor(ctx, "sequencer", challenger.WithPrivKey(sys.Cfg.Secrets.Alice))
@@ -581,7 +581,7 @@ func TestDisputeOutputRootBeyondProposedBlock_InvalidOutputRoot(t *testing.T) {
 	for !claim.IsMaxDepth(ctx) {
 		game.LogGameData(ctx)
 		if claim.IsBottomGameRoot(ctx) {
-			claim = correctTrace.AttackClaim(ctx, claim)
+			claim = correctTrace.AttackClaim(ctx, claim, 0)
 		} else {
 			claim = correctTrace.DefendClaim(ctx, claim)
 		}
@@ -609,7 +609,7 @@ func TestDisputeOutputRoot_ChangeClaimedOutputRoot(t *testing.T) {
 	sys, l1Client := StartFaultDisputeSystem(t)
 	t.Cleanup(sys.Close)
 
-	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys)
+	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys, daType)
 	// Root claim is dishonest
 	game := disputeGameFactory.StartOutputCannonGame(ctx, "sequencer", 1, common.Hash{0xaa})
 	correctTrace := game.CreateHonestActor(ctx, "sequencer", challenger.WithPrivKey(sys.Cfg.Secrets.Alice))
@@ -628,7 +628,7 @@ func TestDisputeOutputRoot_ChangeClaimedOutputRoot(t *testing.T) {
 		if claim.Depth() == game.SplitDepth(ctx)-1 {
 			// Post the correct output root as the leaf.
 			// This is for block 1 which is what the original output root was for too
-			claim = correctTrace.AttackClaim(ctx, claim)
+			claim = correctTrace.AttackClaim(ctx, claim, 0)
 			// Challenger should post the first cannon trace
 			claim = claim.WaitForCounterClaim(ctx)
 			break
@@ -641,7 +641,7 @@ func TestDisputeOutputRoot_ChangeClaimedOutputRoot(t *testing.T) {
 	for !claim.IsMaxDepth(ctx) {
 		game.LogGameData(ctx)
 		if claim.IsBottomGameRoot(ctx) {
-			claim = correctTrace.AttackClaim(ctx, claim)
+			claim = correctTrace.AttackClaim(ctx, claim, 0)
 		} else {
 			claim = correctTrace.DefendClaim(ctx, claim)
 		}
@@ -673,7 +673,7 @@ func TestInvalidateUnsafeProposal(t *testing.T) {
 		{
 			name: "Attack",
 			strategy: func(correctTrace *disputegame.OutputHonestHelper, parent *disputegame.ClaimHelper) *disputegame.ClaimHelper {
-				return correctTrace.AttackClaim(ctx, parent)
+				return correctTrace.AttackClaim(ctx, parent, 0)
 			},
 		},
 		{
@@ -698,7 +698,7 @@ func TestInvalidateUnsafeProposal(t *testing.T) {
 			t.Cleanup(sys.Close)
 
 			blockNum := uint64(1)
-			disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys)
+			disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys, daType)
 			// Root claim is _dishonest_ because the required data is not available on L1
 			game := disputeGameFactory.StartOutputCannonGameWithCorrectRoot(ctx, "sequencer", blockNum, disputegame.WithUnsafeProposal())
 
@@ -709,7 +709,7 @@ func TestInvalidateUnsafeProposal(t *testing.T) {
 
 			game.DefendClaim(ctx, game.RootClaim(ctx), func(parent *disputegame.ClaimHelper) *disputegame.ClaimHelper {
 				if parent.IsBottomGameRoot(ctx) {
-					return correctTrace.AttackClaim(ctx, parent)
+					return correctTrace.AttackClaim(ctx, parent, 0)
 				}
 				return test.strategy(correctTrace, parent)
 			})
@@ -735,7 +735,7 @@ func TestInvalidateProposalForFutureBlock(t *testing.T) {
 		{
 			name: "Attack",
 			strategy: func(correctTrace *disputegame.OutputHonestHelper, parent *disputegame.ClaimHelper) *disputegame.ClaimHelper {
-				return correctTrace.AttackClaim(ctx, parent)
+				return correctTrace.AttackClaim(ctx, parent, 0)
 			},
 		},
 		{
@@ -760,7 +760,7 @@ func TestInvalidateProposalForFutureBlock(t *testing.T) {
 			t.Cleanup(sys.Close)
 
 			farFutureBlockNum := uint64(10_000_000)
-			disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys)
+			disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys, daType)
 			// Root claim is _dishonest_ because the required data is not available on L1
 			game := disputeGameFactory.StartOutputCannonGame(ctx, "sequencer", farFutureBlockNum, common.Hash{0xaa}, disputegame.WithFutureProposal())
 
@@ -771,7 +771,7 @@ func TestInvalidateProposalForFutureBlock(t *testing.T) {
 
 			game.DefendClaim(ctx, game.RootClaim(ctx), func(parent *disputegame.ClaimHelper) *disputegame.ClaimHelper {
 				if parent.IsBottomGameRoot(ctx) {
-					return correctTrace.AttackClaim(ctx, parent)
+					return correctTrace.AttackClaim(ctx, parent, 0)
 				}
 				return test.strategy(correctTrace, parent)
 			})
@@ -794,7 +794,7 @@ func TestInvalidateCorrectProposalFutureBlock(t *testing.T) {
 	t.Cleanup(sys.Close)
 
 	// Create a dispute game factory helper.
-	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys)
+	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys, 0)
 
 	// No batches submitted so safe head is genesis
 	output, err := sys.RollupClient("sequencer").OutputAtBlock(ctx, 0)
diff --git a/op-e2e2/faultproofs/precompile_test.go b/op-e2e2/faultproofs/precompile_test.go
index ea27d1fa61c0d..1b2c7a95854a6 100644
--- a/op-e2e2/faultproofs/precompile_test.go
+++ b/op-e2e2/faultproofs/precompile_test.go
@@ -9,10 +9,10 @@ import (
 	"testing"
 
 	"github.com/ethereum-optimism/optimism/cannon/mipsevm"
-	"github.com/ethereum-optimism/optimism/op-challenger/config"
-	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/cannon"
-	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/utils"
-	"github.com/ethereum-optimism/optimism/op-challenger/metrics"
+	"github.com/ethereum-optimism/optimism/op-challenger2/config"
+	"github.com/ethereum-optimism/optimism/op-challenger2/game/fault/trace/cannon"
+	"github.com/ethereum-optimism/optimism/op-challenger2/game/fault/trace/utils"
+	"github.com/ethereum-optimism/optimism/op-challenger2/metrics"
 	op_e2e "github.com/ethereum-optimism/optimism/op-e2e2"
 	"github.com/ethereum-optimism/optimism/op-e2e2/e2eutils/challenger"
 	"github.com/ethereum-optimism/optimism/op-e2e2/e2eutils/wait"
@@ -143,7 +143,7 @@ func runCannon(t *testing.T, ctx context.Context, sys *op_e2e.System, inputs uti
 	cannonOpts := challenger.WithCannon(t, sys.RollupCfg(), sys.L2Genesis())
 	dir := t.TempDir()
 	proofsDir := filepath.Join(dir, "cannon-proofs")
-	cfg := config.NewConfig(common.Address{}, l1Endpoint, l1Beacon, rollupEndpoint, l2Endpoint, dir)
+	cfg := config.NewConfig(common.Address{}, l1Endpoint, l1Beacon, rollupEndpoint, l2Endpoint, dir, config.DACalldata)
 	cannonOpts(&cfg)
 
 	logger := testlog.Logger(t, log.LevelInfo).New("role", "cannon")
diff --git a/op-e2e2/faultproofs/preimages_test.go b/op-e2e2/faultproofs/preimages_test.go
index cdcd422f77077..860f9d225a0d3 100644
--- a/op-e2e2/faultproofs/preimages_test.go
+++ b/op-e2e2/faultproofs/preimages_test.go
@@ -35,7 +35,7 @@ func TestLocalPreimages(t *testing.T) {
 			sys, _ := StartFaultDisputeSystem(t)
 			t.Cleanup(sys.Close)
 
-			disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys)
+			disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys, daType)
 			game := disputeGameFactory.StartOutputCannonGame(ctx, "sequencer", 3, common.Hash{0x01, 0xaa})
 			require.NotNil(t, game)
 			claim := game.DisputeLastBlock(ctx)
diff --git a/op-service/sources/batching/event_call.go b/op-service/sources/batching/event_call.go
index 01e09b9fc359c..e6ffec94b32f6 100644
--- a/op-service/sources/batching/event_call.go
+++ b/op-service/sources/batching/event_call.go
@@ -1,31 +1,35 @@
 package batching
 
 import (
+	"errors"
+	"fmt"
+	"math/big"
+
 	"github.com/ethereum-optimism/optimism/op-service/sources/batching/rpcblock"
 	"github.com/ethereum/go-ethereum"
-	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/rpc"
 )
 
 type EventCall struct {
-	topics [][]common.Hash
-	to     []common.Address
+	query ethereum.FilterQuery
 }
 
 func NewEventCall(q ethereum.FilterQuery) *EventCall {
-	return &EventCall{
-		topics: q.Topics,
-		to:     q.Addresses,
-	}
+	return &EventCall{query: q}
 }
 
 func (b *EventCall) ToBatchElemCreator() (BatchElementCreator, error) {
+	arg, err := toFilterArg(b.query)
+	if err != nil {
+		return nil, err
+	}
 	return func(block rpcblock.Block) (any, rpc.BatchElem) {
 		out := new([]types.Log)
 		return out, rpc.BatchElem{
-			Method: "eth_getFilterLogs",
-			Args:   []interface{}{b.topics, b.to[0], block.ArgValue()},
+			Method: "eth_getLogs",
+			Args:   []interface{}{arg},
 			Result: &out,
 		}
 	}, nil
@@ -35,3 +39,39 @@ func (c *EventCall) HandleResult(result interface{}) (*CallResult, error) {
 	res := result.(*[]types.Log)
 	return &CallResult{out: []interface{}{*res}}, nil
 }
+
+func toFilterArg(q ethereum.FilterQuery) (interface{}, error) {
+	arg := map[string]interface{}{
+		"address": q.Addresses,
+		"topics":  q.Topics,
+	}
+	if q.BlockHash != nil {
+		arg["blockHash"] = *q.BlockHash
+		if q.FromBlock != nil || q.ToBlock != nil {
+			return nil, errors.New("cannot specify both BlockHash and FromBlock/ToBlock")
+		}
+	} else {
+		if q.FromBlock == nil {
+			arg["fromBlock"] = "0x0"
+		} else {
+			arg["fromBlock"] = toBlockNumArg(q.FromBlock)
+		}
+		arg["toBlock"] = toBlockNumArg(q.ToBlock)
+	}
+	return arg, nil
+}
+
+func toBlockNumArg(number *big.Int) string {
+	if number == nil {
+		return "latest"
+	}
+	if number.Sign() >= 0 {
+		return hexutil.EncodeBig(number)
+	}
+	// It's negative.
+	if number.IsInt64() {
+		return rpc.BlockNumber(number.Int64()).String()
+	}
+	// It's negative and large, which is invalid.
+	return fmt.Sprintf("<invalid %d>", number)
+}
diff --git a/op-service/sources/batching/event_call_test.go b/op-service/sources/batching/event_call_test.go
index 6144e34bd402e..01e41901872b0 100644
--- a/op-service/sources/batching/event_call_test.go
+++ b/op-service/sources/batching/event_call_test.go
@@ -57,7 +57,7 @@ func TestEventLogFilter(t *testing.T) {
 		out[i] = r
 	}
 
-	stub.SetFilterLogResponse(topics, addr, block, _out)
+	stub.SetFilterLogResponse(topics, []common.Address{addr}, block, _out)
 	caller := NewMultiCaller(stub, DefaultBatchSize)
 
 	filter, err := batchingTest.NewERC20Filterer(addr, caller)
diff --git a/op-service/sources/batching/test/abi_stub.go b/op-service/sources/batching/test/abi_stub.go
index d29d2f22045be..7fe0635135f12 100644
--- a/op-service/sources/batching/test/abi_stub.go
+++ b/op-service/sources/batching/test/abi_stub.go
@@ -149,7 +149,7 @@ func (l *AbiBasedRpc) SetResponse(to common.Address, method string, block rpcblo
 	})
 }
 
-func (l *AbiBasedRpc) SetFilterLogResponse(topics [][]common.Hash, to common.Address, block rpcblock.Block, output []types.Log) {
+func (l *AbiBasedRpc) SetFilterLogResponse(topics [][]common.Hash, to []common.Address, block rpcblock.Block, output []types.Log) {
 	if output == nil {
 		output = []types.Log{}
 	}
@@ -162,9 +162,9 @@ func (l *AbiBasedRpc) SetFilterLogResponse(topics [][]common.Hash, to common.Add
 	})
 }
 
-func (l *AbiBasedRpc) SetGetTxByHashResponse(txHash common.Hash, output []byte) {
+func (l *AbiBasedRpc) SetGetTxByHashResponse(txHash common.Hash, output *types.Transaction) {
 	if output == nil {
-		output = []byte{}
+		output = &types.Transaction{}
 	}
 	l.AddExpectedCall(&expectedGetTxByHashCall{txHash: txHash, outputs: output})
 }
diff --git a/op-service/sources/batching/test/event_stub.go b/op-service/sources/batching/test/event_stub.go
index 6b46d385f8191..29a00c6932148 100644
--- a/op-service/sources/batching/test/event_stub.go
+++ b/op-service/sources/batching/test/event_stub.go
@@ -14,28 +14,32 @@ import (
 
 type expectedFilterLogsCall struct {
 	topics  [][]common.Hash
-	to      common.Address
+	to      []common.Address
 	block   rpcblock.Block
 	outputs []types.Log
 	err     error
 }
 
 func (c *expectedFilterLogsCall) Matches(rpcMethod string, args ...interface{}) error {
-	if rpcMethod != "eth_getFilterLogs" {
-		return fmt.Errorf("expected rpcMethod eth_getFilterLogs but was %v", rpcMethod)
+	if rpcMethod != "eth_getLogs" {
+		return fmt.Errorf("expected rpcMethod eth_getLogs but was %v", rpcMethod)
 	}
 
-	topics, ok := args[0].([][]common.Hash)
+	query, ok := args[0].(map[string]interface{})
 	if !ok {
-		return fmt.Errorf("arg 0 is not [][]common.Hash")
+		return fmt.Errorf("arg 0 is not map[string]interface{}")
+	}
+	topics := query["topics"].([][]common.Hash)
+	if !ok {
+		return fmt.Errorf("topics is not [][]common.Hash")
 	}
 
 	if !reflect.DeepEqual(topics, c.topics) {
 		return fmt.Errorf("expected topics %v but was %v", c.topics, topics)
 	}
 
-	to := args[1].(common.Address)
-	if to != c.to {
+	to := query["address"].([]common.Address)
+	if !reflect.DeepEqual(to, c.to) {
 		return fmt.Errorf("expected contract address %v but was %v", c.to, to)
 	}
 	return c.err
@@ -52,7 +56,7 @@ func (c *expectedFilterLogsCall) String() string {
 	return fmt.Sprintf("{to: %v, block: %v, outputs: %v}", c.to, c.block, c.outputs)
 }
 
-func (l *RpcStub) SetFilterLogResponse(topics [][]common.Hash, to common.Address, block rpcblock.Block, output []types.Log) {
+func (l *RpcStub) SetFilterLogResponse(topics [][]common.Hash, to []common.Address, block rpcblock.Block, output []types.Log) {
 	if output == nil {
 		output = []types.Log{}
 	}
diff --git a/op-service/sources/batching/test/generic_stub.go b/op-service/sources/batching/test/generic_stub.go
index d79d121d4363a..ffbc1ac6af5dd 100644
--- a/op-service/sources/batching/test/generic_stub.go
+++ b/op-service/sources/batching/test/generic_stub.go
@@ -11,6 +11,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-service/sources/batching/rpcblock"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -80,11 +81,11 @@ func NewGetBalanceCall(addr common.Address, block rpcblock.Block, balance *big.I
 	}
 }
 
-func NewGetTxCall(txHash common.Hash, block rpcblock.Block, out *[]byte) ExpectedRpcCall {
+func NewGetTxCall(txHash common.Hash, block rpcblock.Block, out *types.Transaction) ExpectedRpcCall {
 	return &GenericExpectedCall{
 		method: "eth_getTransactionByHash",
-		args:   []interface{}{txHash, block.ArgValue()},
-		result: hexutil.Encode(*out),
+		args:   []interface{}{txHash},
+		result: out,
 	}
 }
 
diff --git a/op-service/sources/batching/test/tx_stub.go b/op-service/sources/batching/test/tx_stub.go
index 4b14a7592781c..562093d3187c1 100644
--- a/op-service/sources/batching/test/tx_stub.go
+++ b/op-service/sources/batching/test/tx_stub.go
@@ -6,13 +6,13 @@ import (
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/stretchr/testify/require"
 )
 
 type expectedGetTxByHashCall struct {
 	txHash  common.Hash
-	outputs []byte
+	outputs *types.Transaction
 	err     error
 }
 
@@ -34,7 +34,7 @@ func (c *expectedGetTxByHashCall) Matches(rpcMethod string, args ...interface{})
 }
 
 func (c *expectedGetTxByHashCall) Execute(t *testing.T, out interface{}) error {
-	j, err := json.Marshal(hexutil.Bytes(c.outputs))
+	j, err := json.Marshal(c.outputs)
 	require.NoError(t, err)
 	require.NoError(t, json.Unmarshal(j, out))
 	return c.err
diff --git a/op-service/sources/batching/tx_call.go b/op-service/sources/batching/tx_call.go
index de3d223e2e5d4..e5a0c3b9bf4cf 100644
--- a/op-service/sources/batching/tx_call.go
+++ b/op-service/sources/batching/tx_call.go
@@ -6,7 +6,6 @@ import (
 	"github.com/ethereum-optimism/optimism/op-service/sources/batching/rpcblock"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/rpc"
 )
@@ -27,25 +26,19 @@ func NewTxGetByHash(abi *abi.ABI, txhash common.Hash, method string) *TxGetByHas
 
 func (b *TxGetByHashCall) ToBatchElemCreator() (BatchElementCreator, error) {
 	return func(block rpcblock.Block) (any, rpc.BatchElem) {
-		out := new(hexutil.Bytes)
+		out := new(types.Transaction)
 		return out, rpc.BatchElem{
 			Method: "eth_getTransactionByHash",
-			Args:   []interface{}{b.TxHash, block.ArgValue()},
+			Args:   []interface{}{b.TxHash},
 			Result: &out,
 		}
 	}, nil
 }
 
 func (c *TxGetByHashCall) HandleResult(result interface{}) (*CallResult, error) {
-	res, ok := result.(*hexutil.Bytes)
+	txn, ok := result.(*types.Transaction)
 	if !ok {
-		return nil, fmt.Errorf("result is not hexutil.Bytes")
-	}
-
-	txn := new(types.Transaction)
-	err := txn.UnmarshalBinary(*res)
-	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("result is not types.Transaction")
 	}
 	return &CallResult{out: []interface{}{txn}}, nil
 }
diff --git a/op-service/sources/batching/tx_call_test.go b/op-service/sources/batching/tx_call_test.go
index 7dfdefb883352..b92d3cd1d880f 100644
--- a/op-service/sources/batching/tx_call_test.go
+++ b/op-service/sources/batching/tx_call_test.go
@@ -31,11 +31,9 @@ func TestUnpackTxCalldata(t *testing.T) {
 		Data:     inputData,
 	})
 	require.NoError(t, err)
-	packed, err := tx.MarshalBinary()
-	require.NoError(t, err)
 
 	stub := test.NewRpcStub(t)
-	stub.AddExpectedCall(test.NewGetTxCall(txHash, rpcblock.Latest, &packed))
+	stub.AddExpectedCall(test.NewGetTxCall(txHash, rpcblock.Latest, tx))
 
 	caller := NewMultiCaller(stub, DefaultBatchSize)
 	txCall := NewTxGetByHash(testAbi, txHash, "approve")
diff --git a/packages/contracts-bedrock/scripts/Deploy.s.sol b/packages/contracts-bedrock/scripts/Deploy.s.sol
index 6abe05b612940..76708c9b728b4 100644
--- a/packages/contracts-bedrock/scripts/Deploy.s.sol
+++ b/packages/contracts-bedrock/scripts/Deploy.s.sol
@@ -35,6 +35,7 @@ import { DataAvailabilityChallenge } from "src/L1/DataAvailabilityChallenge.sol"
 import { Constants } from "src/libraries/Constants.sol";
 import { DisputeGameFactory } from "src/dispute/DisputeGameFactory.sol";
 import { FaultDisputeGame } from "src/dispute/FaultDisputeGame.sol";
+import "src/dispute/FaultDisputeGameN.sol" as FdgN;
 import { PermissionedDisputeGame } from "src/dispute/PermissionedDisputeGame.sol";
 import { DelayedWETH } from "src/dispute/weth/DelayedWETH.sol";
 import { AnchorStateRegistry } from "src/dispute/AnchorStateRegistry.sol";
@@ -1420,7 +1421,7 @@ contract Deploy is Deployer {
                     new AlphabetVM(outputAbsolutePrestate, PreimageOracle(mustGetAddress("PreimageOracle")), 4)
                 ),
                 // The max depth for the alphabet trace is always 3. Add 1 because split depth is fully inclusive.
-                maxGameDepth: cfg.faultGameSplitDepth() + 3 + 1
+                maxGameDepth: 12
             })
         });
     }
@@ -1443,21 +1444,39 @@ contract Deploy is Deployer {
 
         uint32 rawGameType = GameType.unwrap(_params.gameType);
         if (rawGameType != GameTypes.PERMISSIONED_CANNON.raw()) {
-            _factory.setImplementation(
-                _params.gameType,
-                new FaultDisputeGame({
-                    _gameType: _params.gameType,
-                    _absolutePrestate: _params.absolutePrestate,
-                    _maxGameDepth: _params.maxGameDepth,
-                    _splitDepth: cfg.faultGameSplitDepth(),
-                    _clockExtension: Duration.wrap(uint64(cfg.faultGameClockExtension())),
-                    _maxClockDuration: Duration.wrap(uint64(cfg.faultGameMaxClockDuration())),
-                    _vm: _params.faultVm,
-                    _weth: _params.weth,
-                    _anchorStateRegistry: _params.anchorStateRegistry,
-                    _l2ChainId: cfg.l2ChainID()
-                })
-            );
+            if (_params.gameType.raw() == GameTypes.ALPHABET.raw()) {
+                _factory.setImplementation(
+                    _params.gameType,
+                    new FdgN.FaultDisputeGame({
+                        _gameType: _params.gameType,
+                        _absolutePrestate: _params.absolutePrestate,
+                        _maxGameDepth: _params.maxGameDepth,
+                        _splitDepth: 4,
+                        _clockExtension: Duration.wrap(uint64(cfg.faultGameClockExtension())),
+                        _maxClockDuration: Duration.wrap(uint64(cfg.faultGameMaxClockDuration())),
+                        _vm: _params.faultVm,
+                        _weth: _params.weth,
+                        _anchorStateRegistry: _params.anchorStateRegistry,
+                        _l2ChainId: cfg.l2ChainID()
+                    })
+                );
+            } else {
+                _factory.setImplementation(
+                    _params.gameType,
+                    new FaultDisputeGame({
+                        _gameType: _params.gameType,
+                        _absolutePrestate: _params.absolutePrestate,
+                        _maxGameDepth: _params.maxGameDepth,
+                        _splitDepth: cfg.faultGameSplitDepth(),
+                        _clockExtension: Duration.wrap(uint64(cfg.faultGameClockExtension())),
+                        _maxClockDuration: Duration.wrap(uint64(cfg.faultGameMaxClockDuration())),
+                        _vm: _params.faultVm,
+                        _weth: _params.weth,
+                        _anchorStateRegistry: _params.anchorStateRegistry,
+                        _l2ChainId: cfg.l2ChainID()
+                    })
+                );
+            }
         } else {
             _factory.setImplementation(
                 _params.gameType,
diff --git a/packages/contracts-bedrock/snapshots/abi/FaultDisputeGameN.json b/packages/contracts-bedrock/snapshots/abi/FaultDisputeGameN.json
index e76bb6f238045..24fb50cc645e8 100644
--- a/packages/contracts-bedrock/snapshots/abi/FaultDisputeGameN.json
+++ b/packages/contracts-bedrock/snapshots/abi/FaultDisputeGameN.json
@@ -1,1292 +1,1292 @@
 [
-    {
-        "type": "constructor",
-        "inputs": [
-            {
-                "name": "_gameType",
-                "type": "uint32",
-                "internalType": "GameType"
-            },
-            {
-                "name": "_absolutePrestate",
-                "type": "bytes32",
-                "internalType": "Claim"
-            },
-            {
-                "name": "_maxGameDepth",
-                "type": "uint256",
-                "internalType": "uint256"
-            },
-            {
-                "name": "_splitDepth",
-                "type": "uint256",
-                "internalType": "uint256"
-            },
-            {
-                "name": "_clockExtension",
-                "type": "uint64",
-                "internalType": "Duration"
-            },
-            {
-                "name": "_maxClockDuration",
-                "type": "uint64",
-                "internalType": "Duration"
-            },
-            {
-                "name": "_vm",
-                "type": "address",
-                "internalType": "contract IBigStepper"
-            },
-            {
-                "name": "_weth",
-                "type": "address",
-                "internalType": "contract IDelayedWETH"
-            },
-            {
-                "name": "_anchorStateRegistry",
-                "type": "address",
-                "internalType": "contract IAnchorStateRegistry"
-            },
-            {
-                "name": "_l2ChainId",
-                "type": "uint256",
-                "internalType": "uint256"
-            }
-        ],
-        "stateMutability": "nonpayable"
-    },
-    {
-        "type": "function",
-        "name": "MAX_ATTACK_BRANCH",
-        "inputs": [],
-        "outputs": [
-            {
-                "name": "",
-                "type": "uint256",
-                "internalType": "uint256"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "N_BITS",
-        "inputs": [],
-        "outputs": [
-            {
-                "name": "",
-                "type": "uint256",
-                "internalType": "uint256"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "absolutePrestate",
-        "inputs": [],
-        "outputs": [
-            {
-                "name": "absolutePrestate_",
-                "type": "bytes32",
-                "internalType": "Claim"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "addLocalData",
-        "inputs": [
-            {
-                "name": "_ident",
-                "type": "uint256",
-                "internalType": "uint256"
-            },
-            {
-                "name": "_execLeafIdx",
-                "type": "uint256",
-                "internalType": "uint256"
-            },
-            {
-                "name": "_partOffset",
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "_gameType",
+        "type": "uint32",
+        "internalType": "GameType"
+      },
+      {
+        "name": "_absolutePrestate",
+        "type": "bytes32",
+        "internalType": "Claim"
+      },
+      {
+        "name": "_maxGameDepth",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "_splitDepth",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "_clockExtension",
+        "type": "uint64",
+        "internalType": "Duration"
+      },
+      {
+        "name": "_maxClockDuration",
+        "type": "uint64",
+        "internalType": "Duration"
+      },
+      {
+        "name": "_vm",
+        "type": "address",
+        "internalType": "contract IBigStepper"
+      },
+      {
+        "name": "_weth",
+        "type": "address",
+        "internalType": "contract IDelayedWETH"
+      },
+      {
+        "name": "_anchorStateRegistry",
+        "type": "address",
+        "internalType": "contract IAnchorStateRegistry"
+      },
+      {
+        "name": "_l2ChainId",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "MAX_ATTACK_BRANCH",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "N_BITS",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "absolutePrestate",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "absolutePrestate_",
+        "type": "bytes32",
+        "internalType": "Claim"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "addLocalData",
+    "inputs": [
+      {
+        "name": "_ident",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "_execLeafIdx",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "_partOffset",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "addLocalData2",
+    "inputs": [
+      {
+        "name": "_ident",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "_execLeafIdx",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "_partOffset",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "_daItem",
+        "type": "tuple",
+        "internalType": "struct LibDA.DAItem",
+        "components": [
+          {
+            "name": "daType",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "dataHash",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "proof",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "uuid_",
+        "type": "bytes32",
+        "internalType": "Hash"
+      },
+      {
+        "name": "value_",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "anchorStateRegistry",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "registry_",
+        "type": "address",
+        "internalType": "contract IAnchorStateRegistry"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "attack",
+    "inputs": [
+      {
+        "name": "_disputed",
+        "type": "bytes32",
+        "internalType": "Claim"
+      },
+      {
+        "name": "_parentIndex",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "_claim",
+        "type": "bytes32",
+        "internalType": "Claim"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "attackV2",
+    "inputs": [
+      {
+        "name": "_disputed",
+        "type": "bytes32",
+        "internalType": "Claim"
+      },
+      {
+        "name": "_parentIndex",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "_attackBranch",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "_daType",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "_claims",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "challengeRootL2Block",
+    "inputs": [
+      {
+        "name": "_outputRootProof",
+        "type": "tuple",
+        "internalType": "struct Types.OutputRootProof",
+        "components": [
+          {
+            "name": "version",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "stateRoot",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "messagePasserStorageRoot",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "latestBlockhash",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "_headerRLP",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "claimCredit",
+    "inputs": [
+      {
+        "name": "_recipient",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "claimData",
+    "inputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "parentIndex",
+        "type": "uint32",
+        "internalType": "uint32"
+      },
+      {
+        "name": "counteredBy",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "claimant",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "bond",
+        "type": "uint128",
+        "internalType": "uint128"
+      },
+      {
+        "name": "claim",
+        "type": "bytes32",
+        "internalType": "Claim"
+      },
+      {
+        "name": "position",
+        "type": "uint128",
+        "internalType": "Position"
+      },
+      {
+        "name": "clock",
+        "type": "uint128",
+        "internalType": "Clock"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "claimDataLen",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "len_",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "claims",
+    "inputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "Hash"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "clockExtension",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "clockExtension_",
+        "type": "uint64",
+        "internalType": "Duration"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "createdAt",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint64",
+        "internalType": "Timestamp"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "credit",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "defend",
+    "inputs": [
+      {
+        "name": "_disputed",
+        "type": "bytes32",
+        "internalType": "Claim"
+      },
+      {
+        "name": "_parentIndex",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "_claim",
+        "type": "bytes32",
+        "internalType": "Claim"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "extraData",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "extraData_",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "gameCreator",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "creator_",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "gameData",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "gameType_",
+        "type": "uint32",
+        "internalType": "GameType"
+      },
+      {
+        "name": "rootClaim_",
+        "type": "bytes32",
+        "internalType": "Claim"
+      },
+      {
+        "name": "extraData_",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "gameType",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "gameType_",
+        "type": "uint32",
+        "internalType": "GameType"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getChallengerDuration",
+    "inputs": [
+      {
+        "name": "_claimIndex",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "duration_",
+        "type": "uint64",
+        "internalType": "Duration"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getNumToResolve",
+    "inputs": [
+      {
+        "name": "_claimIndex",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "numRemainingChildren_",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getRequiredBond",
+    "inputs": [
+      {
+        "name": "_position",
+        "type": "uint128",
+        "internalType": "Position"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "requiredBond_",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "initialize",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "l1Head",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "l1Head_",
+        "type": "bytes32",
+        "internalType": "Hash"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "l2BlockNumber",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "l2BlockNumber_",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "l2BlockNumberChallenged",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "l2BlockNumberChallenger",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "l2ChainId",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "l2ChainId_",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "maxAttackBranch",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "maxAttackBranch_",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "maxClockDuration",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "maxClockDuration_",
+        "type": "uint64",
+        "internalType": "Duration"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "maxGameDepth",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "maxGameDepth_",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "move",
+    "inputs": [
+      {
+        "name": "_disputed",
+        "type": "bytes32",
+        "internalType": "Claim"
+      },
+      {
+        "name": "_challengeIndex",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "_claim",
+        "type": "bytes32",
+        "internalType": "Claim"
+      },
+      {
+        "name": "_isAttack",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "nBits",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "nBits_",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "resolutionCheckpoints",
+    "inputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "initialCheckpointComplete",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "subgameIndex",
+        "type": "uint32",
+        "internalType": "uint32"
+      },
+      {
+        "name": "leftmostPosition",
+        "type": "uint128",
+        "internalType": "Position"
+      },
+      {
+        "name": "counteredBy",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "resolve",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "status_",
+        "type": "uint8",
+        "internalType": "enum GameStatus"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "resolveClaim",
+    "inputs": [
+      {
+        "name": "_claimIndex",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "_numToResolve",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "resolvedAt",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint64",
+        "internalType": "Timestamp"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "resolvedSubgames",
+    "inputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "rootClaim",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "rootClaim_",
+        "type": "bytes32",
+        "internalType": "Claim"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "splitDepth",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "splitDepth_",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "startingBlockNumber",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "startingBlockNumber_",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "startingOutputRoot",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "root",
+        "type": "bytes32",
+        "internalType": "Hash"
+      },
+      {
+        "name": "l2BlockNumber",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "startingRootHash",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "startingRootHash_",
+        "type": "bytes32",
+        "internalType": "Hash"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "status",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint8",
+        "internalType": "enum GameStatus"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "step",
+    "inputs": [
+      {
+        "name": "_claimIndex",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "_isAttack",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "_stateData",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "_proof",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "stepV2",
+    "inputs": [
+      {
+        "name": "_claimIndex",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "_attackBranch",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "_stateData",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "_proof",
+        "type": "tuple",
+        "internalType": "struct FaultDisputeGame.StepProof",
+        "components": [
+          {
+            "name": "preStateItem",
+            "type": "tuple",
+            "internalType": "struct LibDA.DAItem",
+            "components": [
+              {
+                "name": "daType",
                 "type": "uint256",
                 "internalType": "uint256"
-            },
-            {
-                "name": "_daItem",
-                "type": "tuple",
-                "internalType": "struct LibDA.DAItem",
-                "components": [
-                    {
-                        "name": "daType",
-                        "type": "uint256",
-                        "internalType": "uint256"
-                    },
-                    {
-                        "name": "dataHash",
-                        "type": "bytes32",
-                        "internalType": "bytes32"
-                    },
-                    {
-                        "name": "proof",
-                        "type": "bytes",
-                        "internalType": "bytes"
-                    }
-                ]
-            }
-        ],
-        "outputs": [
-            {
-                "name": "uuid_",
-                "type": "bytes32",
-                "internalType": "Hash"
-            },
-            {
-                "name": "value_",
+              },
+              {
+                "name": "dataHash",
                 "type": "bytes32",
                 "internalType": "bytes32"
-            }
-        ],
-        "stateMutability": "nonpayable"
-    },
-    {
-        "type": "function",
-        "name": "addLocalData",
-        "inputs": [
-            {
-                "name": "_ident",
-                "type": "uint256",
-                "internalType": "uint256"
-            },
-            {
-                "name": "_execLeafIdx",
-                "type": "uint256",
-                "internalType": "uint256"
-            },
-            {
-                "name": "_partOffset",
-                "type": "uint256",
-                "internalType": "uint256"
-            }
-        ],
-        "outputs": [],
-        "stateMutability": "nonpayable"
-    },
-    {
-        "type": "function",
-        "name": "anchorStateRegistry",
-        "inputs": [],
-        "outputs": [
-            {
-                "name": "registry_",
-                "type": "address",
-                "internalType": "contract IAnchorStateRegistry"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "attack",
-        "inputs": [
-            {
-                "name": "_disputed",
-                "type": "bytes32",
-                "internalType": "Claim"
-            },
-            {
-                "name": "_parentIndex",
-                "type": "uint256",
-                "internalType": "uint256"
-            },
-            {
-                "name": "_claim",
-                "type": "bytes32",
-                "internalType": "Claim"
-            }
-        ],
-        "outputs": [],
-        "stateMutability": "payable"
-    },
-    {
-        "type": "function",
-        "name": "attackV2",
-        "inputs": [
-            {
-                "name": "_disputed",
-                "type": "bytes32",
-                "internalType": "Claim"
-            },
-            {
-                "name": "_parentIndex",
-                "type": "uint256",
-                "internalType": "uint256"
-            },
-            {
-                "name": "_attackBranch",
-                "type": "uint256",
-                "internalType": "uint256"
-            },
-            {
-                "name": "_daType",
-                "type": "uint256",
-                "internalType": "uint256"
-            },
-            {
-                "name": "_claims",
+              },
+              {
+                "name": "proof",
                 "type": "bytes",
                 "internalType": "bytes"
-            }
-        ],
-        "outputs": [],
-        "stateMutability": "payable"
-    },
-    {
-        "type": "function",
-        "name": "challengeRootL2Block",
-        "inputs": [
-            {
-                "name": "_outputRootProof",
-                "type": "tuple",
-                "internalType": "struct Types.OutputRootProof",
-                "components": [
-                    {
-                        "name": "version",
-                        "type": "bytes32",
-                        "internalType": "bytes32"
-                    },
-                    {
-                        "name": "stateRoot",
-                        "type": "bytes32",
-                        "internalType": "bytes32"
-                    },
-                    {
-                        "name": "messagePasserStorageRoot",
-                        "type": "bytes32",
-                        "internalType": "bytes32"
-                    },
-                    {
-                        "name": "latestBlockhash",
-                        "type": "bytes32",
-                        "internalType": "bytes32"
-                    }
-                ]
-            },
-            {
-                "name": "_headerRLP",
-                "type": "bytes",
-                "internalType": "bytes"
-            }
-        ],
-        "outputs": [],
-        "stateMutability": "nonpayable"
-    },
-    {
-        "type": "function",
-        "name": "claimCredit",
-        "inputs": [
-            {
-                "name": "_recipient",
-                "type": "address",
-                "internalType": "address"
-            }
-        ],
-        "outputs": [],
-        "stateMutability": "nonpayable"
-    },
-    {
-        "type": "function",
-        "name": "claimData",
-        "inputs": [
-            {
-                "name": "",
-                "type": "uint256",
-                "internalType": "uint256"
-            }
-        ],
-        "outputs": [
-            {
-                "name": "parentIndex",
-                "type": "uint32",
-                "internalType": "uint32"
-            },
-            {
-                "name": "counteredBy",
-                "type": "address",
-                "internalType": "address"
-            },
-            {
-                "name": "claimant",
-                "type": "address",
-                "internalType": "address"
-            },
-            {
-                "name": "bond",
-                "type": "uint128",
-                "internalType": "uint128"
-            },
-            {
-                "name": "claim",
-                "type": "bytes32",
-                "internalType": "Claim"
-            },
-            {
-                "name": "position",
-                "type": "uint128",
-                "internalType": "Position"
-            },
-            {
-                "name": "clock",
-                "type": "uint128",
-                "internalType": "Clock"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "claimDataLen",
-        "inputs": [],
-        "outputs": [
-            {
-                "name": "len_",
-                "type": "uint256",
-                "internalType": "uint256"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "claims",
-        "inputs": [
-            {
-                "name": "",
-                "type": "bytes32",
-                "internalType": "Hash"
-            }
-        ],
-        "outputs": [
-            {
-                "name": "",
-                "type": "bool",
-                "internalType": "bool"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "clockExtension",
-        "inputs": [],
-        "outputs": [
-            {
-                "name": "clockExtension_",
-                "type": "uint64",
-                "internalType": "Duration"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "createdAt",
-        "inputs": [],
-        "outputs": [
-            {
-                "name": "",
-                "type": "uint64",
-                "internalType": "Timestamp"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "credit",
-        "inputs": [
-            {
-                "name": "",
-                "type": "address",
-                "internalType": "address"
-            }
-        ],
-        "outputs": [
-            {
-                "name": "",
+              }
+            ]
+          },
+          {
+            "name": "postStateItem",
+            "type": "tuple",
+            "internalType": "struct LibDA.DAItem",
+            "components": [
+              {
+                "name": "daType",
                 "type": "uint256",
                 "internalType": "uint256"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "defend",
-        "inputs": [
-            {
-                "name": "_disputed",
+              },
+              {
+                "name": "dataHash",
                 "type": "bytes32",
-                "internalType": "Claim"
-            },
-            {
-                "name": "_parentIndex",
-                "type": "uint256",
-                "internalType": "uint256"
-            },
-            {
-                "name": "_claim",
-                "type": "bytes32",
-                "internalType": "Claim"
-            }
-        ],
-        "outputs": [],
-        "stateMutability": "payable"
-    },
-    {
-        "type": "function",
-        "name": "extraData",
-        "inputs": [],
-        "outputs": [
-            {
-                "name": "extraData_",
-                "type": "bytes",
-                "internalType": "bytes"
-            }
-        ],
-        "stateMutability": "pure"
-    },
-    {
-        "type": "function",
-        "name": "gameCreator",
-        "inputs": [],
-        "outputs": [
-            {
-                "name": "creator_",
-                "type": "address",
-                "internalType": "address"
-            }
-        ],
-        "stateMutability": "pure"
-    },
-    {
-        "type": "function",
-        "name": "gameData",
-        "inputs": [],
-        "outputs": [
-            {
-                "name": "gameType_",
-                "type": "uint32",
-                "internalType": "GameType"
-            },
-            {
-                "name": "rootClaim_",
-                "type": "bytes32",
-                "internalType": "Claim"
-            },
-            {
-                "name": "extraData_",
-                "type": "bytes",
-                "internalType": "bytes"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "gameType",
-        "inputs": [],
-        "outputs": [
-            {
-                "name": "gameType_",
-                "type": "uint32",
-                "internalType": "GameType"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "getChallengerDuration",
-        "inputs": [
-            {
-                "name": "_claimIndex",
-                "type": "uint256",
-                "internalType": "uint256"
-            }
-        ],
-        "outputs": [
-            {
-                "name": "duration_",
-                "type": "uint64",
-                "internalType": "Duration"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "getNumToResolve",
-        "inputs": [
-            {
-                "name": "_claimIndex",
-                "type": "uint256",
-                "internalType": "uint256"
-            }
-        ],
-        "outputs": [
-            {
-                "name": "numRemainingChildren_",
-                "type": "uint256",
-                "internalType": "uint256"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "getRequiredBond",
-        "inputs": [
-            {
-                "name": "_position",
-                "type": "uint128",
-                "internalType": "Position"
-            }
-        ],
-        "outputs": [
-            {
-                "name": "requiredBond_",
-                "type": "uint256",
-                "internalType": "uint256"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "initialize",
-        "inputs": [],
-        "outputs": [],
-        "stateMutability": "payable"
-    },
-    {
-        "type": "function",
-        "name": "l1Head",
-        "inputs": [],
-        "outputs": [
-            {
-                "name": "l1Head_",
-                "type": "bytes32",
-                "internalType": "Hash"
-            }
-        ],
-        "stateMutability": "pure"
-    },
-    {
-        "type": "function",
-        "name": "l2BlockNumber",
-        "inputs": [],
-        "outputs": [
-            {
-                "name": "l2BlockNumber_",
-                "type": "uint256",
-                "internalType": "uint256"
-            }
-        ],
-        "stateMutability": "pure"
-    },
-    {
-        "type": "function",
-        "name": "l2BlockNumberChallenged",
-        "inputs": [],
-        "outputs": [
-            {
-                "name": "",
-                "type": "bool",
-                "internalType": "bool"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "l2BlockNumberChallenger",
-        "inputs": [],
-        "outputs": [
-            {
-                "name": "",
-                "type": "address",
-                "internalType": "address"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "l2ChainId",
-        "inputs": [],
-        "outputs": [
-            {
-                "name": "l2ChainId_",
-                "type": "uint256",
-                "internalType": "uint256"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "maxAttackBranch",
-        "inputs": [],
-        "outputs": [
-            {
-                "name": "maxAttackBranch_",
-                "type": "uint256",
-                "internalType": "uint256"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "maxClockDuration",
-        "inputs": [],
-        "outputs": [
-            {
-                "name": "maxClockDuration_",
-                "type": "uint64",
-                "internalType": "Duration"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "maxGameDepth",
-        "inputs": [],
-        "outputs": [
-            {
-                "name": "maxGameDepth_",
-                "type": "uint256",
-                "internalType": "uint256"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "move",
-        "inputs": [
-            {
-                "name": "_disputed",
-                "type": "bytes32",
-                "internalType": "Claim"
-            },
-            {
-                "name": "_challengeIndex",
-                "type": "uint256",
-                "internalType": "uint256"
-            },
-            {
-                "name": "_claim",
-                "type": "bytes32",
-                "internalType": "Claim"
-            },
-            {
-                "name": "_isAttack",
-                "type": "bool",
-                "internalType": "bool"
-            }
-        ],
-        "outputs": [],
-        "stateMutability": "payable"
-    },
-    {
-        "type": "function",
-        "name": "nBits",
-        "inputs": [],
-        "outputs": [
-            {
-                "name": "nBits_",
-                "type": "uint256",
-                "internalType": "uint256"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "resolutionCheckpoints",
-        "inputs": [
-            {
-                "name": "",
-                "type": "uint256",
-                "internalType": "uint256"
-            }
-        ],
-        "outputs": [
-            {
-                "name": "initialCheckpointComplete",
-                "type": "bool",
-                "internalType": "bool"
-            },
-            {
-                "name": "subgameIndex",
-                "type": "uint32",
-                "internalType": "uint32"
-            },
-            {
-                "name": "leftmostPosition",
-                "type": "uint128",
-                "internalType": "Position"
-            },
-            {
-                "name": "counteredBy",
-                "type": "address",
-                "internalType": "address"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "resolve",
-        "inputs": [],
-        "outputs": [
-            {
-                "name": "status_",
-                "type": "uint8",
-                "internalType": "enum GameStatus"
-            }
-        ],
-        "stateMutability": "nonpayable"
-    },
-    {
-        "type": "function",
-        "name": "resolveClaim",
-        "inputs": [
-            {
-                "name": "_claimIndex",
-                "type": "uint256",
-                "internalType": "uint256"
-            },
-            {
-                "name": "_numToResolve",
-                "type": "uint256",
-                "internalType": "uint256"
-            }
-        ],
-        "outputs": [],
-        "stateMutability": "nonpayable"
-    },
-    {
-        "type": "function",
-        "name": "resolvedAt",
-        "inputs": [],
-        "outputs": [
-            {
-                "name": "",
-                "type": "uint64",
-                "internalType": "Timestamp"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "resolvedSubgames",
-        "inputs": [
-            {
-                "name": "",
-                "type": "uint256",
-                "internalType": "uint256"
-            }
-        ],
-        "outputs": [
-            {
-                "name": "",
-                "type": "bool",
-                "internalType": "bool"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "rootClaim",
-        "inputs": [],
-        "outputs": [
-            {
-                "name": "rootClaim_",
-                "type": "bytes32",
-                "internalType": "Claim"
-            }
-        ],
-        "stateMutability": "pure"
-    },
-    {
-        "type": "function",
-        "name": "splitDepth",
-        "inputs": [],
-        "outputs": [
-            {
-                "name": "splitDepth_",
-                "type": "uint256",
-                "internalType": "uint256"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "startingBlockNumber",
-        "inputs": [],
-        "outputs": [
-            {
-                "name": "startingBlockNumber_",
-                "type": "uint256",
-                "internalType": "uint256"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "startingOutputRoot",
-        "inputs": [],
-        "outputs": [
-            {
-                "name": "root",
-                "type": "bytes32",
-                "internalType": "Hash"
-            },
-            {
-                "name": "l2BlockNumber",
-                "type": "uint256",
-                "internalType": "uint256"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "startingRootHash",
-        "inputs": [],
-        "outputs": [
-            {
-                "name": "startingRootHash_",
-                "type": "bytes32",
-                "internalType": "Hash"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "status",
-        "inputs": [],
-        "outputs": [
-            {
-                "name": "",
-                "type": "uint8",
-                "internalType": "enum GameStatus"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "step",
-        "inputs": [
-            {
-                "name": "_claimIndex",
-                "type": "uint256",
-                "internalType": "uint256"
-            },
-            {
-                "name": "_isAttack",
-                "type": "bool",
-                "internalType": "bool"
-            },
-            {
-                "name": "_stateData",
-                "type": "bytes",
-                "internalType": "bytes"
-            },
-            {
-                "name": "_proof",
-                "type": "bytes",
-                "internalType": "bytes"
-            }
-        ],
-        "outputs": [],
-        "stateMutability": "nonpayable"
-    },
-    {
-        "type": "function",
-        "name": "stepV2",
-        "inputs": [
-            {
-                "name": "_claimIndex",
-                "type": "uint256",
-                "internalType": "uint256"
-            },
-            {
-                "name": "_attackBranch",
-                "type": "uint256",
-                "internalType": "uint256"
-            },
-            {
-                "name": "_stateData",
+                "internalType": "bytes32"
+              },
+              {
+                "name": "proof",
                 "type": "bytes",
                 "internalType": "bytes"
-            },
-            {
-                "name": "_proof",
-                "type": "tuple",
-                "internalType": "struct FaultDisputeGame.StepProof",
-                "components": [
-                    {
-                        "name": "preStateItem",
-                        "type": "tuple",
-                        "internalType": "struct LibDA.DAItem",
-                        "components": [
-                            {
-                                "name": "daType",
-                                "type": "uint256",
-                                "internalType": "uint256"
-                            },
-                            {
-                                "name": "dataHash",
-                                "type": "bytes32",
-                                "internalType": "bytes32"
-                            },
-                            {
-                                "name": "proof",
-                                "type": "bytes",
-                                "internalType": "bytes"
-                            }
-                        ]
-                    },
-                    {
-                        "name": "postStateItem",
-                        "type": "tuple",
-                        "internalType": "struct LibDA.DAItem",
-                        "components": [
-                            {
-                                "name": "daType",
-                                "type": "uint256",
-                                "internalType": "uint256"
-                            },
-                            {
-                                "name": "dataHash",
-                                "type": "bytes32",
-                                "internalType": "bytes32"
-                            },
-                            {
-                                "name": "proof",
-                                "type": "bytes",
-                                "internalType": "bytes"
-                            }
-                        ]
-                    },
-                    {
-                        "name": "vmProof",
-                        "type": "bytes",
-                        "internalType": "bytes"
-                    }
-                ]
-            }
-        ],
-        "outputs": [],
-        "stateMutability": "nonpayable"
-    },
-    {
-        "type": "function",
-        "name": "subgames",
-        "inputs": [
-            {
-                "name": "",
-                "type": "uint256",
-                "internalType": "uint256"
-            },
-            {
-                "name": "",
-                "type": "uint256",
-                "internalType": "uint256"
-            }
-        ],
-        "outputs": [
-            {
-                "name": "",
-                "type": "uint256",
-                "internalType": "uint256"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "version",
-        "inputs": [],
-        "outputs": [
-            {
-                "name": "",
-                "type": "string",
-                "internalType": "string"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "vm",
-        "inputs": [],
-        "outputs": [
-            {
-                "name": "vm_",
-                "type": "address",
-                "internalType": "contract IBigStepper"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "function",
-        "name": "weth",
-        "inputs": [],
-        "outputs": [
-            {
-                "name": "weth_",
-                "type": "address",
-                "internalType": "contract IDelayedWETH"
-            }
-        ],
-        "stateMutability": "view"
-    },
-    {
-        "type": "event",
-        "name": "Move",
-        "inputs": [
-            {
-                "name": "parentIndex",
-                "type": "uint256",
-                "indexed": true,
-                "internalType": "uint256"
-            },
-            {
-                "name": "claim",
-                "type": "bytes32",
-                "indexed": true,
-                "internalType": "Claim"
-            },
-            {
-                "name": "claimant",
-                "type": "address",
-                "indexed": true,
-                "internalType": "address"
-            }
-        ],
-        "anonymous": false
-    },
-    {
-        "type": "event",
-        "name": "Resolved",
-        "inputs": [
-            {
-                "name": "status",
-                "type": "uint8",
-                "indexed": true,
-                "internalType": "enum GameStatus"
-            }
-        ],
-        "anonymous": false
-    },
-    {
-        "type": "error",
-        "name": "AlreadyInitialized",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "AnchorRootNotFound",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "BlockNumberMatches",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "BondTransferFailed",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "CannotDefendRootClaim",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "ClaimAboveSplit",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "ClaimAlreadyExists",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "ClaimAlreadyResolved",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "ClockNotExpired",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "ClockTimeExceeded",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "ContentLengthMismatch",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "DuplicateStep",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "EmptyItem",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "GameDepthExceeded",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "GameNotInProgress",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "IncorrectBondAmount",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "InvalidClockExtension",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "InvalidDataRemainder",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "InvalidDisputedClaimIndex",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "InvalidHeader",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "InvalidHeaderRLP",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "InvalidLocalIdent",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "InvalidOutputRootProof",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "InvalidParent",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "InvalidPosition",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "InvalidPrestate",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "InvalidSplitDepth",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "L2BlockNumberChallenged",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "MaxDepthTooLarge",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "NoCreditToClaim",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "NotSupported",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "OutOfOrderResolution",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "UnexpectedList",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "UnexpectedRootClaim",
-        "inputs": [
-            {
-                "name": "rootClaim",
-                "type": "bytes32",
-                "internalType": "Claim"
-            }
+              }
+            ]
+          },
+          {
+            "name": "vmProof",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
         ]
-    },
-    {
-        "type": "error",
-        "name": "UnexpectedString",
-        "inputs": []
-    },
-    {
-        "type": "error",
-        "name": "ValidStep",
-        "inputs": []
-    }
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "subgames",
+    "inputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "version",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "vm",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "vm_",
+        "type": "address",
+        "internalType": "contract IBigStepper"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "weth",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "weth_",
+        "type": "address",
+        "internalType": "contract IDelayedWETH"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "event",
+    "name": "Move",
+    "inputs": [
+      {
+        "name": "parentIndex",
+        "type": "uint256",
+        "indexed": true,
+        "internalType": "uint256"
+      },
+      {
+        "name": "claim",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "Claim"
+      },
+      {
+        "name": "claimant",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Resolved",
+    "inputs": [
+      {
+        "name": "status",
+        "type": "uint8",
+        "indexed": true,
+        "internalType": "enum GameStatus"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "error",
+    "name": "AlreadyInitialized",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "AnchorRootNotFound",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "BlockNumberMatches",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "BondTransferFailed",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "CannotDefendRootClaim",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ClaimAboveSplit",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ClaimAlreadyExists",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ClaimAlreadyResolved",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ClockNotExpired",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ClockTimeExceeded",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ContentLengthMismatch",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "DuplicateStep",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "EmptyItem",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "GameDepthExceeded",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "GameNotInProgress",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "IncorrectBondAmount",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidClockExtension",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidDataRemainder",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidDisputedClaimIndex",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidHeader",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidHeaderRLP",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidLocalIdent",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidOutputRootProof",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidParent",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidPosition",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidPrestate",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidSplitDepth",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "L2BlockNumberChallenged",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "MaxDepthTooLarge",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "NoCreditToClaim",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "NotSupported",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "OutOfOrderResolution",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "UnexpectedList",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "UnexpectedRootClaim",
+    "inputs": [
+      {
+        "name": "rootClaim",
+        "type": "bytes32",
+        "internalType": "Claim"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "UnexpectedString",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ValidStep",
+    "inputs": []
+  }
 ]
diff --git a/packages/contracts-bedrock/src/dispute/FaultDisputeGameN.sol b/packages/contracts-bedrock/src/dispute/FaultDisputeGameN.sol
index 7a23f8604c47f..d3e1e99fead79 100644
--- a/packages/contracts-bedrock/src/dispute/FaultDisputeGameN.sol
+++ b/packages/contracts-bedrock/src/dispute/FaultDisputeGameN.sol
@@ -477,7 +477,7 @@ contract FaultDisputeGame is IFaultDisputeGame, Clone, ISemver {
         revert NotSupported();
     }
 
-    function addLocalData(
+    function addLocalData2(
         uint256 _ident,
         uint256 _execLeafIdx,
         uint256 _partOffset,
@@ -1209,7 +1209,12 @@ contract FaultDisputeGame is IFaultDisputeGame, Clone, ISemver {
         public
         payable
     {
-        Claim claim = Claim.wrap(LibDA.getClaimsHash(_daType, MAX_ATTACK_BRANCH, _claims));
+        uint256 nelements = MAX_ATTACK_BRANCH;
+        ClaimData storage parent = claimData[_parentIndex];
+        if (parent.position.depth() == SPLIT_DEPTH) {
+            nelements = 1;
+        }
+        Claim claim = Claim.wrap(LibDA.getClaimsHash(_daType, nelements, _claims));
         moveV2(_disputed, _parentIndex, claim, _attackBranch);
     }
 
diff --git a/packages/contracts-bedrock/test/actors/FaultDisputeActorsN.sol b/packages/contracts-bedrock/test/actors/FaultDisputeActorsN.sol
index 60e9620681f0f..c7de8680df5ad 100644
--- a/packages/contracts-bedrock/test/actors/FaultDisputeActorsN.sol
+++ b/packages/contracts-bedrock/test/actors/FaultDisputeActorsN.sol
@@ -525,7 +525,7 @@ contract HonestDisputeActor is DisputeActor {
                     dataHash: "00000000000000000000000000000000",
                     proof: hex""
                 });
-                GAME.addLocalData({
+                GAME.addLocalData2({
                     _ident: LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER,
                     _execLeafIdx: challengeIndex,
                     _partOffset: 0,
diff --git a/packages/contracts-bedrock/test/dispute/FaultDisputeGameN.t.sol b/packages/contracts-bedrock/test/dispute/FaultDisputeGameN.t.sol
index 6b7bc491c2812..390b29024975f 100644
--- a/packages/contracts-bedrock/test/dispute/FaultDisputeGameN.t.sol
+++ b/packages/contracts-bedrock/test/dispute/FaultDisputeGameN.t.sol
@@ -857,7 +857,7 @@ contract FaultDisputeGameN_Test is FaultDisputeGame_Init {
     //     (,,,, disputed,,) = gameProxy.claimData(3);
     //     gameProxy.attackV2{ value: _getRequiredBondV2(3, 0) }(disputed, 3, _dummyClaim(), 0);
 
-    //     gameProxy.addLocalData(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 4, 0);
+    //     gameProxy.addLocalData2(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 4, 0);
     //     gameProxy.stepV2(4, 0, absolutePrestateData, hex"");
 
     //     vm.expectRevert(DuplicateStep.selector);
@@ -897,7 +897,7 @@ contract FaultDisputeGameN_Test is FaultDisputeGame_Init {
         // This variable is not used
         LibDA.DAItem memory localDataItem =
             LibDA.DAItem({ daType: LibDA.DA_TYPE_CALLDATA, dataHash: "00000000000000000000000000000000", proof: hex"" });
-        gameProxy.addLocalData(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 4, 0, localDataItem);
+        gameProxy.addLocalData2(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 4, 0, localDataItem);
 
         // This variable is not used
         LibDA.DAItem memory preStateItem =
@@ -956,7 +956,7 @@ contract FaultDisputeGameN_Test is FaultDisputeGame_Init {
         FaultDisputeGame.StepProof memory stepProof =
             FaultDisputeGame.StepProof({ preStateItem: preStateItem, postStateItem: postStateItem, vmProof: hex"" });
 
-        gameProxy.addLocalData(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 4, 1, preStateItem);
+        gameProxy.addLocalData2(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 4, 1, preStateItem);
         gameProxy.stepV2({ _claimIndex: 4, _attackBranch: 1, _stateData: claimData1, _proof: stepProof });
     }
 
@@ -1003,7 +1003,7 @@ contract FaultDisputeGameN_Test is FaultDisputeGame_Init {
         FaultDisputeGame.StepProof memory stepProof =
             FaultDisputeGame.StepProof({ preStateItem: preStateItem, postStateItem: postStateItem, vmProof: hex"" });
 
-        gameProxy.addLocalData(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 4, 2, preStateItem);
+        gameProxy.addLocalData2(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 4, 2, preStateItem);
         gameProxy.stepV2({ _claimIndex: 4, _attackBranch: 2, _stateData: claimData2, _proof: stepProof });
     }
 
@@ -1051,7 +1051,7 @@ contract FaultDisputeGameN_Test is FaultDisputeGame_Init {
         FaultDisputeGame.StepProof memory stepProof =
             FaultDisputeGame.StepProof({ preStateItem: preStateItem, postStateItem: postStateItem, vmProof: hex"" });
 
-        gameProxy.addLocalData(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 4, 3, preStateItem);
+        gameProxy.addLocalData2(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 4, 3, preStateItem);
         vm.expectRevert(ValidStep.selector);
         gameProxy.stepV2({ _claimIndex: 4, _attackBranch: 3, _stateData: claimData3, _proof: stepProof });
     }
@@ -1095,10 +1095,10 @@ contract FaultDisputeGameN_Test is FaultDisputeGame_Init {
             proof: abi.encodePacked(claim2, claim3)
         });
         (, bytes32 startingOutputRoot) =
-            gameProxy.addLocalData(LocalPreimageKey.STARTING_OUTPUT_ROOT, 4, 0, startingDataItem);
+            gameProxy.addLocalData2(LocalPreimageKey.STARTING_OUTPUT_ROOT, 4, 0, startingDataItem);
         assertEq(startingOutputRoot, gameProxy.startingRootHash().raw());
         (, bytes32 disputedOutputRoot) =
-            gameProxy.addLocalData(LocalPreimageKey.DISPUTED_OUTPUT_ROOT, 4, 0, disputedDataItem);
+            gameProxy.addLocalData2(LocalPreimageKey.DISPUTED_OUTPUT_ROOT, 4, 0, disputedDataItem);
         assertEq(disputedOutputRoot, claim1.raw());
     }
 
@@ -1144,10 +1144,10 @@ contract FaultDisputeGameN_Test is FaultDisputeGame_Init {
             proof: abi.encodePacked(claim1, claim3)
         });
         (, bytes32 startingOutputRoot) =
-            gameProxy.addLocalData(LocalPreimageKey.STARTING_OUTPUT_ROOT, 4, 0, startingDataItem);
+            gameProxy.addLocalData2(LocalPreimageKey.STARTING_OUTPUT_ROOT, 4, 0, startingDataItem);
         assertEq(startingOutputRoot, claim1.raw());
         (, bytes32 disputedOutputRoot) =
-            gameProxy.addLocalData(LocalPreimageKey.DISPUTED_OUTPUT_ROOT, 4, 0, disputedDataItem);
+            gameProxy.addLocalData2(LocalPreimageKey.DISPUTED_OUTPUT_ROOT, 4, 0, disputedDataItem);
         assertEq(disputedOutputRoot, claim2.raw());
     }
 
@@ -1193,10 +1193,10 @@ contract FaultDisputeGameN_Test is FaultDisputeGame_Init {
             proof: bytes.concat(keccak256(abi.encode(claim1.raw(), claim2.raw())))
         });
         (, bytes32 startingOutputRoot) =
-            gameProxy.addLocalData(LocalPreimageKey.STARTING_OUTPUT_ROOT, 4, 0, startingDataItem);
+            gameProxy.addLocalData2(LocalPreimageKey.STARTING_OUTPUT_ROOT, 4, 0, startingDataItem);
         assertEq(startingOutputRoot, claim2.raw());
         (, bytes32 disputedOutputRoot) =
-            gameProxy.addLocalData(LocalPreimageKey.DISPUTED_OUTPUT_ROOT, 4, 0, disputedDataItem);
+            gameProxy.addLocalData2(LocalPreimageKey.DISPUTED_OUTPUT_ROOT, 4, 0, disputedDataItem);
         assertEq(disputedOutputRoot, claim3.raw());
     }
 
@@ -1242,10 +1242,10 @@ contract FaultDisputeGameN_Test is FaultDisputeGame_Init {
             proof: abi.encodePacked(claim2, claim3)
         });
         (, bytes32 startingOutputRoot) =
-            gameProxy.addLocalData(LocalPreimageKey.STARTING_OUTPUT_ROOT, 4, 0, startingDataItem);
+            gameProxy.addLocalData2(LocalPreimageKey.STARTING_OUTPUT_ROOT, 4, 0, startingDataItem);
         assertEq(startingOutputRoot, claim3.raw());
         (, bytes32 disputedOutputRoot) =
-            gameProxy.addLocalData(LocalPreimageKey.DISPUTED_OUTPUT_ROOT, 4, 0, disputedDataItem);
+            gameProxy.addLocalData2(LocalPreimageKey.DISPUTED_OUTPUT_ROOT, 4, 0, disputedDataItem);
         assertEq(disputedOutputRoot, claim1.raw());
     }
 
@@ -1287,10 +1287,10 @@ contract FaultDisputeGameN_Test is FaultDisputeGame_Init {
         });
         LibDA.DAItem memory disputedDataItem = startingDataItem;
         (, bytes32 startingOutputRoot) =
-            gameProxy.addLocalData(LocalPreimageKey.STARTING_OUTPUT_ROOT, 4, 3, startingDataItem);
+            gameProxy.addLocalData2(LocalPreimageKey.STARTING_OUTPUT_ROOT, 4, 3, startingDataItem);
         assertEq(startingOutputRoot, claim3.raw());
         (, bytes32 disputedOutputRoot) =
-            gameProxy.addLocalData(LocalPreimageKey.DISPUTED_OUTPUT_ROOT, 4, 3, disputedDataItem);
+            gameProxy.addLocalData2(LocalPreimageKey.DISPUTED_OUTPUT_ROOT, 4, 3, disputedDataItem);
         assertEq(disputedOutputRoot, claim3.raw());
     }
 
@@ -1333,10 +1333,10 @@ contract FaultDisputeGameN_Test is FaultDisputeGame_Init {
         LibDA.DAItem memory disputedDataItem =
             LibDA.DAItem({ daType: LibDA.DA_TYPE_CALLDATA, dataHash: ROOT_CLAIM.raw(), proof: hex"" });
         (, bytes32 startingOutputRoot) =
-            gameProxy.addLocalData(LocalPreimageKey.STARTING_OUTPUT_ROOT, 4, 3, startingDataItem);
+            gameProxy.addLocalData2(LocalPreimageKey.STARTING_OUTPUT_ROOT, 4, 3, startingDataItem);
         assertEq(startingOutputRoot, claim3.raw());
         (, bytes32 disputedOutputRoot) =
-            gameProxy.addLocalData(LocalPreimageKey.DISPUTED_OUTPUT_ROOT, 4, 3, disputedDataItem);
+            gameProxy.addLocalData2(LocalPreimageKey.DISPUTED_OUTPUT_ROOT, 4, 3, disputedDataItem);
         assertEq(disputedOutputRoot, ROOT_CLAIM.raw());
     }
 
@@ -1611,7 +1611,7 @@ contract FaultDisputeGameN_Test is FaultDisputeGame_Init {
         // This variable is not used
         LibDA.DAItem memory localDataItem =
             LibDA.DAItem({ daType: LibDA.DA_TYPE_CALLDATA, dataHash: "00000000000000000000000000000000", proof: hex"" });
-        gameProxy.addLocalData(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 4, 0, localDataItem);
+        gameProxy.addLocalData2(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 4, 0, localDataItem);
 
         // This variable is not used
         LibDA.DAItem memory preStateItem =
@@ -1696,7 +1696,7 @@ contract FaultDisputeGameN_Test is FaultDisputeGame_Init {
         // This variable is not used
         LibDA.DAItem memory localDataItem =
             LibDA.DAItem({ daType: LibDA.DA_TYPE_CALLDATA, dataHash: "00000000000000000000000000000000", proof: hex"" });
-        gameProxy.addLocalData(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 4, 0, localDataItem);
+        gameProxy.addLocalData2(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 4, 0, localDataItem);
 
         // This variable is not used
         LibDA.DAItem memory preStateItem =
@@ -1931,7 +1931,7 @@ contract FaultDisputeGameN_Test is FaultDisputeGame_Init {
     }
 
     /// @dev Tests that adding local data with an out of bounds identifier reverts.
-    function testFuzz_addLocalData_oob_reverts(uint256 _ident) public {
+    function testFuzz_addLocalData2_oob_reverts(uint256 _ident) public {
         Claim disputed;
         // Get a claim below the split depth so that we can add local data for an execution trace subgame.
         for (uint256 i; i < 2; i++) {
@@ -1950,12 +1950,12 @@ contract FaultDisputeGameN_Test is FaultDisputeGame_Init {
         LibDA.DAItem memory localDataItem =
             LibDA.DAItem({ daType: LibDA.DA_TYPE_CALLDATA, dataHash: "00000000000000000000000000000000", proof: hex"" });
         vm.expectRevert(InvalidLocalIdent.selector);
-        gameProxy.addLocalData(_ident, 3, 0, localDataItem);
+        gameProxy.addLocalData2(_ident, 3, 0, localDataItem);
     }
 
     /// @dev Tests that local data is loaded into the preimage oracle correctly in the subgame
     ///      that is disputing the transition from `GENESIS -> GENESIS + 1`
-    function test_addLocalDataGenesisTransition_static_succeeds() public {
+    function test_addLocalData2GenesisTransition_static_succeeds() public {
         IPreimageOracle oracle = IPreimageOracle(address(gameProxy.vm().oracle()));
         Claim disputed;
         Claim[] memory claims = generateClaims(3);
@@ -2001,9 +2001,9 @@ contract FaultDisputeGameN_Test is FaultDisputeGame_Init {
             bytes32 key = _getKey(i, keccak256(abi.encode(disputedClaim.raw(), disputedPos)));
 
             if (LocalPreimageKey.DISPUTED_OUTPUT_ROOT == i) {
-                gameProxy.addLocalData(i, 3, 0, disputedDataItem);
+                gameProxy.addLocalData2(i, 3, 0, disputedDataItem);
             } else {
-                gameProxy.addLocalData(i, 3, 0, startingDataItem);
+                gameProxy.addLocalData2(i, 3, 0, startingDataItem);
             }
             (bytes32 dat, uint256 datLen) = oracle.readPreimage(key, 0);
             assertEq(dat >> 0xC0, bytes32(expectedLen));
@@ -2015,9 +2015,9 @@ contract FaultDisputeGameN_Test is FaultDisputeGame_Init {
             assertEq(datLen, expectedLen + (i > 3 ? 8 : 0));
 
             if (LocalPreimageKey.DISPUTED_OUTPUT_ROOT == i) {
-                gameProxy.addLocalData(i, 3, 8, disputedDataItem);
+                gameProxy.addLocalData2(i, 3, 8, disputedDataItem);
             } else {
-                gameProxy.addLocalData(i, 3, 8, startingDataItem);
+                gameProxy.addLocalData2(i, 3, 8, startingDataItem);
             }
             (dat, datLen) = oracle.readPreimage(key, 8);
             assertEq(dat, data[i - 1]);
@@ -2026,7 +2026,7 @@ contract FaultDisputeGameN_Test is FaultDisputeGame_Init {
     }
 
     /// @dev Tests that local data is loaded into the preimage oracle correctly.
-    function test_addLocalDataMiddle_static_succeeds() public {
+    function test_addLocalData2Middle_static_succeeds() public {
         IPreimageOracle oracle = IPreimageOracle(address(gameProxy.vm().oracle()));
         Claim[] memory claims = generateClaims(3);
         Claim root = Claim.wrap(
@@ -2073,9 +2073,9 @@ contract FaultDisputeGameN_Test is FaultDisputeGame_Init {
             bytes32 key = _getKey(i, keccak256(abi.encode(root.raw(), startingPos, root.raw(), disputedPos)));
 
             if (LocalPreimageKey.DISPUTED_OUTPUT_ROOT == i) {
-                gameProxy.addLocalData(i, 3, 0, disputedDataItem);
+                gameProxy.addLocalData2(i, 3, 0, disputedDataItem);
             } else {
-                gameProxy.addLocalData(i, 3, 0, startingDataItem);
+                gameProxy.addLocalData2(i, 3, 0, startingDataItem);
             }
             (bytes32 dat, uint256 datLen) = oracle.readPreimage(key, 0);
             assertEq(dat >> 0xC0, bytes32(expectedLen));
@@ -2087,9 +2087,9 @@ contract FaultDisputeGameN_Test is FaultDisputeGame_Init {
             assertEq(datLen, expectedLen + (i > 3 ? 8 : 0));
 
             if (LocalPreimageKey.DISPUTED_OUTPUT_ROOT == i) {
-                gameProxy.addLocalData(i, 3, 8, disputedDataItem);
+                gameProxy.addLocalData2(i, 3, 8, disputedDataItem);
             } else {
-                gameProxy.addLocalData(i, 3, 8, startingDataItem);
+                gameProxy.addLocalData2(i, 3, 8, startingDataItem);
             }
             (dat, datLen) = oracle.readPreimage(key, 8);
             assertEq(dat, data[i - 1]);
@@ -2262,7 +2262,7 @@ contract FaultDisputeGameN_Test is FaultDisputeGame_Init {
 
         LibDA.DAItem memory dummyDataItem =
             LibDA.DAItem({ daType: LibDA.DA_TYPE_CALLDATA, dataHash: _dummyClaim().raw(), proof: hex"" });
-        gameProxy.addLocalData(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 4, 2, dummyDataItem);
+        gameProxy.addLocalData2(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 4, 2, dummyDataItem);
 
         LibDA.DAItem memory preStateItem = LibDA.DAItem({
             daType: LibDA.DA_TYPE_CALLDATA,
@@ -2357,7 +2357,7 @@ contract FaultDisputeGameN_LessSplitDepth_Test is FaultDisputeGame_Init {
         FaultDisputeGame.StepProof memory stepProof =
             FaultDisputeGame.StepProof({ preStateItem: preStateItem, postStateItem: postStateItem, vmProof: hex"" });
 
-        gameProxy.addLocalData(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 4, 3, preStateItem);
+        gameProxy.addLocalData2(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 4, 3, preStateItem);
         gameProxy.stepV2({ _claimIndex: 4, _attackBranch: 3, _stateData: claimData6, _proof: stepProof });
     }
 
@@ -2411,7 +2411,7 @@ contract FaultDisputeGameN_LessSplitDepth_Test is FaultDisputeGame_Init {
         FaultDisputeGame.StepProof memory stepProof =
             FaultDisputeGame.StepProof({ preStateItem: preStateItem, postStateItem: postStateItem, vmProof: hex"" });
 
-        gameProxy.addLocalData(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 4, 3, preStateItem);
+        gameProxy.addLocalData2(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 4, 3, preStateItem);
         vm.expectRevert(ValidStep.selector);
         gameProxy.stepV2({ _claimIndex: 4, _attackBranch: 3, _stateData: claimData6, _proof: stepProof });
     }
@@ -2464,7 +2464,7 @@ contract FaultDisputeGameN_LessSplitDepth_Test is FaultDisputeGame_Init {
 
         FaultDisputeGame.StepProof memory stepProof =
             FaultDisputeGame.StepProof({ preStateItem: preStateItem, postStateItem: postStateItem, vmProof: hex"" });
-        gameProxy.addLocalData(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 4, 3, preStateItem);
+        gameProxy.addLocalData2(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 4, 3, preStateItem);
         gameProxy.stepV2({ _claimIndex: 4, _attackBranch: 3, _stateData: claimData6, _proof: stepProof });
     }