refactor(juno): renames/cosmetics after Pending and PendingData removal (#3521)

* chore: cleanups, remove dead code

* fix: get rid of unused `ErrUnsupportedPendingDataVariant`

* refactor: drop support for pre-0.14.0 pending block

* refactor: remove the pending data wrappers

* chore: linter issues

* refactor: move `PendingState` from sync to rpc helpers

* chore: address the comments

* test: mock syncer should return

* chore: address comments

* chore: ErrPendingDataNotFound cleanup

* chore: last cleanups

* chore: cleanups, remove dead code

* fix: get rid of unused `ErrUnsupportedPendingDataVariant`

* refactor: get rid of `PendingData` interface

* refactor: remove the pending data wrappers

* refactor: drop support for pre-0.14.0 pending block

* refactor: get rid of pending data

* chore: cleanups after rebase

* chore: renames after rebase

* refactor: remaining renames, tests cleanups

* chore: merge pollPendingData and runPreConfirmedPhase

* chore: fixes after the rebase

* chore: minor cleanups after rebase

* test: fixes for the unit tests

* chore: minor fixes after rebase

* chore: fix unit tests

* chore: linter

* chore: linter fixes

* chore: clean-ups, address the comments

* chore: address flaky comment

* test: fix the unit test

Author: MaksymMalicki

blockchain/blockchain.go

@@ -59,7 +59,7 @@ type Reader interface {
 	EventFilter(
 		addresses []felt.Address,
 		keys [][]felt.Felt,
-		pendingDataFn func() (*core.PreConfirmed, error),
+		preConfirmedFn func() (*core.PreConfirmed, error),
 	) (EventFilterer, error)
 
 	Network() *utils.Network
@@ -390,7 +390,7 @@ func (b *Blockchain) StateAtBlockHash(
 func (b *Blockchain) EventFilter(
 	addresses []felt.Address,
 	keys [][]felt.Felt,
-	pendingDataFn func() (*core.PreConfirmed, error),
+	preConfirmedFn func() (*core.PreConfirmed, error),
 ) (EventFilterer, error) {
 	b.listener.OnRead("EventFilter")
 	latest, err := core.GetChainHeight(b.database)
@@ -404,7 +404,7 @@ func (b *Blockchain) EventFilter(
 		keys,
 		0,
 		latest,
-		pendingDataFn,
+		preConfirmedFn,
 		b.cachedFilters,
 		b.runningFilter,
 		b.transactionLayout,

blockchain/blockchain_test.go

@@ -450,7 +450,7 @@ func TestState(t *testing.T) {
 
 func TestEvents(t *testing.T) {
 	var pendingB *core.Block
-	pendingDataFunc := func() (*core.PreConfirmed, error) { //nolint:unparam // used in tests
+	preConfirmedFunc := func() (*core.PreConfirmed, error) { //nolint:unparam // used in tests
 		preConfirmed := core.NewPreConfirmed(pendingB, nil, nil, nil)
 		return &preConfirmed, nil
 	}
@@ -480,7 +480,7 @@ func TestEvents(t *testing.T) {
 	}
 
 	t.Run("filter non-existent", func(t *testing.T) {
-		filter, err := chain.EventFilter(nil, nil, pendingDataFunc)
+		filter, err := chain.EventFilter(nil, nil, preConfirmedFunc)
 
 		t.Run("block number", func(t *testing.T) {
 			err = filter.SetRangeEndBlockByNumber(blockchain.EventFilterTo, uint64(44))
@@ -505,7 +505,7 @@ func TestEvents(t *testing.T) {
 		),
 	}
 	t.Run("filter with no keys", func(t *testing.T) {
-		filter, err := chain.EventFilter(from, nil, pendingDataFunc)
+		filter, err := chain.EventFilter(from, nil, preConfirmedFunc)
 		require.NoError(t, err)
 
 		require.NoError(t, filter.SetRangeEndBlockByNumber(blockchain.EventFilterFrom, 0))
@@ -561,7 +561,7 @@ func TestEvents(t *testing.T) {
 		key := felt.NewUnsafeFromString[felt.Felt](
 			"0x3774b0545aabb37c45c1eddc6a7dae57de498aae6d5e3589e362d4b4323a533",
 		)
-		filter, err := chain.EventFilter(from, [][]felt.Felt{{*key}}, pendingDataFunc)
+		filter, err := chain.EventFilter(from, [][]felt.Felt{{*key}}, preConfirmedFunc)
 		require.NoError(t, err)
 
 		require.NoError(t, filter.SetRangeEndBlockByHash(blockchain.EventFilterFrom,
@@ -589,7 +589,7 @@ func TestEvents(t *testing.T) {
 				)},
 				{*felt.NewUnsafeFromString[felt.Felt]("0xDEADBEEF")},
 			},
-			pendingDataFunc,
+			preConfirmedFunc,
 		)
 		require.NoError(t, err)
 		require.NoError(t, filter.SetRangeEndBlockByNumber(blockchain.EventFilterFrom, 0))
@@ -610,7 +610,7 @@ func TestEvents(t *testing.T) {
 		)
 
 		addresses := []felt.Address{address1, address1, address1}
-		filter, err := chain.EventFilter(addresses, nil, pendingDataFunc)
+		filter, err := chain.EventFilter(addresses, nil, preConfirmedFunc)
 		require.NoError(t, err)
 
 		require.NoError(t, filter.SetRangeEndBlockByNumber(blockchain.EventFilterFrom, 0))
@@ -642,7 +642,7 @@ func TestEvents(t *testing.T) {
 		}
 		for _, testCase := range testCases {
 			t.Run("filter with no addresses ("+testCase.name+")", func(t *testing.T) {
-				filter, err := chain.EventFilter(testCase.addresses, nil, pendingDataFunc)
+				filter, err := chain.EventFilter(testCase.addresses, nil, preConfirmedFunc)
 				require.NoError(t, err)
 
 				require.NoError(t, filter.SetRangeEndBlockByNumber(blockchain.EventFilterFrom, 0))

blockchain/event_filter.go

@@ -25,15 +25,15 @@ type EventFilterer interface {
 }
 
 type EventFilter struct {
-	txn           db.KeyValueStore
-	fromBlock     uint64
-	toBlock       uint64
-	matcher       EventMatcher
-	maxScanned    uint // maximum number of scanned blocks in single call.
-	pendingDataFn func() (*core.PreConfirmed, error)
-	cachedFilters *AggregatedBloomFilterCache
-	runningFilter *core.RunningEventFilter
-	layout        core.TransactionLayout
+	txn            db.KeyValueStore
+	fromBlock      uint64
+	toBlock        uint64
+	matcher        EventMatcher
+	maxScanned     uint // maximum number of scanned blocks in single call.
+	preConfirmedFn func() (*core.PreConfirmed, error)
+	cachedFilters  *AggregatedBloomFilterCache
+	runningFilter  *core.RunningEventFilter
+	layout         core.TransactionLayout
 }
 
 type EventFilterRange uint
@@ -48,21 +48,21 @@ func newEventFilter(
 	contractAddresses []felt.Address,
 	keys [][]felt.Felt,
 	fromBlock, toBlock uint64,
-	pendingDataFn func() (*core.PreConfirmed, error),
+	preConfirmedFn func() (*core.PreConfirmed, error),
 	cachedFilters *AggregatedBloomFilterCache,
 	runningFilter *core.RunningEventFilter,
 	layout core.TransactionLayout,
 ) *EventFilter {
 	return &EventFilter{
-		txn:           txn,
-		matcher:       NewEventMatcher(contractAddresses, keys),
-		fromBlock:     fromBlock,
-		toBlock:       toBlock,
-		maxScanned:    math.MaxUint,
-		pendingDataFn: pendingDataFn,
-		cachedFilters: cachedFilters,
-		runningFilter: runningFilter,
-		layout:        layout,
+		txn:            txn,
+		matcher:        NewEventMatcher(contractAddresses, keys),
+		fromBlock:      fromBlock,
+		toBlock:        toBlock,
+		maxScanned:     math.MaxUint,
+		preConfirmedFn: preConfirmedFn,
+		cachedFilters:  cachedFilters,
+		runningFilter:  runningFilter,
+		layout:         layout,
 	}
 }
 
@@ -290,15 +290,15 @@ func (e *EventFilter) pendingEvents(
 	skippedEvents,
 	chunkSize uint64,
 ) ([]FilteredEvent, ContinuationToken, error) {
-	pendingData, err := e.pendingDataFn()
+	preConfirmed, err := e.preConfirmedFn()
 	if err != nil {
 		if errors.Is(err, core.ErrPreConfirmedNotFound) {
 			return matchedEvents, ContinuationToken{}, nil
 		}
 		return nil, ContinuationToken{}, err
 	}
 
-	preLatest := pendingData.GetPreLatest()
+	preLatest := preConfirmed.GetPreLatest()
 	if preLatest != nil && fromBlock <= preLatest.Block.Number {
 		var cToken ContinuationToken
 		var err error
@@ -318,7 +318,7 @@ func (e *EventFilter) pendingEvents(
 		skippedEvents = 0
 	}
 	// Process pre-confirmed block
-	return e.processPreConfirmedBlock(matchedEvents, pendingData, skippedEvents, chunkSize)
+	return e.processPreConfirmedBlock(matchedEvents, preConfirmed, skippedEvents, chunkSize)
 }
 
 // processPreLatestBlock processes pre-latest block events
@@ -359,11 +359,11 @@ func (e *EventFilter) processPreLatestBlock(
 // processPreConfirmedBlock processes pre-confirmed block events
 func (e *EventFilter) processPreConfirmedBlock(
 	matchedEvents []FilteredEvent,
-	pendingData *core.PreConfirmed,
+	preConfirmed *core.PreConfirmed,
 	skippedEvents,
 	chunkSize uint64,
 ) ([]FilteredEvent, ContinuationToken, error) {
-	pendingHeader := pendingData.GetHeader()
+	pendingHeader := preConfirmed.GetHeader()
 	if !e.matcher.TestBloom(pendingHeader.EventsBloom) {
 		return matchedEvents, ContinuationToken{}, nil
 	}
@@ -373,15 +373,15 @@ func (e *EventFilter) processPreConfirmedBlock(
 	matchedEvents, processedEvents, err = e.matcher.AppendBlockEvents(
 		matchedEvents,
 		pendingHeader,
-		pendingData.GetBlock().Receipts,
+		preConfirmed.GetBlock().Receipts,
 		skippedEvents,
 		chunkSize,
 		false,
 	)
 	if err != nil {
 		if errors.Is(err, errChunkSizeReached) {
 			cToken := ContinuationToken{
-				fromBlock:       pendingData.GetBlock().Number,
+				fromBlock:       preConfirmed.GetBlock().Number,
 				processedEvents: processedEvents,
 			}
 			return matchedEvents, cToken, nil

builder/builder.go

@@ -110,7 +110,7 @@ func (b *Builder) InitPreconfirmedBlock(params *BuildParams) (*BuildState, error
 	}
 
 	return &BuildState{
-		Preconfirmed:      &preconfirmed,
+		PreConfirmed:      &preconfirmed,
 		RevealedBlockHash: revealedBlockHash,
 		L2GasConsumed:     0,
 	}, nil
@@ -131,7 +131,7 @@ func (b *Builder) getRevealedBlockHash(blockHeight uint64) (*felt.Felt, error) {
 func (b *Builder) PendingState(
 	buildState *BuildState,
 ) (core.StateReader, func() error, error) {
-	if buildState.Preconfirmed == nil {
+	if buildState.PreConfirmed == nil {
 		return nil, nil, core.ErrPreConfirmedNotFound
 	}
 
@@ -142,10 +142,10 @@ func (b *Builder) PendingState(
 
 	// TODO: remove the state closer once we refactor the state
 	return core.NewPendingState(
-			buildState.Preconfirmed.StateUpdate.StateDiff,
-			buildState.Preconfirmed.NewClasses,
+			buildState.PreConfirmed.StateUpdate.StateDiff,
+			buildState.PreConfirmed.NewClasses,
 			headState,
-			buildState.Preconfirmed.Block.Number,
+			buildState.PreConfirmed.Block.Number,
 		),
 		headCloser, nil
 }
@@ -174,7 +174,7 @@ func (b *Builder) Finish(state *BuildState) (BuildResult, error) {
 
 	// Todo: we ignore some values until the spec is Finalised: VersionConstantCommitment, NextL2GasPriceFRI
 	buildResult := BuildResult{
-		Preconfirmed:   state.Preconfirmed,
+		PreConfirmed:   state.PreConfirmed,
 		SimulateResult: &simulatedResult,
 		L2GasConsumed:  state.L2GasConsumed,
 	}

builder/executor.go

@@ -59,8 +59,8 @@ func (e *executor) RunTxns(state *BuildState, txns []mempool.BroadcastedTransact
 
 	// Create a state writer for the transaction execution
 	stateWriter := core.NewPendingStateWriter(
-		state.Preconfirmed.StateUpdate.StateDiff,
-		state.Preconfirmed.NewClasses,
+		state.PreConfirmed.StateUpdate.StateDiff,
+		state.PreConfirmed.NewClasses,
 		headState,
 	)
 
@@ -84,7 +84,7 @@ func (e *executor) RunTxns(state *BuildState, txns []mempool.BroadcastedTransact
 		declaredClasses,
 		paidFeesOnL1,
 		&vm.BlockInfo{
-			Header:                state.Preconfirmed.Block.Header,
+			Header:                state.PreConfirmed.Block.Header,
 			BlockHashToBeRevealed: state.RevealedBlockHash,
 		},
 		stateWriter,
@@ -121,7 +121,7 @@ func (e *executor) RunTxns(state *BuildState, txns []mempool.BroadcastedTransact
 	}
 
 	// Update preconfirmed block with transaction results
-	updatePreconfirmedBlock(state.Preconfirmed, receipts, coreTxns, stateDiffs)
+	updatePreconfirmedBlock(state.PreConfirmed, receipts, coreTxns, stateDiffs)
 
 	for i := range vmResults.GasConsumed {
 		state.L2GasConsumed += vmResults.GasConsumed[i].L2Gas
@@ -171,5 +171,10 @@ func updatePreconfirmedBlock(
 }
 
 func (e *executor) Finish(state *BuildState) (blockchain.SimulateResult, error) {
-	return e.blockchain.Simulate(state.Preconfirmed.Block, state.Preconfirmed.StateUpdate, state.Preconfirmed.NewClasses, nil)
+	return e.blockchain.Simulate(
+		state.PreConfirmed.Block,
+		state.PreConfirmed.StateUpdate,
+		state.PreConfirmed.NewClasses,
+		nil,
+	)
 }

builder/result.go

@@ -9,33 +9,33 @@ import (
 )
 
 type BuildResult struct {
-	Preconfirmed   *core.PreConfirmed
+	PreConfirmed   *core.PreConfirmed
 	SimulateResult *blockchain.SimulateResult
 	L2GasConsumed  uint64
 }
 
 func (b *BuildResult) ProposalCommitment() (types.ProposalCommitment, error) {
-	version, err := semver.NewVersion(b.Preconfirmed.Block.ProtocolVersion)
+	version, err := semver.NewVersion(b.PreConfirmed.Block.ProtocolVersion)
 	if err != nil {
 		return types.ProposalCommitment{}, err
 	}
 
 	return types.ProposalCommitment{
-		BlockNumber:           b.Preconfirmed.Block.Number,
-		Builder:               *b.Preconfirmed.Block.SequencerAddress,
-		ParentCommitment:      *b.Preconfirmed.Block.ParentHash,
-		Timestamp:             b.Preconfirmed.Block.Timestamp,
+		BlockNumber:           b.PreConfirmed.Block.Number,
+		Builder:               *b.PreConfirmed.Block.SequencerAddress,
+		ParentCommitment:      *b.PreConfirmed.Block.ParentHash,
+		Timestamp:             b.PreConfirmed.Block.Timestamp,
 		ProtocolVersion:       *version,
-		OldStateRoot:          *b.Preconfirmed.StateUpdate.OldRoot,
+		OldStateRoot:          *b.PreConfirmed.StateUpdate.OldRoot,
 		StateDiffCommitment:   *b.SimulateResult.BlockCommitments.StateDiffCommitment,
 		TransactionCommitment: *b.SimulateResult.BlockCommitments.TransactionCommitment,
 		EventCommitment:       *b.SimulateResult.BlockCommitments.EventCommitment,
 		ReceiptCommitment:     *b.SimulateResult.BlockCommitments.ReceiptCommitment,
 		ConcatenatedCounts:    b.SimulateResult.ConcatCount,
-		L1GasPriceFRI:         *b.Preconfirmed.Block.L1GasPriceSTRK,
-		L1DataGasPriceFRI:     *b.Preconfirmed.Block.L1DataGasPrice.PriceInFri,
-		L2GasPriceFRI:         *b.Preconfirmed.Block.L2GasPrice.PriceInFri,
+		L1GasPriceFRI:         *b.PreConfirmed.Block.L1GasPriceSTRK,
+		L1DataGasPriceFRI:     *b.PreConfirmed.Block.L1DataGasPrice.PriceInFri,
+		L2GasPriceFRI:         *b.PreConfirmed.Block.L2GasPrice.PriceInFri,
 		L2GasUsed:             *new(felt.Felt).SetUint64(b.L2GasConsumed),
-		L1DAMode:              b.Preconfirmed.Block.L1DAMode,
+		L1DAMode:              b.PreConfirmed.Block.L1DAMode,
 	}, nil
 }

builder/state.go

@@ -10,21 +10,21 @@ import (
 )
 
 type BuildState struct {
-	Preconfirmed      *core.PreConfirmed
+	PreConfirmed      *core.PreConfirmed
 	L2GasConsumed     uint64
 	RevealedBlockHash *felt.Felt
 }
 
-func (b *BuildState) PendingBlock() *core.Block {
-	if b.Preconfirmed == nil {
+func (b *BuildState) PreConfirmedBlock() *core.Block {
+	if b.PreConfirmed == nil {
 		return nil
 	}
-	return b.Preconfirmed.Block
+	return b.PreConfirmed.Block
 }
 
 func (b *BuildState) ClearPending() error {
 	b.L2GasConsumed = 0
-	b.Preconfirmed = &core.PreConfirmed{}
+	b.PreConfirmed = &core.PreConfirmed{}
 	b.RevealedBlockHash = nil
 
 	return nil
@@ -37,7 +37,7 @@ func (b *BuildState) ClearPending() error {
 // - Signatures and EventsBloom are not set before `Finish` is called
 func (b *BuildState) Clone() BuildState {
 	return BuildState{
-		Preconfirmed:      clonePreconfirmed(b.Preconfirmed),
+		PreConfirmed:      clonePreconfirmed(b.PreConfirmed),
 		RevealedBlockHash: b.RevealedBlockHash, // Safe to reuse an immutable value
 		L2GasConsumed:     b.L2GasConsumed,     // Value, safe to shallow copy
 	}

consensus/driver/commit_listener.go

@@ -53,9 +53,9 @@ func (b *commitListener[V, H]) OnCommit(ctx context.Context, height types.Height
 	}
 
 	committedBlock := sync.CommittedBlock{
-		Block:       buildResult.Preconfirmed.Block,
-		StateUpdate: buildResult.Preconfirmed.StateUpdate,
-		NewClasses:  buildResult.Preconfirmed.NewClasses,
+		Block:       buildResult.PreConfirmed.Block,
+		StateUpdate: buildResult.PreConfirmed.StateUpdate,
+		NewClasses:  buildResult.PreConfirmed.NewClasses,
 		Persisted:   make(chan struct{}),
 	}