Merge pull request #7366 from ethereum-optimism/refcell/split-trace-provider

feat(op-challenger): Split Trace Provider

op-challenger/game/fault/trace/split/provider.go

+package split
+
+import (
+	"context"
+
+	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/log"
+)
+
+var _ types.TraceProvider = (*SplitTraceProvider)(nil)
+
+// SplitTraceProvider is a [types.TraceProvider] implementation that
+// routes requests to the correct internal trace provider based on the
+// depth of the requested trace.
+type SplitTraceProvider struct {
+	logger         log.Logger
+	topProvider    types.TraceProvider
+	bottomProvider types.TraceProvider
+	topDepth       uint64
+}
+
+// NewTraceProvider creates a new [SplitTraceProvider] instance.
+// The [topDepth] parameter specifies the depth at which the internal
+// [types.TraceProvider] should be switched.
+func NewTraceProvider(logger log.Logger, topProvider types.TraceProvider, bottomProvider types.TraceProvider, topDepth uint64) *SplitTraceProvider {
+	return &SplitTraceProvider{
+		logger:         logger,
+		topProvider:    topProvider,
+		bottomProvider: bottomProvider,
+		topDepth:       topDepth,
+	}
+}
+
+func (s *SplitTraceProvider) providerForDepth(depth uint64) (uint64, types.TraceProvider) {
+	if depth <= s.topDepth {
+		return 0, s.topProvider
+	}
+	return s.topDepth, s.bottomProvider
+}
+
+// Get routes the Get request to the internal [types.TraceProvider] that
+// that serves the trace index at the depth.
+func (s *SplitTraceProvider) Get(ctx context.Context, pos types.Position) (common.Hash, error) {
+	ancestorDepth, provider := s.providerForDepth(uint64(pos.Depth()))
+	relativePosition, err := pos.RelativeToAncestorAtDepth(ancestorDepth)
+	if err != nil {
+		return common.Hash{}, err
+	}
+	return provider.Get(ctx, relativePosition)
+}
+
+// AbsolutePreStateCommitment returns the absolute prestate from the lowest internal [types.TraceProvider]
+func (s *SplitTraceProvider) AbsolutePreStateCommitment(ctx context.Context) (hash common.Hash, err error) {
+	return s.bottomProvider.AbsolutePreStateCommitment(ctx)
+}
+
+// AbsolutePreState routes the AbsolutePreState request to the lowest internal [types.TraceProvider].
+func (s *SplitTraceProvider) AbsolutePreState(ctx context.Context) (preimage []byte, err error) {
+	return s.bottomProvider.AbsolutePreState(ctx)
+}
+
+// GetStepData routes the GetStepData request to the lowest internal [types.TraceProvider].
+func (s *SplitTraceProvider) GetStepData(ctx context.Context, pos types.Position) (prestate []byte, proofData []byte, preimageData *types.PreimageOracleData, err error) {
+	ancestorDepth, provider := s.providerForDepth(uint64(pos.Depth()))
+	relativePosition, err := pos.RelativeToAncestorAtDepth(ancestorDepth)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+	return provider.GetStepData(ctx, relativePosition)
+}

op-challenger/game/fault/trace/split/provider_test.go

