Merge pull request #7272 from ethereum-optimism/refcell/output-provider

feat(op-challenger): Output Trace Provider

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

+package outputs
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
+	"github.com/ethereum-optimism/optimism/op-service/client"
+	"github.com/ethereum-optimism/optimism/op-service/eth"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/log"
+)
+
+var (
+	GetStepDataErr      = fmt.Errorf("GetStepData not supported")
+	AbsolutePreStateErr = fmt.Errorf("AbsolutePreState not supported")
+)
+
+var _ types.TraceProvider = (*OutputTraceProvider)(nil)
+
+type OutputRollupClient interface {
+	OutputAtBlock(ctx context.Context, blockNum uint64) (*eth.OutputResponse, error)
+}
+
+// OutputTraceProvider is a [types.TraceProvider] implementation that uses
+// output roots for given L2 Blocks as a trace.
+type OutputTraceProvider struct {
+	logger         log.Logger
+	rollupClient   OutputRollupClient
+	prestateBlock  uint64
+	poststateBlock uint64
+	gameDepth      uint64
+}
+
+func NewTraceProvider(ctx context.Context, logger log.Logger, rollupRpc string, gameDepth, prestateBlock, poststateBlock uint64) (*OutputTraceProvider, error) {
+	rollupClient, err := client.DialRollupClientWithTimeout(client.DefaultDialTimeout, logger, rollupRpc)
+	if err != nil {
+		return nil, err
+	}
+	return NewTraceProviderFromInputs(logger, rollupClient, gameDepth, prestateBlock, poststateBlock), nil
+}
+
+func NewTraceProviderFromInputs(logger log.Logger, rollupClient OutputRollupClient, gameDepth, prestateBlock, poststateBlock uint64) *OutputTraceProvider {
+	return &OutputTraceProvider{
+		logger:         logger,
+		rollupClient:   rollupClient,
+		prestateBlock:  prestateBlock,
+		poststateBlock: poststateBlock,
+		gameDepth:      gameDepth,
+	}
+}
+
+func (o *OutputTraceProvider) Get(ctx context.Context, pos types.Position) (common.Hash, error) {
+	outputBlock := pos.TraceIndex(int(o.gameDepth)) + o.prestateBlock + 1
+	if outputBlock > o.poststateBlock {
+		outputBlock = o.poststateBlock
+	}
+	output, err := o.rollupClient.OutputAtBlock(ctx, outputBlock)
+	if err != nil {
+		o.logger.Error("Failed to fetch output", "blockNumber", outputBlock, "err", err)
+		return common.Hash{}, err
+	}
+	return common.Hash(output.OutputRoot), nil
+}
+
+// AbsolutePreStateCommitment returns the absolute prestate at the configured prestateBlock.
+func (o *OutputTraceProvider) AbsolutePreStateCommitment(ctx context.Context) (hash common.Hash, err error) {
+	output, err := o.rollupClient.OutputAtBlock(ctx, o.prestateBlock)
+	if err != nil {
+		o.logger.Error("Failed to fetch output", "blockNumber", o.prestateBlock, "err", err)
+		return common.Hash{}, err
+	}
+	return common.Hash(output.OutputRoot), nil
+}
+
+// AbsolutePreState is not supported in the [OutputTraceProvider].
+func (o *OutputTraceProvider) AbsolutePreState(ctx context.Context) (preimage []byte, err error) {
+	return nil, AbsolutePreStateErr
+}
+
+// GetStepData is not supported in the [OutputTraceProvider].
+func (o *OutputTraceProvider) GetStepData(ctx context.Context, pos types.Position) (prestate []byte, proofData []byte, preimageData *types.PreimageOracleData, err error) {
+	return nil, nil, nil, GetStepDataErr
+}

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

