Merge pull request OffchainLabs#3331 from OffchainLabs/refractor_stateless

Remove stateless_block_validator public function for reader, streamer and tracker

Author: eljobe

arbnode/node.go

@@ -730,6 +730,7 @@ func getStaker(
 	deployInfo *chaininfo.RollupAddresses,
 	txStreamer *TransactionStreamer,
 	inboxTracker *InboxTracker,
+	inboxReader *InboxReader,
 	stack *node.Node,
 	fatalErrChan chan error,
 	statelessBlockValidator *staker.StatelessBlockValidator,
@@ -789,7 +790,7 @@ func getStaker(
 			confirmedNotifiers = append(confirmedNotifiers, messagePruner)
 		}
 
-		stakerObj, err = multiprotocolstaker.NewMultiProtocolStaker(stack, l1Reader, wallet, bind.CallOpts{}, func() *legacystaker.L1ValidatorConfig { return &configFetcher.Get().Staker }, &configFetcher.Get().Bold, blockValidator, statelessBlockValidator, nil, deployInfo.StakeToken, deployInfo.Rollup, confirmedNotifiers, deployInfo.ValidatorUtils, deployInfo.Bridge, fatalErrChan)
+		stakerObj, err = multiprotocolstaker.NewMultiProtocolStaker(stack, l1Reader, wallet, bind.CallOpts{}, func() *legacystaker.L1ValidatorConfig { return &configFetcher.Get().Staker }, &configFetcher.Get().Bold, blockValidator, statelessBlockValidator, nil, deployInfo.StakeToken, deployInfo.Rollup, confirmedNotifiers, deployInfo.ValidatorUtils, deployInfo.Bridge, txStreamer, inboxTracker, inboxReader, fatalErrChan)
 		if err != nil {
 			return nil, nil, common.Address{}, err
 		}
@@ -1110,7 +1111,7 @@ func createNodeImpl(
 		return nil, err
 	}
 
-	stakerObj, messagePruner, stakerAddr, err := getStaker(ctx, config, configFetcher, arbDb, l1Reader, txOptsValidator, syncMonitor, parentChainID, l1client, deployInfo, txStreamer, inboxTracker, stack, fatalErrChan, statelessBlockValidator, blockValidator)
+	stakerObj, messagePruner, stakerAddr, err := getStaker(ctx, config, configFetcher, arbDb, l1Reader, txOptsValidator, syncMonitor, parentChainID, l1client, deployInfo, txStreamer, inboxTracker, inboxReader, stack, fatalErrChan, statelessBlockValidator, blockValidator)
 	if err != nil {
 		return nil, err
 	}

staker/bold/bold_staker.go

@@ -190,17 +190,18 @@ func DelegatedStakingConfigAddOptions(prefix string, f *flag.FlagSet) {
 
 type BOLDStaker struct {
 	stopwaiter.StopWaiter
-	config                  *BoldConfig
-	chalManager             *challengemanager.Manager
-	blockValidator          *staker.BlockValidator
-	statelessBlockValidator *staker.StatelessBlockValidator
-	rollupAddress           common.Address
-	l1Reader                *headerreader.HeaderReader
-	client                  protocol.ChainBackend
-	callOpts                bind.CallOpts
-	wallet                  legacystaker.ValidatorWalletInterface
-	stakedNotifiers         []legacystaker.LatestStakedNotifier
-	confirmedNotifiers      []legacystaker.LatestConfirmedNotifier
+	config             *BoldConfig
+	chalManager        *challengemanager.Manager
+	blockValidator     *staker.BlockValidator
+	rollupAddress      common.Address
+	l1Reader           *headerreader.HeaderReader
+	client             protocol.ChainBackend
+	callOpts           bind.CallOpts
+	wallet             legacystaker.ValidatorWalletInterface
+	stakedNotifiers    []legacystaker.LatestStakedNotifier
+	confirmedNotifiers []legacystaker.LatestConfirmedNotifier
+	inboxTracker       staker.InboxTrackerInterface
+	inboxStreamer      staker.TransactionStreamerInterface
 }
 
 func NewBOLDStaker(
@@ -217,27 +218,31 @@ func NewBOLDStaker(
 	wallet legacystaker.ValidatorWalletInterface,
 	stakedNotifiers []legacystaker.LatestStakedNotifier,
 	confirmedNotifiers []legacystaker.LatestConfirmedNotifier,
+	inboxTracker staker.InboxTrackerInterface,
+	inboxStreamer staker.TransactionStreamerInterface,
+	inboxReader staker.InboxReaderInterface,
 ) (*BOLDStaker, error) {
 	if err := config.Validate(); err != nil {
 		return nil, err
 	}
 	wrappedClient := util.NewBackendWrapper(l1Reader.Client(), rpc.LatestBlockNumber)
-	manager, err := newBOLDChallengeManager(ctx, stack, rollupAddress, txOpts, l1Reader, wrappedClient, blockValidator, statelessBlockValidator, config, dataPoster)
+	manager, err := newBOLDChallengeManager(ctx, stack, rollupAddress, txOpts, l1Reader, wrappedClient, blockValidator, statelessBlockValidator, config, dataPoster, inboxTracker, inboxStreamer, inboxReader)
 	if err != nil {
 		return nil, err
 	}
 	return &BOLDStaker{
-		config:                  config,
-		chalManager:             manager,
-		blockValidator:          blockValidator,
-		statelessBlockValidator: statelessBlockValidator,
-		rollupAddress:           rollupAddress,
-		l1Reader:                l1Reader,
-		client:                  wrappedClient,
-		callOpts:                callOpts,
-		wallet:                  wallet,
-		stakedNotifiers:         stakedNotifiers,
-		confirmedNotifiers:      confirmedNotifiers,
+		config:             config,
+		chalManager:        manager,
+		blockValidator:     blockValidator,
+		rollupAddress:      rollupAddress,
+		l1Reader:           l1Reader,
+		client:             wrappedClient,
+		callOpts:           callOpts,
+		wallet:             wallet,
+		stakedNotifiers:    stakedNotifiers,
+		confirmedNotifiers: confirmedNotifiers,
+		inboxTracker:       inboxTracker,
+		inboxStreamer:      inboxStreamer,
 	}, nil
 }
 
@@ -343,7 +348,7 @@ func (b *BOLDStaker) getLatestState(ctx context.Context, confirmed bool) (arbuti
 	if err != nil {
 		return 0, nil, fmt.Errorf("error getting latest %s: %w", assertionType, err)
 	}
-	caughtUp, count, err := staker.GlobalStateToMsgCount(b.statelessBlockValidator.InboxTracker(), b.statelessBlockValidator.InboxStreamer(), validator.GoGlobalState(globalState))
+	caughtUp, count, err := staker.GlobalStateToMsgCount(b.inboxTracker, b.inboxStreamer, validator.GoGlobalState(globalState))
 	if err != nil {
 		if errors.Is(err, staker.ErrGlobalStateNotInChain) {
 			return 0, nil, fmt.Errorf("latest %s assertion of %v not yet in our node: %w", assertionType, globalState, err)
@@ -356,7 +361,7 @@ func (b *BOLDStaker) getLatestState(ctx context.Context, confirmed bool) (arbuti
 		return 0, nil, nil
 	}
 
-	processedCount, err := b.statelessBlockValidator.InboxStreamer().GetProcessedMessageCount()
+	processedCount, err := b.inboxStreamer.GetProcessedMessageCount()
 	if err != nil {
 		return 0, nil, err
 	}
@@ -409,6 +414,9 @@ func newBOLDChallengeManager(
 	statelessBlockValidator *staker.StatelessBlockValidator,
 	config *BoldConfig,
 	dataPoster *dataposter.DataPoster,
+	inboxTracker staker.InboxTrackerInterface,
+	inboxStreamer staker.TransactionStreamerInterface,
+	inboxReader staker.InboxReaderInterface,
 ) (*challengemanager.Manager, error) {
 	// Initializes the BOLD contract bindings and the assertion chain abstraction.
 	rollupBindings, err := boldrollup.NewRollupUserLogic(rollupAddress, client)
@@ -499,6 +507,9 @@ func newBOLDChallengeManager(
 		blockChallengeLeafHeight,
 		&config.StateProviderConfig,
 		machineHashesPath,
+		inboxTracker,
+		inboxStreamer,
+		inboxReader,
 	)
 	if err != nil {
 		return nil, fmt.Errorf("could not create state manager: %w", err)

staker/bold/bold_state_provider.go

@@ -41,6 +41,9 @@ type BOLDStateProvider struct {
 	historyCache             challengecache.HistoryCommitmentCacher
 	blockChallengeLeafHeight l2stateprovider.Height
 	stateProviderConfig      *StateProviderConfig
+	inboxTracker             staker.InboxTrackerInterface
+	inboxStreamer            staker.TransactionStreamerInterface
+	inboxReader              staker.InboxReaderInterface
 	sync.RWMutex
 }
 
@@ -50,6 +53,9 @@ func NewBOLDStateProvider(
 	blockChallengeLeafHeight l2stateprovider.Height,
 	stateProviderConfig *StateProviderConfig,
 	machineHashesCachePath string,
+	inboxTracker staker.InboxTrackerInterface,
+	inboxStreamer staker.TransactionStreamerInterface,
+	inboxReader staker.InboxReaderInterface,
 ) (*BOLDStateProvider, error) {
 	historyCache, err := challengecache.New(machineHashesCachePath)
 	if err != nil {
@@ -61,6 +67,9 @@ func NewBOLDStateProvider(
 		historyCache:             historyCache,
 		blockChallengeLeafHeight: blockChallengeLeafHeight,
 		stateProviderConfig:      stateProviderConfig,
+		inboxTracker:             inboxTracker,
+		inboxStreamer:            inboxStreamer,
+		inboxReader:              inboxReader,
 	}
 	return sp, nil
 }
@@ -79,7 +88,7 @@ func (s *BOLDStateProvider) ExecutionStateAfterPreviousState(
 	}
 	batchIndex := maxSeqInboxCount
 	maxNumberOfBlocks := uint64(s.blockChallengeLeafHeight)
-	messageCount, err := s.statelessValidator.InboxTracker().GetBatchMessageCount(batchIndex - 1)
+	messageCount, err := s.inboxTracker.GetBatchMessageCount(batchIndex - 1)
 	if err != nil {
 		if strings.Contains(err.Error(), "not found") {
 			return nil, fmt.Errorf("%w: batch count %d", l2stateprovider.ErrChainCatchingUp, maxSeqInboxCount)
@@ -88,7 +97,7 @@ func (s *BOLDStateProvider) ExecutionStateAfterPreviousState(
 	}
 	var previousMessageCount arbutil.MessageIndex
 	if previousGlobalState.Batch > 0 {
-		previousMessageCount, err = s.statelessValidator.InboxTracker().GetBatchMessageCount(previousGlobalState.Batch - 1)
+		previousMessageCount, err = s.inboxTracker.GetBatchMessageCount(previousGlobalState.Batch - 1)
 		if err != nil {
 			if strings.Contains(err.Error(), "not found") {
 				return nil, fmt.Errorf("%w: batch count %d", l2stateprovider.ErrChainCatchingUp, maxSeqInboxCount)
@@ -101,7 +110,7 @@ func (s *BOLDStateProvider) ExecutionStateAfterPreviousState(
 	maxMessageCount := previousMessageCount + arbutil.MessageIndex(maxNumberOfBlocks)
 	if messageDiffBetweenBatches > maxMessageCount {
 		messageCount = maxMessageCount
-		batchIndex, _, err = s.statelessValidator.InboxTracker().FindInboxBatchContainingMessage(messageCount)
+		batchIndex, _, err = s.inboxTracker.FindInboxBatchContainingMessage(messageCount)
 		if err != nil {
 			return nil, err
 		}
@@ -146,7 +155,7 @@ func (s *BOLDStateProvider) isStateValidatedAndMessageCountPastThreshold(
 	ctx context.Context, gs validator.GoGlobalState, messageCount arbutil.MessageIndex,
 ) (bool, error) {
 	if s.stateProviderConfig.CheckBatchFinality {
-		finalizedMessageCount, err := s.statelessValidator.InboxReader().GetFinalizedMsgCount(ctx)
+		finalizedMessageCount, err := s.inboxReader.GetFinalizedMsgCount(ctx)
 		if err != nil {
 			return false, err
 		}
@@ -188,14 +197,14 @@ func (s *BOLDStateProvider) StatesInBatchRange(
 	var prevBatchMsgCount arbutil.MessageIndex
 	var err error
 	if fromState.Batch > 0 {
-		prevBatchMsgCount, err = s.statelessValidator.InboxTracker().GetBatchMessageCount(uint64(fromState.Batch) - 1)
+		prevBatchMsgCount, err = s.inboxTracker.GetBatchMessageCount(uint64(fromState.Batch) - 1)
 		if err != nil {
 			return nil, nil, err
 		}
 	}
 
 	batchNum := fromState.Batch
-	currBatchMsgCount, err := s.statelessValidator.InboxTracker().GetBatchMessageCount(batchNum)
+	currBatchMsgCount, err := s.inboxTracker.GetBatchMessageCount(batchNum)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -210,7 +219,7 @@ func (s *BOLDStateProvider) StatesInBatchRange(
 		}
 		executionResult := &execution.MessageResult{}
 		if pos > 0 {
-			executionResult, err = s.statelessValidator.InboxStreamer().ResultAtMessageIndex(pos - 1)
+			executionResult, err = s.inboxStreamer.ResultAtMessageIndex(pos - 1)
 			if err != nil {
 				return nil, nil, err
 			}
@@ -234,7 +243,7 @@ func (s *BOLDStateProvider) StatesInBatchRange(
 			// Otherwise, we might try to read too many batches, and hit an error that
 			// the next batch isn't found.
 			if uint64(len(states)) < totalDesiredHashes && batchNum < batchLimit {
-				currBatchMsgCount, err = s.statelessValidator.InboxTracker().GetBatchMessageCount(batchNum)
+				currBatchMsgCount, err = s.inboxTracker.GetBatchMessageCount(batchNum)
 				if err != nil {
 					return nil, nil, err
 				}
@@ -254,7 +263,7 @@ func (s *BOLDStateProvider) findGlobalStateFromMessageCountAndBatch(count arbuti
 	var prevBatchMsgCount arbutil.MessageIndex
 	var err error
 	if batchIndex > 0 {
-		prevBatchMsgCount, err = s.statelessValidator.InboxTracker().GetBatchMessageCount(uint64(batchIndex) - 1)
+		prevBatchMsgCount, err = s.inboxTracker.GetBatchMessageCount(uint64(batchIndex) - 1)
 		if err != nil {
 			return validator.GoGlobalState{}, err
 		}
@@ -263,7 +272,7 @@ func (s *BOLDStateProvider) findGlobalStateFromMessageCountAndBatch(count arbuti
 		}
 	}
 	if count != prevBatchMsgCount {
-		batchMsgCount, err := s.statelessValidator.InboxTracker().GetBatchMessageCount(uint64(batchIndex))
+		batchMsgCount, err := s.inboxTracker.GetBatchMessageCount(uint64(batchIndex))
 		if err != nil {
 			return validator.GoGlobalState{}, err
 		}
@@ -273,7 +282,7 @@ func (s *BOLDStateProvider) findGlobalStateFromMessageCountAndBatch(count arbuti
 	}
 	res := &execution.MessageResult{}
 	if count > 0 {
-		res, err = s.statelessValidator.InboxStreamer().ResultAtMessageIndex(count - 1)
+		res, err = s.inboxStreamer.ResultAtMessageIndex(count - 1)
 		if err != nil {
 			return validator.GoGlobalState{}, fmt.Errorf("%s: could not check if we have result at count %d: %w", s.stateProviderConfig.ValidatorName, count, err)
 		}
@@ -335,7 +344,7 @@ func (s *BOLDStateProvider) CollectMachineHashes(
 	for i, h := range cfg.StepHeights {
 		stepHeights[i] = uint64(h)
 	}
-	messageResult, err := s.statelessValidator.InboxStreamer().ResultAtMessageIndex(messageNum)
+	messageResult, err := s.inboxStreamer.ResultAtMessageIndex(messageNum)
 	if err != nil {
 		return nil, err
 	}
@@ -401,7 +410,7 @@ func (s *BOLDStateProvider) messageNum(md *l2stateprovider.AssociatedAssertionMe
 	posInBatch := md.FromState.PosInBatch
 	if bNum > 0 {
 		var err error
-		prevBatchMsgCount, err = s.statelessValidator.InboxTracker().GetBatchMessageCount(uint64(bNum - 1))
+		prevBatchMsgCount, err = s.inboxTracker.GetBatchMessageCount(uint64(bNum - 1))
 		if err != nil {
 			return 0, fmt.Errorf("could not get prevBatchMsgCount at %d: %w", bNum-1, err)
 		}
@@ -427,14 +436,14 @@ func (s *BOLDStateProvider) messageNum(md *l2stateprovider.AssociatedAssertionMe
 // FINISHED state's hash.
 func (s *BOLDStateProvider) virtualState(msgNum arbutil.MessageIndex, limit l2stateprovider.Batch) (option.Option[validator.GoGlobalState], error) {
 	gs := option.None[validator.GoGlobalState]()
-	limitMsgCount, err := s.statelessValidator.InboxTracker().GetBatchMessageCount(uint64(limit) - 1)
+	limitMsgCount, err := s.inboxTracker.GetBatchMessageCount(uint64(limit) - 1)
 	if err != nil {
 		return gs, fmt.Errorf("could not get limitMsgCount at %d: %w", limit, err)
 	}
 	if msgNum >= limitMsgCount {
 		result := &execution.MessageResult{}
 		if limitMsgCount > 0 {
-			result, err = s.statelessValidator.InboxStreamer().ResultAtMessageIndex(limitMsgCount - 1)
+			result, err = s.inboxStreamer.ResultAtMessageIndex(limitMsgCount - 1)
 			if err != nil {
 				return gs, fmt.Errorf("could not get global state at limitMsgCount %d: %w", limitMsgCount, err)
 			}

staker/legacy/challenge_manager.go

@@ -93,6 +93,8 @@ func NewChallengeManager(
 	val *staker.StatelessBlockValidator,
 	startL1Block uint64,
 	confirmationBlocks int64,
+	inboxTracker staker.InboxTrackerInterface,
+	inboxStreamer staker.TransactionStreamerInterface,
 ) (*ChallengeManager, error) {
 	con, err := challenge_legacy_gen.NewChallengeManager(challengeManagerAddr, l1client)
 	if err != nil {
@@ -130,8 +132,8 @@ func NewChallengeManager(
 	backend, err := NewBlockChallengeBackend(
 		parsedLog,
 		challengeInfo.MaxInboxMessages,
-		val.InboxStreamer(),
-		val.InboxTracker(),
+		inboxStreamer,
+		inboxTracker,
 	)
 	if err != nil {
 		return nil, fmt.Errorf("error creating block challenge backend for challenge %v: %w", challengeIndex, err)

staker/legacy/staker.go

@@ -310,14 +310,17 @@ func NewStaker(
 	confirmedNotifiers []LatestConfirmedNotifier,
 	validatorUtilsAddress common.Address,
 	rollupAddress common.Address,
+	inboxTracker staker.InboxTrackerInterface,
+	inboxStreamer staker.TransactionStreamerInterface,
+	inboxReader staker.InboxReaderInterface,
 	fatalErr chan<- error,
 ) (*Staker, error) {
 	if err := config().Validate(); err != nil {
 		return nil, err
 	}
 	client := l1Reader.Client()
 	val, err := NewL1Validator(client, wallet, validatorUtilsAddress, rollupAddress, config().GasRefunder(), callOpts,
-		statelessBlockValidator.InboxTracker(), statelessBlockValidator.InboxStreamer(), blockValidator)
+		inboxTracker, inboxStreamer, blockValidator)
 	if err != nil {
 		return nil, err
 	}
@@ -334,7 +337,7 @@ func NewStaker(
 		config:                  config,
 		highGasBlocksBuffer:     big.NewInt(config().PostingStrategy.HighGasDelayBlocks),
 		lastActCalledBlock:      nil,
-		inboxReader:             statelessBlockValidator.InboxReader(),
+		inboxReader:             inboxReader,
 		statelessBlockValidator: statelessBlockValidator,
 		fatalErr:                fatalErr,
 		inactiveValidatedNodes:  inactiveValidatedNodes,
@@ -991,6 +994,8 @@ func (s *Staker) handleConflict(ctx context.Context, info *StakerInfo) error {
 			s.statelessBlockValidator,
 			latestConfirmedCreated,
 			s.config().ConfirmationBlocks,
+			s.inboxTracker,
+			s.txStreamer,
 		)
 		if err != nil {
 			return fmt.Errorf("error creating challenge manager: %w", err)