+package split
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
+	"github.com/ethereum-optimism/optimism/op-service/testlog"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/stretchr/testify/require"
+)
+
+var (
+	mockGetError   = errors.New("mock get error")
+	mockOutput     = common.HexToHash("0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
+	mockCommitment = common.HexToHash("0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb")
+)
+
+func TestGet(t *testing.T) {
+	t.Run("ErrorBubblesUp", func(t *testing.T) {
+		mockOutputProvider := mockTraceProvider{getError: mockGetError}
+		splitProvider := newSplitTraceProvider(t, &mockOutputProvider, nil, 40)
+		_, err := splitProvider.Get(context.Background(), types.NewPosition(1, 0))
+		require.ErrorIs(t, err, mockGetError)
+	})
+
+	t.Run("ReturnsCorrectOutputFromTopProvider", func(t *testing.T) {
+		mockOutputProvider := mockTraceProvider{getOutput: mockOutput}
+		splitProvider := newSplitTraceProvider(t, &mockOutputProvider, &mockTraceProvider{}, 40)
+		output, err := splitProvider.Get(context.Background(), types.NewPosition(6, 3))
+		require.NoError(t, err)
+		expectedGIndex := types.NewPosition(6, 3).ToGIndex()
+		require.Equal(t, common.BytesToHash([]byte{byte(expectedGIndex)}), output)
+	})
+
+	t.Run("ReturnsCorrectOutputWithMultipleProviders", func(t *testing.T) {
+		bottomProvider := mockTraceProvider{getOutput: mockOutput}
+		splitProvider := newSplitTraceProvider(t, &mockTraceProvider{}, &bottomProvider, 40)
+		output, err := splitProvider.Get(context.Background(), types.NewPosition(42, 17))
+		require.NoError(t, err)
+		expectedGIndex := types.NewPosition(2, 1).ToGIndex()
+		require.Equal(t, common.BytesToHash([]byte{byte(expectedGIndex)}), output)
+	})
+}
+
+func TestAbsolutePreStateCommitment(t *testing.T) {
+	t.Run("ErrorBubblesUp", func(t *testing.T) {
+		mockOutputProvider := mockTraceProvider{absolutePreStateCommitmentError: mockGetError}
+		splitProvider := newSplitTraceProvider(t, nil, &mockOutputProvider, 40)
+		_, err := splitProvider.AbsolutePreStateCommitment(context.Background())
+		require.ErrorIs(t, err, mockGetError)
+	})
+
+	t.Run("ReturnsCorrectOutput", func(t *testing.T) {
+		mockOutputProvider := mockTraceProvider{absolutePreStateCommitment: mockCommitment}
+		splitProvider := newSplitTraceProvider(t, nil, &mockOutputProvider, 40)
+		output, err := splitProvider.AbsolutePreStateCommitment(context.Background())
+		require.NoError(t, err)
+		require.Equal(t, mockCommitment, output)
+	})
+}
+
+func TestAbsolutePreState(t *testing.T) {
+	t.Run("ErrorBubblesUp", func(t *testing.T) {
+		mockOutputProvider := mockTraceProvider{absolutePreStateError: mockGetError}
+		splitProvider := newSplitTraceProvider(t, nil, &mockOutputProvider, 40)
+		_, err := splitProvider.AbsolutePreState(context.Background())
+		require.ErrorIs(t, err, mockGetError)
+	})
+
+	t.Run("ReturnsCorrectPreimageData", func(t *testing.T) {
+		expectedPreimage := []byte{1, 2, 3, 4}
+		mockOutputProvider := mockTraceProvider{preImageData: expectedPreimage}
+		splitProvider := newSplitTraceProvider(t, nil, &mockOutputProvider, 40)
+		output, err := splitProvider.AbsolutePreState(context.Background())
+		require.NoError(t, err)
+		require.Equal(t, expectedPreimage, output)
+	})
+}
+
+func TestGetStepData(t *testing.T) {
+	t.Run("ErrorBubblesUp", func(t *testing.T) {
+		mockOutputProvider := mockTraceProvider{getStepDataError: mockGetError}
+		splitProvider := newSplitTraceProvider(t, &mockOutputProvider, nil, 40)
+		_, _, _, err := splitProvider.GetStepData(context.Background(), types.NewPosition(0, 0))
+		require.ErrorIs(t, err, mockGetError)
+	})
+
+	t.Run("ReturnsCorrectStepData", func(t *testing.T) {
+		expectedStepData := []byte{1, 2, 3, 4}
+		mockOutputProvider := mockTraceProvider{stepPrestateData: expectedStepData}
+		splitProvider := newSplitTraceProvider(t, nil, &mockOutputProvider, 40)
+		output, _, _, err := splitProvider.GetStepData(context.Background(), types.NewPosition(41, 0))
+		require.NoError(t, err)
+		require.Equal(t, expectedStepData, output)
+	})
+}
+
+type mockTraceProvider struct {
+	getOutput                       common.Hash
+	getError                        error
+	absolutePreStateCommitmentError error
+	absolutePreStateCommitment      common.Hash
+	absolutePreStateError           error
+	preImageData                    []byte
+	getStepDataError                error
+	stepPrestateData                []byte
+}
+
+func newSplitTraceProvider(t *testing.T, tp *mockTraceProvider, bp *mockTraceProvider, topDepth uint64) SplitTraceProvider {
+	return SplitTraceProvider{
+		logger:         testlog.Logger(t, log.LvlInfo),
+		topProvider:    tp,
+		bottomProvider: bp,
+		topDepth:       topDepth,
+	}
+}
+
+func (m *mockTraceProvider) Get(ctx context.Context, pos types.Position) (common.Hash, error) {
+	if m.getError != nil {
+		return common.Hash{}, m.getError
+	}
+	return common.BytesToHash([]byte{byte(pos.ToGIndex())}), nil
+}
+
+func (m *mockTraceProvider) AbsolutePreStateCommitment(ctx context.Context) (hash common.Hash, err error) {
+	if m.absolutePreStateCommitmentError != nil {
+		return common.Hash{}, m.absolutePreStateCommitmentError
+	}
+	return m.absolutePreStateCommitment, nil
+}
+
+func (m *mockTraceProvider) AbsolutePreState(ctx context.Context) (preimage []byte, err error) {
+	if m.absolutePreStateError != nil {
+		return []byte{}, m.absolutePreStateError
+	}
+	return m.preImageData, nil
+}
+
+func (m *mockTraceProvider) GetStepData(ctx context.Context, pos types.Position) ([]byte, []byte, *types.PreimageOracleData, error) {
+	if m.getStepDataError != nil {
+		return nil, nil, nil, m.getStepDataError
+	}
+	return m.stepPrestateData, nil, nil, nil
+}

op-challenger/game/fault/types/position.go

 package types
 
-import "fmt"
+import (
+	"errors"
+	"fmt"
+)
+
+var (
+	ErrPositionDepthTooSmall = errors.New("Position depth is too small")
+)
 
 // Position is a golang wrapper around the dispute game Position type.
 type Position struct {
@@ -25,6 +32,18 @@ func (p Position) MoveRight() Position {
 	}
 }
 
+// RelativeToAncestorAtDepth returns a new position for a subtree.
+// [ancestor] is the depth of the subtree root node.
+func (p Position) RelativeToAncestorAtDepth(ancestor uint64) (Position, error) {
+	if ancestor > uint64(p.depth) {
+		return Position{}, ErrPositionDepthTooSmall
+	}
+	newPosDepth := uint64(p.depth) - ancestor
+	nodesAtDepth := 1 << newPosDepth
+	newIndexAtDepth := p.indexAtDepth % nodesAtDepth
+	return NewPosition(int(newPosDepth), newIndexAtDepth), nil
+}
+
 func (p Position) Depth() int {
 	return p.depth
 }

op-challenger/game/fault/types/position_test.go

@@ -119,3 +119,19 @@ func TestDefend(t *testing.T) {
 		require.Equalf(t, test.DefendGIndex, result.ToGIndex(), "Defend from GIndex %v", pos.ToGIndex())
 	}
 }
+
+func TestRelativeToAncestorAtDepth(t *testing.T) {
+	t.Run("ErrorsForDeepAncestor", func(t *testing.T) {
+		pos := NewPosition(1, 1)
+		_, err := pos.RelativeToAncestorAtDepth(2)
+		require.ErrorIs(t, err, ErrPositionDepthTooSmall)
+	})
+
+	t.Run("Success", func(t *testing.T) {
+		pos := NewPosition(2, 1)
+		expectedRelativePosition := NewPosition(1, 1)
+		relativePosition, err := pos.RelativeToAncestorAtDepth(1)
+		require.NoError(t, err)
+		require.Equal(t, expectedRelativePosition, relativePosition)
+	})
+}