Merge pull request #6459 from ethereum-optimism/refcell/solver-oracle-data

feat(op-challenger): GetOracleData call in Solver

op-challenger/fault/solver/solver.go

@@ -47,10 +47,11 @@ func (s *Solver) NextMove(claim types.Claim, agreeWithClaimLevel bool) (*types.C
 }
 
 type StepData struct {
-	LeafClaim types.Claim
-	IsAttack  bool
-	PreState  []byte
-	ProofData []byte
+	LeafClaim  types.Claim
+	IsAttack   bool
+	PreState   []byte
+	ProofData  []byte
+	OracleData types.PreimageOracleData
 }
 
 // AttemptStep determines what step should occur for a given leaf claim.
@@ -83,11 +84,17 @@ func (s *Solver) AttemptStep(claim types.Claim, agreeWithClaimLevel bool) (StepD
 		}
 	}
 
+	oracleData, err := s.trace.GetOracleData(index)
+	if err != nil {
+		return StepData{}, err
+	}
+
 	return StepData{
-		LeafClaim: claim,
-		IsAttack:  !claimCorrect,
-		PreState:  preState,
-		ProofData: proofData,
+		LeafClaim:  claim,
+		IsAttack:   !claimCorrect,
+		PreState:   preState,
+		ProofData:  proofData,
+		OracleData: *oracleData,
 	}, nil
 }
 

