diff --git a/client/testnet.go b/client/testnet.go index bf2878532b..9e6af7a25f 100644 --- a/client/testnet.go +++ b/client/testnet.go @@ -19,6 +19,8 @@ package client import ( "bufio" + "context" + sdkmath "cosmossdk.io/math" "encoding/json" "fmt" "net" @@ -324,12 +326,12 @@ func initTestnetFiles( valTokens := sdk.TokensFromConsensusPower(100, ethermint.PowerReduction) createValMsg, err := stakingtypes.NewMsgCreateValidator( - sdk.ValAddress(addr), + addr.String(), valPubKeys[i], sdk.NewCoin(ethermint.AttoPhoton, valTokens), stakingtypes.NewDescription(nodeDirName, "", "", "", ""), stakingtypes.NewCommissionRates(sdkmath.LegacyOneDec(), sdkmath.LegacyOneDec(), sdkmath.LegacyOneDec()), - sdk.OneInt(), + sdkmath.OneInt(), ) if err != nil { return err @@ -349,7 +351,8 @@ func initTestnetFiles( WithKeybase(kb). WithTxConfig(clientCtx.TxConfig) - if err := tx.Sign(txFactory, nodeDirName, txBuilder, true); err != nil { + // TODO(boodyvo): + if err := tx.Sign(context.Background(), txFactory, nodeDirName, txBuilder, true); err != nil { return err } @@ -486,7 +489,11 @@ func collectGenFiles( nodeID, valPubKey := nodeIDs[i], valPubKeys[i] initCfg := genutiltypes.NewInitConfig(chainID, gentxsDir, nodeID, valPubKey) - genDoc, err := types.GenesisDocFromFile(nodeConfig.GenesisFile()) + //genDoc, err := types.GenesisDocFromFile(nodeConfig.GenesisFile()) + //if err != nil { + // return err + //} + appGenesis, err := genutiltypes.AppGenesisFromFile(nodeConfig.GenesisFile()) if err != nil { return err } @@ -496,9 +503,10 @@ func collectGenFiles( clientCtx.TxConfig, nodeConfig, initCfg, - *genDoc, + appGenesis, genBalIterator, genutiltypes.DefaultMessageValidator, + clientCtx.TxConfig.SigningContext().ValidatorAddressCodec(), ) if err != nil { return err diff --git a/go.mod b/go.mod index d997eee7a6..76f042c788 100644 --- a/go.mod +++ b/go.mod @@ -12,7 +12,8 @@ require ( cosmossdk.io/x/feegrant v0.1.1 cosmossdk.io/x/tx v0.13.5 cosmossdk.io/x/upgrade v0.1.4 - github.com/Kava-Labs/opendb v0.0.0-20240719173129-a2f11f6d7e51 + //github.com/Kava-Labs/opendb v0.0.0-20240719173129-a2f11f6d7e51 + github.com/Kava-Labs/opendb v0.0.0-20241024062216-dd5bc73e28f2 github.com/btcsuite/btcd v0.24.2 github.com/btcsuite/btcd/btcutil v1.1.6 github.com/cenkalti/backoff/v4 v4.3.0 @@ -53,6 +54,8 @@ require ( sigs.k8s.io/yaml v1.4.0 ) +require golang.org/x/sync v0.8.0 + require ( cloud.google.com/go v0.115.0 // indirect cloud.google.com/go/auth v0.6.0 // indirect @@ -221,7 +224,6 @@ require ( golang.org/x/crypto v0.26.0 // indirect golang.org/x/exp v0.0.0-20240613232115-7f521ea00fb8 // indirect golang.org/x/oauth2 v0.21.0 // indirect - golang.org/x/sync v0.8.0 // indirect golang.org/x/sys v0.24.0 // indirect golang.org/x/term v0.23.0 // indirect golang.org/x/text v0.17.0 // indirect diff --git a/go.sum b/go.sum index 421a7689a2..946c0f6c29 100644 --- a/go.sum +++ b/go.sum @@ -229,8 +229,8 @@ github.com/DataDog/zstd v1.5.5 h1:oWf5W7GtOLgp6bciQYDmhHHjdhYkALu6S/5Ni9ZgSvQ= github.com/DataDog/zstd v1.5.5/go.mod h1:g4AWEaM3yOg3HYfnJ3YIawPnVdXJh9QME85blwSAmyw= github.com/Kava-Labs/go-ethereum v1.10.27-0.20240308170502-da7973e5eee0 h1:pPFzOjEZmihLk70TQRPUCWs8uar6nfh4vZ/I1r0zeso= github.com/Kava-Labs/go-ethereum v1.10.27-0.20240308170502-da7973e5eee0/go.mod h1:/6CsT5Ceen2WPLI/oCA3xMcZ5sWMF/D46SjM/ayY0Oo= -github.com/Kava-Labs/opendb v0.0.0-20240719173129-a2f11f6d7e51 h1:tMTENCeSPIJO8yCpEQbT15XYXt4EFNQUx3s334uxVts= -github.com/Kava-Labs/opendb v0.0.0-20240719173129-a2f11f6d7e51/go.mod h1:LbPsJiWvj90NT3Y9YV8EFPkWfvp8A15Tp88qqKa3LxA= +github.com/Kava-Labs/opendb v0.0.0-20241024062216-dd5bc73e28f2 h1:nbPWQhtnAbLVcRwiboKRdAe9LHCqXTqv53LFWsbMBXI= +github.com/Kava-Labs/opendb v0.0.0-20241024062216-dd5bc73e28f2/go.mod h1:HVK6fke4/iQusTLZ0Us/0Mmj/CTiHmU2VQqmScQHsHg= github.com/Knetic/govaluate v3.0.1-0.20171022003610-9aa49832a739+incompatible/go.mod h1:r7JcOSlj0wfOMncg0iLm8Leh48TZaKVeNIfJntJ2wa0= github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow= github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM= diff --git a/server/json_rpc.go b/server/json_rpc.go index 7934a30c77..d800d67167 100644 --- a/server/json_rpc.go +++ b/server/json_rpc.go @@ -24,7 +24,6 @@ import ( "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/server" - "github.com/cosmos/cosmos-sdk/server/types" ethlog "github.com/ethereum/go-ethereum/log" ethrpc "github.com/ethereum/go-ethereum/rpc" "github.com/evmos/ethermint/rpc" @@ -115,7 +114,7 @@ func StartJSONRPC(ctx *server.Context, case err := <-errCh: ctx.Logger.Error("failed to boot JSON-RPC server", "error", err.Error()) return nil, nil, err - case <-time.After(types.ServerStartTime): // assume JSON RPC server started successfully + case <-time.After(ServerStartTime): // assume JSON RPC server started successfully } ctx.Logger.Info("Starting JSON WebSocket server", "address", config.JSONRPC.WsAddress) diff --git a/server/start.go b/server/start.go index 2ded974df4..196d34ac76 100644 --- a/server/start.go +++ b/server/start.go @@ -18,29 +18,19 @@ package server import ( "context" "fmt" - cmtconfig "github.com/cometbft/cometbft/config" + "golang.org/x/sync/errgroup" "io" "net" - "net/http" "os" "path/filepath" - "runtime/pprof" "strconv" "time" - errorsmod "cosmossdk.io/errors" pruningtypes "cosmossdk.io/store/pruning/types" "github.com/Kava-Labs/opendb" - abciserver "github.com/cometbft/cometbft/abci/server" tcmd "github.com/cometbft/cometbft/cmd/cometbft/commands" - tmos "github.com/cometbft/cometbft/libs/os" - "github.com/cometbft/cometbft/node" - "github.com/cometbft/cometbft/p2p" - pvm "github.com/cometbft/cometbft/privval" - "github.com/cometbft/cometbft/proxy" - rpcclient "github.com/cometbft/cometbft/rpc/client" - "github.com/cometbft/cometbft/rpc/client/local" dbm "github.com/cosmos/cosmos-db" + //dbm "github.com/cometbft/cometbft-db" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/client/flags" "github.com/cosmos/cosmos-sdk/codec" @@ -49,21 +39,14 @@ import ( "github.com/cosmos/cosmos-sdk/server/api" serverconfig "github.com/cosmos/cosmos-sdk/server/config" servergrpc "github.com/cosmos/cosmos-sdk/server/grpc" - servercmtlog "github.com/cosmos/cosmos-sdk/server/log" "github.com/cosmos/cosmos-sdk/server/types" "github.com/cosmos/cosmos-sdk/telemetry" - "github.com/cosmos/rosetta" - crgserver "github.com/cosmos/rosetta/lib/server" - ethmetricsexp "github.com/ethereum/go-ethereum/metrics/exp" "github.com/spf13/cobra" "google.golang.org/grpc" "google.golang.org/grpc/credentials/insecure" - "github.com/evmos/ethermint/indexer" - ethdebug "github.com/evmos/ethermint/rpc/namespaces/ethereum/debug" "github.com/evmos/ethermint/server/config" srvflags "github.com/evmos/ethermint/server/flags" - ethermint "github.com/evmos/ethermint/types" ) // ErrorCode contains the exit code for server exit. @@ -209,7 +192,7 @@ which accepts a path for the resulting pprof file. cmd.Flags().Bool(srvflags.GRPCEnable, true, "Define if the gRPC server should be enabled") cmd.Flags().String(srvflags.GRPCAddress, serverconfig.DefaultGRPCAddress, "the gRPC server address to listen on") cmd.Flags().Bool(srvflags.GRPCWebEnable, true, "Define if the gRPC-Web server should be enabled. (Note: gRPC must also be enabled.)") - cmd.Flags().String(srvflags.GRPCWebAddress, serverconfig.DefaultGRPCWebAddress, "The gRPC-Web server address to listen on") + //cmd.Flags().String(srvflags.GRPCWebAddress, serverconfig.DefaultGRPCWebAddress, "The gRPC-Web server address to listen on") cmd.Flags().Bool(srvflags.JSONRPCEnable, true, "Define if the JSON-RPC server should be enabled") cmd.Flags().StringSlice(srvflags.JSONRPCAPI, config.GetDefaultAPINamespaces(), "Defines a list of JSON-RPC namespaces that should be enabled") @@ -245,423 +228,535 @@ which accepts a path for the resulting pprof file. } func startStandAlone(ctx *server.Context, opts StartOptions) error { - addr := ctx.Viper.GetString(srvflags.Address) - transport := ctx.Viper.GetString(srvflags.Transport) - home := ctx.Viper.GetString(flags.FlagHome) - - db, err := opts.DBOpener(ctx.Viper, home, server.GetAppDBBackend(ctx.Viper)) - if err != nil { - return err - } - - defer func() { - if err := db.Close(); err != nil { - ctx.Logger.Error("error closing db", "error", err.Error()) - } - }() - - traceWriterFile := ctx.Viper.GetString(srvflags.TraceStore) - traceWriter, err := openTraceWriter(traceWriterFile) - if err != nil { - return err - } - - app := opts.AppCreator(ctx.Logger, db, traceWriter, ctx.Viper) - - config, err := config.GetConfig(ctx.Viper) - if err != nil { - ctx.Logger.Error("failed to get server config", "error", err.Error()) - return err - } - - if err := config.ValidateBasic(); err != nil { - ctx.Logger.Error("invalid server config", "error", err.Error()) - return err - } - - _, err = startTelemetry(config) - if err != nil { - return err - } - - svr, err := abciserver.NewServer(addr, transport, app) - if err != nil { - return fmt.Errorf("error creating listener: %v", err) - } - - svr.SetLogger(servercmtlog.CometLoggerWrapper{Logger: ctx.Logger.With("server", "abci")}) - - err = svr.Start() - if err != nil { - tmos.Exit(err.Error()) - } - - defer func() { - if err = svr.Stop(); err != nil { - tmos.Exit(err.Error()) - } - }() - - // Wait for SIGINT or SIGTERM signal - return server.ListenForQuitSignals + return nil + //addr := ctx.Viper.GetString(srvflags.Address) + //transport := ctx.Viper.GetString(srvflags.Transport) + //home := ctx.Viper.GetString(flags.FlagHome) + // + //db, err := opts.DBOpener(ctx.Viper, home, server.GetAppDBBackend(ctx.Viper)) + //if err != nil { + // return err + //} + // + //defer func() { + // if err := db.Close(); err != nil { + // ctx.Logger.Error("error closing db", "error", err.Error()) + // } + //}() + // + //traceWriterFile := ctx.Viper.GetString(srvflags.TraceStore) + //traceWriter, err := openTraceWriter(traceWriterFile) + //if err != nil { + // return err + //} + // + //app := opts.AppCreator(ctx.Logger, db, traceWriter, ctx.Viper) + // + //config, err := config.GetConfig(ctx.Viper) + //if err != nil { + // ctx.Logger.Error("failed to get server config", "error", err.Error()) + // return err + //} + // + //if err := config.ValidateBasic(); err != nil { + // ctx.Logger.Error("invalid server config", "error", err.Error()) + // return err + //} + // + //_, err = startTelemetry(config) + //if err != nil { + // return err + //} + // + //svr, err := abciserver.NewServer(addr, transport, app) + //if err != nil { + // return fmt.Errorf("error creating listener: %v", err) + //} + // + //svr.SetLogger(servercmtlog.CometLoggerWrapper{Logger: ctx.Logger.With("server", "abci")}) + // + //err = svr.Start() + //if err != nil { + // tmos.Exit(err.Error()) + //} + // + //defer func() { + // if err = svr.Stop(); err != nil { + // tmos.Exit(err.Error()) + // } + //}() + // + //// Wait for SIGINT or SIGTERM signal + //return server.ListenForQuitSignals } // DBProviderFromAppOpts returns a database using the DBBackend and DBDir specified in the ctx.Config. // It uses opendb package which takes into account appOpts and provides configurability and observability. -func DBProviderFromAppOpts(appOpts types.AppOptions) cmtconfig.DBProvider { - return func(ctx *cmtconfig.DBContext) (dbm.DB, error) { - dbType := dbm.BackendType(ctx.Config.DBBackend) - - return opendb.OpenDB(appOpts, ctx.Config.DBDir(), ctx.ID, dbType) - } -} +//func DBProviderFromAppOpts(appOpts types.AppOptions) cmtconfig.DBProvider { +// return func(ctx *cmtconfig.DBContext) (dbm.DB, error) { +// dbType := dbm.BackendType(ctx.Config.DBBackend) +// +// return opendb.OpenDB(appOpts, ctx.Config.DBDir(), ctx.ID, dbType) +// } +//} // legacyAminoCdc is used for the legacy REST API func startInProcess(ctx *server.Context, clientCtx client.Context, opts StartOptions) (err error) { - cfg := ctx.Config - home := cfg.RootDir - logger := ctx.Logger - - if cpuProfile := ctx.Viper.GetString(srvflags.CPUProfile); cpuProfile != "" { - fp, err := ethdebug.ExpandHome(cpuProfile) - if err != nil { - ctx.Logger.Debug("failed to get filepath for the CPU profile file", "error", err.Error()) - return err - } - - f, err := os.Create(fp) - if err != nil { - return err - } - - ctx.Logger.Info("starting CPU profiler", "profile", cpuProfile) - if err := pprof.StartCPUProfile(f); err != nil { - return err - } - - defer func() { - ctx.Logger.Info("stopping CPU profiler", "profile", cpuProfile) - pprof.StopCPUProfile() - if err := f.Close(); err != nil { - logger.Error("failed to close CPU profiler file", "error", err.Error()) - } - }() - } - - db, err := opts.DBOpener(ctx.Viper, home, server.GetAppDBBackend(ctx.Viper)) - if err != nil { - logger.Error("failed to open DB", "error", err.Error()) - return err - } - - defer func() { - if err := db.Close(); err != nil { - ctx.Logger.With("error", err).Error("error closing db") - } - }() + return nil + //cfg := ctx.Config + //home := cfg.RootDir + //logger := ctx.Logger + // + //g, ctxServ := getCtx(ctx, true) + // + //if cpuProfile := ctx.Viper.GetString(srvflags.CPUProfile); cpuProfile != "" { + // fp, err := ethdebug.ExpandHome(cpuProfile) + // if err != nil { + // ctx.Logger.Debug("failed to get filepath for the CPU profile file", "error", err.Error()) + // return err + // } + // + // f, err := os.Create(fp) + // if err != nil { + // return err + // } + // + // ctx.Logger.Info("starting CPU profiler", "profile", cpuProfile) + // if err := pprof.StartCPUProfile(f); err != nil { + // return err + // } + // + // defer func() { + // ctx.Logger.Info("stopping CPU profiler", "profile", cpuProfile) + // pprof.StopCPUProfile() + // if err := f.Close(); err != nil { + // logger.Error("failed to close CPU profiler file", "error", err.Error()) + // } + // }() + //} + // + //db, err := opts.DBOpener(ctx.Viper, home, server.GetAppDBBackend(ctx.Viper)) + //if err != nil { + // logger.Error("failed to open DB", "error", err.Error()) + // return err + //} + // + //defer func() { + // if err := db.Close(); err != nil { + // ctx.Logger.With("error", err).Error("error closing db") + // } + //}() + // + //traceWriterFile := ctx.Viper.GetString(srvflags.TraceStore) + //traceWriter, err := openTraceWriter(traceWriterFile) + //if err != nil { + // logger.Error("failed to open trace writer", "error", err.Error()) + // return err + //} + // + //config, err := config.GetConfig(ctx.Viper) + //if err != nil { + // logger.Error("failed to get server config", "error", err.Error()) + // return err + //} + // + //if err := config.ValidateBasic(); err != nil { + // logger.Error("invalid server config", "error", err.Error()) + // return err + //} + // + //app := opts.AppCreator(ctx.Logger, db, traceWriter, ctx.Viper) + // + //nodeKey, err := p2p.LoadOrGenNodeKey(cfg.NodeKeyFile()) + //if err != nil { + // logger.Error("failed load or gen node key", "error", err.Error()) + // return err + //} + // + //genDocProvider := node.DefaultGenesisDocProviderFunc(cfg) + // + //var ( + // tmNode *node.Node + // gRPCOnly = ctx.Viper.GetBool(srvflags.GRPCOnly) + //) + // + //if gRPCOnly { + // logger.Info("starting node in query only mode; Tendermint is disabled") + // config.GRPC.Enable = true + // config.JSONRPC.EnableIndexer = false + //} else { + // logger.Info("starting node with ABCI Tendermint in-process") + // + // tmNode, err = node.NewNode( + // cfg, + // pvm.LoadOrGenFilePV(cfg.PrivValidatorKeyFile(), cfg.PrivValidatorStateFile()), + // nodeKey, + // proxy.NewLocalClientCreator(app), + // genDocProvider, + // DBProviderFromAppOpts(ctx.Viper), + // node.DefaultMetricsProvider(cfg.Instrumentation), + // servercmtlog.CometLoggerWrapper{ctx.Logger.With("server", "node")}, + // ) + // if err != nil { + // logger.Error("failed init node", "error", err.Error()) + // return err + // } + // + // if err := tmNode.Start(); err != nil { + // logger.Error("failed start tendermint server", "error", err.Error()) + // return err + // } + // + // defer func() { + // if tmNode.IsRunning() { + // _ = tmNode.Stop() + // } + // }() + //} + // + //// Add the tx service to the gRPC router. We only need to register this + //// service if API or gRPC or JSONRPC is enabled, and avoid doing so in the general + //// case, because it spawns a new local tendermint RPC client. + //if (config.API.Enable || config.GRPC.Enable || config.JSONRPC.Enable || config.JSONRPC.EnableIndexer) && tmNode != nil { + // clientCtx = clientCtx.WithClient(local.New(tmNode)) + // + // app.RegisterTxService(clientCtx) + // app.RegisterTendermintService(clientCtx) + // app.RegisterNodeService(clientCtx, config.Config) + //} + // + //metrics, err := startTelemetry(config) + //if err != nil { + // return err + //} + // + //// Enable metrics if JSONRPC is enabled and --metrics is passed + //// Flag not added in config to avoid user enabling in config without passing in CLI + //if config.JSONRPC.Enable && ctx.Viper.GetBool(srvflags.JSONRPCEnableMetrics) { + // ethmetricsexp.Setup(config.JSONRPC.MetricsAddress) + //} + // + //var idxer ethermint.EVMTxIndexer + //if config.JSONRPC.EnableIndexer { + // idxDB, err := OpenIndexerDB(ctx.Viper, home, server.GetAppDBBackend(ctx.Viper)) + // if err != nil { + // logger.Error("failed to open evm indexer DB", "error", err.Error()) + // return err + // } + // + // idxLogger := ctx.Logger.With("indexer", "evm") + // idxer = indexer.NewKVIndexer(idxDB, idxLogger, clientCtx) + // indexerService := NewEVMIndexerService(idxer, clientCtx.Client.(rpcclient.Client)) + // indexerService.SetLogger(servercmtlog.CometLoggerWrapper{Logger: idxLogger}) + // + // errCh := make(chan error) + // go func() { + // if err := indexerService.Start(); err != nil { + // errCh <- err + // } + // }() + // + // select { + // case err := <-errCh: + // return err + // case <-time.After(ServerStartTime): // assume server started successfully + // } + //} + // + //if config.API.Enable || config.JSONRPC.Enable { + // genDoc, err := genDocProvider() + // if err != nil { + // return err + // } + // + // clientCtx = clientCtx. + // WithHomeDir(home). + // WithChainID(genDoc.ChainID) + // + // // Set `GRPCClient` to `clientCtx` to enjoy concurrent grpc query. + // // only use it if gRPC server is enabled. + // if config.GRPC.Enable { + // _, port, err := net.SplitHostPort(config.GRPC.Address) + // if err != nil { + // return errorsmod.Wrapf(err, "invalid grpc address %s", config.GRPC.Address) + // } + // + // maxSendMsgSize := config.GRPC.MaxSendMsgSize + // if maxSendMsgSize == 0 { + // maxSendMsgSize = serverconfig.DefaultGRPCMaxSendMsgSize + // } + // + // maxRecvMsgSize := config.GRPC.MaxRecvMsgSize + // if maxRecvMsgSize == 0 { + // maxRecvMsgSize = serverconfig.DefaultGRPCMaxRecvMsgSize + // } + // + // grpcAddress := fmt.Sprintf("127.0.0.1:%s", port) + // + // // If grpc is enabled, configure grpc client for grpc gateway and json-rpc. + // grpcClient, err := grpc.Dial( + // grpcAddress, + // grpc.WithTransportCredentials(insecure.NewCredentials()), + // grpc.WithDefaultCallOptions( + // grpc.ForceCodec(codec.NewProtoCodec(clientCtx.InterfaceRegistry).GRPCCodec()), + // grpc.MaxCallRecvMsgSize(maxRecvMsgSize), + // grpc.MaxCallSendMsgSize(maxSendMsgSize), + // ), + // ) + // if err != nil { + // return err + // } + // + // clientCtx = clientCtx.WithGRPCClient(grpcClient) + // ctx.Logger.Debug("gRPC client assigned to client context", "address", grpcAddress) + // } + //} + // + //var apiSrv *api.Server + //if config.API.Enable { + // // + // //apiSrv = api.New(clientCtx, servercmtlog.CometLoggerWrapper{Logger: ctx.Logger.With("server", "api")}) + // apiSrv = api.New(clientCtx, servercmtlog.CometLoggerWrapper{Logger: ctx.Logger.With("server", "api")}) + // app.RegisterAPIRoutes(apiSrv, config.API) + // + // if config.Telemetry.Enabled { + // apiSrv.SetTelemetry(metrics) + // } + // + // errCh := make(chan error) + // go func() { + // if err := apiSrv.Start(ctxServ, config.Config); err != nil { + // errCh <- err + // } + // }() + // + // select { + // case err := <-errCh: + // return err + // case <-time.After(ServerStartTime): // assume server started successfully + // } + // + // defer apiSrv.Close() + //} + // + //var ( + // grpcSrv *grpc.Server + // //grpcWebSrv *http.Server + //) + // + //if config.GRPC.Enable { + // grpcSrv, err = servergrpc.StartGRPCServer(clientCtx, app, config.GRPC) + // if err != nil { + // return err + // } + // defer grpcSrv.Stop() + // //if config.GRPCWeb.Enable { + // // grpcWebSrv, err = servergrpc.StartGRPCWeb(grpcSrv, config.Config) + // // if err != nil { + // // ctx.Logger.Error("failed to start grpc-web http server", "error", err.Error()) + // // return err + // // } + // // + // // defer func() { + // // if err := grpcWebSrv.Close(); err != nil { + // // logger.Error("failed to close the grpc-web http server", "error", err.Error()) + // // } + // // }() + // //} + //} + // + //var ( + // httpSrv *http.Server + // httpSrvDone chan struct{} + //) + // + //if config.JSONRPC.Enable { + // genDoc, err := genDocProvider() + // if err != nil { + // return err + // } + // + // clientCtx := clientCtx.WithChainID(genDoc.ChainID) + // + // tmEndpoint := "/websocket" + // tmRPCAddr := cfg.RPC.ListenAddress + // httpSrv, httpSrvDone, err = StartJSONRPC(ctx, clientCtx, tmRPCAddr, tmEndpoint, &config, idxer) + // if err != nil { + // return err + // } + // defer func() { + // shutdownCtx, cancelFn := context.WithTimeout(context.Background(), 10*time.Second) + // defer cancelFn() + // if err := httpSrv.Shutdown(shutdownCtx); err != nil { + // logger.Error("HTTP server shutdown produced a warning", "error", err.Error()) + // } else { + // logger.Info("HTTP server shut down, waiting 5 sec") + // select { + // case <-time.Tick(5 * time.Second): + // case <-httpSrvDone: + // } + // } + // }() + //} + // + //// At this point it is safe to block the process if we're in query only mode as + //// we do not need to start Rosetta or handle any Tendermint related processes. + //if gRPCOnly { + // // wait for signal capture and gracefully return + // return nil + // //return server.WaitForQuitSignals() + //} + // + ////var rosettaSrv crgserver.Server + ////if config.Rosetta.Enable { + //// offlineMode := config.Rosetta.Offline + //// + //// // If GRPC is not enabled rosetta cannot work in online mode, so it works in + //// // offline mode. + //// if !config.GRPC.Enable { + //// offlineMode = true + //// } + //// + //// conf := &rosetta.Config{ + //// Blockchain: config.Rosetta.Blockchain, + //// Network: config.Rosetta.Network, + //// TendermintRPC: ctx.Config.RPC.ListenAddress, + //// GRPCEndpoint: config.GRPC.Address, + //// Addr: config.Rosetta.Address, + //// Retries: config.Rosetta.Retries, + //// Offline: offlineMode, + //// GasToSuggest: config.Rosetta.GasToSuggest, + //// EnableFeeSuggestion: config.Rosetta.EnableFeeSuggestion, + //// Codec: clientCtx.Codec.(*codec.ProtoCodec), + //// InterfaceRegistry: clientCtx.InterfaceRegistry, + //// } + //// + //// rosettaSrv, err = rosetta.ServerFromConfig(conf) + //// if err != nil { + //// return err + //// } + //// + //// errCh := make(chan error) + //// go func() { + //// if err := rosettaSrv.Start(); err != nil { + //// errCh <- err + //// } + //// }() + //// + //// select { + //// case err := <-errCh: + //// return err + //// case <-time.After(types.ServerStartTime): // assume server started successfully + //// } + ////} + // + ////func getCtx(svrCtx *Context, block bool) (*errgroup.Group, context.Context) { + //// ctx, cancelFn := context.WithCancel(context.Background()) + //// g, ctx := errgroup.WithContext(ctx) + //// // listen for quit signals so the calling parent process can gracefully exit + //// ListenForQuitSignals(g, block, cancelFn, svrCtx.Logger) + //// return g, ctx + ////} + // + //// Wait for SIGINT or SIGTERM signal + //return nil + //return server.WaitForQuitSignals() +} - traceWriterFile := ctx.Viper.GetString(srvflags.TraceStore) - traceWriter, err := openTraceWriter(traceWriterFile) - if err != nil { - logger.Error("failed to open trace writer", "error", err.Error()) - return err +func startGrpcServer( + ctx context.Context, + g *errgroup.Group, + config serverconfig.GRPCConfig, + clientCtx client.Context, + svrCtx *server.Context, + app types.Application, +) (*grpc.Server, client.Context, error) { + if !config.Enable { + // return grpcServer as nil if gRPC is disabled + return nil, clientCtx, nil } - - config, err := config.GetConfig(ctx.Viper) + _, _, err := net.SplitHostPort(config.Address) if err != nil { - logger.Error("failed to get server config", "error", err.Error()) - return err + return nil, clientCtx, err } - if err := config.ValidateBasic(); err != nil { - logger.Error("invalid server config", "error", err.Error()) - return err + maxSendMsgSize := config.MaxSendMsgSize + if maxSendMsgSize == 0 { + maxSendMsgSize = serverconfig.DefaultGRPCMaxSendMsgSize } - app := opts.AppCreator(ctx.Logger, db, traceWriter, ctx.Viper) - - nodeKey, err := p2p.LoadOrGenNodeKey(cfg.NodeKeyFile()) - if err != nil { - logger.Error("failed load or gen node key", "error", err.Error()) - return err + maxRecvMsgSize := config.MaxRecvMsgSize + if maxRecvMsgSize == 0 { + maxRecvMsgSize = serverconfig.DefaultGRPCMaxRecvMsgSize } - genDocProvider := node.DefaultGenesisDocProviderFunc(cfg) - - var ( - tmNode *node.Node - gRPCOnly = ctx.Viper.GetBool(srvflags.GRPCOnly) + // if gRPC is enabled, configure gRPC client for gRPC gateway + grpcClient, err := grpc.Dial( //nolint: staticcheck // ignore this line for this linter + config.Address, + grpc.WithTransportCredentials(insecure.NewCredentials()), + grpc.WithDefaultCallOptions( + grpc.ForceCodec(codec.NewProtoCodec(clientCtx.InterfaceRegistry).GRPCCodec()), + grpc.MaxCallRecvMsgSize(maxRecvMsgSize), + grpc.MaxCallSendMsgSize(maxSendMsgSize), + ), ) - - if gRPCOnly { - logger.Info("starting node in query only mode; Tendermint is disabled") - config.GRPC.Enable = true - config.JSONRPC.EnableIndexer = false - } else { - logger.Info("starting node with ABCI Tendermint in-process") - - tmNode, err = node.NewNode( - cfg, - pvm.LoadOrGenFilePV(cfg.PrivValidatorKeyFile(), cfg.PrivValidatorStateFile()), - nodeKey, - proxy.NewLocalClientCreator(app), - genDocProvider, - DBProviderFromAppOpts(ctx.Viper), - node.DefaultMetricsProvider(cfg.Instrumentation), - servercmtlog.CometLoggerWrapper{ctx.Logger.With("server", "node")}, - ) - if err != nil { - logger.Error("failed init node", "error", err.Error()) - return err - } - - if err := tmNode.Start(); err != nil { - logger.Error("failed start tendermint server", "error", err.Error()) - return err - } - - defer func() { - if tmNode.IsRunning() { - _ = tmNode.Stop() - } - }() - } - - // Add the tx service to the gRPC router. We only need to register this - // service if API or gRPC or JSONRPC is enabled, and avoid doing so in the general - // case, because it spawns a new local tendermint RPC client. - if (config.API.Enable || config.GRPC.Enable || config.JSONRPC.Enable || config.JSONRPC.EnableIndexer) && tmNode != nil { - clientCtx = clientCtx.WithClient(local.New(tmNode)) - - app.RegisterTxService(clientCtx) - app.RegisterTendermintService(clientCtx) - app.RegisterNodeService(clientCtx, config.Config) - } - - metrics, err := startTelemetry(config) if err != nil { - return err - } - - // Enable metrics if JSONRPC is enabled and --metrics is passed - // Flag not added in config to avoid user enabling in config without passing in CLI - if config.JSONRPC.Enable && ctx.Viper.GetBool(srvflags.JSONRPCEnableMetrics) { - ethmetricsexp.Setup(config.JSONRPC.MetricsAddress) - } - - var idxer ethermint.EVMTxIndexer - if config.JSONRPC.EnableIndexer { - idxDB, err := OpenIndexerDB(ctx.Viper, home, server.GetAppDBBackend(ctx.Viper)) - if err != nil { - logger.Error("failed to open evm indexer DB", "error", err.Error()) - return err - } - - idxLogger := ctx.Logger.With("indexer", "evm") - idxer = indexer.NewKVIndexer(idxDB, idxLogger, clientCtx) - indexerService := NewEVMIndexerService(idxer, clientCtx.Client.(rpcclient.Client)) - indexerService.SetLogger(servercmtlog.CometLoggerWrapper{Logger: idxLogger}) - - errCh := make(chan error) - go func() { - if err := indexerService.Start(); err != nil { - errCh <- err - } - }() - - select { - case err := <-errCh: - return err - case <-time.After(ServerStartTime): // assume server started successfully - } - } - - if config.API.Enable || config.JSONRPC.Enable { - genDoc, err := genDocProvider() - if err != nil { - return err - } - - clientCtx = clientCtx. - WithHomeDir(home). - WithChainID(genDoc.ChainID) - - // Set `GRPCClient` to `clientCtx` to enjoy concurrent grpc query. - // only use it if gRPC server is enabled. - if config.GRPC.Enable { - _, port, err := net.SplitHostPort(config.GRPC.Address) - if err != nil { - return errorsmod.Wrapf(err, "invalid grpc address %s", config.GRPC.Address) - } - - maxSendMsgSize := config.GRPC.MaxSendMsgSize - if maxSendMsgSize == 0 { - maxSendMsgSize = serverconfig.DefaultGRPCMaxSendMsgSize - } - - maxRecvMsgSize := config.GRPC.MaxRecvMsgSize - if maxRecvMsgSize == 0 { - maxRecvMsgSize = serverconfig.DefaultGRPCMaxRecvMsgSize - } - - grpcAddress := fmt.Sprintf("127.0.0.1:%s", port) - - // If grpc is enabled, configure grpc client for grpc gateway and json-rpc. - grpcClient, err := grpc.Dial( - grpcAddress, - grpc.WithTransportCredentials(insecure.NewCredentials()), - grpc.WithDefaultCallOptions( - grpc.ForceCodec(codec.NewProtoCodec(clientCtx.InterfaceRegistry).GRPCCodec()), - grpc.MaxCallRecvMsgSize(maxRecvMsgSize), - grpc.MaxCallSendMsgSize(maxSendMsgSize), - ), - ) - if err != nil { - return err - } - - clientCtx = clientCtx.WithGRPCClient(grpcClient) - ctx.Logger.Debug("gRPC client assigned to client context", "address", grpcAddress) - } + return nil, clientCtx, err } - var apiSrv *api.Server - if config.API.Enable { - // - apiSrv = api.New(clientCtx, servercmtlog.CometLoggerWrapper{Logger: ctx.Logger.With("server", "api")}) - app.RegisterAPIRoutes(apiSrv, config.API) + clientCtx = clientCtx.WithGRPCClient(grpcClient) + svrCtx.Logger.Debug("gRPC client assigned to client context", "target", config.Address) - if config.Telemetry.Enabled { - apiSrv.SetTelemetry(metrics) - } - - errCh := make(chan error) - go func() { - if err := apiSrv.Start(config.Config); err != nil { - errCh <- err - } - }() - - select { - case err := <-errCh: - return err - case <-time.After(ServerStartTime): // assume server started successfully - } - - defer apiSrv.Close() + grpcSrv, err := servergrpc.NewGRPCServer(clientCtx, app, config) + if err != nil { + return nil, clientCtx, err } - var ( - grpcSrv *grpc.Server - grpcWebSrv *http.Server - ) - - if config.GRPC.Enable { - grpcSrv, err = servergrpc.StartGRPCServer(clientCtx, app, config.GRPC) - if err != nil { - return err - } - defer grpcSrv.Stop() - if config.GRPCWeb.Enable { - grpcWebSrv, err = servergrpc.StartGRPCWeb(grpcSrv, config.Config) - if err != nil { - ctx.Logger.Error("failed to start grpc-web http server", "error", err.Error()) - return err - } + // Start the gRPC server in a goroutine. Note, the provided ctx will ensure + // that the server is gracefully shut down. + g.Go(func() error { + return servergrpc.StartGRPCServer(ctx, svrCtx.Logger.With("module", "grpc-server"), config, grpcSrv) + }) + return grpcSrv, clientCtx, nil +} - defer func() { - if err := grpcWebSrv.Close(); err != nil { - logger.Error("failed to close the grpc-web http server", "error", err.Error()) - } - }() - } +func startAPIServer( + ctx context.Context, + g *errgroup.Group, + svrCfg serverconfig.Config, + clientCtx client.Context, + svrCtx *server.Context, + app types.Application, + home string, + grpcSrv *grpc.Server, + metrics *telemetry.Metrics, +) error { + if !svrCfg.API.Enable { + return nil } - var ( - httpSrv *http.Server - httpSrvDone chan struct{} - ) - - if config.JSONRPC.Enable { - genDoc, err := genDocProvider() - if err != nil { - return err - } + clientCtx = clientCtx.WithHomeDir(home) - clientCtx := clientCtx.WithChainID(genDoc.ChainID) + apiSrv := api.New(clientCtx, svrCtx.Logger.With("module", "api-server"), grpcSrv) + app.RegisterAPIRoutes(apiSrv, svrCfg.API) - tmEndpoint := "/websocket" - tmRPCAddr := cfg.RPC.ListenAddress - httpSrv, httpSrvDone, err = StartJSONRPC(ctx, clientCtx, tmRPCAddr, tmEndpoint, &config, idxer) - if err != nil { - return err - } - defer func() { - shutdownCtx, cancelFn := context.WithTimeout(context.Background(), 10*time.Second) - defer cancelFn() - if err := httpSrv.Shutdown(shutdownCtx); err != nil { - logger.Error("HTTP server shutdown produced a warning", "error", err.Error()) - } else { - logger.Info("HTTP server shut down, waiting 5 sec") - select { - case <-time.Tick(5 * time.Second): - case <-httpSrvDone: - } - } - }() + if svrCfg.Telemetry.Enabled { + apiSrv.SetTelemetry(metrics) } - // At this point it is safe to block the process if we're in query only mode as - // we do not need to start Rosetta or handle any Tendermint related processes. - if gRPCOnly { - // wait for signal capture and gracefully return - return server.WaitForQuitSignals() - } - - var rosettaSrv crgserver.Server - if config.Rosetta.Enable { - offlineMode := config.Rosetta.Offline - - // If GRPC is not enabled rosetta cannot work in online mode, so it works in - // offline mode. - if !config.GRPC.Enable { - offlineMode = true - } - - conf := &rosetta.Config{ - Blockchain: config.Rosetta.Blockchain, - Network: config.Rosetta.Network, - TendermintRPC: ctx.Config.RPC.ListenAddress, - GRPCEndpoint: config.GRPC.Address, - Addr: config.Rosetta.Address, - Retries: config.Rosetta.Retries, - Offline: offlineMode, - GasToSuggest: config.Rosetta.GasToSuggest, - EnableFeeSuggestion: config.Rosetta.EnableFeeSuggestion, - Codec: clientCtx.Codec.(*codec.ProtoCodec), - InterfaceRegistry: clientCtx.InterfaceRegistry, - } - - rosettaSrv, err = rosetta.ServerFromConfig(conf) - if err != nil { - return err - } + g.Go(func() error { + return apiSrv.Start(ctx, svrCfg) + }) + return nil +} - errCh := make(chan error) - go func() { - if err := rosettaSrv.Start(); err != nil { - errCh <- err - } - }() +func getCtx(svrCtx *server.Context, block bool) (*errgroup.Group, context.Context) { + ctx, cancelFn := context.WithCancel(context.Background()) + g, ctx := errgroup.WithContext(ctx) + // listen for quit signals so the calling parent process can gracefully exit + server.ListenForQuitSignals(g, block, cancelFn, svrCtx.Logger) - select { - case err := <-errCh: - return err - case <-time.After(types.ServerStartTime): // assume server started successfully - } - } - // Wait for SIGINT or SIGTERM signal - return server.WaitForQuitSignals() + return g, ctx } func openDB(_ types.AppOptions, rootDir string, backendType dbm.BackendType) (dbm.DB, error) { diff --git a/testutil/network/network.go b/testutil/network/network.go index 9bc2a24f04..3ad65cdcb1 100644 --- a/testutil/network/network.go +++ b/testutil/network/network.go @@ -24,16 +24,16 @@ import ( "net/http" "net/url" "os" + "os/signal" "path/filepath" "strings" "sync" + "syscall" "testing" "time" "cosmossdk.io/log" sdkmath "cosmossdk.io/math" - tmcfg "github.com/cometbft/cometbft/config" - tmflags "github.com/cometbft/cometbft/libs/cli/flags" tmrand "github.com/cometbft/cometbft/libs/rand" "github.com/cometbft/cometbft/node" tmclient "github.com/cometbft/cometbft/rpc/client" @@ -57,6 +57,7 @@ import ( srvconfig "github.com/cosmos/cosmos-sdk/server/config" servertypes "github.com/cosmos/cosmos-sdk/server/types" "github.com/cosmos/cosmos-sdk/testutil" + networkServer "github.com/cosmos/cosmos-sdk/testutil/network" sdk "github.com/cosmos/cosmos-sdk/types" authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" @@ -285,7 +286,7 @@ func New(l Logger, baseDir string, cfg Config) (*Network, error) { apiListenAddr = cfg.APIAddress } else { var err error - apiListenAddr, _, err = server.FreeTCPAddr() + apiListenAddr, _, _, err = networkServer.FreeTCPAddr() if err != nil { return nil, err } @@ -301,7 +302,7 @@ func New(l Logger, baseDir string, cfg Config) (*Network, error) { if cfg.RPCAddress != "" { tmCfg.RPC.ListenAddress = cfg.RPCAddress } else { - rpcAddr, _, err := server.FreeTCPAddr() + rpcAddr, _, _, err := networkServer.FreeTCPAddr() if err != nil { return nil, err } @@ -311,7 +312,7 @@ func New(l Logger, baseDir string, cfg Config) (*Network, error) { if cfg.GRPCAddress != "" { appCfg.GRPC.Address = cfg.GRPCAddress } else { - _, grpcPort, err := server.FreeTCPAddr() + _, grpcPort, _, err := networkServer.FreeTCPAddr() if err != nil { return nil, err } @@ -319,17 +320,17 @@ func New(l Logger, baseDir string, cfg Config) (*Network, error) { } appCfg.GRPC.Enable = true - _, grpcWebPort, err := server.FreeTCPAddr() - if err != nil { - return nil, err - } - appCfg.GRPCWeb.Address = fmt.Sprintf("0.0.0.0:%s", grpcWebPort) - appCfg.GRPCWeb.Enable = true + //_, grpcWebPort, _, err := networkServer.FreeTCPAddr() + //if err != nil { + // return nil, err + //} + //appCfg.GRPCWeb.Address = fmt.Sprintf("0.0.0.0:%s", grpcWebPort) + //appCfg.GRPCWeb.Enable = true if cfg.JSONRPCAddress != "" { appCfg.JSONRPC.Address = cfg.JSONRPCAddress } else { - _, jsonRPCPort, err := server.FreeTCPAddr() + _, jsonRPCPort, _, err := networkServer.FreeTCPAddr() if err != nil { return nil, err } @@ -341,8 +342,8 @@ func New(l Logger, baseDir string, cfg Config) (*Network, error) { logger := log.NewNopLogger() if cfg.EnableTMLogging { - logger = log.NewTMLogger(log.NewSyncWriter(os.Stdout)) - logger, _ = tmflags.ParseLogLevel("info", logger, tmcfg.DefaultLogLevel) + logger = log.NewLogger(os.Stdout) + //logger, _ = tmflags.ParseLogLevel("info", servercmtlog.CometLoggerWrapper{Logger: logger}, tmcfg.DefaultLogLevel) } ctx.Logger = logger @@ -366,13 +367,13 @@ func New(l Logger, baseDir string, cfg Config) (*Network, error) { tmCfg.Moniker = nodeDirName monikers[i] = nodeDirName - proxyAddr, _, err := server.FreeTCPAddr() + proxyAddr, _, _, err := networkServer.FreeTCPAddr() if err != nil { return nil, err } tmCfg.ProxyApp = proxyAddr - p2pAddr, _, err := server.FreeTCPAddr() + p2pAddr, _, _, err := networkServer.FreeTCPAddr() if err != nil { return nil, err } @@ -439,12 +440,12 @@ func New(l Logger, baseDir string, cfg Config) (*Network, error) { } createValMsg, err := stakingtypes.NewMsgCreateValidator( - sdk.ValAddress(addr), + addr.String(), valPubKeys[i], sdk.NewCoin(cfg.BondDenom, cfg.BondedTokens), stakingtypes.NewDescription(nodeDirName, "", "", "", ""), stakingtypes.NewCommissionRates(commission, sdkmath.LegacyOneDec(), sdkmath.LegacyOneDec()), - sdk.OneInt(), + sdkmath.OneInt(), ) if err != nil { return nil, err @@ -473,7 +474,8 @@ func New(l Logger, baseDir string, cfg Config) (*Network, error) { WithKeybase(kb). WithTxConfig(cfg.TxConfig) - if err := tx.Sign(txFactory, nodeDirName, txBuilder, true); err != nil { + // TODO(boodyvo): what context was + if err := tx.Sign(context.Background(), txFactory, nodeDirName, txBuilder, true); err != nil { return nil, err } @@ -545,11 +547,35 @@ func New(l Logger, baseDir string, cfg Config) (*Network, error) { // Ensure we cleanup incase any test was abruptly halted (e.g. SIGINT) as any // defer in a test would not be called. - server.TrapSignal(network.Cleanup) + trapSignal(network.Cleanup) return network, nil } +// trapSignal traps SIGINT and SIGTERM and calls os.Exit once a signal is received. +func trapSignal(cleanupFunc func()) { + sigs := make(chan os.Signal, 1) + signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM) + + go func() { + sig := <-sigs + + if cleanupFunc != nil { + cleanupFunc() + } + exitCode := 128 + + switch sig { + case syscall.SIGINT: + exitCode += int(syscall.SIGINT) + case syscall.SIGTERM: + exitCode += int(syscall.SIGTERM) + } + + os.Exit(exitCode) + }() +} + // LatestHeight returns the latest height of the network or an error if the // query fails or no validators exist. func (n *Network) LatestHeight() (int64, error) { diff --git a/testutil/network/util.go b/testutil/network/util.go index 784433434e..5f0f163aa3 100644 --- a/testutil/network/util.go +++ b/testutil/network/util.go @@ -17,23 +17,11 @@ package network import ( "encoding/json" - "fmt" - "path/filepath" - "time" - tmos "github.com/cometbft/cometbft/libs/os" - "github.com/cometbft/cometbft/node" - "github.com/cometbft/cometbft/p2p" - pvm "github.com/cometbft/cometbft/privval" - "github.com/cometbft/cometbft/proxy" - "github.com/cometbft/cometbft/rpc/client/local" "github.com/cometbft/cometbft/types" tmtime "github.com/cometbft/cometbft/types/time" - "github.com/ethereum/go-ethereum/ethclient" + "path/filepath" - "github.com/cosmos/cosmos-sdk/server/api" - servergrpc "github.com/cosmos/cosmos-sdk/server/grpc" - srvtypes "github.com/cosmos/cosmos-sdk/server/types" authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" crisistypes "github.com/cosmos/cosmos-sdk/x/crisis/types" @@ -44,122 +32,123 @@ import ( mintypes "github.com/cosmos/cosmos-sdk/x/mint/types" stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" - "github.com/evmos/ethermint/server" evmtypes "github.com/evmos/ethermint/x/evm/types" ) func startInProcess(cfg Config, val *Validator) error { - logger := val.Ctx.Logger - tmCfg := val.Ctx.Config - tmCfg.Instrumentation.Prometheus = false - - if err := val.AppConfig.ValidateBasic(); err != nil { - return err - } - - nodeKey, err := p2p.LoadOrGenNodeKey(tmCfg.NodeKeyFile()) - if err != nil { - return err - } - - app := cfg.AppConstructor(*val) - - genDocProvider := node.DefaultGenesisDocProviderFunc(tmCfg) - tmNode, err := node.NewNode( - tmCfg, - pvm.LoadOrGenFilePV(tmCfg.PrivValidatorKeyFile(), tmCfg.PrivValidatorStateFile()), - nodeKey, - proxy.NewLocalClientCreator(app), - genDocProvider, - node.DefaultDBProvider, - node.DefaultMetricsProvider(tmCfg.Instrumentation), - logger.With("module", val.Moniker), - ) - if err != nil { - return err - } - - if err := tmNode.Start(); err != nil { - return err - } - - val.tmNode = tmNode - - if val.RPCAddress != "" { - val.RPCClient = local.New(tmNode) - } - - // We'll need a RPC client if the validator exposes a gRPC or REST endpoint. - if val.APIAddress != "" || val.AppConfig.GRPC.Enable { - val.ClientCtx = val.ClientCtx. - WithClient(val.RPCClient) - - // Add the tx service in the gRPC router. - app.RegisterTxService(val.ClientCtx) - - // Add the tendermint queries service in the gRPC router. - app.RegisterTendermintService(val.ClientCtx) - } - - if val.AppConfig.API.Enable && val.APIAddress != "" { - apiSrv := api.New(val.ClientCtx, logger.With("module", "api-server")) - app.RegisterAPIRoutes(apiSrv, val.AppConfig.API) - - errCh := make(chan error) - - go func() { - if err := apiSrv.Start(val.AppConfig.Config); err != nil { - errCh <- err - } - }() - - select { - case err := <-errCh: - return err - case <-time.After(srvtypes.ServerStartTime): // assume server started successfully - } - - val.api = apiSrv - } - - if val.AppConfig.GRPC.Enable { - grpcSrv, err := servergrpc.StartGRPCServer(val.ClientCtx, app, val.AppConfig.GRPC) - if err != nil { - return err - } - - val.grpc = grpcSrv - - if val.AppConfig.GRPCWeb.Enable { - val.grpcWeb, err = servergrpc.StartGRPCWeb(grpcSrv, val.AppConfig.Config) - if err != nil { - return err - } - } - } - - if val.AppConfig.JSONRPC.Enable && val.AppConfig.JSONRPC.Address != "" { - if val.Ctx == nil || val.Ctx.Viper == nil { - return fmt.Errorf("validator %s context is nil", val.Moniker) - } - - tmEndpoint := "/websocket" - tmRPCAddr := val.RPCAddress - - val.jsonrpc, val.jsonrpcDone, err = server.StartJSONRPC(val.Ctx, val.ClientCtx, tmRPCAddr, tmEndpoint, val.AppConfig, nil) - if err != nil { - return err - } - - address := fmt.Sprintf("http://%s", val.AppConfig.JSONRPC.Address) - - val.JSONRPCClient, err = ethclient.Dial(address) - if err != nil { - return fmt.Errorf("failed to dial JSON-RPC at %s: %w", val.AppConfig.JSONRPC.Address, err) - } - } - return nil + //logger := val.Ctx.Logger + //tmCfg := val.Ctx.Config + //tmCfg.Instrumentation.Prometheus = false + // + //if err := val.AppConfig.ValidateBasic(); err != nil { + // return err + //} + // + //nodeKey, err := p2p.LoadOrGenNodeKey(tmCfg.NodeKeyFile()) + //if err != nil { + // return err + //} + // + //app := cfg.AppConstructor(*val) + // + //genDocProvider := node.DefaultGenesisDocProviderFunc(tmCfg) + //tmNode, err := node.NewNode( + // tmCfg, + // pvm.LoadOrGenFilePV(tmCfg.PrivValidatorKeyFile(), tmCfg.PrivValidatorStateFile()), + // nodeKey, + // proxy.NewLocalClientCreator(app), + // genDocProvider, + // cmtcfg.DefaultDBProvider, + // node.DefaultMetricsProvider(tmCfg.Instrumentation), + // servercmtlog.CometLoggerWrapper{Logger: logger.With("module", val.Moniker)}, + //) + //if err != nil { + // return err + //} + // + //if err := tmNode.Start(); err != nil { + // return err + //} + // + //val.tmNode = tmNode + // + //if val.RPCAddress != "" { + // val.RPCClient = local.New(tmNode) + //} + // + //// We'll need a RPC client if the validator exposes a gRPC or REST endpoint. + //if val.APIAddress != "" || val.AppConfig.GRPC.Enable { + // val.ClientCtx = val.ClientCtx. + // WithClient(val.RPCClient) + // + // // Add the tx service in the gRPC router. + // app.RegisterTxService(val.ClientCtx) + // + // // Add the tendermint queries service in the gRPC router. + // app.RegisterTendermintService(val.ClientCtx) + //} + // + //// TODO(boodyvo): implement + ////if val.AppConfig.API.Enable && val.APIAddress != "" { + //// apiSrv := api.New(val.ClientCtx, logger.With("module", "api-server")) + //// app.RegisterAPIRoutes(apiSrv, val.AppConfig.API) + //// + //// errCh := make(chan error) + //// + //// go func() { + //// if err := apiSrv.Start(val.AppConfig.Config); err != nil { + //// errCh <- err + //// } + //// }() + //// + //// select { + //// case err := <-errCh: + //// return err + //// case <-time.After(srvtypes.ServerStartTime): // assume server started successfully + //// } + //// + //// val.api = apiSrv + ////} + //// + ////if val.AppConfig.GRPC.Enable { + //// grpcSrv, err := servergrpc.StartGRPCServer(val.ClientCtx, app, val.AppConfig.GRPC) + //// if err != nil { + //// return err + //// } + //// + //// val.grpc = grpcSrv + //// + //// if val.AppConfig.GRPCWeb.Enable { + //// val.grpcWeb, err = servergrpc.StartGRPCWeb(grpcSrv, val.AppConfig.Config) + //// if err != nil { + //// return err + //// } + //// } + ////} + // + //if val.AppConfig.JSONRPC.Enable && val.AppConfig.JSONRPC.Address != "" { + // if val.Ctx == nil || val.Ctx.Viper == nil { + // return fmt.Errorf("validator %s context is nil", val.Moniker) + // } + // + // tmEndpoint := "/websocket" + // tmRPCAddr := val.RPCAddress + // + // val.jsonrpc, val.jsonrpcDone, err = server.StartJSONRPC(val.Ctx, val.ClientCtx, tmRPCAddr, tmEndpoint, val.AppConfig, nil) + // if err != nil { + // return err + // } + // + // address := fmt.Sprintf("http://%s", val.AppConfig.JSONRPC.Address) + // + // val.JSONRPCClient, err = ethclient.Dial(address) + // if err != nil { + // return fmt.Errorf("failed to dial JSON-RPC at %s: %w", val.AppConfig.JSONRPC.Address, err) + // } + //} + // + //return nil } func collectGenFiles(cfg Config, vals []*Validator, outputDir string) error { @@ -177,13 +166,18 @@ func collectGenFiles(cfg Config, vals []*Validator, outputDir string) error { initCfg := genutiltypes.NewInitConfig(cfg.ChainID, gentxsDir, vals[i].NodeID, vals[i].PubKey) genFile := tmCfg.GenesisFile() - genDoc, err := types.GenesisDocFromFile(genFile) + // Change for ethermint + appGenesis, err := genutiltypes.AppGenesisFromFile(genFile) if err != nil { return err } + //genDoc, err := types.GenesisDocFromFile(genFile) + //if err != nil { + // return err + //} appState, err := genutil.GenAppStateFromConfig(cfg.Codec, cfg.TxConfig, - tmCfg, initCfg, *genDoc, banktypes.GenesisBalancesIterator{}, genutiltypes.DefaultMessageValidator) + tmCfg, initCfg, appGenesis, banktypes.GenesisBalancesIterator{}, genutiltypes.DefaultMessageValidator, cfg.TxConfig.SigningContext().ValidatorAddressCodec()) if err != nil { return err }