Implement EIP-3076 minimal slashing protection, using a filesystem database (#13360)

* `EpochFromString`: Use already defined `Uint64FromString` function.

* `Test_uint64FromString` => `Test_FromString`

This test function tests more functions than `Uint64FromString`.

* Slashing protection history: Remove unreachable code.

The function `NewKVStore` creates, via `kv.UpdatePublicKeysBuckets`,
a new item in the `proposal-history-bucket-interchange`.

IMO there is no real reason to prefer `proposal` than `attestation`
as a prefix for this bucket, but this is the way it is done right now
and renaming the bucket will probably be backward incompatible.

An `attestedPublicKey` cannot exist without
the corresponding `proposedPublicKey`.

Thus, the `else` portion of code removed in this commit is not reachable.
We raise an error if we get there.

This is also probably the reason why the removed `else` portion was not
tested.

* `NewKVStore`: Switch items in `createBuckets`.

So the order corresponds to `schema.go`

* `slashableAttestationCheck`: Fix comments and logs.

* `ValidatorClient.db`: Use `iface.ValidatorDB`.

* BoltDB database: Implement `GraffitiFileHash`.

* Filesystem database: Creates `db.go`.

This file defines the following structs:
- `Store`
- `Graffiti`
- `Configuration`
- `ValidatorSlashingProtection`

This files implements the following public functions:
- `NewStore`
- `Close`
- `Backup`
- `DatabasePath`
- `ClearDB`
- `UpdatePublicKeysBuckets`

This files implements the following private functions:
- `slashingProtectionDirPath`
- `configurationFilePath`
- `configuration`
- `saveConfiguration`
- `validatorSlashingProtection`
- `saveValidatorSlashingProtection`
- `publicKeys`

* Filesystem database: Creates `genesis.go`.

This file defines the following public functions:
- `GenesisValidatorsRoot`
- `SaveGenesisValidatorsRoot`

* Filesystem database: Creates `graffiti.go`.

This file defines the following public functions:
- `SaveGraffitiOrderedIndex`
- `GraffitiOrderedIndex`

* Filesystem database: Creates `migration.go`.

This file defines the following public functions:
- `RunUpMigrations`
- `RunDownMigrations`

* Filesystem database: Creates proposer_settings.go.

This file defines the following public functions:
- `ProposerSettings`
- `ProposerSettingsExists`
- `SaveProposerSettings`

* Filesystem database: Creates `attester_protection.go`.

This file defines the following public functions:
- `EIPImportBlacklistedPublicKeys`
- `SaveEIPImportBlacklistedPublicKeys`
- `SigningRootAtTargetEpoch`
- `LowestSignedTargetEpoch`
- `LowestSignedSourceEpoch`
- `AttestedPublicKeys`
- `CheckSlashableAttestation`
- `SaveAttestationForPubKey`
- `SaveAttestationsForPubKey`
- `AttestationHistoryForPubKey`

* Filesystem database: Creates `proposer_protection.go`.

This file defines the following public functions:
- `HighestSignedProposal`
- `LowestSignedProposal`
- `ProposalHistoryForPubKey`
- `ProposalHistoryForSlot`
- `ProposedPublicKeys`

* Ensure that the filesystem store implements the `ValidatorDB` interface.

* `slashableAttestationCheck`: Check the database type.

* `slashableProposalCheck`: Check the database type.

* `slashableAttestationCheck`: Allow usage of minimal slashing protection.

* `slashableProposalCheck`: Allow usage of minimal slashing protection.

* `ImportStandardProtectionJSON`: Check the database type.

* `ImportStandardProtectionJSON`: Allow usage of min slashing protection.

* Implement `RecursiveDirFind`.

* Implement minimal<->complete DB conversion.

3 public functions are implemented:
- `IsCompleteDatabaseExisting`
- `IsMinimalDatabaseExisting`
- `ConvertDatabase`

* `setupDB`: Add `isSlashingProtectionMinimal` argument.

The feature addition is located in `validator/node/node_test.go`.
The rest of this commit consists in minimal slashing protection testing.

* `setupWithKey`: Add `isSlashingProtectionMinimal` argument.

The feature addition is located in `validator/client/propose_test.go`.

The rest of this commit consists in tests wrapping.

* `setup`: Add `isSlashingProtectionMinimal` argument.

The added feature is located in the `validator/client/propose_test.go`
file.

The rest of this commit consists in tests wrapping.

* `initializeFromCLI` and `initializeForWeb`: Factorize db init.

* Add `convert-complete-to-minimal` command.

* Creates `--enable-minimal-slashing-protection` flag.

* `importSlashingProtectionJSON`: Check database type.

* `exportSlashingProtectionJSON`: Check database type.

* `TestClearDB`: Test with minimal slashing protection.

* KeyManager: Test with minimal slashing protection.

* RPC: KeyManager: Test with minimal slashing protection.

* `convert-complete-to-minimal`: Change option names.

Options were:
- `--source` (for source data directory), and
- `--target` (for target data directory)

However, since this command deals with slashing protection, which has
source (epochs) and target (epochs), the initial option names may confuse
the user.

In this commit:
`--source` ==> `--source-data-dir`
`--target` ==> `--target-data-dir`

* Set `SlashableAttestationCheck` as an iface method.

And delete `CheckSlashableAttestation` from iface.

* Move helpers functions in a more general directory.

No functional change.

* Extract common structs out of `kv`.

==> `filesystem` does not depend anymore on `kv`.
==> `iface` does not depend anymore on `kv`.
==> `slashing-protection` does not depend anymore on `kv`.

* Move `ValidateMetadata` in `validator/helpers`.

* `ValidateMetadata`: Test with mock.

This way, we can:
- Avoid any circular import for tests.
- Implement once for all `iface.ValidatorDB` implementations
  the `ValidateMetadata`function.
- Have tests (and coverage) of `ValidateMetadata`in
  its own package.

The ideal solution would have been to implement `ValidateMetadata` as
a method with the `iface.ValidatorDB`receiver.
Unfortunately, golang does not allow that.

* `iface.ValidatorDB`: Implement ImportStandardProtectionJSON.

The whole purpose of this commit is to avoid the `switch validatorDB.(type)`
in `ImportStandardProtectionJSON`.

* `iface.ValidatorDB`: Implement `SlashableProposalCheck`.

* Remove now useless `slashableProposalCheck`.

* Delete useless `ImportStandardProtectionJSON`.

* `file.Exists`: Detect directories and return an error.

Before, `Exists` was only able to detect if a file exists.
Now, this function takes an extra `File` or `Directory` argument.
It detects either if a file or a directory exists.

Before, if an error was returned by `os.Stat`, the the file was
considered as non existing.
Now, it is treated as a real error.

* Replace `os.Stat` by `file.Exists`.

* Remove `Is{Complete,Minimal}DatabaseExisting`.

* `publicKeys`: Add log if unexpected file found.

* Move `{Source,Target}DataDirFlag`in `db.go`.

* `failedAttLocalProtectionErr`: `var`==> `const`

* `signingRoot`: `32`==> `fieldparams.RootLength`.

* `validatorClientData`==> `validator-client-data`.

To be consistent with `slashing-protection`.

* Add progress bars for `import` and `convert`.

* `parseBlocksForUniquePublicKeys`: Move in `db/kv`.

* helpers: Remove unused `initializeProgressBar` function.

cmd/validator/accounts/backup_test.go

@@ -98,7 +98,9 @@ func TestBackupAccounts_Noninteractive_Derived(t *testing.T) {
 
 	// We check a backup.zip file was created at the output path.
 	zipFilePath := filepath.Join(backupDir, accounts.ArchiveFilename)
-	assert.DeepEqual(t, true, file.Exists(zipFilePath))
+	fileExists, err := file.Exists(zipFilePath, file.Regular)
+	require.NoError(t, err, "could not check if backup file exists")
+	assert.Equal(t, true, fileExists, "backup file does not exist")
 
 	// We attempt to unzip the file and verify the keystores do match our accounts.
 	f, err := os.Open(zipFilePath)
@@ -189,7 +191,9 @@ func TestBackupAccounts_Noninteractive_Imported(t *testing.T) {
 
 	// We check a backup.zip file was created at the output path.
 	zipFilePath := filepath.Join(backupDir, accounts.ArchiveFilename)
-	assert.DeepEqual(t, true, file.Exists(zipFilePath))
+	exists, err := file.Exists(zipFilePath, file.Regular)
+	require.NoError(t, err, "could not check if backup file exists")
+	assert.Equal(t, true, exists, "backup file does not exist")
 
 	// We attempt to unzip the file and verify the keystores do match our accounts.
 	f, err := os.Open(zipFilePath)

cmd/validator/accounts/exit_test.go

@@ -395,5 +395,7 @@ func TestExitAccountsCli_WriteJSON_NoBroadcast(t *testing.T) {
 	require.Equal(t, 1, len(formattedExitedKeys))
 	assert.Equal(t, "0x"+keystore.Pubkey[:12], formattedExitedKeys[0])
 
-	require.Equal(t, true, file.Exists(path.Join(out, "validator-exit-1.json")), "Expected file to exist")
+	exists, err := file.Exists(path.Join(out, "validator-exit-1.json"), file.Regular)
+	require.NoError(t, err, "could not check if exit file exists")
+	require.Equal(t, true, exists, "Expected file to exist")
 }

cmd/validator/db/db.go

@@ -10,6 +10,22 @@ import (
 
 var log = logrus.WithField("prefix", "db")
 
+var (
+	// SourceDataDirFlag defines a path on disk where source Prysm databases are stored. Used for conversion.
+	SourceDataDirFlag = &cli.StringFlag{
+		Name:     "source-data-dir",
+		Usage:    "Source data directory",
+		Required: true,
+	}
+
+	// SourceDataDirFlag defines a path on disk where source Prysm databases are stored. Used for conversion.
+	TargetDataDirFlag = &cli.StringFlag{
+		Name:     "target-data-dir",
+		Usage:    "Target data directory",
+		Required: true,
+	}
+)
+
 // Commands for interacting with the Prysm validator database.
 var Commands = &cli.Command{
 	Name:     "db",
@@ -66,5 +82,29 @@ var Commands = &cli.Command{
 				},
 			},
 		},
+		{
+			Name:     "convert-complete-to-minimal",
+			Category: "db",
+			Usage:    "Convert a complete EIP-3076 slashing protection to a minimal one",
+			Flags: []cli.Flag{
+				SourceDataDirFlag,
+				TargetDataDirFlag,
+			},
+			Before: func(cliCtx *cli.Context) error {
+				return cmd.LoadFlagsFromConfig(cliCtx, cliCtx.Command.Flags)
+			},
+			Action: func(cliCtx *cli.Context) error {
+				sourcedDatabasePath := cliCtx.String(SourceDataDirFlag.Name)
+				targetDatabasePath := cliCtx.String(TargetDataDirFlag.Name)
+
+				// Convert the database
+				err := validatordb.ConvertDatabase(cliCtx.Context, sourcedDatabasePath, targetDatabasePath, false)
+				if err != nil {
+					log.WithError(err).Fatal("Could not convert database")
+				}
+
+				return nil
+			},
+		},
 	},
 }

cmd/validator/slashing-protection/BUILD.bazel

@@ -17,8 +17,11 @@ go_library(
         "//io/file:go_default_library",
         "//runtime/tos:go_default_library",
         "//validator/accounts/userprompt:go_default_library",
+        "//validator/db/filesystem:go_default_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",
@@ -35,7 +38,7 @@ go_test(
         "//io/file:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
-        "//validator/db/kv:go_default_library",
+        "//validator/db/common:go_default_library",
         "//validator/db/testing:go_default_library",
         "//validator/slashing-protection-history/format:go_default_library",
         "//validator/testing:go_default_library",

cmd/validator/slashing-protection/export.go

@@ -8,10 +8,14 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/cmd"
 	"github.com/prysmaticlabs/prysm/v5/cmd/validator/flags"
+	"github.com/prysmaticlabs/prysm/v5/config/features"
 	"github.com/prysmaticlabs/prysm/v5/io/file"
 	"github.com/prysmaticlabs/prysm/v5/validator/accounts/userprompt"
+	"github.com/prysmaticlabs/prysm/v5/validator/db/filesystem"
+	"github.com/prysmaticlabs/prysm/v5/validator/db/iface"
 	"github.com/prysmaticlabs/prysm/v5/validator/db/kv"
 	slashingprotection "github.com/prysmaticlabs/prysm/v5/validator/slashing-protection-history"
+	"github.com/prysmaticlabs/prysm/v5/validator/slashing-protection-history/format"
 	"github.com/urfave/cli/v2"
 )
 
@@ -30,11 +34,21 @@ 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
+		found       bool
+		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.EnableMinimalSlashingProtection.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)
@@ -42,27 +56,45 @@ func exportSlashingProtectionJSON(cliCtx *cli.Context) error {
 			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
+	if isDatabaseMinimal {
+		found, _, err = file.RecursiveDirFind(filesystem.DatabaseDirName, 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,
-		)
+		databaseFileDir := kv.ProtectionDbFileName
+		if isDatabaseMinimal {
+			databaseFileDir = filesystem.DatabaseDirName
+		}
+		return fmt.Errorf("%s (validator database) was not found at path %s, so nothing to export", databaseFileDir, 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 +111,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
 }

cmd/validator/slashing-protection/import.go

@@ -7,10 +7,12 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/cmd"
 	"github.com/prysmaticlabs/prysm/v5/cmd/validator/flags"
+	"github.com/prysmaticlabs/prysm/v5/config/features"
 	"github.com/prysmaticlabs/prysm/v5/io/file"
 	"github.com/prysmaticlabs/prysm/v5/validator/accounts/userprompt"
+	"github.com/prysmaticlabs/prysm/v5/validator/db/filesystem"
+	"github.com/prysmaticlabs/prysm/v5/validator/db/iface"
 	"github.com/prysmaticlabs/prysm/v5/validator/db/kv"
-	slashingprotection "github.com/prysmaticlabs/prysm/v5/validator/slashing-protection-history"
 	"github.com/urfave/cli/v2"
 )
 
@@ -24,7 +26,16 @@ import (
 // 4. Call the function which actually imports the data from
 // the standard slashing protection JSON file into our database.
 func importSlashingProtectionJSON(cliCtx *cli.Context) error {
-	var err error
+	var (
+		valDB iface.ValidatorDB
+		found bool
+		err   error
+	)
+
+	// Check if a minimal database is requested
+	isDatabaseMimimal := cliCtx.Bool(features.EnableMinimalSlashingProtection.Name)
+
+	// Get 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)
@@ -32,28 +43,44 @@ func importSlashingProtectionJSON(cliCtx *cli.Context) error {
 			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 directory or its subdirectories
+	if isDatabaseMimimal {
+		found, _, err = file.RecursiveDirFind(filesystem.DatabaseDirName, dataDir)
+	} else {
+		found, _, err = file.RecursiveFileFind(kv.ProtectionDbFileName, dataDir)
+	}
+
 	if err != nil {
 		return errors.Wrapf(err, "error finding validator database at path %s", dataDir)
 	}
+
+	message := "Found existing database inside of %s"
 	if !found {
-		log.Infof(
-			"Did not find existing validator.db inside of %s, creating a new one",
-			dataDir,
-		)
-	} else {
-		log.Infof("Found existing validator.db inside of %s", dataDir)
+		message = "Did not find existing database inside of %s, creating a new one"
 	}
-	valDB, err := kv.NewKVStore(cliCtx.Context, dataDir, &kv.Config{})
+
+	log.Infof(message, dataDir)
+
+	// Open the validator database.
+	if isDatabaseMimimal {
+		valDB, err = filesystem.NewStore(dataDir, nil)
+	} else {
+		valDB, err = kv.NewKVStore(cliCtx.Context, dataDir, nil)
+	}
+
 	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 := valDB.Close(); err != nil {
 			log.WithError(err).Errorf("Could not close validator DB")
 		}
 	}()
+
+	// Get the path to the slashing protection JSON file from the CLI context.
 	protectionFilePath, err := userprompt.InputDirectory(cliCtx, userprompt.SlashingProtectionJSONPromptText, flags.SlashingProtectionJSONFileFlag)
 	if err != nil {
 		return errors.Wrap(err, "could not get slashing protection json file")
@@ -65,17 +92,22 @@ func importSlashingProtectionJSON(cliCtx *cli.Context) error {
 			flags.SlashingProtectionJSONFileFlag.Name,
 		)
 	}
+
+	// Read the JSON file from user input.
 	enc, err := file.ReadFileAsBytes(protectionFilePath)
 	if err != nil {
 		return err
 	}
+
+	// Import the data from the standard slashing protection JSON file into our database.
 	log.Infof("Starting import of slashing protection file %s", protectionFilePath)
 	buf := bytes.NewBuffer(enc)
-	if err := slashingprotection.ImportStandardProtectionJSON(
-		cliCtx.Context, valDB, buf,
-	); err != nil {
-		return err
+
+	if err := valDB.ImportStandardProtectionJSON(cliCtx.Context, buf); err != nil {
+		return errors.Wrapf(err, "could not import slashing protection JSON file %s", protectionFilePath)
 	}
+
 	log.Infof("Slashing protection JSON successfully imported into %s", dataDir)
+
 	return nil
 }

cmd/validator/slashing-protection/import_export_test.go

@@ -11,7 +11,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/io/file"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/validator/db/kv"
+	"github.com/prysmaticlabs/prysm/v5/validator/db/common"
 	dbTest "github.com/prysmaticlabs/prysm/v5/validator/db/testing"
 	"github.com/prysmaticlabs/prysm/v5/validator/slashing-protection-history/format"
 	mocks "github.com/prysmaticlabs/prysm/v5/validator/testing"
@@ -35,6 +35,11 @@ func setupCliCtx(
 	return cli.NewContext(&app, set, nil)
 }
 
+// TestImportExportSlashingProtectionCli_RoundTrip imports a EIP-3076 interchange format JSON file,
+// and exports it back to disk. It then compare the exported file to the original file.
+// This test is only suitable for complete slashing protection history database, since minimal
+// slashing protection history database will keep only the latest signed block slot / attestations,
+// and thus will not be able to export the same data as the original file.
 func TestImportExportSlashingProtectionCli_RoundTrip(t *testing.T) {
 	numValidators := 10
 	outputPath := filepath.Join(t.TempDir(), "slashing-exports")
@@ -59,7 +64,8 @@ func TestImportExportSlashingProtectionCli_RoundTrip(t *testing.T) {
 	require.NoError(t, err)
 
 	// We create a CLI context with the required values, such as the database datadir and output directory.
-	validatorDB := dbTest.SetupDB(t, pubKeys)
+	isSlashingProtectionMinimal := false
+	validatorDB := dbTest.SetupDB(t, pubKeys, isSlashingProtectionMinimal)
 	dbPath := validatorDB.DatabasePath()
 	require.NoError(t, validatorDB.Close())
 	cliCtx := setupCliCtx(t, dbPath, protectionFilePath, outputPath)
@@ -108,6 +114,11 @@ func TestImportExportSlashingProtectionCli_RoundTrip(t *testing.T) {
 	}
 }
 
+// TestImportExportSlashingProtectionCli_EmptyData imports a EIP-3076 interchange format JSON file,
+// and exports it back to disk. It then compare the exported file to the original file.
+// This test is only suitable for complete slashing protection history database, since minimal
+// slashing protection history database will keep only the latest signed block slot / attestations,
+// and thus will not be able to export the same data as the original file.
 func TestImportExportSlashingProtectionCli_EmptyData(t *testing.T) {
 	numValidators := 10
 	outputPath := filepath.Join(t.TempDir(), "slashing-exports")
@@ -118,10 +129,10 @@ func TestImportExportSlashingProtectionCli_EmptyData(t *testing.T) {
 	// Create some mock slashing protection history. and JSON file
 	pubKeys, err := mocks.CreateRandomPubKeys(numValidators)
 	require.NoError(t, err)
-	attestingHistory := make([][]*kv.AttestationRecord, 0)
-	proposalHistory := make([]kv.ProposalHistoryForPubkey, len(pubKeys))
+	attestingHistory := make([][]*common.AttestationRecord, 0)
+	proposalHistory := make([]common.ProposalHistoryForPubkey, len(pubKeys))
 	for i := 0; i < len(pubKeys); i++ {
-		proposalHistory[i].Proposals = make([]kv.Proposal, 0)
+		proposalHistory[i].Proposals = make([]common.Proposal, 0)
 	}
 	mockJSON, err := mocks.MockSlashingProtectionJSON(pubKeys, attestingHistory, proposalHistory)
 	require.NoError(t, err)
@@ -135,7 +146,8 @@ func TestImportExportSlashingProtectionCli_EmptyData(t *testing.T) {
 	require.NoError(t, err)
 
 	// We create a CLI context with the required values, such as the database datadir and output directory.
-	validatorDB := dbTest.SetupDB(t, pubKeys)
+	isSlashingProtectionMinimal := false
+	validatorDB := dbTest.SetupDB(t, pubKeys, isSlashingProtectionMinimal)
 	dbPath := validatorDB.DatabasePath()
 	require.NoError(t, validatorDB.Close())
 	cliCtx := setupCliCtx(t, dbPath, protectionFilePath, outputPath)

cmd/validator/slashing-protection/slashing-protection.go

@@ -25,6 +25,7 @@ var Commands = &cli.Command{
 				features.PraterTestnet,
 				features.SepoliaTestnet,
 				features.HoleskyTestnet,
+				features.EnableMinimalSlashingProtection,
 				cmd.AcceptTosFlag,
 			}),
 			Before: func(cliCtx *cli.Context) error {
@@ -53,6 +54,7 @@ var Commands = &cli.Command{
 				features.PraterTestnet,
 				features.SepoliaTestnet,
 				features.HoleskyTestnet,
+				features.EnableMinimalSlashingProtection,
 				cmd.AcceptTosFlag,
 			}),
 			Before: func(cliCtx *cli.Context) error {