:broom: Resolve conflicts

op-challenger/fault/service.go

-package fault
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
-	"github.com/ethereum-optimism/optimism/op-challenger/config"
-	"github.com/ethereum-optimism/optimism/op-challenger/fault/alphabet"
-	"github.com/ethereum-optimism/optimism/op-challenger/fault/cannon"
-	"github.com/ethereum-optimism/optimism/op-challenger/fault/types"
-	"github.com/ethereum-optimism/optimism/op-service/client"
-	"github.com/ethereum-optimism/optimism/op-service/txmgr"
-	"github.com/ethereum-optimism/optimism/op-service/txmgr/metrics"
-	"github.com/ethereum/go-ethereum/ethclient"
-	"github.com/ethereum/go-ethereum/log"
-)
-
-// Service provides a clean interface for the challenger to interact
-// with the fault package.
-type Service interface {
-	// MonitorGame monitors the fault dispute game and attempts to progress it.
-	MonitorGame(context.Context) error
-}
-
-type service struct {
-	agent                   *Agent
-	agreeWithProposedOutput bool
-	caller                  *FaultCaller
-	logger                  log.Logger
-}
-
-// NewService creates a new Service.
-func NewService(ctx context.Context, logger log.Logger, cfg *config.Config) (*service, error) {
-	txMgr, err := txmgr.NewSimpleTxManager("challenger", logger, &metrics.NoopTxMetrics{}, cfg.TxMgrConfig)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create the transaction manager: %w", err)
-	}
-
-	client, err := client.DialEthClientWithTimeout(client.DefaultDialTimeout, logger, cfg.L1EthRpc)
-	if err != nil {
-		return nil, fmt.Errorf("failed to dial L1: %w", err)
-	}
-
-	contract, err := bindings.NewFaultDisputeGameCaller(cfg.GameAddress, client)
-	if err != nil {
-		return nil, fmt.Errorf("failed to bind the fault dispute game contract: %w", err)
-	}
-
-	loader := NewLoader(contract)
-
-	gameDepth, err := loader.FetchGameDepth(ctx)
-	if err != nil {
-		return nil, fmt.Errorf("failed to fetch the game depth: %w", err)
-	}
-	gameDepth = uint64(gameDepth)
-
-	var trace types.TraceProvider
-	var updater types.OracleUpdater
-	switch cfg.TraceType {
-	case config.TraceTypeCannon:
-		trace, err = cannon.NewTraceProvider(ctx, logger, cfg, client)
-		if err != nil {
-			return nil, fmt.Errorf("create cannon trace provider: %w", err)
-		}
-		updater, err = cannon.NewOracleUpdater(ctx, logger, txMgr, cfg.GameAddress, client)
-		if err != nil {
-			return nil, fmt.Errorf("failed to create the cannon updater: %w", err)
-		}
-	case config.TraceTypeAlphabet:
-		trace = alphabet.NewTraceProvider(cfg.AlphabetTrace, gameDepth)
-		updater = alphabet.NewOracleUpdater(logger)
-	default:
-		return nil, fmt.Errorf("unsupported trace type: %v", cfg.TraceType)
-	}
-
-	return newTypedService(ctx, logger, cfg, loader, gameDepth, client, trace, updater, txMgr)
-}
-
-// newTypedService creates a new Service from a provided trace provider.
-func newTypedService(ctx context.Context, logger log.Logger, cfg *config.Config, loader Loader, gameDepth uint64, client *ethclient.Client, provider types.TraceProvider, updater types.OracleUpdater, txMgr txmgr.TxManager) (*service, error) {
-	if err := ValidateAbsolutePrestate(ctx, provider, loader); err != nil {
-		return nil, fmt.Errorf("failed to validate absolute prestate: %w", err)
-	}
-
-	gameLogger := logger.New("game", cfg.GameAddress)
-	responder, err := NewFaultResponder(gameLogger, txMgr, cfg.GameAddress)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create the responder: %w", err)
-	}
-
-	caller, err := NewFaultCallerFromBindings(cfg.GameAddress, client, gameLogger)
-	if err != nil {
-		return nil, fmt.Errorf("failed to bind the fault contract: %w", err)
-	}
-
-	return &service{
-		agent:                   NewAgent(loader, int(gameDepth), provider, responder, updater, cfg.AgreeWithProposedOutput, gameLogger),
-		agreeWithProposedOutput: cfg.AgreeWithProposedOutput,
-		caller:                  caller,
-		logger:                  gameLogger,
-	}, nil
-}
-
-// ValidateAbsolutePrestate validates the absolute prestate of the fault game.
-func ValidateAbsolutePrestate(ctx context.Context, trace types.TraceProvider, loader Loader) error {
-	providerPrestate, err := trace.AbsolutePreState(ctx)
-	if err != nil {
-		return fmt.Errorf("failed to get the trace provider's absolute prestate: %w", err)
-	}
-	providerPrestateHash, err := trace.StateHash(ctx, providerPrestate)
-	if err != nil {
-		return fmt.Errorf("failed to compute state-hash: %w", err)
-	}
-	onchainPrestateHash, err := loader.FetchAbsolutePrestateHash(ctx)
-	if err != nil {
-		return fmt.Errorf("failed to get the onchain absolute prestate: %w", err)
-	}
-	if providerPrestateHash != onchainPrestateHash {
-		return fmt.Errorf("trace provider's absolute prestate does not match onchain absolute prestate")
-	}
-	return nil
-}
-
-// MonitorGame monitors the fault dispute game and attempts to progress it.
-func (s *service) MonitorGame(ctx context.Context) error {
-	return MonitorGame(ctx, s.logger, s.agreeWithProposedOutput, s.agent, s.caller)
-}

