package commands
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
|
|
"github.com/spf13/cobra"
|
|
|
|
cfg "github.com/tendermint/tendermint/config"
|
|
tmos "github.com/tendermint/tendermint/libs/os"
|
|
tmrand "github.com/tendermint/tendermint/libs/rand"
|
|
tmtime "github.com/tendermint/tendermint/libs/time"
|
|
"github.com/tendermint/tendermint/privval"
|
|
"github.com/tendermint/tendermint/types"
|
|
)
|
|
|
|
// InitFilesCmd initializes a fresh Tendermint Core instance.
|
|
var InitFilesCmd = &cobra.Command{
|
|
Use: "init [full|validator|seed]",
|
|
Short: "Initializes a Tendermint node",
|
|
ValidArgs: []string{"full", "validator", "seed"},
|
|
// We allow for zero args so we can throw a more informative error
|
|
Args: cobra.MaximumNArgs(1),
|
|
RunE: initFiles,
|
|
}
|
|
|
|
var (
|
|
keyType string
|
|
)
|
|
|
|
func init() {
|
|
InitFilesCmd.Flags().StringVar(&keyType, "key", types.ABCIPubKeyTypeEd25519,
|
|
"Key type to generate privval file with. Options: ed25519, secp256k1")
|
|
}
|
|
|
|
func initFiles(cmd *cobra.Command, args []string) error {
|
|
if len(args) == 0 {
|
|
return errors.New("must specify a node type: tendermint init [validator|full|seed]")
|
|
}
|
|
config.Mode = args[0]
|
|
return initFilesWithConfig(cmd.Context(), config)
|
|
}
|
|
|
|
func initFilesWithConfig(ctx context.Context, config *cfg.Config) error {
|
|
var (
|
|
pv *privval.FilePV
|
|
err error
|
|
)
|
|
|
|
if config.Mode == cfg.ModeValidator {
|
|
// private validator
|
|
privValKeyFile := config.PrivValidator.KeyFile()
|
|
privValStateFile := config.PrivValidator.StateFile()
|
|
if tmos.FileExists(privValKeyFile) {
|
|
pv, err = privval.LoadFilePV(privValKeyFile, privValStateFile)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
logger.Info("Found private validator", "keyFile", privValKeyFile,
|
|
"stateFile", privValStateFile)
|
|
} else {
|
|
pv, err = privval.GenFilePV(privValKeyFile, privValStateFile, keyType)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := pv.Save(); err != nil {
|
|
return err
|
|
}
|
|
logger.Info("Generated private validator", "keyFile", privValKeyFile,
|
|
"stateFile", privValStateFile)
|
|
}
|
|
}
|
|
|
|
nodeKeyFile := config.NodeKeyFile()
|
|
if tmos.FileExists(nodeKeyFile) {
|
|
logger.Info("Found node key", "path", nodeKeyFile)
|
|
} else {
|
|
if _, err := types.LoadOrGenNodeKey(nodeKeyFile); err != nil {
|
|
return err
|
|
}
|
|
logger.Info("Generated node key", "path", nodeKeyFile)
|
|
}
|
|
|
|
// genesis file
|
|
genFile := config.GenesisFile()
|
|
if tmos.FileExists(genFile) {
|
|
logger.Info("Found genesis file", "path", genFile)
|
|
} else {
|
|
|
|
genDoc := types.GenesisDoc{
|
|
ChainID: fmt.Sprintf("test-chain-%v", tmrand.Str(6)),
|
|
GenesisTime: tmtime.Now(),
|
|
ConsensusParams: types.DefaultConsensusParams(),
|
|
}
|
|
if keyType == "secp256k1" {
|
|
genDoc.ConsensusParams.Validator = types.ValidatorParams{
|
|
PubKeyTypes: []string{types.ABCIPubKeyTypeSecp256k1},
|
|
}
|
|
}
|
|
|
|
ctx, cancel := context.WithTimeout(ctx, ctxTimeout)
|
|
defer cancel()
|
|
|
|
// if this is a validator we add it to genesis
|
|
if pv != nil {
|
|
pubKey, err := pv.GetPubKey(ctx)
|
|
if err != nil {
|
|
return fmt.Errorf("can't get pubkey: %w", err)
|
|
}
|
|
genDoc.Validators = []types.GenesisValidator{{
|
|
Address: pubKey.Address(),
|
|
PubKey: pubKey,
|
|
Power: 10,
|
|
}}
|
|
}
|
|
|
|
if err := genDoc.SaveAs(genFile); err != nil {
|
|
return err
|
|
}
|
|
logger.Info("Generated genesis file", "path", genFile)
|
|
}
|
|
|
|
// write config file
|
|
if err := cfg.WriteConfigFile(config.RootDir, config); err != nil {
|
|
return err
|
|
}
|
|
logger.Info("Generated config", "mode", config.Mode)
|
|
|
|
return nil
|
|
}
|