+package outputs
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
+	"github.com/ethereum-optimism/optimism/op-service/eth"
+	"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 (
+	prestateBlock       = uint64(100)
+	poststateBlock      = uint64(200)
+	gameDepth           = uint64(7) // 128 leaf nodes
+	prestateOutputRoot  = common.HexToHash("0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
+	firstOutputRoot     = common.HexToHash("0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb")
+	poststateOutputRoot = common.HexToHash("0xcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc")
+)
+
+func TestGet(t *testing.T) {
+	t.Run("PrePrestateErrors", func(t *testing.T) {
+		provider, _ := setupWithTestData(t, 0, poststateBlock)
+		_, err := provider.Get(context.Background(), types.NewPosition(1, 0))
+		require.ErrorAs(t, fmt.Errorf("no output at block %d", 1), &err)
+	})
+
+	t.Run("MisconfiguredPoststateErrors", func(t *testing.T) {
+		provider, _ := setupWithTestData(t, 0, 0)
+		_, err := provider.Get(context.Background(), types.NewPosition(1, 0))
+		require.ErrorAs(t, fmt.Errorf("no output at block %d", 0), &err)
+	})
+
+	t.Run("FirstBlockAfterPrestate", func(t *testing.T) {
+		provider, _ := setupWithTestData(t, prestateBlock, poststateBlock)
+		value, err := provider.Get(context.Background(), types.NewPositionFromGIndex(128))
+		require.NoError(t, err)
+		require.Equal(t, firstOutputRoot, value)
+	})
+
+	t.Run("MissingOutputAtBlock", func(t *testing.T) {
+		provider, _ := setupWithTestData(t, prestateBlock, poststateBlock)
+		_, err := provider.Get(context.Background(), types.NewPositionFromGIndex(129))
+		require.ErrorAs(t, fmt.Errorf("no output at block %d", prestateBlock+2), &err)
+	})
+
+	t.Run("PostStateBlock", func(t *testing.T) {
+		provider, _ := setupWithTestData(t, prestateBlock, poststateBlock)
+		value, err := provider.Get(context.Background(), types.NewPositionFromGIndex(228))
+		require.NoError(t, err)
+		require.Equal(t, value, poststateOutputRoot)
+	})
+
+	t.Run("AfterPostStateBlock", func(t *testing.T) {
+		provider, _ := setupWithTestData(t, prestateBlock, poststateBlock)
+		value, err := provider.Get(context.Background(), types.NewPositionFromGIndex(229))
+		require.NoError(t, err)
+		require.Equal(t, value, poststateOutputRoot)
+	})
+}
+
+func TestAbsolutePreStateCommitment(t *testing.T) {
+	t.Run("FailedToFetchOutput", func(t *testing.T) {
+		provider, rollupClient := setupWithTestData(t, prestateBlock, poststateBlock)
+		rollupClient.errorsOnPrestateFetch = true
+		_, err := provider.AbsolutePreStateCommitment(context.Background())
+		require.ErrorAs(t, fmt.Errorf("no output at block %d", prestateBlock), &err)
+	})
+
+	t.Run("ReturnsCorrectPrestateOutput", func(t *testing.T) {
+		provider, _ := setupWithTestData(t, prestateBlock, poststateBlock)
+		value, err := provider.AbsolutePreStateCommitment(context.Background())
+		require.NoError(t, err)
+		require.Equal(t, value, prestateOutputRoot)
+	})
+}
+
+func TestGetStepData(t *testing.T) {
+	provider, _ := setupWithTestData(t, prestateBlock, poststateBlock)
+	_, _, _, err := provider.GetStepData(context.Background(), types.NewPosition(1, 0))
+	require.ErrorIs(t, err, GetStepDataErr)
+}
+
+func TestAbsolutePreState(t *testing.T) {
+	provider, _ := setupWithTestData(t, prestateBlock, poststateBlock)
+	_, err := provider.AbsolutePreState(context.Background())
+	require.ErrorIs(t, err, AbsolutePreStateErr)
+}
+
+func setupWithTestData(t *testing.T, prestateBlock, poststateBlock uint64) (*OutputTraceProvider, *stubRollupClient) {
+	rollupClient := stubRollupClient{
+		outputs: map[uint64]*eth.OutputResponse{
+			prestateBlock: {
+				OutputRoot: eth.Bytes32(prestateOutputRoot),
+			},
+			101: {
+				OutputRoot: eth.Bytes32(firstOutputRoot),
+			},
+			poststateBlock: {
+				OutputRoot: eth.Bytes32(poststateOutputRoot),
+			},
+		},
+	}
+	return &OutputTraceProvider{
+		logger:         testlog.Logger(t, log.LvlInfo),
+		rollupClient:   &rollupClient,
+		prestateBlock:  prestateBlock,
+		poststateBlock: poststateBlock,
+		gameDepth:      gameDepth,
+	}, &rollupClient
+}
+
+type stubRollupClient struct {
+	errorsOnPrestateFetch bool
+	outputs               map[uint64]*eth.OutputResponse
+}
+
+func (s *stubRollupClient) OutputAtBlock(ctx context.Context, blockNum uint64) (*eth.OutputResponse, error) {
+	output, ok := s.outputs[blockNum]
+	if !ok || s.errorsOnPrestateFetch {
+		return nil, fmt.Errorf("no output at block %d", blockNum)
+	}
+	return output, nil
+}