Merge pull request #6306 from ethereum-optimism/jg/absolute_prestate

op-challenger: Properly implement stepping against trace index 0

op-challenger/fault/agent.go

@@ -102,19 +102,13 @@ func (a *Agent) step(claim Claim, game Game) error {
 		a.log.Warn("Failed to get a step", "err", err)
 		return err
 	}
-	stateData, err := a.trace.GetPreimage(step.PreStateTraceIndex)
-	if err != nil {
-		a.log.Warn("Failed to get a state data", "err", err)
-		return err
-	}
 
-	a.log.Info("Performing step",
-		"depth", step.LeafClaim.Depth(), "index_at_depth", step.LeafClaim.IndexAtDepth(), "value", step.LeafClaim.Value,
-		"is_attack", step.IsAttack, "prestate_trace_index", step.PreStateTraceIndex)
+	a.log.Info("Performing step", "is_attack", step.IsAttack,
+		"depth", step.LeafClaim.Depth(), "index_at_depth", step.LeafClaim.IndexAtDepth(), "value", step.LeafClaim.Value)
 	callData := StepCallData{
 		ClaimIndex: uint64(step.LeafClaim.ContractIndex),
 		IsAttack:   step.IsAttack,
-		StateData:  stateData,
+		StateData:  step.PreState,
 	}
 	return a.responder.Step(context.TODO(), callData)
 }

op-challenger/fault/alphabet_provider.go

@@ -8,6 +8,8 @@ import (
 	"github.com/ethereum/go-ethereum/crypto"
 )
 
+var _ TraceProvider = (*AlphabetProvider)(nil)
+
 // AlphabetProvider is a [TraceProvider] that provides claims for specific
 // indices in the given trace.
 type AlphabetProvider struct {
@@ -45,6 +47,12 @@ func (ap *AlphabetProvider) Get(i uint64) (common.Hash, error) {
 	return crypto.Keccak256Hash(claimBytes), nil
 }
 
+func (ap *AlphabetProvider) AbsolutePreState() []byte {
+	out := make([]byte, 32)
+	out[31] = 140 // ascii character 140 is "`"
+	return out
+}
+
 // BuildAlphabetPreimage constructs the claim bytes for the index and state item.
 func BuildAlphabetPreimage(i uint64, letter string) []byte {
 	return append(IndexToBytes(i), LetterToBytes(letter)...)

op-challenger/fault/solver.go

@@ -64,9 +64,9 @@ func (s *Solver) handleMiddle(claim Claim) (*Claim, error) {
 }
 
 type StepData struct {
-	LeafClaim          Claim
-	IsAttack           bool
-	PreStateTraceIndex uint64
+	LeafClaim Claim
+	IsAttack  bool
+	PreState  []byte
 }
 
 // AttemptStep determines what step should occur for a given leaf claim.
@@ -80,14 +80,25 @@ func (s *Solver) AttemptStep(claim Claim) (StepData, error) {
 		return StepData{}, err
 	}
 	index := claim.TraceIndex(s.gameDepth)
-	// TODO(CLI-4198): Handle case where we dispute trace index 0
-	if !claimCorrect {
-		index -= 1
+	var preState []byte
+	// If we are attacking index 0, we provide the absolute pre-state, not an intermediate state
+	if index == 0 && !claimCorrect {
+		preState = s.AbsolutePreState()
+	} else {
+		// If attacking, get the state just before, other get the state after
+		if !claimCorrect {
+			index = index - 1
+		}
+		preState, err = s.GetPreimage(index)
+		if err != nil {
+			return StepData{}, err
+		}
 	}
+
 	return StepData{
-		LeafClaim:          claim,
-		IsAttack:           !claimCorrect,
-		PreStateTraceIndex: index,
+		LeafClaim: claim,
+		IsAttack:  !claimCorrect,
+		PreState:  preState,
 	}, nil
 }
 

op-challenger/fault/solver_test.go

@@ -102,17 +102,27 @@ func TestAttemptStep(t *testing.T) {
 	maxDepth := 3
 	canonicalProvider := NewAlphabetProvider("abcdefgh", uint64(maxDepth))
 	solver := NewSolver(maxDepth, canonicalProvider)
-	root, top, middle, bottom := createTestClaims()
-	g := NewGameState(false, root, testMaxDepth)
-	require.NoError(t, g.Put(top))
-	require.NoError(t, g.Put(middle))
-	require.NoError(t, g.Put(bottom))
+	_, _, middle, bottom := createTestClaims()
+
+	zero := Claim{
+		ClaimData: ClaimData{
+			// Zero value is a purposely disagree with claim value "a"
+			Position: NewPosition(3, 0),
+		},
+	}
 
 	step, err := solver.AttemptStep(bottom)
 	require.NoError(t, err)
 	require.Equal(t, bottom, step.LeafClaim)
 	require.True(t, step.IsAttack)
+	require.Equal(t, step.PreState, BuildAlphabetPreimage(3, "d"))
 
 	_, err = solver.AttemptStep(middle)
 	require.Error(t, err)
+
+	step, err = solver.AttemptStep(zero)
+	require.NoError(t, err)
+	require.Equal(t, zero, step.LeafClaim)
+	require.True(t, step.IsAttack)
+	require.Equal(t, canonicalProvider.AbsolutePreState(), step.PreState)
 }

op-challenger/fault/types.go

@@ -22,10 +22,12 @@ type StepCallData struct {
 
 // TraceProvider is a generic way to get a claim value at a specific
 // step in the trace.
-// The [AlphabetProvider] is a minimal implementation of this interface.
+// Get(i) = Keccak256(GetPreimage(i))
+// AbsolutePreState is the value of the trace that transitions to the trace value at index 0
 type TraceProvider interface {
 	Get(i uint64) (common.Hash, error)
 	GetPreimage(i uint64) ([]byte, error)
+	AbsolutePreState() []byte
 }
 
 // ClaimData is the core of a claim. It must be unique inside a specific game.

packages/contracts-bedrock/deploy-config/devnetL1.json

@@ -44,6 +44,6 @@
   "l1GenesisBlockTimestamp": "0x64935846",
   "l1StartingBlockTag": "earliest",
   "l2GenesisRegolithTimeOffset": "0x0",
-  "faultGameAbsolutePrestate": 15,
+  "faultGameAbsolutePrestate": 140,
   "faultGameMaxDepth": 4
-}
+}
\ No newline at end of file