mirror of
https://gitlab.com/pulsechaincom/prysm-pulse.git
synced 2025-01-05 09:14:28 +00:00
ef21d3adf8
* `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.
402 lines
13 KiB
Go
402 lines
13 KiB
Go
package accounts
|
|
|
|
import (
|
|
"bytes"
|
|
"os"
|
|
"path"
|
|
"path/filepath"
|
|
"sort"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/prysmaticlabs/prysm/v5/build/bazel"
|
|
"github.com/prysmaticlabs/prysm/v5/io/file"
|
|
ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
|
|
"github.com/prysmaticlabs/prysm/v5/testing/assert"
|
|
"github.com/prysmaticlabs/prysm/v5/testing/require"
|
|
validatormock "github.com/prysmaticlabs/prysm/v5/testing/validator-mock"
|
|
"github.com/prysmaticlabs/prysm/v5/validator/accounts"
|
|
"github.com/prysmaticlabs/prysm/v5/validator/keymanager"
|
|
"go.uber.org/mock/gomock"
|
|
"google.golang.org/protobuf/types/known/timestamppb"
|
|
)
|
|
|
|
func TestExitAccountsCli_OK(t *testing.T) {
|
|
ctrl := gomock.NewController(t)
|
|
defer ctrl.Finish()
|
|
mockValidatorClient := validatormock.NewMockValidatorClient(ctrl)
|
|
mockNodeClient := validatormock.NewMockNodeClient(ctrl)
|
|
|
|
mockValidatorClient.EXPECT().
|
|
ValidatorIndex(gomock.Any(), gomock.Any()).
|
|
Return(ðpb.ValidatorIndexResponse{Index: 1}, nil)
|
|
|
|
// Any time in the past will suffice
|
|
genesisTime := ×tamppb.Timestamp{
|
|
Seconds: time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC).Unix(),
|
|
}
|
|
|
|
mockNodeClient.EXPECT().
|
|
GetGenesis(gomock.Any(), gomock.Any()).
|
|
Return(ðpb.Genesis{GenesisTime: genesisTime}, nil)
|
|
|
|
mockValidatorClient.EXPECT().
|
|
DomainData(gomock.Any(), gomock.Any()).
|
|
Return(ðpb.DomainResponse{SignatureDomain: make([]byte, 32)}, nil)
|
|
|
|
mockValidatorClient.EXPECT().
|
|
ProposeExit(gomock.Any(), gomock.AssignableToTypeOf(ðpb.SignedVoluntaryExit{})).
|
|
Return(ðpb.ProposeExitResponse{}, nil)
|
|
|
|
walletDir, _, passwordFilePath := setupWalletAndPasswordsDir(t)
|
|
// Write a directory where we will import keys from.
|
|
keysDir := filepath.Join(t.TempDir(), "keysDir")
|
|
require.NoError(t, os.MkdirAll(keysDir, os.ModePerm))
|
|
|
|
// Create keystore file in the keys directory we can then import from in our wallet.
|
|
keystore, _ := createKeystore(t, keysDir)
|
|
time.Sleep(time.Second)
|
|
|
|
// We initialize a wallet with a local keymanager.
|
|
cliCtx := setupWalletCtx(t, &testWalletConfig{
|
|
// Wallet configuration flags.
|
|
walletDir: walletDir,
|
|
keymanagerKind: keymanager.Local,
|
|
walletPasswordFile: passwordFilePath,
|
|
accountPasswordFile: passwordFilePath,
|
|
// Flag required for ImportAccounts to work.
|
|
keysDir: keysDir,
|
|
// Flag required for ExitAccounts to work.
|
|
voluntaryExitPublicKeys: keystore.Pubkey,
|
|
})
|
|
opts := []accounts.Option{
|
|
accounts.WithWalletDir(walletDir),
|
|
accounts.WithKeymanagerType(keymanager.Local),
|
|
accounts.WithWalletPassword(password),
|
|
}
|
|
acc, err := accounts.NewCLIManager(opts...)
|
|
require.NoError(t, err)
|
|
_, err = acc.WalletCreate(cliCtx.Context)
|
|
require.NoError(t, err)
|
|
require.NoError(t, accountsImport(cliCtx))
|
|
|
|
_, km, err := walletWithKeymanager(cliCtx)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, km)
|
|
|
|
validatingPublicKeys, err := km.FetchValidatingPublicKeys(cliCtx.Context)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, validatingPublicKeys)
|
|
|
|
// Prepare user input for final confirmation step
|
|
var stdin bytes.Buffer
|
|
stdin.Write([]byte("Y"))
|
|
rawPubKeys, formattedPubKeys, err := accounts.FilterExitAccountsFromUserInput(
|
|
cliCtx, &stdin, validatingPublicKeys, false,
|
|
)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, rawPubKeys)
|
|
require.NotNil(t, formattedPubKeys)
|
|
|
|
cfg := accounts.PerformExitCfg{
|
|
ValidatorClient: mockValidatorClient,
|
|
NodeClient: mockNodeClient,
|
|
Keymanager: km,
|
|
RawPubKeys: rawPubKeys,
|
|
FormattedPubKeys: formattedPubKeys,
|
|
}
|
|
rawExitedKeys, formattedExitedKeys, err := accounts.PerformVoluntaryExit(cliCtx.Context, cfg)
|
|
require.NoError(t, err)
|
|
require.Equal(t, 1, len(rawExitedKeys))
|
|
assert.DeepEqual(t, rawPubKeys[0], rawExitedKeys[0])
|
|
require.Equal(t, 1, len(formattedExitedKeys))
|
|
assert.Equal(t, "0x"+keystore.Pubkey[:12], formattedExitedKeys[0])
|
|
}
|
|
|
|
func TestExitAccountsCli_OK_AllPublicKeys(t *testing.T) {
|
|
ctrl := gomock.NewController(t)
|
|
defer ctrl.Finish()
|
|
mockValidatorClient := validatormock.NewMockValidatorClient(ctrl)
|
|
mockNodeClient := validatormock.NewMockNodeClient(ctrl)
|
|
|
|
mockValidatorClient.EXPECT().
|
|
ValidatorIndex(gomock.Any(), gomock.Any()).
|
|
Return(ðpb.ValidatorIndexResponse{Index: 0}, nil)
|
|
|
|
mockValidatorClient.EXPECT().
|
|
ValidatorIndex(gomock.Any(), gomock.Any()).
|
|
Return(ðpb.ValidatorIndexResponse{Index: 1}, nil)
|
|
|
|
// Any time in the past will suffice
|
|
genesisTime := ×tamppb.Timestamp{
|
|
Seconds: time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC).Unix(),
|
|
}
|
|
|
|
mockNodeClient.EXPECT().
|
|
GetGenesis(gomock.Any(), gomock.Any()).
|
|
Return(ðpb.Genesis{GenesisTime: genesisTime}, nil)
|
|
|
|
mockValidatorClient.EXPECT().
|
|
DomainData(gomock.Any(), gomock.Any()).
|
|
Times(2).
|
|
Return(ðpb.DomainResponse{SignatureDomain: make([]byte, 32)}, nil)
|
|
|
|
mockValidatorClient.EXPECT().
|
|
ProposeExit(gomock.Any(), gomock.AssignableToTypeOf(ðpb.SignedVoluntaryExit{})).
|
|
Times(2).
|
|
Return(ðpb.ProposeExitResponse{}, nil)
|
|
|
|
walletDir, _, passwordFilePath := setupWalletAndPasswordsDir(t)
|
|
// Write a directory where we will import keys from.
|
|
keysDir := filepath.Join(t.TempDir(), "keysDir")
|
|
require.NoError(t, os.MkdirAll(keysDir, os.ModePerm))
|
|
|
|
// Create keystore file in the keys directory we can then import from in our wallet.
|
|
keystore1, _ := createKeystore(t, keysDir)
|
|
time.Sleep(time.Second)
|
|
keystore2, _ := createKeystore(t, keysDir)
|
|
time.Sleep(time.Second)
|
|
|
|
// We initialize a wallet with a local keymanager.
|
|
cliCtx := setupWalletCtx(t, &testWalletConfig{
|
|
// Wallet configuration flags.
|
|
walletDir: walletDir,
|
|
keymanagerKind: keymanager.Local,
|
|
walletPasswordFile: passwordFilePath,
|
|
accountPasswordFile: passwordFilePath,
|
|
// Flag required for ImportAccounts to work.
|
|
keysDir: keysDir,
|
|
// Exit all public keys.
|
|
exitAll: true,
|
|
})
|
|
opts := []accounts.Option{
|
|
accounts.WithWalletDir(walletDir),
|
|
accounts.WithKeymanagerType(keymanager.Local),
|
|
accounts.WithWalletPassword(password),
|
|
}
|
|
acc, err := accounts.NewCLIManager(opts...)
|
|
require.NoError(t, err)
|
|
_, err = acc.WalletCreate(cliCtx.Context)
|
|
require.NoError(t, err)
|
|
require.NoError(t, accountsImport(cliCtx))
|
|
|
|
_, km, err := walletWithKeymanager(cliCtx)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, km)
|
|
|
|
validatingPublicKeys, err := km.FetchValidatingPublicKeys(cliCtx.Context)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, validatingPublicKeys)
|
|
|
|
// Prepare user input for final confirmation step
|
|
var stdin bytes.Buffer
|
|
stdin.Write([]byte("Y"))
|
|
rawPubKeys, formattedPubKeys, err := accounts.FilterExitAccountsFromUserInput(
|
|
cliCtx, &stdin, validatingPublicKeys, false,
|
|
)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, rawPubKeys)
|
|
require.NotNil(t, formattedPubKeys)
|
|
|
|
cfg := accounts.PerformExitCfg{
|
|
ValidatorClient: mockValidatorClient,
|
|
NodeClient: mockNodeClient,
|
|
Keymanager: km,
|
|
RawPubKeys: rawPubKeys,
|
|
FormattedPubKeys: formattedPubKeys,
|
|
}
|
|
rawExitedKeys, formattedExitedKeys, err := accounts.PerformVoluntaryExit(cliCtx.Context, cfg)
|
|
require.NoError(t, err)
|
|
require.Equal(t, 2, len(rawExitedKeys))
|
|
assert.DeepEqual(t, rawPubKeys, rawExitedKeys)
|
|
require.Equal(t, 2, len(formattedExitedKeys))
|
|
wantedFormatted := []string{
|
|
"0x" + keystore1.Pubkey[:12],
|
|
"0x" + keystore2.Pubkey[:12],
|
|
}
|
|
sort.Strings(wantedFormatted)
|
|
sort.Strings(formattedExitedKeys)
|
|
require.DeepEqual(t, wantedFormatted, formattedExitedKeys)
|
|
}
|
|
|
|
func TestExitAccountsCli_OK_ForceExit(t *testing.T) {
|
|
ctrl := gomock.NewController(t)
|
|
defer ctrl.Finish()
|
|
mockValidatorClient := validatormock.NewMockValidatorClient(ctrl)
|
|
mockNodeClient := validatormock.NewMockNodeClient(ctrl)
|
|
|
|
mockValidatorClient.EXPECT().
|
|
ValidatorIndex(gomock.Any(), gomock.Any()).
|
|
Return(ðpb.ValidatorIndexResponse{Index: 1}, nil)
|
|
|
|
// Any time in the past will suffice
|
|
genesisTime := ×tamppb.Timestamp{
|
|
Seconds: time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC).Unix(),
|
|
}
|
|
|
|
mockNodeClient.EXPECT().
|
|
GetGenesis(gomock.Any(), gomock.Any()).
|
|
Return(ðpb.Genesis{GenesisTime: genesisTime}, nil)
|
|
|
|
mockValidatorClient.EXPECT().
|
|
DomainData(gomock.Any(), gomock.Any()).
|
|
Return(ðpb.DomainResponse{SignatureDomain: make([]byte, 32)}, nil)
|
|
|
|
mockValidatorClient.EXPECT().
|
|
ProposeExit(gomock.Any(), gomock.AssignableToTypeOf(ðpb.SignedVoluntaryExit{})).
|
|
Return(ðpb.ProposeExitResponse{}, nil)
|
|
|
|
walletDir, _, passwordFilePath := setupWalletAndPasswordsDir(t)
|
|
// Write a directory where we will import keys from.
|
|
keysDir := filepath.Join(t.TempDir(), "keysDir")
|
|
require.NoError(t, os.MkdirAll(keysDir, os.ModePerm))
|
|
|
|
// Create keystore file in the keys directory we can then import from in our wallet.
|
|
keystore, _ := createKeystore(t, keysDir)
|
|
time.Sleep(time.Second)
|
|
|
|
// We initialize a wallet with a local keymanager.
|
|
cliCtx := setupWalletCtx(t, &testWalletConfig{
|
|
// Wallet configuration flags.
|
|
walletDir: walletDir,
|
|
keymanagerKind: keymanager.Local,
|
|
walletPasswordFile: passwordFilePath,
|
|
accountPasswordFile: passwordFilePath,
|
|
// Flag required for ImportAccounts to work.
|
|
keysDir: keysDir,
|
|
// Flag required for ExitAccounts to work.
|
|
voluntaryExitPublicKeys: keystore.Pubkey,
|
|
})
|
|
opts := []accounts.Option{
|
|
accounts.WithWalletDir(walletDir),
|
|
accounts.WithKeymanagerType(keymanager.Local),
|
|
accounts.WithWalletPassword(password),
|
|
}
|
|
acc, err := accounts.NewCLIManager(opts...)
|
|
require.NoError(t, err)
|
|
_, err = acc.WalletCreate(cliCtx.Context)
|
|
require.NoError(t, err)
|
|
require.NoError(t, accountsImport(cliCtx))
|
|
|
|
_, km, err := walletWithKeymanager(cliCtx)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, km)
|
|
|
|
validatingPublicKeys, err := km.FetchValidatingPublicKeys(cliCtx.Context)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, validatingPublicKeys)
|
|
|
|
rawPubKeys, formattedPubKeys, err := accounts.FilterExitAccountsFromUserInput(
|
|
cliCtx, &bytes.Buffer{}, validatingPublicKeys, true,
|
|
)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, rawPubKeys)
|
|
require.NotNil(t, formattedPubKeys)
|
|
|
|
cfg := accounts.PerformExitCfg{
|
|
ValidatorClient: mockValidatorClient,
|
|
NodeClient: mockNodeClient,
|
|
Keymanager: km,
|
|
RawPubKeys: rawPubKeys,
|
|
FormattedPubKeys: formattedPubKeys,
|
|
}
|
|
rawExitedKeys, formattedExitedKeys, err := accounts.PerformVoluntaryExit(cliCtx.Context, cfg)
|
|
require.NoError(t, err)
|
|
require.Equal(t, 1, len(rawExitedKeys))
|
|
assert.DeepEqual(t, rawPubKeys[0], rawExitedKeys[0])
|
|
require.Equal(t, 1, len(formattedExitedKeys))
|
|
assert.Equal(t, "0x"+keystore.Pubkey[:12], formattedExitedKeys[0])
|
|
}
|
|
|
|
func TestExitAccountsCli_WriteJSON_NoBroadcast(t *testing.T) {
|
|
ctrl := gomock.NewController(t)
|
|
defer ctrl.Finish()
|
|
mockValidatorClient := validatormock.NewMockValidatorClient(ctrl)
|
|
mockNodeClient := validatormock.NewMockNodeClient(ctrl)
|
|
|
|
mockValidatorClient.EXPECT().
|
|
ValidatorIndex(gomock.Any(), gomock.Any()).
|
|
Return(ðpb.ValidatorIndexResponse{Index: 1}, nil)
|
|
|
|
// Any time in the past will suffice
|
|
genesisTime := ×tamppb.Timestamp{
|
|
Seconds: time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC).Unix(),
|
|
}
|
|
|
|
mockNodeClient.EXPECT().
|
|
GetGenesis(gomock.Any(), gomock.Any()).
|
|
Return(ðpb.Genesis{GenesisTime: genesisTime}, nil)
|
|
|
|
mockValidatorClient.EXPECT().
|
|
DomainData(gomock.Any(), gomock.Any()).
|
|
Return(ðpb.DomainResponse{SignatureDomain: make([]byte, 32)}, nil)
|
|
|
|
walletDir, _, passwordFilePath := setupWalletAndPasswordsDir(t)
|
|
// Write a directory where we will import keys from.
|
|
keysDir := filepath.Join(t.TempDir(), "keysDir")
|
|
require.NoError(t, os.MkdirAll(keysDir, os.ModePerm))
|
|
|
|
// Create keystore file in the keys directory we can then import from in our wallet.
|
|
keystore, _ := createKeystore(t, keysDir)
|
|
time.Sleep(time.Second)
|
|
|
|
// We initialize a wallet with a local keymanager.
|
|
cliCtx := setupWalletCtx(t, &testWalletConfig{
|
|
// Wallet configuration flags.
|
|
walletDir: walletDir,
|
|
keymanagerKind: keymanager.Local,
|
|
walletPasswordFile: passwordFilePath,
|
|
accountPasswordFile: passwordFilePath,
|
|
// Flag required for ImportAccounts to work.
|
|
keysDir: keysDir,
|
|
// Flag required for ExitAccounts to work.
|
|
voluntaryExitPublicKeys: keystore.Pubkey,
|
|
})
|
|
opts := []accounts.Option{
|
|
accounts.WithWalletDir(walletDir),
|
|
accounts.WithKeymanagerType(keymanager.Local),
|
|
accounts.WithWalletPassword(password),
|
|
}
|
|
acc, err := accounts.NewCLIManager(opts...)
|
|
require.NoError(t, err)
|
|
_, err = acc.WalletCreate(cliCtx.Context)
|
|
require.NoError(t, err)
|
|
require.NoError(t, accountsImport(cliCtx))
|
|
|
|
_, km, err := walletWithKeymanager(cliCtx)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, km)
|
|
|
|
validatingPublicKeys, err := km.FetchValidatingPublicKeys(cliCtx.Context)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, validatingPublicKeys)
|
|
|
|
rawPubKeys, formattedPubKeys, err := accounts.FilterExitAccountsFromUserInput(
|
|
cliCtx, &bytes.Buffer{}, validatingPublicKeys, true,
|
|
)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, rawPubKeys)
|
|
require.NotNil(t, formattedPubKeys)
|
|
|
|
out := path.Join(bazel.TestTmpDir(), "exits")
|
|
|
|
cfg := accounts.PerformExitCfg{
|
|
ValidatorClient: mockValidatorClient,
|
|
NodeClient: mockNodeClient,
|
|
Keymanager: km,
|
|
RawPubKeys: rawPubKeys,
|
|
FormattedPubKeys: formattedPubKeys,
|
|
OutputDirectory: out,
|
|
}
|
|
rawExitedKeys, formattedExitedKeys, err := accounts.PerformVoluntaryExit(cliCtx.Context, cfg)
|
|
require.NoError(t, err)
|
|
require.Equal(t, 1, len(rawExitedKeys))
|
|
assert.DeepEqual(t, rawPubKeys[0], rawExitedKeys[0])
|
|
require.Equal(t, 1, len(formattedExitedKeys))
|
|
assert.Equal(t, "0x"+keystore.Pubkey[:12], formattedExitedKeys[0])
|
|
|
|
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")
|
|
}
|