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.

io/file/BUILD.bazel

@@ -8,7 +8,6 @@ go_library(
     deps = [
         "//config/params:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
     ],
 )
 

io/file/fileutil.go

@@ -14,7 +14,13 @@ import (
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
-	log "github.com/sirupsen/logrus"
+)
+
+type ObjType int
+
+const (
+	Regular ObjType = iota
+	Directory
 )
 
 // ExpandPath given a string which may be a relative path.
@@ -85,7 +91,13 @@ func WriteFile(file string, data []byte) error {
 	if err != nil {
 		return err
 	}
-	if Exists(expanded) {
+
+	exists, err := Exists(expanded, Regular)
+	if err != nil {
+		return errors.Wrapf(err, "could not check if file exists at path %s", expanded)
+	}
+
+	if exists {
 		info, err := os.Stat(expanded)
 		if err != nil {
 			return err
@@ -136,19 +148,28 @@ func HasReadWritePermissions(itemPath string) (bool, error) {
 
 // Exists returns true if a file is not a directory and exists
 // at the specified path.
-func Exists(filename string) bool {
+func Exists(filename string, objType ObjType) (bool, error) {
 	filePath, err := ExpandPath(filename)
 	if err != nil {
-		return false
+		return false, errors.Wrapf(err, "could not expend path of file %s", filename)
 	}
+
 	info, err := os.Stat(filePath)
 	if err != nil {
-		if !os.IsNotExist(err) {
-			log.WithError(err).Info("Checking for file existence returned an error")
+		if os.IsNotExist(err) {
+			return false, nil
 		}
-		return false
+
+		return false, errors.Wrapf(err, "could not get file info for file %s", filename)
 	}
-	return info != nil && !info.IsDir()
+
+	if info == nil {
+		return false, errors.New("file info is nil")
+	}
+
+	isDir := info.IsDir()
+
+	return objType == Directory && isDir || objType == Regular && !isDir, nil
 }
 
 // RecursiveFileFind returns true, and the path,  if a file is not a directory and exists
@@ -183,6 +204,40 @@ func RecursiveFileFind(filename, dir string) (bool, string, error) {
 	return found, fpath, nil
 }
 
+// RecursiveDirFind searches for directory in a directory and its subdirectories.
+func RecursiveDirFind(dirname, dir string) (bool, string, error) {
+	var (
+		found bool
+		fpath string
+	)
+
+	dir = filepath.Clean(dir)
+	found = false
+
+	err := filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return errors.Wrapf(err, "error walking directory %s", dir)
+		}
+
+		// Checks if its a file  and has the exact name as the dirname
+		// need to break the walk function by using a non-fatal error
+		if info.IsDir() && dirname == info.Name() {
+			found = true
+			fpath = path
+			return errStopWalk
+		}
+
+		// No errors or file found
+		return nil
+	})
+
+	if err != nil && err != errStopWalk {
+		return false, "", errors.Wrapf(err, "error walking directory %s", dir)
+	}
+
+	return found, fpath, nil
+}
+
 // ReadFileAsBytes expands a file name's absolute path and reads it as bytes from disk.
 func ReadFileAsBytes(filename string) ([]byte, error) {
 	filePath, err := ExpandPath(filename)
@@ -194,7 +249,12 @@ func ReadFileAsBytes(filename string) ([]byte, error) {
 
 // CopyFile copy a file from source to destination path.
 func CopyFile(src, dst string) error {
-	if !Exists(src) {
+	exists, err := Exists(src, Regular)
+	if err != nil {
+		return errors.Wrapf(err, "could not check if file exists at path %s", src)
+	}
+
+	if !exists {
 		return errors.New("source file does not exist at provided path")
 	}
 	f, err := os.Open(src) // #nosec G304

io/file/fileutil_test.go

@@ -125,8 +125,9 @@ func TestWriteFile_OK(t *testing.T) {
 	require.NoError(t, err)
 	someFileName := filepath.Join(dirName, "somefile.txt")
 	require.NoError(t, file.WriteFile(someFileName, []byte("hi")))
-	exists := file.Exists(someFileName)
-	assert.Equal(t, true, exists)
+	exists, err := file.Exists(someFileName, file.Regular)
+	require.NoError(t, err, "could not check if file exists")
+	assert.Equal(t, true, exists, "file does not exist")
 }
 
 func TestCopyFile(t *testing.T) {
@@ -176,8 +177,14 @@ func TestCopyDir(t *testing.T) {
 	require.NoError(t, os.MkdirAll(filepath.Join(tmpDir1, "subfolder2"), 0777))
 	for _, fd := range fds {
 		require.NoError(t, file.WriteFile(filepath.Join(tmpDir1, fd.path), fd.content))
-		assert.Equal(t, true, file.Exists(filepath.Join(tmpDir1, fd.path)))
-		assert.Equal(t, false, file.Exists(filepath.Join(tmpDir2, fd.path)))
+
+		exists, err := file.Exists(filepath.Join(tmpDir1, fd.path), file.Regular)
+		require.NoError(t, err, "could not check if file exists")
+		assert.Equal(t, true, exists, "file does not exist")
+
+		exists, err = file.Exists(filepath.Join(tmpDir2, fd.path), file.Regular)
+		require.NoError(t, err, "could not check if file exists")
+		assert.Equal(t, false, exists, "file does exist")
 	}
 
 	// Make sure that files are copied into non-existent directory only. If directory exists function exits.
@@ -186,7 +193,9 @@ func TestCopyDir(t *testing.T) {
 
 	// Now, all files should have been copied.
 	for _, fd := range fds {
-		assert.Equal(t, true, file.Exists(filepath.Join(tmpDir2, fd.path)))
+		exists, err := file.Exists(filepath.Join(tmpDir2, fd.path), file.Regular)
+		require.NoError(t, err, "could not check if file exists")
+		assert.Equal(t, true, exists)
 		assert.Equal(t, true, deepCompare(t, filepath.Join(tmpDir1, fd.path), filepath.Join(tmpDir2, fd.path)))
 	}
 	assert.Equal(t, true, file.DirsEqual(tmpDir1, tmpDir2))
@@ -238,6 +247,66 @@ func TestHashDir(t *testing.T) {
 	})
 }
 
+func TestExists(t *testing.T) {
+	tmpDir := t.TempDir()
+	tmpFile := filepath.Join(tmpDir, "testfile")
+	nonExistentTmpFile := filepath.Join(tmpDir, "nonexistent")
+	_, err := os.Create(tmpFile)
+	require.NoError(t, err, "could not create test file")
+
+	tests := []struct {
+		name     string
+		itemPath string
+		itemType file.ObjType
+		want     bool
+	}{
+		{
+			name:     "file exists",
+			itemPath: tmpFile,
+			itemType: file.Regular,
+			want:     true,
+		},
+		{
+			name:     "dir exists",
+			itemPath: tmpDir,
+			itemType: file.Directory,
+			want:     true,
+		},
+		{
+			name:     "non-existent file",
+			itemPath: nonExistentTmpFile,
+			itemType: file.Regular,
+			want:     false,
+		},
+		{
+			name:     "non-existent dir",
+			itemPath: nonExistentTmpFile,
+			itemType: file.Directory,
+			want:     false,
+		},
+		{
+			name:     "file is dir",
+			itemPath: tmpDir,
+			itemType: file.Regular,
+			want:     false,
+		},
+		{
+			name:     "dir is file",
+			itemPath: tmpFile,
+			itemType: file.Directory,
+			want:     false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			exists, err := file.Exists(tt.itemPath, tt.itemType)
+			require.NoError(t, err, "could not check if file exists")
+			assert.Equal(t, tt.want, exists)
+		})
+	}
+}
+
 func TestHashFile(t *testing.T) {
 	originalData := []byte("test data")
 	originalChecksum := sha256.Sum256(originalData)
@@ -290,40 +359,43 @@ func TestDirFiles(t *testing.T) {
 
 func TestRecursiveFileFind(t *testing.T) {
 	tmpDir, _ := tmpDirWithContentsForRecursiveFind(t)
+	/*
+		 tmpDir
+		 ├── file3
+		 ├── subfolder1
+		 │   └── subfolder11
+		 │       └── file1
+		 └── subfolder2
+			 └── file2
+	*/
 	tests := []struct {
 		name  string
 		root  string
-		path  string
 		found bool
 	}{
 		{
 			name:  "file1",
 			root:  tmpDir,
-			path:  "subfolder1/subfolder11/file1",
 			found: true,
 		},
 		{
 			name:  "file2",
 			root:  tmpDir,
-			path:  "subfolder2/file2",
 			found: true,
 		},
 		{
 			name:  "file1",
 			root:  tmpDir + "/subfolder1",
-			path:  "subfolder11/file1",
 			found: true,
 		},
 		{
 			name:  "file3",
 			root:  tmpDir,
-			path:  "file3",
 			found: true,
 		},
 		{
 			name:  "file4",
 			root:  tmpDir,
-			path:  "",
 			found: false,
 		},
 	}
@@ -338,6 +410,61 @@ func TestRecursiveFileFind(t *testing.T) {
 	}
 }
 
+func TestRecursiveDirFind(t *testing.T) {
+	tmpDir, _ := tmpDirWithContentsForRecursiveFind(t)
+
+	/*
+		 tmpDir
+		 ├── file3
+		 ├── subfolder1
+		 │   └── subfolder11
+		 │       └── file1
+		 └── subfolder2
+			 └── file2
+	*/
+
+	tests := []struct {
+		name  string
+		root  string
+		found bool
+	}{
+		{
+			name:  "subfolder11",
+			root:  tmpDir,
+			found: true,
+		},
+		{
+			name:  "subfolder2",
+			root:  tmpDir,
+			found: true,
+		},
+		{
+			name:  "subfolder11",
+			root:  tmpDir + "/subfolder1",
+			found: true,
+		},
+		{
+			name:  "file3",
+			root:  tmpDir,
+			found: false,
+		},
+		{
+			name:  "file4",
+			root:  tmpDir,
+			found: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			found, _, err := file.RecursiveDirFind(tt.name, tt.root)
+			require.NoError(t, err)
+
+			assert.DeepEqual(t, tt.found, found)
+		})
+	}
+}
+
 func deepCompare(t *testing.T, file1, file2 string) bool {
 	sf, err := os.Open(file1)
 	assert.NoError(t, err)