306 lines
7.5 KiB
Go
306 lines
7.5 KiB
Go
package cfg
|
|
|
|
import (
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"flag"
|
|
"fmt"
|
|
"io"
|
|
"lbc/yggdrasil"
|
|
"os"
|
|
"path/filepath"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/spf13/viper"
|
|
cfg "github.com/tendermint/tendermint/config"
|
|
"github.com/tendermint/tendermint/p2p"
|
|
"github.com/tendermint/tendermint/privval"
|
|
tmTypes "github.com/tendermint/tendermint/types"
|
|
)
|
|
|
|
type Config = cfg.Config
|
|
|
|
var (
|
|
yggListenPort = 4224
|
|
yggKeyPath = flag.String("ygg-key", "./config/yggdrasil.key", "Path to Yggdrasil key file")
|
|
)
|
|
|
|
func copyFile(src, dst string) error {
|
|
in, err := os.Open(src)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer in.Close()
|
|
|
|
if err = os.MkdirAll(filepath.Dir(dst), 0o700); err != nil {
|
|
return err
|
|
}
|
|
|
|
out, err := os.Create(dst)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer func() {
|
|
_ = out.Sync()
|
|
_ = out.Close()
|
|
}()
|
|
|
|
_, err = io.Copy(out, in)
|
|
return err
|
|
}
|
|
|
|
func LoadViperConfig(path string) (*viper.Viper, error) {
|
|
v := viper.New()
|
|
v.SetConfigFile(path)
|
|
err := v.ReadInConfig()
|
|
return v, err
|
|
}
|
|
|
|
func InitTendermintFiles(config *cfg.Config, isGenesis bool, chainName string) error {
|
|
if err := os.MkdirAll(filepath.Dir(config.PrivValidatorKeyFile()), 0700); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := os.MkdirAll(filepath.Join(config.RootDir, "data"), 0700); err != nil {
|
|
return err
|
|
}
|
|
|
|
pv := privval.GenFilePV(
|
|
config.PrivValidatorKeyFile(),
|
|
config.PrivValidatorStateFile(),
|
|
)
|
|
|
|
if _, err := p2p.LoadOrGenNodeKey(config.NodeKeyFile()); err != nil {
|
|
return err
|
|
}
|
|
|
|
key, err := pv.GetPubKey()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
pv.Save()
|
|
|
|
if isGenesis {
|
|
// Genesis
|
|
genDoc := &tmTypes.GenesisDoc{
|
|
ChainID: chainName,
|
|
GenesisTime: time.Now(),
|
|
ConsensusParams: tmTypes.DefaultConsensusParams(),
|
|
Validators: []tmTypes.GenesisValidator{
|
|
{
|
|
Address: key.Address(),
|
|
PubKey: key,
|
|
Power: 10,
|
|
Name: config.Moniker,
|
|
},
|
|
},
|
|
AppHash: []byte{},
|
|
}
|
|
|
|
return genDoc.SaveAs(config.GenesisFile())
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func writeYggdrasilKey(path string) {
|
|
bytes := yggdrasil.GeneratePrivateKey()
|
|
if err := os.MkdirAll(filepath.Dir(path), 0700); err != nil {
|
|
return
|
|
}
|
|
|
|
hexKey := hex.EncodeToString(bytes[:])
|
|
os.WriteFile(path, []byte(hexKey), 0600)
|
|
}
|
|
|
|
func WriteConfig(config *cfg.Config, configPath *string, nodeInfo p2p.NodeInfo) *viper.Viper {
|
|
writeYggdrasilKey(*yggKeyPath)
|
|
pubkey, err := yggdrasil.GetPublicKey(*yggKeyPath)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "yggdrasil key not found: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
domain := hex.EncodeToString(pubkey) + ".pk.ygg"
|
|
fmt.Printf("Yggdrasil node domain: %s\n", domain)
|
|
|
|
v := viper.New()
|
|
v.SetConfigFile(*configPath)
|
|
v.SetConfigType("toml")
|
|
|
|
v.Set("moniker", config.Moniker)
|
|
v.Set("db_backend", config.DBBackend)
|
|
v.Set("db_dir", config.DBDir())
|
|
v.Set("log_level", config.LogLevel)
|
|
v.Set("log_format", config.LogFormat)
|
|
v.Set("genesis_file", config.GenesisFile())
|
|
v.Set("node_key_file", config.NodeKeyFile())
|
|
v.Set("abci", config.ABCI)
|
|
v.Set("filter_peers", config.FilterPeers)
|
|
|
|
v.Set("priv_validator", map[string]any{
|
|
"key_file": config.PrivValidatorKeyFile(),
|
|
"state_file": config.PrivValidatorStateFile(),
|
|
"laddr": config.PrivValidatorListenAddr,
|
|
"client_certificate_file": "",
|
|
"client_key_file": "",
|
|
"root_ca_file": "",
|
|
})
|
|
|
|
v.Set("yggdrasil", map[string]any{
|
|
"admin_listen": "none",
|
|
"peers": "auto",
|
|
"allowed_public_keys": []string{},
|
|
"private_key_file": *yggKeyPath,
|
|
})
|
|
|
|
if a := ReadP2Peers(*configPath); a == "" {
|
|
nodeId := nodeInfo.ID()
|
|
myPeer := yggdrasil.GetYggdrasilAddress(v)
|
|
config.P2P.PersistentPeers = string(nodeId) + "@ygg://[" + myPeer + "]:" + strconv.Itoa(yggListenPort)
|
|
} else {
|
|
config.P2P.PersistentPeers = a
|
|
}
|
|
|
|
v.Set("p2p", map[string]interface{}{
|
|
"use_legacy": false,
|
|
"queue_type": "priority",
|
|
"laddr": strconv.Itoa(yggListenPort) + ":127.0.0.1:8000",
|
|
"external_address": "", // will be set automatically by Tendermint if needed
|
|
"upnp": false,
|
|
"bootstrap_peers": "",
|
|
"persistent_peers": config.P2P.PersistentPeers,
|
|
"addr_book_file": "config/addrbook.json",
|
|
"addr_book_strict": false,
|
|
})
|
|
|
|
err = v.WriteConfigAs(*configPath)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "error writing config: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
return v
|
|
}
|
|
|
|
func ReadConfig(configFile string) (*cfg.Config, error) {
|
|
config := cfg.DefaultConfig()
|
|
config.RootDir = filepath.Dir(filepath.Dir(configFile))
|
|
viper.SetConfigFile(configFile)
|
|
viper.SetConfigType("toml")
|
|
|
|
if err := viper.ReadInConfig(); err != nil {
|
|
return nil, fmt.Errorf("viper read config: %w", err)
|
|
}
|
|
|
|
if err := viper.Unmarshal(config); err != nil {
|
|
return nil, fmt.Errorf("viper unmarshal: %w", err)
|
|
}
|
|
|
|
if err := config.ValidateBasic(); err != nil {
|
|
return nil, fmt.Errorf("config invalid: %w", err)
|
|
}
|
|
|
|
return config, nil
|
|
}
|
|
|
|
func DefaultConfig() *cfg.Config {
|
|
return cfg.DefaultConfig()
|
|
}
|
|
|
|
func ReadP2Peers(configFile string) string {
|
|
var genesis map[string]any
|
|
genesisJson, err := os.ReadFile(filepath.Join(filepath.Dir(configFile), "genesis.json"))
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
_ = json.Unmarshal(genesisJson, &genesis)
|
|
p2peers, ok := genesis["p2peers"].(string)
|
|
if ok && p2peers != "" {
|
|
return p2peers
|
|
} else {
|
|
return ""
|
|
}
|
|
}
|
|
|
|
func UpdateGenesisJson(nodeInfo p2p.NodeInfo, v *viper.Viper, defaultConfigDirectoryPath string) {
|
|
genesisJsonPath := filepath.Join(defaultConfigDirectoryPath, "genesis.json")
|
|
file, err := os.ReadFile(genesisJsonPath)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
var dat map[string]any
|
|
if err := json.Unmarshal(file, &dat); err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
myPeer := yggdrasil.GetYggdrasilAddress(v)
|
|
|
|
p2peers := fmt.Sprintf("%s@ygg://[%s]:%d", nodeInfo.ID(), myPeer, yggListenPort)
|
|
dat["p2peers"] = p2peers
|
|
|
|
out, err := json.MarshalIndent(dat, "", " ")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
if err := os.WriteFile(genesisJsonPath, out, 0o644); err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
|
|
func InitGenesis(chainName, defaultConfigPath string) (*cfg.Config, *viper.Viper) {
|
|
config := cfg.DefaultConfig()
|
|
config.RootDir = filepath.Dir(filepath.Dir(defaultConfigPath))
|
|
|
|
nodeinfo := p2p.DefaultNodeInfo{}
|
|
viper := WriteConfig(config, &defaultConfigPath, nodeinfo)
|
|
if err := InitTendermintFiles(config, true, chainName); err != nil {
|
|
fmt.Fprintf(os.Stderr, "Failed to init files: %v\n", err)
|
|
panic(err)
|
|
}
|
|
|
|
return config, viper
|
|
}
|
|
|
|
func InitJoiner(chainName, defaultConfigPath, path string) error {
|
|
config := cfg.DefaultConfig()
|
|
config.RootDir = filepath.Dir(filepath.Dir(defaultConfigPath))
|
|
|
|
if err := copyFile(path, config.GenesisFile()); err != nil {
|
|
fmt.Fprintln(os.Stderr, "не удалось скопировать genesis.json:", err)
|
|
os.Exit(3)
|
|
}
|
|
|
|
nodeinfo := p2p.DefaultNodeInfo{}
|
|
WriteConfig(config, &defaultConfigPath, nodeinfo)
|
|
//viper := cfg.WriteConfig(config, &defaultConfigPath, nodeinfo)
|
|
if err := InitTendermintFiles(config, false, chainName); err != nil {
|
|
fmt.Fprintf(os.Stderr, "Failed to init files: %v\n", err)
|
|
panic(err)
|
|
}
|
|
|
|
//node, db, err := buildNode()
|
|
//if err != nil {
|
|
// panic(err)
|
|
//}
|
|
//defer db.Close()
|
|
|
|
//cfg.WriteConfig(config, &defaultConfigPath, node.NodeInfo())
|
|
|
|
//if err := os.MkdirAll(filepath.Join(config.RootDir, "data"), 0o700); err != nil {
|
|
// fmt.Fprintln(os.Stderr, "не удалось создать директорию data")
|
|
// os.Exit(1)
|
|
//}
|
|
|
|
if _, err := p2p.LoadOrGenNodeKey(config.NodeKeyFile()); err != nil {
|
|
return fmt.Errorf("ошибка генерации node_key.json")
|
|
}
|
|
|
|
pv := privval.GenFilePV(
|
|
config.PrivValidatorKeyFile(),
|
|
config.PrivValidatorStateFile(),
|
|
)
|
|
pv.Save()
|
|
return nil
|
|
}
|