Merge pull request #7673 from devbugging/gregor/callbacks/verifier

[Scheduled Callbacks] Verification

Author: janezpodhostnik

cmd/util/cmd/verify_execution_result/cmd.go

@@ -13,14 +13,15 @@ import (
 )
 
 var (
-	flagLastK                   uint64
-	flagDatadir                 string
-	flagChunkDataPackDir        string
-	flagChain                   string
-	flagFromTo                  string
-	flagWorkerCount             uint // number of workers to verify the blocks concurrently
-	flagStopOnMismatch          bool
-	flagtransactionFeesDisabled bool
+	flagLastK                     uint64
+	flagDatadir                   string
+	flagChunkDataPackDir          string
+	flagChain                     string
+	flagFromTo                    string
+	flagWorkerCount               uint // number of workers to verify the blocks concurrently
+	flagStopOnMismatch            bool
+	flagtransactionFeesDisabled   bool
+	flagScheduledCallbacksEnabled bool
 )
 
 // # verify the last 100 sealed blocks
@@ -57,6 +58,8 @@ func init() {
 	Cmd.Flags().BoolVar(&flagStopOnMismatch, "stop_on_mismatch", false, "stop verification on first mismatch")
 
 	Cmd.Flags().BoolVar(&flagtransactionFeesDisabled, "fees_disabled", false, "disable transaction fees")
+
+	Cmd.Flags().BoolVar(&flagScheduledCallbacksEnabled, "scheduled_callbacks_enabled", false, "enable scheduled callbacks")
 }
 
 func run(*cobra.Command, []string) {
@@ -84,15 +87,15 @@ func run(*cobra.Command, []string) {
 		}
 
 		lg.Info().Msgf("verifying range from %d to %d", from, to)
-		err = verifier.VerifyRange(from, to, chainID, flagDatadir, flagChunkDataPackDir, flagWorkerCount, flagStopOnMismatch, flagtransactionFeesDisabled)
+		err = verifier.VerifyRange(from, to, chainID, flagDatadir, flagChunkDataPackDir, flagWorkerCount, flagStopOnMismatch, flagtransactionFeesDisabled, flagScheduledCallbacksEnabled)
 		if err != nil {
 			lg.Fatal().Err(err).Msgf("could not verify range from %d to %d", from, to)
 		}
 		lg.Info().Msgf("successfully verified range from %d to %d", from, to)
 
 	} else {
 		lg.Info().Msgf("verifying last %d sealed blocks", flagLastK)
-		err := verifier.VerifyLastKHeight(flagLastK, chainID, flagDatadir, flagChunkDataPackDir, flagWorkerCount, flagStopOnMismatch, flagtransactionFeesDisabled)
+		err := verifier.VerifyLastKHeight(flagLastK, chainID, flagDatadir, flagChunkDataPackDir, flagWorkerCount, flagStopOnMismatch, flagtransactionFeesDisabled, flagScheduledCallbacksEnabled)
 		if err != nil {
 			lg.Fatal().Err(err).Msg("could not verify last k height")
 		}

cmd/verification_builder.go

@@ -55,8 +55,8 @@ type VerificationConfig struct {
 	blockWorkers uint64 // number of blocks processed in parallel.
 	chunkWorkers uint64 // number of chunks processed in parallel.
 
-	stopAtHeight             uint64 // height to stop the node on
-	scheduleCallbacksEnabled bool   // enable execution of scheduled callbacks
+	stopAtHeight              uint64 // height to stop the node on
+	scheduledCallbacksEnabled bool   // enable execution of scheduled callbacks
 }
 
 type VerificationNodeBuilder struct {
@@ -84,7 +84,7 @@ func (v *VerificationNodeBuilder) LoadFlags() {
 			flags.Uint64Var(&v.verConf.blockWorkers, "block-workers", blockconsumer.DefaultBlockWorkers, "maximum number of blocks being processed in parallel")
 			flags.Uint64Var(&v.verConf.chunkWorkers, "chunk-workers", chunkconsumer.DefaultChunkWorkers, "maximum number of execution nodes a chunk data pack request is dispatched to")
 			flags.Uint64Var(&v.verConf.stopAtHeight, "stop-at-height", 0, "height to stop the node at (0 to disable)")
-			flags.BoolVar(&v.verConf.scheduleCallbacksEnabled, "scheduled-callbacks-enabled", false, "enable execution of scheduled callbacks")
+			flags.BoolVar(&v.verConf.scheduledCallbacksEnabled, "scheduled-callbacks-enabled", false, "enable execution of scheduled callbacks")
 		})
 }
 