op-challenger/fault/solver/solver_test.go

 package solver_test
 
 import (
-	"fmt"
+	"errors"
 	"testing"
 
 	"github.com/ethereum-optimism/optimism/op-challenger/fault/solver"
@@ -103,62 +103,78 @@ func TestNextMove(t *testing.T) {
 func TestAttemptStep(t *testing.T) {
 	maxDepth := 3
 	builder := test.NewAlphabetClaimBuilder(t, maxDepth)
-	alphabetSolver := solver.NewSolver(maxDepth, builder.CorrectTraceProvider())
 
 	// 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 := uint64(1<<maxDepth - 2)
 
+	errProvider := errors.New("provider error")
+
 	tests := []struct {
-		name            string
-		claim           types.Claim
-		agreeWithLevel  bool
-		expectedErr     error
-		expectAttack    bool
-		expectPreState  []byte
-		expectProofData []byte
+		name               string
+		claim              types.Claim
+		agreeWithLevel     bool
+		expectedErr        error
+		expectAttack       bool
+		expectPreState     []byte
+		expectProofData    []byte
+		expectedLocal      bool
+		expectedOracleKey  []byte
+		expectedOracleData []byte
 	}{
 		{
-			name:            "AttackFirstTraceIndex",
-			claim:           builder.CreateLeafClaim(0, false),
-			expectAttack:    true,
-			expectPreState:  builder.CorrectTraceProvider().AbsolutePreState(),
-			expectProofData: nil,
+			name:               "AttackFirstTraceIndex",
+			claim:              builder.CreateLeafClaim(0, false),
+			expectAttack:       true,
+			expectPreState:     builder.CorrectTraceProvider().AbsolutePreState(),
+			expectProofData:    nil,
+			expectedOracleKey:  []byte{byte(0)},
+			expectedOracleData: []byte{byte(0)},
 		},
 		{
-			name:            "DefendFirstTraceIndex",
-			claim:           builder.CreateLeafClaim(0, true),
-			expectAttack:    false,
-			expectPreState:  builder.CorrectPreState(0),
-			expectProofData: builder.CorrectProofData(0),
+			name:               "DefendFirstTraceIndex",
+			claim:              builder.CreateLeafClaim(0, true),
+			expectAttack:       false,
+			expectPreState:     builder.CorrectPreState(0),
+			expectProofData:    builder.CorrectProofData(0),
+			expectedOracleKey:  []byte{byte(0)},
+			expectedOracleData: []byte{byte(0)},
 		},
 		{
-			name:            "AttackMiddleTraceIndex",
-			claim:           builder.CreateLeafClaim(4, false),
-			expectAttack:    true,
-			expectPreState:  builder.CorrectPreState(3),
-			expectProofData: builder.CorrectProofData(3),
+			name:               "AttackMiddleTraceIndex",
+			claim:              builder.CreateLeafClaim(4, false),
+			expectAttack:       true,
+			expectPreState:     builder.CorrectPreState(3),
+			expectProofData:    builder.CorrectProofData(3),
+			expectedOracleKey:  []byte{byte(3)},
+			expectedOracleData: []byte{byte(3)},
 		},
 		{
-			name:            "DefendMiddleTraceIndex",
-			claim:           builder.CreateLeafClaim(4, true),
-			expectAttack:    false,
-			expectPreState:  builder.CorrectPreState(4),
-			expectProofData: builder.CorrectProofData(4),
+			name:               "DefendMiddleTraceIndex",
+			claim:              builder.CreateLeafClaim(4, true),
+			expectAttack:       false,
+			expectPreState:     builder.CorrectPreState(4),
+			expectProofData:    builder.CorrectProofData(4),
+			expectedOracleKey:  []byte{byte(4)},
+			expectedOracleData: []byte{byte(4)},
 		},
 		{
-			name:            "AttackLastTraceIndex",
-			claim:           builder.CreateLeafClaim(lastLeafTraceIndex, false),
-			expectAttack:    true,
-			expectPreState:  builder.CorrectPreState(lastLeafTraceIndex - 1),
-			expectProofData: builder.CorrectProofData(lastLeafTraceIndex - 1),
+			name:               "AttackLastTraceIndex",
+			claim:              builder.CreateLeafClaim(lastLeafTraceIndex, false),
+			expectAttack:       true,
+			expectPreState:     builder.CorrectPreState(lastLeafTraceIndex - 1),
+			expectProofData:    builder.CorrectProofData(lastLeafTraceIndex - 1),
+			expectedOracleKey:  []byte{byte(5)},
+			expectedOracleData: []byte{byte(5)},
 		},
 		{
-			name:            "DefendLastTraceIndex",
-			claim:           builder.CreateLeafClaim(lastLeafTraceIndex, true),
-			expectAttack:    false,
-			expectPreState:  builder.CorrectPreState(lastLeafTraceIndex),
-			expectProofData: builder.CorrectProofData(lastLeafTraceIndex),
+			name:               "DefendLastTraceIndex",
+			claim:              builder.CreateLeafClaim(lastLeafTraceIndex, true),
+			expectAttack:       false,
+			expectPreState:     builder.CorrectPreState(lastLeafTraceIndex),
+			expectProofData:    builder.CorrectProofData(lastLeafTraceIndex),
+			expectedOracleKey:  []byte{byte(6)},
+			expectedOracleData: []byte{byte(6)},
 		},
 		{
 			name:        "CannotStepNonLeaf",
@@ -171,21 +187,53 @@ func TestAttemptStep(t *testing.T) {
 			agreeWithLevel: true,
 			expectedErr:    solver.ErrStepNonLeafNode,
 		},
+		{
+			name:           "CannotStepAgreedNode",
+			claim:          builder.Seq(false).Attack(false).Get(),
+			agreeWithLevel: true,
+			expectedErr:    solver.ErrStepNonLeafNode,
+		},
+		{
+			name:               "AttackLocalOracleData",
+			claim:              builder.Seq(false).Attack(false).Attack(true).Defend(false).Get(),
+			expectAttack:       true,
+			agreeWithLevel:     false,
+			expectPreState:     builder.CorrectPreState(1),
+			expectProofData:    builder.CorrectProofData(1),
+			expectedLocal:      true,
+			expectedOracleKey:  []byte{0x01},
+			expectedOracleData: []byte{0x01},
+			expectedErr:        nil,
+		},
+		{
+			name:           "AttackStepOracleError",
+			claim:          builder.Seq(false).Attack(false).Attack(false).Attack(false).Get(),
+			agreeWithLevel: false,
+			expectedErr:    errProvider,
+		},
 	}
 
-	for _, test := range tests {
-		test := test
-		t.Run(test.name, func(t *testing.T) {
-			fmt.Printf("%v\n", test.claim.Position.TraceIndex(maxDepth))
-			step, err := alphabetSolver.AttemptStep(test.claim, test.agreeWithLevel)
-			if test.expectedErr == nil {
+	for _, tableTest := range tests {
+		tableTest := tableTest
+		t.Run(tableTest.name, func(t *testing.T) {
+			alphabetProvider := test.NewAlphabetWithProofProvider(t, maxDepth, nil)
+			if errors.Is(tableTest.expectedErr, errProvider) {
+				alphabetProvider = test.NewAlphabetWithProofProvider(t, maxDepth, errProvider)
+			}
+			builder = test.NewClaimBuilder(t, maxDepth, alphabetProvider)
+			alphabetSolver := solver.NewSolver(maxDepth, builder.CorrectTraceProvider())
+			step, err := alphabetSolver.AttemptStep(tableTest.claim, tableTest.agreeWithLevel)
+			if tableTest.expectedErr == nil {
 				require.NoError(t, err)
-				require.Equal(t, test.claim, step.LeafClaim)
-				require.Equal(t, test.expectAttack, step.IsAttack)
-				require.Equal(t, test.expectPreState, step.PreState)
-				require.Equal(t, test.expectProofData, step.ProofData)
+				require.Equal(t, tableTest.claim, step.LeafClaim)
+				require.Equal(t, tableTest.expectAttack, step.IsAttack)
+				require.Equal(t, tableTest.expectPreState, step.PreState)
+				require.Equal(t, tableTest.expectProofData, step.ProofData)
+				require.Equal(t, tableTest.expectedLocal, step.OracleData.IsLocal)
+				require.Equal(t, tableTest.expectedOracleKey, step.OracleData.OracleKey)
+				require.Equal(t, tableTest.expectedOracleData, step.OracleData.OracleData)
 			} else {
-				require.ErrorIs(t, err, test.expectedErr)
+				require.ErrorIs(t, err, tableTest.expectedErr)
 				require.Equal(t, solver.StepData{}, step)
 			}
 		})

op-challenger/fault/test/alphabet.go

@@ -4,15 +4,24 @@ import (
 	"testing"
 
 	"github.com/ethereum-optimism/optimism/op-challenger/fault/alphabet"
+	"github.com/ethereum-optimism/optimism/op-challenger/fault/types"
 )
 
+func NewAlphabetWithProofProvider(t *testing.T, maxDepth int, oracleError error) *alphabetWithProofProvider {
+	return &alphabetWithProofProvider{
+		alphabet.NewAlphabetProvider("abcdefghijklmnopqrstuvwxyz", uint64(maxDepth)),
+		oracleError,
+	}
+}
+
 func NewAlphabetClaimBuilder(t *testing.T, maxDepth int) *ClaimBuilder {
-	alphabetProvider := &alphabetWithProofProvider{alphabet.NewAlphabetProvider("abcdefghijklmnopqrstuvwxyz", uint64(maxDepth))}
+	alphabetProvider := NewAlphabetWithProofProvider(t, maxDepth, nil)
 	return NewClaimBuilder(t, maxDepth, alphabetProvider)
 }
 
 type alphabetWithProofProvider struct {
 	*alphabet.AlphabetProvider
+	OracleError error
 }
 
 func (a *alphabetWithProofProvider) GetPreimage(i uint64) ([]byte, []byte, error) {
@@ -22,3 +31,11 @@ func (a *alphabetWithProofProvider) GetPreimage(i uint64) ([]byte, []byte, error
 	}
 	return preimage, []byte{byte(i)}, nil
 }
+
+func (a *alphabetWithProofProvider) GetOracleData(i uint64) (*types.PreimageOracleData, error) {
+	if a.OracleError != nil {
+		return &types.PreimageOracleData{}, a.OracleError
+	}
+	data := types.NewPreimageOracleData([]byte{byte(i)}, []byte{byte(i)})
+	return &data, nil
+}