Update the output trace provider to use positions

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

@@ -30,27 +30,29 @@ type OutputTraceProvider struct {
 	rollupClient   OutputRollupClient
 	prestateBlock  uint64
 	poststateBlock uint64
+	gameDepth      uint64
 }
 
-func NewTraceProvider(ctx context.Context, logger log.Logger, rollupRpc string, prestateBlock, poststateBlock uint64) (*OutputTraceProvider, error) {
+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, prestateBlock, poststateBlock), nil
+	return NewTraceProviderFromInputs(logger, rollupClient, gameDepth, prestateBlock, poststateBlock), nil
 }
 
-func NewTraceProviderFromInputs(logger log.Logger, rollupClient OutputRollupClient, prestateBlock, poststateBlock uint64) *OutputTraceProvider {
+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, traceIndex uint64) (common.Hash, error) {
-	outputBlock := traceIndex + o.prestateBlock + 1
+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
 	}
@@ -78,6 +80,6 @@ func (o *OutputTraceProvider) AbsolutePreState(ctx context.Context) (preimage []
 }
 
 // GetStepData is not supported in the [OutputTraceProvider].
-func (o *OutputTraceProvider) GetStepData(ctx context.Context, i uint64) (prestate []byte, proofData []byte, preimageData *types.PreimageOracleData, err error) {
+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

@@ -5,8 +5,9 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/ethereum-optimism/optimism/op-node/testlog"
+	"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"
@@ -16,6 +17,7 @@ import (
 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")
@@ -24,41 +26,39 @@ var (
 func TestGet(t *testing.T) {
 	t.Run("PrePrestateErrors", func(t *testing.T) {
 		provider, _ := setupWithTestData(t, 0, poststateBlock)
-		_, err := provider.Get(context.Background(), 0)
+		_, 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(), 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(), 0)
+		value, err := provider.Get(context.Background(), types.NewPositionFromGIndex(128))
 		require.NoError(t, err)
-		require.Equal(t, value, firstOutputRoot)
+		require.Equal(t, firstOutputRoot, value)
 	})
 
 	t.Run("MissingOutputAtBlock", func(t *testing.T) {
 		provider, _ := setupWithTestData(t, prestateBlock, poststateBlock)
-		_, err := provider.Get(context.Background(), 1)
+		_, 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)
-		traceIndex := poststateBlock - prestateBlock
-		value, err := provider.Get(context.Background(), traceIndex)
+		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)
-		traceIndex := poststateBlock - prestateBlock + 1
-		value, err := provider.Get(context.Background(), traceIndex)
+		value, err := provider.Get(context.Background(), types.NewPositionFromGIndex(229))
 		require.NoError(t, err)
 		require.Equal(t, value, poststateOutputRoot)
 	})
@@ -82,7 +82,7 @@ func TestAbsolutePreStateCommitment(t *testing.T) {
 
 func TestGetStepData(t *testing.T) {
 	provider, _ := setupWithTestData(t, prestateBlock, poststateBlock)
-	_, _, _, err := provider.GetStepData(context.Background(), 0)
+	_, _, _, err := provider.GetStepData(context.Background(), types.NewPosition(1, 0))
 	require.ErrorIs(t, err, GetStepDataErr)
 }
 
@@ -111,6 +111,7 @@ func setupWithTestData(t *testing.T, prestateBlock, poststateBlock uint64) (*Out
 		rollupClient:   &rollupClient,
 		prestateBlock:  prestateBlock,
 		poststateBlock: poststateBlock,
+		gameDepth:      gameDepth,
 	}, &rollupClient
 }