MSFDG: adapt AttackV2 and StepV2 functions in op-challenger2 and alphabet E2E test

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:

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) {

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{

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)
 	}

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,15 +205,17 @@ 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)
 		require.NoError(t, err)
 
 		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,15 +229,17 @@ 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)
 		require.NoError(t, err)
 
 		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