Merge branch 'master' into leo/refactor-stored-chunk-data-pack

Author: j1010001

cmd/access/node_builder/access_node_builder.go

@@ -351,6 +351,7 @@ type FlowAccessNodeBuilder struct {
 	transactionResultErrorMessages storage.TransactionResultErrorMessages
 	transactions                   storage.Transactions
 	collections                    storage.Collections
+	scheduledTransactions          storage.ScheduledTransactions
 
 	// The sync engine participants provider is the libp2p peer store for the access node
 	// which is not available until after the network has started.
@@ -852,6 +853,10 @@ func (builder *FlowAccessNodeBuilder) BuildExecutionSyncComponents() *FlowAccess
 				builder.lightTransactionResults = store.NewLightTransactionResults(node.Metrics.Cache, node.ProtocolDB, bstorage.DefaultCacheSize)
 				return nil
 			}).
+			Module("scheduled transactions storage", func(node *cmd.NodeConfig) error {
+				builder.scheduledTransactions = store.NewScheduledTransactions(node.Metrics.Cache, node.ProtocolDB, bstorage.DefaultCacheSize)
+				return nil
+			}).
 			DependableComponent("execution data indexer", func(node *cmd.NodeConfig) (module.ReadyDoneAware, error) {
 				// Note: using a DependableComponent here to ensure that the indexer does not block
 				// other components from starting while bootstrapping the register db since it may
@@ -937,7 +942,7 @@ func (builder *FlowAccessNodeBuilder) BuildExecutionSyncComponents() *FlowAccess
 					return nil, fmt.Errorf("could not create derived chain data: %w", err)
 				}
 
-				indexerCore, err := indexer.New(
+				builder.ExecutionIndexerCore = indexer.New(
 					builder.Logger,
 					metrics.NewExecutionStateIndexerCollector(),
 					notNil(builder.ProtocolDB),
@@ -947,22 +952,19 @@ func (builder *FlowAccessNodeBuilder) BuildExecutionSyncComponents() *FlowAccess
 					notNil(builder.collections),
 					notNil(builder.transactions),
 					notNil(builder.lightTransactionResults),
-					builder.RootChainID.Chain(),
+					notNil(builder.scheduledTransactions),
+					builder.RootChainID,
 					indexerDerivedChainData,
 					notNil(builder.collectionExecutedMetric),
 					node.StorageLockMgr,
 				)
-				if err != nil {
-					return nil, err
-				}
-				builder.ExecutionIndexerCore = indexerCore
 
 				// execution state worker uses a jobqueue to process new execution data and indexes it by using the indexer.
 				builder.ExecutionIndexer, err = indexer.NewIndexer(
 					builder.Logger,
 					registers.FirstHeight(),
 					registers,
-					indexerCore,
+					builder.ExecutionIndexerCore,
 					executionDataStoreCache,
 					builder.ExecutionDataRequester.HighestConsecutiveHeight,
 					indexedBlockHeight,

cmd/observer/node_builder/observer_builder.go

@@ -299,6 +299,7 @@ type ObserverServiceBuilder struct {
 	// storage
 	events                  storage.Events
 	lightTransactionResults storage.LightTransactionResults
+	scheduledTransactions   storage.ScheduledTransactions
 
 	// available until after the network has started. Hence, a factory function that needs to be called just before
 	// creating the sync engine
@@ -1349,6 +1350,9 @@ func (builder *ObserverServiceBuilder) BuildExecutionSyncComponents() *ObserverS
 		}).Module("transaction results storage", func(node *cmd.NodeConfig) error {
 			builder.lightTransactionResults = store.NewLightTransactionResults(node.Metrics.Cache, node.ProtocolDB, bstorage.DefaultCacheSize)
 			return nil
+		}).Module("scheduled transactions storage", func(node *cmd.NodeConfig) error {
+			builder.scheduledTransactions = store.NewScheduledTransactions(node.Metrics.Cache, node.ProtocolDB, bstorage.DefaultCacheSize)
+			return nil
 		}).DependableComponent("execution data indexer", func(node *cmd.NodeConfig) (module.ReadyDoneAware, error) {
 			// Note: using a DependableComponent here to ensure that the indexer does not block
 			// other components from starting while bootstrapping the register db since it may
@@ -1435,7 +1439,7 @@ func (builder *ObserverServiceBuilder) BuildExecutionSyncComponents() *ObserverS
 			}
 
 			var collectionExecutedMetric module.CollectionExecutedMetric = metrics.NewNoopCollector()
-			indexerCore, err := indexer.New(
+			builder.ExecutionIndexerCore = indexer.New(
 				builder.Logger,
 				metrics.NewExecutionStateIndexerCollector(),
 				builder.ProtocolDB,
@@ -1445,22 +1449,19 @@ func (builder *ObserverServiceBuilder) BuildExecutionSyncComponents() *ObserverS
 				builder.Storage.Collections,
 				builder.Storage.Transactions,
 				builder.lightTransactionResults,
-				builder.RootChainID.Chain(),
+				builder.scheduledTransactions,
+				builder.RootChainID,
 				indexerDerivedChainData,
 				collectionExecutedMetric,
 				node.StorageLockMgr,
 			)
-			if err != nil {
-				return nil, err
-			}
-			builder.ExecutionIndexerCore = indexerCore
 
 			// execution state worker uses a jobqueue to process new execution data and indexes it by using the indexer.
 			builder.ExecutionIndexer, err = indexer.NewIndexer(
 				builder.Logger,
 				registers.FirstHeight(),
 				registers,
-				indexerCore,
+				builder.ExecutionIndexerCore,
 				executionDataStoreCache,
 				builder.ExecutionDataRequester.HighestConsecutiveHeight,
 				indexedBlockHeight,

engine/access/rpc/backend/script_executor_test.go

@@ -129,7 +129,7 @@ func (s *ScriptExecutorSuite) SetupTest() {
 	derivedChainData, err := derived.NewDerivedChainData(derived.DefaultDerivedDataCacheSize)
 	s.Require().NoError(err)
 
-	indexerCore, err := indexer.New(
+	indexerCore := indexer.New(
 		s.log,
 		module.ExecutionStateIndexerMetrics(metrics.NewNoopCollector()),
 		nil,
@@ -139,12 +139,12 @@ func (s *ScriptExecutorSuite) SetupTest() {
 		nil,
 		nil,
 		nil,
-		s.chain,
+		nil,
+		s.chain.ChainID(),
 		derivedChainData,
 		module.CollectionExecutedMetric(metrics.NewNoopCollector()),
 		lockManager,
 	)
-	s.Require().NoError(err)
 
 	s.scripts = execution.NewScripts(
 		s.log,

fvm/blueprints/scheduled_callback.go

@@ -73,7 +73,7 @@ func ExecuteCallbacksTransactions(chainID flow.Chain, processEvents flow.EventsL
 		// event.EventIndex
 
 		// skip any fee events or other events that are not pending execution events
-		if !isPendingExecutionEvent(env, event) {
+		if !IsPendingExecutionEvent(env, event) {
 			continue
 		}
 
@@ -114,19 +114,42 @@ func executeCallbackTransaction(
 // callback scheduler contract and has the following signature:
 // event PendingExecution(id: UInt64, priority: UInt8, executionEffort: UInt64, fees: UFix64, callbackOwner: Address)
 func callbackArgsFromEvent(event flow.Event) ([]byte, uint64, error) {
+	cadenceId, cadenceEffort, err := ParsePendingExecutionEvent(event)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	effort := uint64(cadenceEffort)
+
+	if effort > flow.DefaultMaxTransactionGasLimit {
+		log.Warn().Uint64("effort", effort).Msg("effort is greater than max transaction gas limit, setting to max")
+		effort = flow.DefaultMaxTransactionGasLimit
+	}
+
+	encID, err := jsoncdc.Encode(cadenceId)
+	if err != nil {
+		return nil, 0, fmt.Errorf("failed to encode id: %w", err)
+	}
+
+	return encID, uint64(effort), nil
+}
+
+// ParsePendingExecutionEvent decodes the PendingExecution event payload and returns the scheduled
+// transaction's id and effort.
+func ParsePendingExecutionEvent(event flow.Event) (cadence.UInt64, cadence.UInt64, error) {
 	const (
 		processedCallbackIDFieldName     = "id"
 		processedCallbackEffortFieldName = "executionEffort"
 	)
 
 	eventData, err := ccf.Decode(nil, event.Payload)
 	if err != nil {
-		return nil, 0, fmt.Errorf("failed to decode event: %w", err)
+		return 0, 0, fmt.Errorf("failed to decode event: %w", err)
 	}
 
 	cadenceEvent, ok := eventData.(cadence.Event)
 	if !ok {
-		return nil, 0, fmt.Errorf("event data is not a cadence event")
+		return 0, 0, fmt.Errorf("event data is not a cadence event")
 	}
 
 	idValue := cadence.SearchFieldByName(
@@ -139,32 +162,21 @@ func callbackArgsFromEvent(event flow.Event) ([]byte, uint64, error) {
 		processedCallbackEffortFieldName,
 	)
 
-	id, ok := idValue.(cadence.UInt64)
+	cadenceId, ok := idValue.(cadence.UInt64)
 	if !ok {
-		return nil, 0, fmt.Errorf("id is not uint64")
+		return 0, 0, fmt.Errorf("id is not uint64")
 	}
 
 	cadenceEffort, ok := effortValue.(cadence.UInt64)
 	if !ok {
-		return nil, 0, fmt.Errorf("effort is not uint64")
-	}
-
-	effort := uint64(cadenceEffort)
-
-	if effort > flow.DefaultMaxTransactionGasLimit {
-		log.Warn().Uint64("effort", effort).Msg("effort is greater than max transaction gas limit, setting to max")
-		effort = flow.DefaultMaxTransactionGasLimit
+		return 0, 0, fmt.Errorf("effort is not uint64")
 	}
 
-	encID, err := jsoncdc.Encode(id)
-	if err != nil {
-		return nil, 0, fmt.Errorf("failed to encode id: %w", err)
-	}
-
-	return encID, uint64(effort), nil
+	return cadenceId, cadenceEffort, nil
 }
 
-func isPendingExecutionEvent(env templates.Environment, event flow.Event) bool {
+// IsPendingExecutionEvent returns true if the event is a pending execution event.
+func IsPendingExecutionEvent(env templates.Environment, event flow.Event) bool {
 	processedEventType := PendingExecutionEventType(env)
 	return event.Type == processedEventType
 }

fvm/blueprints/scheduled_callback_test.go

@@ -183,6 +183,27 @@ func TestExecuteCallbackTransaction(t *testing.T) {
 	assert.Equal(t, tx.GasLimit, uint64(effort))
 }
 
+func TestIsPendingExecutionEvent(t *testing.T) {
+	t.Parallel()
+
+	chain := flow.Mainnet.Chain()
+	env := systemcontracts.SystemContractsForChain(chain.ChainID()).AsTemplateEnv()
+	assert.True(t, blueprints.IsPendingExecutionEvent(env, createValidCallbackEvent(t, 1, 100)))
+}
+
+func TestParsePendingExecutionEvent(t *testing.T) {
+	t.Parallel()
+
+	expectedID := uint64(123)
+	expectedEffort := uint64(456)
+	event := createValidCallbackEvent(t, expectedID, expectedEffort)
+
+	actualID, actualEffort, err := blueprints.ParsePendingExecutionEvent(event)
+	require.NoError(t, err)
+	assert.Equal(t, expectedID, uint64(actualID))
+	assert.Equal(t, expectedEffort, uint64(actualEffort))
+}
+
 func createValidCallbackEvent(t *testing.T, id uint64, effort uint64) flow.Event {
 	const processedEventTypeTemplate = "A.%v.FlowTransactionScheduler.PendingExecution"
 	env := systemcontracts.SystemContractsForChain(flow.Mainnet.Chain().ChainID()).AsTemplateEnv()

module/builder/collection/builder.go

@@ -191,7 +191,7 @@ func (b *Builder) BuildOn(parentID flow.Identifier, setter func(*flow.HeaderBody
 	// STEP 2: build a payload of valid transactions, while at the same
 	// time figuring out the correct reference block ID for the collection.
 	span, _ = b.tracer.StartSpanFromContext(ctx, trace.COLBuildOnCreatePayload)
-	payload, err := b.buildPayload(buildCtx)
+	payload, priorityTransactionsCount, err := b.buildPayload(buildCtx)
 	span.End()
 	if err != nil {
 		return nil, fmt.Errorf("could not build payload: %w", err)
@@ -216,6 +216,8 @@ func (b *Builder) BuildOn(parentID flow.Identifier, setter func(*flow.HeaderBody
 		return nil, fmt.Errorf("could not build cluster block: %w", err)
 	}
 
+	b.metrics.ClusterBlockCreated(block, priorityTransactionsCount)
+
 	blockProposal, err := cluster.NewProposal(
 		cluster.UntrustedProposal{
 			Block:           *block,
@@ -403,8 +405,13 @@ func (b *Builder) populateFinalizedAncestryLookup(lctx lockctx.Proof, ctx *block
 
 // buildPayload constructs a valid payload based on transactions available in the mempool.
 // If the mempool is empty, an empty payload will be returned.
+// Return values:
+//   - *cluster.Payload: the payload that has been built.
+//   - uint: number of prioritized transactions included in the payload.
+//   - error: exception if failed to build the payload.
+//
 // No errors are expected during normal operation.
-func (b *Builder) buildPayload(buildCtx *blockBuildContext) (*cluster.Payload, error) {
+func (b *Builder) buildPayload(buildCtx *blockBuildContext) (*cluster.Payload, uint, error) {
 	lookup := buildCtx.lookup
 	limiter := buildCtx.limiter
 	config := buildCtx.config
@@ -469,7 +476,7 @@ func (b *Builder) buildPayload(buildCtx *blockBuildContext) (*cluster.Payload, e
 			continue // in case we are configured with liberal transaction ingest rules
 		}
 		if err != nil {
-			return nil, fmt.Errorf("could not retrieve reference header: %w", err)
+			return nil, 0, fmt.Errorf("could not retrieve reference header: %w", err)
 		}
 
 		// disallow un-finalized reference blocks, and reference blocks beyond the cluster's operating epoch
@@ -480,7 +487,7 @@ func (b *Builder) buildPayload(buildCtx *blockBuildContext) (*cluster.Payload, e
 		// make sure the reference block is finalized and not orphaned
 		blockIDFinalizedAtRefHeight, err := b.mainHeaders.BlockIDByHeight(refHeader.Height)
 		if err != nil {
-			return nil, fmt.Errorf("could not check that reference block (id=%x) for transaction (id=%x) is finalized: %w", tx.ReferenceBlockID, txID, err)
+			return nil, 0, fmt.Errorf("could not check that reference block (id=%x) for transaction (id=%x) is finalized: %w", tx.ReferenceBlockID, txID, err)
 		}
 		if blockIDFinalizedAtRefHeight != tx.ReferenceBlockID {
 			// the transaction references an orphaned block - it will never be valid
@@ -544,7 +551,7 @@ func (b *Builder) buildPayload(buildCtx *blockBuildContext) (*cluster.Payload, e
 	// build the payload from the transactions
 	collection, err := flow.NewCollection(flow.UntrustedCollection{Transactions: transactions})
 	if err != nil {
-		return nil, fmt.Errorf("could not build the collection from the transactions: %w", err)
+		return nil, 0, fmt.Errorf("could not build the collection from the transactions: %w", err)
 	}
 
 	payload, err := cluster.NewPayload(
@@ -554,9 +561,9 @@ func (b *Builder) buildPayload(buildCtx *blockBuildContext) (*cluster.Payload, e
 		},
 	)
 	if err != nil {
-		return nil, fmt.Errorf("could not build a payload: %w", err)
+		return nil, 0, fmt.Errorf("could not build a payload: %w", err)
 	}
-	return payload, nil
+	return payload, uint(len(priorityTransactions)), nil
 }
 
 // buildHeader constructs the header for the cluster block being built.

module/execution/scripts_test.go

@@ -178,7 +178,7 @@ func (s *scriptTestSuite) SetupTest() {
 	derivedChainData, err := derived.NewDerivedChainData(derived.DefaultDerivedDataCacheSize)
 	s.Require().NoError(err)
 
-	index, err := indexer.New(
+	index := indexer.New(
 		logger,
 		metrics.NewNoopCollector(),
 		nil,
@@ -188,12 +188,12 @@ func (s *scriptTestSuite) SetupTest() {
 		nil,
 		nil,
 		nil,
-		flow.Testnet.Chain(),
+		nil,
+		flow.Testnet,
 		derivedChainData,
 		nil,
 		lockManager,
 	)
-	s.Require().NoError(err)
 
 	s.scripts = NewScripts(
 		logger,