github/prysm
1
1
Fork 0
mirror of https://github.com/OffchainLabs/prysm.git synced 2026-01-08 23:18:15 -05:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
* `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.
This commit is contained in:
Manu NALEPA
2024-03-05 16:27:15 +01:00
committed by GitHub
parent b6ce6c2eba
commit ef21d3adf8
105 changed files with 9816 additions and 4575 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
validator/helpers/BUILD.bazel
View File

@@ -1,11 +1,41 @@
load("@prysm//tools/go:def.bzl", "go_library")
load("@prysm//tools/go:def.bzl", "go_library", "go_test")
go_library(
name = "go_default_library",
srcs = ["node_connection.go"],
srcs = [
"converts.go",
"metadata.go",
"node_connection.go",
],
importpath = "github.com/prysmaticlabs/prysm/v5/validator/helpers",
visibility = ["//visibility:public"],
deps = [
"//config/fieldparams:go_default_library",
"//consensus-types/primitives:go_default_library",
"//validator/db/iface:go_default_library",
"//validator/slashing-protection-history/format:go_default_library",
"@com_github_pkg_errors//:go_default_library",
"@org_golang_google_grpc//:go_default_library",
],
)
go_test(
name = "go_default_test",
srcs = [
"converts_test.go",
"metadata_test.go",
],
embed = [":go_default_library"],
deps = [
"//config/fieldparams:go_default_library",
"//config/proposer:go_default_library",
"//consensus-types/interfaces:go_default_library",
"//consensus-types/primitives:go_default_library",
"//proto/prysm/v1alpha1:go_default_library",
"//testing/require:go_default_library",
"//validator/db/common:go_default_library",
"//validator/db/iface:go_default_library",
"//validator/slashing-protection-history/format:go_default_library",
"@com_github_prometheus_client_golang//prometheus:go_default_library",
],
)

80
validator/helpers/converts.go Normal file
View File

@@ -0,0 +1,80 @@
package helpers
import (
"encoding/hex"
"fmt"
"strconv"
"strings"
fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
)
// Uint64FromString converts a string into a uint64 representation.
func Uint64FromString(str string) (uint64, error) {
return strconv.ParseUint(str, 10, 64)
}
// EpochFromString converts a string into Epoch.
func EpochFromString(str string) (primitives.Epoch, error) {
e, err := Uint64FromString(str)
if err != nil {
return primitives.Epoch(e), err
}
return primitives.Epoch(e), nil
}
// SlotFromString converts a string into Slot.
func SlotFromString(str string) (primitives.Slot, error) {
s, err := Uint64FromString(str)
if err != nil {
return primitives.Slot(s), err
}
return primitives.Slot(s), nil
}
// PubKeyFromHex takes in a hex string, verifies its length as 48 bytes, and converts that representation.
func PubKeyFromHex(str string) ([fieldparams.BLSPubkeyLength]byte, error) {
pubKeyBytes, err := hex.DecodeString(strings.TrimPrefix(str, "0x"))
if err != nil {
return [fieldparams.BLSPubkeyLength]byte{}, err
}
if len(pubKeyBytes) != 48 {
return [fieldparams.BLSPubkeyLength]byte{}, fmt.Errorf("public key is not correct, 48-byte length: %s", str)
}
var pk [fieldparams.BLSPubkeyLength]byte
copy(pk[:], pubKeyBytes[:fieldparams.BLSPubkeyLength])
return pk, nil
}
// RootFromHex takes in a hex string, verifies its length as 32 bytes, and converts that representation.
func RootFromHex(str string) ([32]byte, error) {
rootHexBytes, err := hex.DecodeString(strings.TrimPrefix(str, "0x"))
if err != nil {
return [32]byte{}, err
}
if len(rootHexBytes) != 32 {
return [32]byte{}, fmt.Errorf("wrong root length, 32-byte length: %s", str)
}
var root [32]byte
copy(root[:], rootHexBytes[:32])
return root, nil
}
func RootToHexString(root []byte) (string, error) {
// Nil signing roots are allowed in EIP-3076.
if len(root) == 0 {
return "", nil
}
if len(root) != 32 {
return "", fmt.Errorf("wanted length 32, received %d", len(root))
}
return fmt.Sprintf("%#x", root), nil
}
func PubKeyToHexString(pubKey []byte) (string, error) {
if len(pubKey) != 48 {
return "", fmt.Errorf("wanted length 48, received %d", len(pubKey))
}
return fmt.Sprintf("%#x", pubKey), nil
}

283
validator/helpers/converts_test.go Normal file
View File

@@ -0,0 +1,283 @@
package helpers
import (
"fmt"
"math"
"reflect"
"testing"
fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
)
func Test_fromString(t *testing.T) {
tests := []struct {
name string
str string
want uint64
wantErr bool
}{
{
name: "Overflow uint64 gets MaxUint64",
str: "29348902839048290384902839048290384902938748278934789273984728934789273894798273498",
want: math.MaxUint64,
wantErr: true,
},
{
name: "Max Uint64 works",
str: "18446744073709551615",
want: math.MaxUint64,
wantErr: false,
},
{
name: "Negative number fails",
str: "-3",
wantErr: true,
},
{
name: "Junk fails",
str: "alksjdkjasd",
wantErr: true,
},
{
name: "0 works",
str: "0",
want: 0,
},
{
name: "Normal uint64 works",
str: "23980",
want: 23980,
},
}
for _, tt := range tests {
t.Run(fmt.Sprintf("Uint64/%s", tt.name), func(t *testing.T) {
got, err := Uint64FromString(tt.str)
if (err != nil) != tt.wantErr {
t.Errorf("Uint64FromString() error = %v, wantErr %v", err, tt.wantErr)
return
}
if got != tt.want {
t.Errorf("Uint64FromString() got = %v, want %v", got, tt.want)
}
})
t.Run(fmt.Sprintf("Epoch/%s", tt.name), func(t *testing.T) {
got, err := EpochFromString(tt.str)
if (err != nil) != tt.wantErr {
t.Errorf("EpochFromString() error = %v, wantErr %v", err, tt.wantErr)
return
}
if got != primitives.Epoch(tt.want) {
t.Errorf("EpochFromString() got = %v, want %v", got, tt.want)
}
})
t.Run(fmt.Sprintf("Slot/%s", tt.name), func(t *testing.T) {
got, err := SlotFromString(tt.str)
if (err != nil) != tt.wantErr {
t.Errorf("SlotFromString() error = %v, wantErr %v", err, tt.wantErr)
return
}
if got != primitives.Slot(tt.want) {
t.Errorf("SlotFromString() got = %v, want %v", got, tt.want)
}
})
}
}
func Test_pubKeyFromHex(t *testing.T) {
tests := []struct {
name string
str string
want [fieldparams.BLSPubkeyLength]byte
wantErr bool
}{
{
name: "Empty value fails due to wrong length",
str: "",
wantErr: true,
},
{
name: "Junk fails",
str: "alksjdkjasd",
wantErr: true,
},
{
name: "Empty value with 0x prefix fails due to wrong length",
str: "0x",
wantErr: true,
},
{
name: "Works with 0x prefix and good public key",
str: "0xb845089a1457f811bfc000588fbb4e713669be8ce060ea6be3c6ece09afc3794106c91ca73acda5e5457122d58723bed",
want: [fieldparams.BLSPubkeyLength]byte{184, 69, 8, 154, 20, 87, 248, 17, 191, 192, 0, 88, 143, 187, 78, 113, 54, 105, 190, 140, 224, 96, 234, 107, 227, 198, 236, 224, 154, 252, 55, 148, 16, 108, 145, 202, 115, 172, 218, 94, 84, 87, 18, 45, 88, 114, 59, 237},
},
{
name: "Works without 0x prefix and good public key",
str: "b845089a1457f811bfc000588fbb4e713669be8ce060ea6be3c6ece09afc3794106c91ca73acda5e5457122d58723bed",
want: [fieldparams.BLSPubkeyLength]byte{184, 69, 8, 154, 20, 87, 248, 17, 191, 192, 0, 88, 143, 187, 78, 113, 54, 105, 190, 140, 224, 96, 234, 107, 227, 198, 236, 224, 154, 252, 55, 148, 16, 108, 145, 202, 115, 172, 218, 94, 84, 87, 18, 45, 88, 114, 59, 237},
},
{
name: "0x prefix and wrong length public key fails",
str: "0xb845089a1457f811bfc000588fbb4e713669be8",
wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := PubKeyFromHex(tt.str)
if (err != nil) != tt.wantErr {
t.Errorf("PubKeyFromHex() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("PubKeyFromHex() got = %v, want %v", got, tt.want)
}
})
}
}
func Test_rootFromHex(t *testing.T) {
tests := []struct {
name string
str string
want [32]byte
wantErr bool
}{
{
name: "Empty value fails due to wrong length",
str: "",
wantErr: true,
},
{
name: "Junk fails",
str: "alksjdkjasd",
wantErr: true,
},
{
name: "Empty value with 0x prefix fails due to wrong length",
str: "0x",
wantErr: true,
},
{
name: "Works with 0x prefix and good root",
str: "0x4ff6f743a43f3b4f95350831aeaf0a122a1a392922c45d804280284a69eb850b",
want: [32]byte{79, 246, 247, 67, 164, 63, 59, 79, 149, 53, 8, 49, 174, 175, 10, 18, 42, 26, 57, 41, 34, 196, 93, 128, 66, 128, 40, 74, 105, 235, 133, 11},
},
{
name: "Works without 0x prefix and good root",
str: "4ff6f743a43f3b4f95350831aeaf0a122a1a392922c45d804280284a69eb850b",
want: [32]byte{79, 246, 247, 67, 164, 63, 59, 79, 149, 53, 8, 49, 174, 175, 10, 18, 42, 26, 57, 41, 34, 196, 93, 128, 66, 128, 40, 74, 105, 235, 133, 11},
},
{
name: "0x prefix and wrong length root fails",
str: "0xb845089a14",
wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := RootFromHex(tt.str)
if (err != nil) != tt.wantErr {
t.Errorf("rootFromHex() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("rootFromHex() got = %v, want %v", got, tt.want)
}
})
}
}
func Test_rootToHexString(t *testing.T) {
mockRoot := [32]byte{1}
tests := []struct {
name string
root []byte
want string
wantErr bool
}{
{
name: "nil roots return empty string",
root: nil,
want: "",
wantErr: false,
},
{
name: "len(root) == 0 returns empty string",
root: make([]byte, 0),
want: "",
wantErr: false,
},
{
name: "non-empty root with incorrect size returns error",
root: make([]byte, 20),
want: "",
wantErr: true,
},
{
name: "non-empty root with correct size returns expected value",
root: mockRoot[:],
want: "0x0100000000000000000000000000000000000000000000000000000000000000",
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := RootToHexString(tt.root)
if (err != nil) != tt.wantErr {
t.Errorf("rootToHexString() error = %v, wantErr %v", err, tt.wantErr)
return
}
if got != tt.want {
t.Errorf("rootToHexString() got = %v, want %v", got, tt.want)
}
})
}
}
func Test_pubKeyToHexString(t *testing.T) {
mockPubKey := [fieldparams.BLSPubkeyLength]byte{1}
tests := []struct {
name string
pubKey []byte
want string
wantErr bool
}{
{
name: "nil pubkey should return error",
pubKey: nil,
want: "",
wantErr: true,
},
{
name: "empty pubkey should return error",
pubKey: make([]byte, 0),
want: "",
wantErr: true,
},
{
name: "wrong length pubkey should return error",
pubKey: make([]byte, 3),
want: "",
wantErr: true,
},
{
name: "non-empty pubkey with correct size returns expected value",
pubKey: mockPubKey[:],
want: "0x010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := PubKeyToHexString(tt.pubKey)
if (err != nil) != tt.wantErr {
t.Errorf("pubKeyToHexString() error = %v, wantErr %v", err, tt.wantErr)
return
}
if got != tt.want {
t.Errorf("pubKeyToHexString() got = %v, want %v", got, tt.want)
}
})
}
}

45
validator/helpers/metadata.go Normal file
View File

@@ -0,0 +1,45 @@
package helpers
import (
"bytes"
"context"
"fmt"
"github.com/pkg/errors"
"github.com/prysmaticlabs/prysm/v5/validator/db/iface"
"github.com/prysmaticlabs/prysm/v5/validator/slashing-protection-history/format"
)
func ValidateMetadata(ctx context.Context, validatorDB iface.ValidatorDB, interchangeJSON *format.EIPSlashingProtectionFormat) error {
// We need to ensure the version in the metadata field matches the one we support.
version := interchangeJSON.Metadata.InterchangeFormatVersion
if version != format.InterchangeFormatVersion {
return fmt.Errorf(
"slashing protection JSON version '%s' is not supported, wanted '%s'",
version,
format.InterchangeFormatVersion,
)
}
// We need to verify the genesis validators root matches that of our chain data, otherwise
// the imported slashing protection JSON was created on a different chain.
gvr, err := RootFromHex(interchangeJSON.Metadata.GenesisValidatorsRoot)
if err != nil {
return fmt.Errorf("%#x is not a valid root: %w", interchangeJSON.Metadata.GenesisValidatorsRoot, err)
}
dbGvr, err := validatorDB.GenesisValidatorsRoot(ctx)
if err != nil {
return errors.Wrap(err, "could not retrieve genesis validators root to db")
}
if dbGvr == nil {
if err = validatorDB.SaveGenesisValidatorsRoot(ctx, gvr[:]); err != nil {
return errors.Wrap(err, "could not save genesis validators root to db")
}
return nil
}
if !bytes.Equal(dbGvr, gvr[:]) {
return errors.New("genesis validators root doesn't match the one that is stored in slashing protection db. " +
"Please make sure you import the protection data that is relevant to the chain you are on")
}
return nil
}

283
validator/helpers/metadata_test.go Normal file
View File

@@ -0,0 +1,283 @@
package helpers
import (
"context"
"encoding/hex"
"io"
"testing"
"github.com/prometheus/client_golang/prometheus"
fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
"github.com/prysmaticlabs/prysm/v5/config/proposer"
"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
"github.com/prysmaticlabs/prysm/v5/testing/require"
"github.com/prysmaticlabs/prysm/v5/validator/db/common"
"github.com/prysmaticlabs/prysm/v5/validator/db/iface"
"github.com/prysmaticlabs/prysm/v5/validator/slashing-protection-history/format"
)
type ValidatorDBMock struct {
genesisValidatorsRoot []byte
}
func NewValidatorDBMock() *ValidatorDBMock {
return &ValidatorDBMock{}
}
var _ iface.ValidatorDB = (*ValidatorDBMock)(nil)
func (db *ValidatorDBMock) Backup(ctx context.Context, outputPath string, permissionOverride bool) error {
panic("not implemented")
}
func (db *ValidatorDBMock) Close() error { panic("not implemented") }
func (db *ValidatorDBMock) DatabasePath() string { panic("not implemented") }
func (db *ValidatorDBMock) ClearDB() error { panic("not implemented") }
func (db *ValidatorDBMock) RunUpMigrations(ctx context.Context) error { panic("not implemented") }
func (db *ValidatorDBMock) RunDownMigrations(ctx context.Context) error { panic("not implemented") }
func (db *ValidatorDBMock) UpdatePublicKeysBuckets(publicKeys [][fieldparams.BLSPubkeyLength]byte) error {
panic("not implemented")
}
// Genesis information related methods.
func (db *ValidatorDBMock) GenesisValidatorsRoot(ctx context.Context) ([]byte, error) {
return db.genesisValidatorsRoot, nil
}
func (db *ValidatorDBMock) SaveGenesisValidatorsRoot(ctx context.Context, genValRoot []byte) error {
db.genesisValidatorsRoot = genValRoot
return nil
}
// Proposer protection related methods.
func (db *ValidatorDBMock) HighestSignedProposal(ctx context.Context, publicKey [fieldparams.BLSPubkeyLength]byte) (primitives.Slot, bool, error) {
panic("not implemented")
}
func (db *ValidatorDBMock) LowestSignedProposal(ctx context.Context, publicKey [fieldparams.BLSPubkeyLength]byte) (primitives.Slot, bool, error) {
panic("not implemented")
}
func (db *ValidatorDBMock) ProposalHistoryForPubKey(ctx context.Context, publicKey [fieldparams.BLSPubkeyLength]byte) ([]*common.Proposal, error) {
panic("not implemented")
}
func (db *ValidatorDBMock) ProposalHistoryForSlot(ctx context.Context, publicKey [fieldparams.BLSPubkeyLength]byte, slot primitives.Slot) ([32]byte, bool, bool, error) {
panic("not implemented")
}
func (db *ValidatorDBMock) SaveProposalHistoryForSlot(ctx context.Context, pubKey [fieldparams.BLSPubkeyLength]byte, slot primitives.Slot, signingRoot []byte) error {
panic("not implemented")
}
func (db *ValidatorDBMock) ProposedPublicKeys(ctx context.Context) ([][fieldparams.BLSPubkeyLength]byte, error) {
panic("not implemented")
}
func (db *ValidatorDBMock) SlashableProposalCheck(
ctx context.Context,
pubKey [fieldparams.BLSPubkeyLength]byte,
signedBlock interfaces.ReadOnlySignedBeaconBlock,
signingRoot [fieldparams.RootLength]byte,
emitAccountMetrics bool,
validatorProposeFailVec *prometheus.CounterVec,
) error {
panic("not implemented")
}
// Attester protection related methods.
// Methods to store and read blacklisted public keys from EIP-3076
// slashing protection imports.
func (db *ValidatorDBMock) EIPImportBlacklistedPublicKeys(ctx context.Context) ([][fieldparams.BLSPubkeyLength]byte, error) {
panic("not implemented")
}
func (db *ValidatorDBMock) SaveEIPImportBlacklistedPublicKeys(ctx context.Context, publicKeys [][fieldparams.BLSPubkeyLength]byte) error {
panic("not implemented")
}
func (db *ValidatorDBMock) SigningRootAtTargetEpoch(ctx context.Context, publicKey [fieldparams.BLSPubkeyLength]byte, target primitives.Epoch) ([]byte, error) {
panic("not implemented")
}
func (db *ValidatorDBMock) LowestSignedTargetEpoch(ctx context.Context, publicKey [fieldparams.BLSPubkeyLength]byte) (primitives.Epoch, bool, error) {
panic("not implemented")
}
func (db *ValidatorDBMock) LowestSignedSourceEpoch(ctx context.Context, publicKey [fieldparams.BLSPubkeyLength]byte) (primitives.Epoch, bool, error) {
panic("not implemented")
}
func (db *ValidatorDBMock) AttestedPublicKeys(ctx context.Context) ([][fieldparams.BLSPubkeyLength]byte, error) {
panic("not implemented")
}
func (db *ValidatorDBMock) SlashableAttestationCheck(
ctx context.Context, indexedAtt *ethpb.IndexedAttestation, pubKey [fieldparams.BLSPubkeyLength]byte,
signingRoot32 [32]byte,
emitAccountMetrics bool,
validatorAttestFailVec *prometheus.CounterVec,
) error {
panic("not implemented")
}
func (db *ValidatorDBMock) SaveAttestationForPubKey(
ctx context.Context, pubKey [fieldparams.BLSPubkeyLength]byte, signingRoot [fieldparams.RootLength]byte, att *ethpb.IndexedAttestation,
) error {
panic("not implemented")
}
func (db *ValidatorDBMock) SaveAttestationsForPubKey(
ctx context.Context, pubKey [fieldparams.BLSPubkeyLength]byte, signingRoots [][]byte, atts []*ethpb.IndexedAttestation,
) error {
panic("not implemented")
}
func (db *ValidatorDBMock) AttestationHistoryForPubKey(
ctx context.Context, pubKey [fieldparams.BLSPubkeyLength]byte,
) ([]*common.AttestationRecord, error) {
panic("not implemented")
}
// Graffiti ordered index related methods
func (db *ValidatorDBMock) SaveGraffitiOrderedIndex(ctx context.Context, index uint64) error {
panic("not implemented")
}
func (db *ValidatorDBMock) GraffitiOrderedIndex(ctx context.Context, fileHash [32]byte) (uint64, error) {
panic("not implemented")
}
func (db *ValidatorDBMock) GraffitiFileHash() ([32]byte, bool, error) { panic("not implemented") }
// ProposerSettings related methods
func (db *ValidatorDBMock) ProposerSettings(context.Context) (*proposer.Settings, error) {
panic("not implemented")
}
func (db *ValidatorDBMock) ProposerSettingsExists(ctx context.Context) (bool, error) {
panic("not implemented")
}
func (db *ValidatorDBMock) UpdateProposerSettingsDefault(context.Context, *proposer.Option) error {
panic("not implemented")
}
func (db *ValidatorDBMock) UpdateProposerSettingsForPubkey(context.Context, [fieldparams.BLSPubkeyLength]byte, *proposer.Option) error {
panic("not implemented")
}
func (db *ValidatorDBMock) SaveProposerSettings(ctx context.Context, settings *proposer.Settings) error {
panic("not implemented")
}
// EIP-3076 slashing protection related methods
func (db *ValidatorDBMock) ImportStandardProtectionJSON(ctx context.Context, r io.Reader) error {
panic("not implemented")
}
func Test_validateMetadata(t *testing.T) {
goodRoot := [32]byte{1}
goodStr := make([]byte, hex.EncodedLen(len(goodRoot)))
hex.Encode(goodStr, goodRoot[:])
tests := []struct {
name string
interchangeJSON *format.EIPSlashingProtectionFormat
dbGenesisValidatorsRoot []byte
wantErr bool
wantFatal string
}{
{
name: "Incorrect version for EIP format should fail",
interchangeJSON: &format.EIPSlashingProtectionFormat{
Metadata: struct {
InterchangeFormatVersion string `json:"interchange_format_version"`
GenesisValidatorsRoot string `json:"genesis_validators_root"`
}{
InterchangeFormatVersion: "1",
GenesisValidatorsRoot: string(goodStr),
},
},
wantErr: true,
},
{
name: "Junk data for version should fail",
interchangeJSON: &format.EIPSlashingProtectionFormat{
Metadata: struct {
InterchangeFormatVersion string `json:"interchange_format_version"`
GenesisValidatorsRoot string `json:"genesis_validators_root"`
}{
InterchangeFormatVersion: "asdljas$d",
GenesisValidatorsRoot: string(goodStr),
},
},
wantErr: true,
},
{
name: "Proper version field should pass",
interchangeJSON: &format.EIPSlashingProtectionFormat{
Metadata: struct {
InterchangeFormatVersion string `json:"interchange_format_version"`
GenesisValidatorsRoot string `json:"genesis_validators_root"`
}{
InterchangeFormatVersion: format.InterchangeFormatVersion,
GenesisValidatorsRoot: string(goodStr),
},
},
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if err := ValidateMetadata(context.Background(), NewValidatorDBMock(), tt.interchangeJSON); (err != nil) != tt.wantErr {
t.Errorf("validateMetadata() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func Test_validateMetadataGenesisValidatorsRoot(t *testing.T) {
goodRoot := [32]byte{1}
goodStr := make([]byte, hex.EncodedLen(len(goodRoot)))
hex.Encode(goodStr, goodRoot[:])
secondRoot := [32]byte{2}
secondStr := make([]byte, hex.EncodedLen(len(secondRoot)))
hex.Encode(secondStr, secondRoot[:])
tests := []struct {
name string
interchangeJSON *format.EIPSlashingProtectionFormat
dbGenesisValidatorsRoot []byte
wantErr bool
}{
{
name: "Same genesis roots should not fail",
interchangeJSON: &format.EIPSlashingProtectionFormat{
Metadata: struct {
InterchangeFormatVersion string `json:"interchange_format_version"`
GenesisValidatorsRoot string `json:"genesis_validators_root"`
}{
InterchangeFormatVersion: format.InterchangeFormatVersion,
GenesisValidatorsRoot: string(goodStr),
},
},
dbGenesisValidatorsRoot: goodRoot[:],
wantErr: false,
},
{
name: "Different genesis roots should not fail",
interchangeJSON: &format.EIPSlashingProtectionFormat{
Metadata: struct {
InterchangeFormatVersion string `json:"interchange_format_version"`
GenesisValidatorsRoot string `json:"genesis_validators_root"`
}{
InterchangeFormatVersion: format.InterchangeFormatVersion,
GenesisValidatorsRoot: string(secondStr),
},
},
dbGenesisValidatorsRoot: goodRoot[:],
wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
ctx := context.Background()
validatorDB := NewValidatorDBMock()
require.NoError(t, validatorDB.SaveGenesisValidatorsRoot(ctx, tt.dbGenesisValidatorsRoot))
err := ValidateMetadata(ctx, validatorDB, tt.interchangeJSON)
if tt.wantErr {
require.ErrorContains(t, "genesis validators root doesn't match the one that is stored", err)
} else {
require.NoError(t, err)
}
})
}
}

2
validator/helpers/node_connection.go
View File

@@ -1,4 +1,4 @@
package validator_helpers
package helpers
import (
"time"