op-challenger/fault/service_test.go

-package fault
-
-import (
-	"context"
-	"fmt"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/crypto"
-
-	"github.com/ethereum-optimism/optimism/op-challenger/fault/types"
-)
-
-var (
-	mockTraceProviderError = fmt.Errorf("mock trace provider error")
-	mockLoaderError        = fmt.Errorf("mock loader error")
-)
-
-// TestValidateAbsolutePrestate tests that the absolute prestate is validated
-// correctly by the service component.
-func TestValidateAbsolutePrestate(t *testing.T) {
-	t.Run("ValidPrestates", func(t *testing.T) {
-		prestate := []byte{0x00, 0x01, 0x02, 0x03}
-		prestateHash := mockStateHash(prestate)
-		mockTraceProvider := newMockTraceProvider(false, prestate)
-		mockLoader := newMockLoader(false, prestateHash)
-		err := ValidateAbsolutePrestate(context.Background(), mockTraceProvider, mockLoader)
-		require.NoError(t, err)
-	})
-
-	t.Run("TraceProviderErrors", func(t *testing.T) {
-		prestate := []byte{0x00, 0x01, 0x02, 0x03}
-		mockTraceProvider := newMockTraceProvider(true, prestate)
-		mockLoader := newMockLoader(false, mockStateHash(prestate))
-		err := ValidateAbsolutePrestate(context.Background(), mockTraceProvider, mockLoader)
-		require.ErrorIs(t, err, mockTraceProviderError)
-	})
-
-	t.Run("LoaderErrors", func(t *testing.T) {
-		prestate := []byte{0x00, 0x01, 0x02, 0x03}
-		mockTraceProvider := newMockTraceProvider(false, prestate)
-		mockLoader := newMockLoader(true, mockStateHash(prestate))
-		err := ValidateAbsolutePrestate(context.Background(), mockTraceProvider, mockLoader)
-		require.ErrorIs(t, err, mockLoaderError)
-	})
-
-	t.Run("PrestateMismatch", func(t *testing.T) {
-		mockTraceProvider := newMockTraceProvider(false, []byte{0x00, 0x01, 0x02, 0x03})
-		mockLoader := newMockLoader(false, common.Hash{0x00})
-		err := ValidateAbsolutePrestate(context.Background(), mockTraceProvider, mockLoader)
-		require.Error(t, err)
-	})
-}
-
-type mockTraceProvider struct {
-	prestateErrors bool
-	prestate       []byte
-}
-
-func newMockTraceProvider(prestateErrors bool, prestate []byte) *mockTraceProvider {
-	return &mockTraceProvider{
-		prestateErrors: prestateErrors,
-		prestate:       prestate,
-	}
-}
-func (m *mockTraceProvider) Get(ctx context.Context, i uint64) (common.Hash, error) {
-	panic("not implemented")
-}
-func (m *mockTraceProvider) GetStepData(ctx context.Context, i uint64) (prestate []byte, proofData []byte, preimageData *types.PreimageOracleData, err error) {
-	panic("not implemented")
-}
-func (m *mockTraceProvider) AbsolutePreState(ctx context.Context) ([]byte, error) {
-	if m.prestateErrors {
-		return nil, mockTraceProviderError
-	}
-	return m.prestate, nil
-}
-
-func mockStateHash(state []byte) common.Hash {
-	h := crypto.Keccak256Hash(state)
-	h[0] = types.VMStatusValid
-	return h
-}
-
-func (m *mockTraceProvider) StateHash(ctx context.Context, state []byte) (common.Hash, error) {
-	return mockStateHash(state), nil
-}
-
-type mockLoader struct {
-	prestateError bool
-	prestateHash  common.Hash
-}
-
-func newMockLoader(prestateError bool, prestateHash common.Hash) *mockLoader {
-	return &mockLoader{
-		prestateError: prestateError,
-		prestateHash:  prestateHash,
-	}
-}
-func (m *mockLoader) FetchClaims(ctx context.Context) ([]types.Claim, error) {
-	panic("not implemented")
-}
-func (m *mockLoader) FetchGameDepth(ctx context.Context) (uint64, error) {
-	panic("not implemented")
-}
-func (m *mockLoader) FetchAbsolutePrestateHash(ctx context.Context) (common.Hash, error) {
-	if m.prestateError {
-		return common.Hash{}, mockLoaderError
-	}
-	return m.prestateHash, nil
-}

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

@@ -9,8 +9,6 @@ import (
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
-
-	"github.com/ethereum-optimism/optimism/op-challenger/fault/types"
 )
 
 var (

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

@@ -19,9 +19,6 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 
 	"github.com/ethereum-optimism/optimism/cannon/mipsevm"
-	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
-	"github.com/ethereum-optimism/optimism/op-challenger/config"
-	"github.com/ethereum-optimism/optimism/op-challenger/fault/types"
 )
 
 const (