@@ -218,7 +218,7 @@ func (v *VerificationNodeBuilder) LoadComponentsAndModules() {
 				computation.DefaultFVMOptions(
 					node.RootChainID,
 					false,
-					v.verConf.scheduleCallbacksEnabled,
+					v.verConf.scheduledCallbacksEnabled,
 				)...,
 			)
 			vmCtx := fvm.NewContext(fvmOptions...)

engine/verification/verifier/verifiers.go

@@ -38,8 +38,9 @@ func VerifyLastKHeight(
 	nWorker uint,
 	stopOnMismatch bool,
 	transactionFeesDisabled bool,
+	scheduledCallbacksEnabled bool,
 ) (err error) {
-	closer, storages, chunkDataPacks, state, verifier, err := initStorages(chainID, protocolDataDir, chunkDataPackDir, transactionFeesDisabled)
+	closer, storages, chunkDataPacks, state, verifier, err := initStorages(chainID, protocolDataDir, chunkDataPackDir, transactionFeesDisabled, scheduledCallbacksEnabled)
 	if err != nil {
 		return fmt.Errorf("could not init storages: %w", err)
 	}
@@ -92,8 +93,9 @@ func VerifyRange(
 	nWorker uint,
 	stopOnMismatch bool,
 	transactionFeesDisabled bool,
+	scheduledCallbacksEnabled bool,
 ) (err error) {
-	closer, storages, chunkDataPacks, state, verifier, err := initStorages(chainID, protocolDataDir, chunkDataPackDir, transactionFeesDisabled)
+	closer, storages, chunkDataPacks, state, verifier, err := initStorages(chainID, protocolDataDir, chunkDataPackDir, transactionFeesDisabled, scheduledCallbacksEnabled)
 	if err != nil {
 		return fmt.Errorf("could not init storages: %w", err)
 	}
@@ -221,6 +223,7 @@ func initStorages(
 	dataDir string,
 	chunkDataPackDir string,
 	transactionFeesDisabled bool,
+	scheduledCallbacksEnabled bool,
 ) (
 	func() error,
 	*storage.All,
@@ -246,7 +249,7 @@ func initStorages(
 	chunkDataPacks := store.NewChunkDataPacks(metrics.NewNoopCollector(),
 		pebbleimpl.ToDB(chunkDataPackDB), storages.Collections, 1000)
 
-	verifier := makeVerifier(log.Logger, chainID, storages.Headers, transactionFeesDisabled)
+	verifier := makeVerifier(log.Logger, chainID, storages.Headers, transactionFeesDisabled, scheduledCallbacksEnabled)
 	closer := func() error {
 		var dbErr, chunkDataPackDBErr error
 
@@ -319,6 +322,7 @@ func makeVerifier(
 	chainID flow.ChainID,
 	headers storage.Headers,
 	transactionFeesDisabled bool,
+	scheduledCallbacksEnabled bool,
 ) module.ChunkVerifier {
 
 	vm := fvm.NewVirtualMachine()
@@ -338,7 +342,7 @@ func makeVerifier(
 		computation.DefaultFVMOptions(
 			chainID,
 			false,
-			true,
+			scheduledCallbacksEnabled,
 		)...,
 	)
 	vmCtx := fvm.NewContext(fvmOptions...)

integration/testnet/client.go

@@ -458,8 +458,21 @@ func (c *Client) GetEventsForBlockIDs(
 	return events, nil
 }
 
+func (c *Client) GetEventsForHeightRange(
+	ctx context.Context,
+	eventType string,
+	startHeight uint64,
+	endHeight uint64,
+) ([]sdk.BlockEvents, error) {
+	events, err := c.client.GetEventsForHeightRange(ctx, eventType, startHeight, endHeight)
+	if err != nil {
+		return nil, fmt.Errorf("could not get events for height range: %w", err)
+	}
+	return events, nil
+}
+
 func getAccount(ctx context.Context, client *client.Client, address sdk.Address) (*sdk.Account, error) {
-	header, err := client.GetLatestBlockHeader(ctx, false) // todo change back to true when sealing is done
+	header, err := client.GetLatestBlockHeader(ctx, true)
 	if err != nil {
 		return nil, fmt.Errorf("could not get latest block header: %w", err)
 	}