exportSlashingProtectionJSON: Check database type.

cmd/validator/slashing-protection/BUILD.bazel

@@ -21,6 +21,7 @@ go_library(
         "//validator/db/iface:go_default_library",
         "//validator/db/kv:go_default_library",
         "//validator/slashing-protection-history:go_default_library",
+        "//validator/slashing-protection-history/format:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_urfave_cli_v2//:go_default_library",

cmd/validator/slashing-protection/export.go

@@ -8,10 +8,15 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v4/cmd"
 	"github.com/prysmaticlabs/prysm/v4/cmd/validator/flags"
+	"github.com/prysmaticlabs/prysm/v4/config/features"
 	"github.com/prysmaticlabs/prysm/v4/io/file"
 	"github.com/prysmaticlabs/prysm/v4/validator/accounts/userprompt"
+	"github.com/prysmaticlabs/prysm/v4/validator/db/filesystem"
+	"github.com/prysmaticlabs/prysm/v4/validator/db/iface"
 	"github.com/prysmaticlabs/prysm/v4/validator/db/kv"
 	slashingprotection "github.com/prysmaticlabs/prysm/v4/validator/slashing-protection-history"
+	"github.com/prysmaticlabs/prysm/v4/validator/slashing-protection-history/format"
+
 	"github.com/urfave/cli/v2"
 )
 
@@ -30,39 +35,63 @@ const (
 // the validator's db into an EIP standard slashing protection format
 // 4. Format and save the JSON file to a user's specified output directory.
 func exportSlashingProtectionJSON(cliCtx *cli.Context) error {
+	var (
+		validatorDB iface.ValidatorDB
+		err         error
+	)
+
 	log.Info(
 		"This command exports your validator's attestation and proposal history into " +
 			"a file that can then be imported into any other Prysm setup across computers",
 	)
-	var err error
+
+	// Check if a minimal database is requested
+	isDatabaseMinimal := cliCtx.Bool(features.EnableMinimalSlashingProtectionDatabase.Name)
+
+	// Read the data directory from the CLI context.
 	dataDir := cliCtx.String(cmd.DataDirFlag.Name)
 	if !cliCtx.IsSet(cmd.DataDirFlag.Name) {
 		dataDir, err = userprompt.InputDirectory(cliCtx, userprompt.DataDirDirPromptText, cmd.DataDirFlag)
 		if err != nil {
 			return errors.Wrapf(err, "could not read directory value from input")
 		}
 	}
-	// ensure that the validator.db is found under the specified dir or its subdirectories
-	found, _, err := file.RecursiveFileFind(kv.ProtectionDbFileName, dataDir)
+
+	// Ensure that the database is found under the specified dir or its subdirectories
+	found := false
+	if isDatabaseMinimal {
+		found, _, err = file.RecursiveDirFind(filesystem.SlashingProtectionDirName, dataDir)
+	} else {
+		found, _, err = file.RecursiveFileFind(kv.ProtectionDbFileName, dataDir)
+	}
+
 	if err != nil {
 		return errors.Wrapf(err, "error finding validator database at path %s", dataDir)
 	}
+
 	if !found {
-		return fmt.Errorf(
-			"validator.db file (validator database) was not found at path %s, so nothing to export",
-			dataDir,
-		)
+		return fmt.Errorf("validator.db file (validator database) was not found at path %s, so nothing to export", dataDir)
+	}
+
+	// Open the validator database.
+	if isDatabaseMinimal {
+		validatorDB, err = filesystem.NewStore(dataDir, nil)
+	} else {
+		validatorDB, err = kv.NewKVStore(cliCtx.Context, dataDir, nil)
 	}
 
-	validatorDB, err := kv.NewKVStore(cliCtx.Context, dataDir, &kv.Config{})
 	if err != nil {
 		return errors.Wrapf(err, "could not access validator database at path %s", dataDir)
 	}
+
+	// Close the database when we're done.
 	defer func() {
 		if err := validatorDB.Close(); err != nil {
 			log.WithError(err).Errorf("Could not close validator DB")
 		}
 	}()
+
+	// Export the slashing protection history from the validator's database.
 	eipJSON, err := slashingprotection.ExportStandardProtectionJSON(cliCtx.Context, validatorDB)
 	if err != nil {
 		return errors.Wrap(err, "could not export slashing protection history")
@@ -79,39 +108,60 @@ func exportSlashingProtectionJSON(cliCtx *cli.Context) error {
 		)
 	}
 
+	// Write the result to the output file
+	if err := writeToOutput(cliCtx, eipJSON); err != nil {
+		return errors.Wrap(err, "could not write slashing protection history to output file")
+	}
+
+	return nil
+}
+
+func writeToOutput(cliCtx *cli.Context, eipJSON *format.EIPSlashingProtectionFormat) error {
+	// Get the output directory where the slashing protection history file will be stored
 	outputDir, err := userprompt.InputDirectory(
 		cliCtx,
 		"Enter your desired output directory for your slashing protection history file",
 		flags.SlashingProtectionExportDirFlag,
 	)
+
 	if err != nil {
 		return errors.Wrap(err, "could not get slashing protection json file")
 	}
+
 	if outputDir == "" {
 		return errors.New("output directory not specified")
 	}
+
+	// Check is the output directory already exists, if not, create it
 	exists, err := file.HasDir(outputDir)
 	if err != nil {
 		return errors.Wrapf(err, "could not check if output directory %s already exists", outputDir)
 	}
+
 	if !exists {
 		if err := file.MkdirAll(outputDir); err != nil {
 			return errors.Wrapf(err, "could not create output directory %s", outputDir)
 		}
 	}
+
+	// Write into the output file
 	outputFilePath := filepath.Join(outputDir, jsonExportFileName)
 	log.Infof("Writing slashing protection export JSON file to %s", outputFilePath)
+
 	encoded, err := json.MarshalIndent(eipJSON, "", "\t")
 	if err != nil {
 		return errors.Wrap(err, "could not JSON marshal slashing protection history")
 	}
+
 	if err := file.WriteFile(outputFilePath, encoded); err != nil {
 		return errors.Wrapf(err, "could not write file to path %s", outputFilePath)
 	}
+
 	log.Infof(
 		"Successfully wrote %s. You can import this file using Prysm's "+
 			"validator slashing-protection-history import command in another machine",
 		outputFilePath,
 	)
+
 	return nil
 }