mirror of
https://gitlab.com/pulsechaincom/prysm-pulse.git
synced 2024-12-23 11:57:18 +00:00
8c2fff3a75
* advanced functionality, enable 25th word mnemonic passphrase * 25th word passphrase * add test * added test to ensure differences when using the mnemonic 25th word * better message * passing tests * fix up logic
252 lines
8.7 KiB
Go
252 lines
8.7 KiB
Go
package accounts
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"path/filepath"
|
|
"strings"
|
|
|
|
"github.com/logrusorgru/aurora"
|
|
"github.com/pkg/errors"
|
|
"github.com/prysmaticlabs/prysm/shared/petnames"
|
|
"github.com/prysmaticlabs/prysm/validator/accounts/iface"
|
|
"github.com/prysmaticlabs/prysm/validator/accounts/wallet"
|
|
"github.com/prysmaticlabs/prysm/validator/flags"
|
|
"github.com/prysmaticlabs/prysm/validator/keymanager"
|
|
"github.com/prysmaticlabs/prysm/validator/keymanager/derived"
|
|
"github.com/prysmaticlabs/prysm/validator/keymanager/imported"
|
|
"github.com/prysmaticlabs/prysm/validator/keymanager/remote"
|
|
"github.com/urfave/cli/v2"
|
|
)
|
|
|
|
// ListAccountsCli displays all available validator accounts in a Prysm wallet.
|
|
func ListAccountsCli(cliCtx *cli.Context) error {
|
|
w, err := wallet.OpenWalletOrElseCli(cliCtx, func(cliCtx *cli.Context) (*wallet.Wallet, error) {
|
|
return nil, wallet.ErrNoWalletFound
|
|
})
|
|
if err != nil {
|
|
return errors.Wrap(err, "could not open wallet")
|
|
}
|
|
km, err := w.InitializeKeymanager(cliCtx.Context, &iface.InitializeKeymanagerConfig{
|
|
SkipMnemonicConfirm: true,
|
|
})
|
|
if err != nil && strings.Contains(err.Error(), "invalid checksum") {
|
|
return errors.New("wrong wallet password entered")
|
|
}
|
|
if err != nil {
|
|
return errors.Wrap(err, "could not initialize keymanager")
|
|
}
|
|
showDepositData := cliCtx.Bool(flags.ShowDepositDataFlag.Name)
|
|
showPrivateKeys := cliCtx.Bool(flags.ShowPrivateKeysFlag.Name)
|
|
switch w.KeymanagerKind() {
|
|
case keymanager.Imported:
|
|
km, ok := km.(*imported.Keymanager)
|
|
if !ok {
|
|
return errors.New("could not assert keymanager interface to concrete type")
|
|
}
|
|
if err := listImportedKeymanagerAccounts(cliCtx.Context, showDepositData, showPrivateKeys, km); err != nil {
|
|
return errors.Wrap(err, "could not list validator accounts with imported keymanager")
|
|
}
|
|
case keymanager.Derived:
|
|
km, ok := km.(*derived.Keymanager)
|
|
if !ok {
|
|
return errors.New("could not assert keymanager interface to concrete type")
|
|
}
|
|
if err := listDerivedKeymanagerAccounts(cliCtx.Context, showDepositData, showPrivateKeys, km); err != nil {
|
|
return errors.Wrap(err, "could not list validator accounts with derived keymanager")
|
|
}
|
|
case keymanager.Remote:
|
|
km, ok := km.(*remote.Keymanager)
|
|
if !ok {
|
|
return errors.New("could not assert keymanager interface to concrete type")
|
|
}
|
|
if err := listRemoteKeymanagerAccounts(cliCtx.Context, w, km, km.KeymanagerOpts()); err != nil {
|
|
return errors.Wrap(err, "could not list validator accounts with remote keymanager")
|
|
}
|
|
default:
|
|
return fmt.Errorf("keymanager kind %s not yet supported", w.KeymanagerKind().String())
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func listImportedKeymanagerAccounts(
|
|
ctx context.Context,
|
|
showDepositData,
|
|
showPrivateKeys bool,
|
|
keymanager *imported.Keymanager,
|
|
) error {
|
|
// We initialize the wallet's keymanager.
|
|
accountNames, err := keymanager.ValidatingAccountNames()
|
|
if err != nil {
|
|
return errors.Wrap(err, "could not fetch account names")
|
|
}
|
|
numAccounts := au.BrightYellow(len(accountNames))
|
|
fmt.Printf("(keymanager kind) %s\n", au.BrightGreen("imported wallet").Bold())
|
|
fmt.Println("")
|
|
if len(accountNames) == 1 {
|
|
fmt.Printf("Showing %d validator account\n", numAccounts)
|
|
} else {
|
|
fmt.Printf("Showing %d validator accounts\n", numAccounts)
|
|
}
|
|
fmt.Println(
|
|
au.BrightRed("View the eth1 deposit transaction data for your accounts " +
|
|
"by running `validator accounts list --show-deposit-data"),
|
|
)
|
|
|
|
pubKeys, err := keymanager.FetchValidatingPublicKeys(ctx)
|
|
if err != nil {
|
|
return errors.Wrap(err, "could not fetch validating public keys")
|
|
}
|
|
var privateKeys [][32]byte
|
|
if showPrivateKeys {
|
|
privateKeys, err = keymanager.FetchValidatingPrivateKeys(ctx)
|
|
if err != nil {
|
|
return errors.Wrap(err, "could not fetch private keys")
|
|
}
|
|
}
|
|
for i := 0; i < len(accountNames); i++ {
|
|
fmt.Println("")
|
|
fmt.Printf("%s | %s\n", au.BrightBlue(fmt.Sprintf("Account %d", i)).Bold(), au.BrightGreen(accountNames[i]).Bold())
|
|
fmt.Printf("%s %#x\n", au.BrightMagenta("[validating public key]").Bold(), pubKeys[i])
|
|
if showPrivateKeys {
|
|
fmt.Printf("%s %#x\n", au.BrightRed("[validating private key]").Bold(), privateKeys[i])
|
|
}
|
|
if !showDepositData {
|
|
continue
|
|
}
|
|
fmt.Printf(
|
|
"%s\n",
|
|
au.BrightRed("If you imported your account coming from the eth2 launchpad, you will find your "+
|
|
"deposit_data.json in the eth2.0-deposit-cli's validator_keys folder"),
|
|
)
|
|
fmt.Println("")
|
|
}
|
|
fmt.Println("")
|
|
return nil
|
|
}
|
|
|
|
func listDerivedKeymanagerAccounts(
|
|
ctx context.Context,
|
|
showDepositData,
|
|
showPrivateKeys bool,
|
|
keymanager *derived.Keymanager,
|
|
) error {
|
|
au := aurora.NewAurora(true)
|
|
fmt.Printf("(keymanager kind) %s\n", au.BrightGreen("derived, (HD) hierarchical-deterministic").Bold())
|
|
fmt.Printf("(derivation format) %s\n", au.BrightGreen(keymanager.KeymanagerOpts().DerivedPathStructure).Bold())
|
|
validatingPubKeys, err := keymanager.FetchValidatingPublicKeys(ctx)
|
|
if err != nil {
|
|
return errors.Wrap(err, "could not fetch validating public keys")
|
|
}
|
|
var validatingPrivateKeys [][32]byte
|
|
if showPrivateKeys {
|
|
validatingPrivateKeys, err = keymanager.FetchValidatingPrivateKeys(ctx)
|
|
if err != nil {
|
|
return errors.Wrap(err, "could not fetch validating private keys")
|
|
}
|
|
}
|
|
withdrawalPublicKeys, err := keymanager.FetchWithdrawalPublicKeys(ctx)
|
|
if err != nil {
|
|
return errors.Wrap(err, "could not fetch validating public keys")
|
|
}
|
|
var withdrawalPrivateKeys [][32]byte
|
|
if showPrivateKeys {
|
|
withdrawalPrivateKeys, err = keymanager.FetchWithdrawalPrivateKeys(ctx)
|
|
if err != nil {
|
|
return errors.Wrap(err, "could not fetch withdrawal private keys")
|
|
}
|
|
}
|
|
nextAccountNumber := keymanager.NextAccountNumber()
|
|
currentAccountNumber := nextAccountNumber
|
|
if nextAccountNumber > 0 {
|
|
currentAccountNumber--
|
|
}
|
|
accountNames, err := keymanager.ValidatingAccountNames(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if len(accountNames) == 1 {
|
|
fmt.Print("Showing 1 validator account\n")
|
|
} else if len(accountNames) == 0 {
|
|
fmt.Print("No accounts found\n")
|
|
return nil
|
|
} else {
|
|
fmt.Printf("Showing %d validator accounts\n", len(accountNames))
|
|
}
|
|
for i := uint64(0); i <= currentAccountNumber; i++ {
|
|
fmt.Println("")
|
|
validatingKeyPath := fmt.Sprintf(derived.ValidatingKeyDerivationPathTemplate, i)
|
|
withdrawalKeyPath := fmt.Sprintf(derived.WithdrawalKeyDerivationPathTemplate, i)
|
|
|
|
// Retrieve the withdrawal key account metadata.
|
|
fmt.Printf("%s | %s\n", au.BrightBlue(fmt.Sprintf("Account %d", i)).Bold(), au.BrightGreen(accountNames[i]).Bold())
|
|
fmt.Printf("%s %#x\n", au.BrightMagenta("[withdrawal public key]").Bold(), withdrawalPublicKeys[i])
|
|
if showPrivateKeys {
|
|
fmt.Printf("%s %#x\n", au.BrightRed("[withdrawal private key]").Bold(), withdrawalPrivateKeys[i])
|
|
}
|
|
fmt.Printf("%s %s\n", au.BrightMagenta("[derivation path]").Bold(), withdrawalKeyPath)
|
|
|
|
// Retrieve the validating key account metadata.
|
|
fmt.Printf("%s %#x\n", au.BrightCyan("[validating public key]").Bold(), validatingPubKeys[i])
|
|
if showPrivateKeys {
|
|
fmt.Printf("%s %#x\n", au.BrightRed("[validating private key]").Bold(), validatingPrivateKeys[i])
|
|
}
|
|
fmt.Printf("%s %s\n", au.BrightCyan("[derivation path]").Bold(), validatingKeyPath)
|
|
|
|
if !showDepositData {
|
|
continue
|
|
}
|
|
enc, err := keymanager.DepositDataForAccount(i)
|
|
if err != nil {
|
|
return errors.Wrapf(err, "could not deposit data for account: %s", accountNames[i])
|
|
}
|
|
fmt.Printf(`
|
|
======================Eth1 Deposit Transaction Data=====================
|
|
|
|
%#x
|
|
|
|
===================================================================`, enc)
|
|
fmt.Println(" ")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func listRemoteKeymanagerAccounts(
|
|
ctx context.Context,
|
|
w *wallet.Wallet,
|
|
keymanager keymanager.IKeymanager,
|
|
opts *remote.KeymanagerOpts,
|
|
) error {
|
|
au := aurora.NewAurora(true)
|
|
fmt.Printf("(keymanager kind) %s\n", au.BrightGreen("remote signer").Bold())
|
|
fmt.Printf(
|
|
"(configuration file path) %s\n",
|
|
au.BrightGreen(filepath.Join(w.AccountsDir(), wallet.KeymanagerConfigFileName)).Bold(),
|
|
)
|
|
fmt.Println(" ")
|
|
fmt.Printf("%s\n", au.BrightGreen("Configuration options").Bold())
|
|
fmt.Println(opts)
|
|
validatingPubKeys, err := keymanager.FetchValidatingPublicKeys(ctx)
|
|
if err != nil {
|
|
return errors.Wrap(err, "could not fetch validating public keys")
|
|
}
|
|
if len(validatingPubKeys) == 1 {
|
|
fmt.Print("Showing 1 validator account\n")
|
|
} else if len(validatingPubKeys) == 0 {
|
|
fmt.Print("No accounts found\n")
|
|
return nil
|
|
} else {
|
|
fmt.Printf("Showing %d validator accounts\n", len(validatingPubKeys))
|
|
}
|
|
for i := 0; i < len(validatingPubKeys); i++ {
|
|
fmt.Println("")
|
|
fmt.Printf(
|
|
"%s\n", au.BrightGreen(petnames.DeterministicName(validatingPubKeys[i][:], "-")).Bold(),
|
|
)
|
|
// Retrieve the validating key account metadata.
|
|
fmt.Printf("%s %#x\n", au.BrightCyan("[validating public key]").Bold(), validatingPubKeys[i])
|
|
fmt.Println(" ")
|
|
}
|
|
return nil
|
|
}
|