refactor verify

Author: zhangchiqing

cmd/util/cmd/verify-evm-offchain-replay/main.go

@@ -17,11 +17,12 @@ var (
 	flagEVMStateGobDir   string
 	flagChain            string
 	flagFromTo           string
+	flagSaveEveryNBlocks uint64
 )
 
 // usage example
 //
-//		./util verify-evm-offchain-replay --chain flow-testnet --from-to 211176671-211177000
+//		./util verify-evm-offchain-replay --chain flow-testnet --from_to 211176671-211177000
 //	     --datadir /var/flow/data/protocol --execution_data_dir /var/flow/data/execution_data
 var Cmd = &cobra.Command{
 	Use:   "verify-evm-offchain-replay",
@@ -44,23 +45,23 @@ func init() {
 
 	Cmd.Flags().StringVar(&flagEVMStateGobDir, "evm_state_gob_dir", "/var/flow/data/evm_state_gob",
 		"directory that stores the evm state gob files as checkpoint")
+
+	Cmd.Flags().Uint64Var(&flagSaveEveryNBlocks, "save_every", uint64(1_000_000),
+		"save the evm state gob files every N blocks")
 }
 
 func run(*cobra.Command, []string) {
-	_ = flow.ChainID(flagChain).Chain()
+	chainID := flow.ChainID(flagChain)
 
 	from, to, err := parseFromTo(flagFromTo)
 	if err != nil {
 		log.Fatal().Err(err).Msg("could not parse from_to")
 	}
 
-	log.Info().Msgf("verifying range from %d to %d", from, to)
-	err = Verify(log.Logger, from, to, flow.Testnet, flagDatadir, flagExecutionDataDir, flagEVMStateGobDir)
+	err = Verify(log.Logger, from, to, chainID, flagDatadir, flagExecutionDataDir, flagEVMStateGobDir, flagSaveEveryNBlocks)
 	if err != nil {
 		log.Fatal().Err(err).Msg("could not verify height")
 	}
-	log.Info().Msgf("successfully verified range from %d to %d", from, to)
-
 }
 
 func parseFromTo(fromTo string) (from, to uint64, err error) {

cmd/util/cmd/verify-evm-offchain-replay/verify.go

@@ -9,10 +9,9 @@ import (
 	"github.com/dgraph-io/badger/v2"
 	badgerds "github.com/ipfs/go-ds-badger2"
 	"github.com/rs/zerolog"
+	"github.com/rs/zerolog/log"
 
 	"github.com/onflow/flow-go/cmd/util/cmd/common"
-	"github.com/onflow/flow-go/fvm/environment"
-	"github.com/onflow/flow-go/fvm/evm"
 	"github.com/onflow/flow-go/fvm/evm/offchain/utils"
 	"github.com/onflow/flow-go/fvm/evm/testutils"
 	"github.com/onflow/flow-go/model/flow"
@@ -23,13 +22,26 @@ import (
 
 // Verify verifies the offchain replay of EVM blocks from the given height range
 // and updates the EVM state gob files with the latest state
-func Verify(log zerolog.Logger, from uint64, to uint64, chainID flow.ChainID, dataDir string, executionDataDir string, evmStateGobDir string) error {
-	log.Info().
+func Verify(
+	log zerolog.Logger,
+	from uint64,
+	to uint64,
+	chainID flow.ChainID,
+	dataDir string,
+	executionDataDir string,
+	evmStateGobDir string,
+	saveEveryNBlocks uint64,
+) error {
+	lg := log.With().
+		Uint64("from", from).Uint64("to", to).
 		Str("chain", chainID.String()).
 		Str("dataDir", dataDir).
 		Str("executionDataDir", executionDataDir).
 		Str("evmStateGobDir", evmStateGobDir).
-		Msgf("verifying range from %d to %d", from, to)
+		Uint64("saveEveryNBlocks", saveEveryNBlocks).
+		Logger()
+
+	lg.Info().Msgf("verifying range from %d to %d", from, to)
 
 	db, storages, executionDataStore, dsStore, err := initStorages(dataDir, executionDataDir)
 	if err != nil {
@@ -40,34 +52,32 @@ func Verify(log zerolog.Logger, from uint64, to uint64, chainID flow.ChainID, da
 	defer dsStore.Close()
 
 	var store *testutils.TestValueStore
-	isRoot := isEVMRootHeight(chainID, from)
-	if isRoot {
-		log.Info().Msgf("initializing EVM state for root height %d", from)
 
+	// root block require the account status registers to be saved
+	isRoot := utils.IsEVMRootHeight(chainID, from)
+	if isRoot {
 		store = testutils.GetSimpleValueStore()
-		as := environment.NewAccountStatus()
-		rootAddr := evm.StorageAccountAddress(chainID)
-		err = store.SetValue(rootAddr[:], []byte(flow.AccountStatusKey), as.ToBytes())
-		if err != nil {
-			return err
-		}
 	} else {
 		prev := from - 1
-		log.Info().Msgf("loading EVM state from previous height %d", prev)
-
-		valueFileName, allocatorFileName := evmStateGobFileNamesByEndHeight(evmStateGobDir, prev)
-		values, err := testutils.DeserializeState(valueFileName)
+		store, err = loadState(prev, evmStateGobDir)
 		if err != nil {
-			return fmt.Errorf("could not deserialize state %v: %w", valueFileName, err)
+			return fmt.Errorf("could not load EVM state from previous height %d: %w", prev, err)
 		}
+	}
 
-		allocators, err := testutils.DeserializeAllocator(allocatorFileName)
-		if err != nil {
-			return fmt.Errorf("could not deserialize allocator %v: %w", allocatorFileName, err)
+	// save state every N blocks
+	onHeightReplayed := func(height uint64) error {
+		log.Info().Msgf("replayed height %d", height)
+		if height%saveEveryNBlocks == 0 {
+			err := saveState(store, height, evmStateGobDir)
+			if err != nil {
+				return err
+			}
 		}
-		store = testutils.GetSimpleValueStorePopulated(values, allocators)
+		return nil
 	}
 
+	// replay blocks
 	err = utils.OffchainReplayBackwardCompatibilityTest(
 		log,
 		chainID,
@@ -77,16 +87,27 @@ func Verify(log zerolog.Logger, from uint64, to uint64, chainID flow.ChainID, da
 		storages.Results,
 		executionDataStore,
 		store,
-		func(uint64) error { return nil },
+		onHeightReplayed,
 	)
 
 	if err != nil {
 		return err
 	}
 
-	valueFileName, allocatorFileName := evmStateGobFileNamesByEndHeight(evmStateGobDir, to)
+	err = saveState(store, to, evmStateGobDir)
+	if err != nil {
+		return err
+	}
+
+	lg.Info().Msgf("successfully verified range from %d to %d", from, to)
+
+	return nil
+}
+
+func saveState(store *testutils.TestValueStore, height uint64, gobDir string) error {
+	valueFileName, allocatorFileName := evmStateGobFileNamesByEndHeight(gobDir, height)
 	values, allocators := store.Dump()
-	err = testutils.SerializeState(valueFileName, values)
+	err := testutils.SerializeState(valueFileName, values)
 	if err != nil {
 		return err
 	}
@@ -100,6 +121,23 @@ func Verify(log zerolog.Logger, from uint64, to uint64, chainID flow.ChainID, da
 	return nil
 }
 
+func loadState(height uint64, gobDir string) (*testutils.TestValueStore, error) {
+	valueFileName, allocatorFileName := evmStateGobFileNamesByEndHeight(gobDir, height)
+	values, err := testutils.DeserializeState(valueFileName)
+	if err != nil {
+		return nil, fmt.Errorf("could not deserialize state %v: %w", valueFileName, err)
+	}
+
+	allocators, err := testutils.DeserializeAllocator(allocatorFileName)
+	if err != nil {
+		return nil, fmt.Errorf("could not deserialize allocator %v: %w", allocatorFileName, err)
+	}
+	store := testutils.GetSimpleValueStorePopulated(values, allocators)
+
+	log.Info().Msgf("loaded EVM state for height %d from gob file %v", height, valueFileName)
+	return store, nil
+}
+
 func initStorages(dataDir string, executionDataDir string) (
 	*badger.DB,
 	*storage.All,
@@ -128,16 +166,6 @@ func initStorages(dataDir string, executionDataDir string) (
 	return db, storages, executionDataStore, ds, nil
 }
 
-// EVM Root Height is the first block that has EVM Block Event where the EVM block height is 1
-func isEVMRootHeight(chainID flow.ChainID, flowHeight uint64) bool {
-	if chainID == flow.Testnet {
-		return flowHeight == 211176671
-	} else if chainID == flow.Mainnet {
-		return flowHeight == 85981136
-	}
-	return flowHeight == 1
-}
-
 func evmStateGobFileNamesByEndHeight(evmStateGobDir string, endHeight uint64) (string, string) {
 	valueFileName := filepath.Join(evmStateGobDir, fmt.Sprintf("values-%d.gob", endHeight))
 	allocatorFileName := filepath.Join(evmStateGobDir, fmt.Sprintf("allocators-%d.gob", endHeight))