evm, server: configurable tracer (#434)

* server: update server and enable configurable tracer

* config validation

* fix import cycle

* fix start

* update fields

* c++

* c++

server/config/config.go

@@ -1,19 +1,33 @@
 package config
 
 import (
-	"github.com/cosmos/cosmos-sdk/server/config"
+	"fmt"
+
 	"github.com/spf13/viper"
+
+	"github.com/tendermint/tendermint/libs/strings"
+
+	"github.com/cosmos/cosmos-sdk/server/config"
+
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 )
 
 const (
 	// DefaultGRPCAddress is the default address the gRPC server binds to.
 	DefaultGRPCAddress = "0.0.0.0:9900"
 
-	// DefaultEVMAddress is the default address the EVM JSON-RPC server binds to.
-	DefaultEVMAddress = "0.0.0.0:8545"
+	// DefaultJSONRPCAddress is the default address the JSON-RPC server binds to.
+	DefaultJSONRPCAddress = "0.0.0.0:8545"
 
-	// DefaultEVMWSAddress is the default address the EVM WebSocket server binds to.
-	DefaultEVMWSAddress = "0.0.0.0:8546"
+	// DefaultJSONRPCWsAddress is the default address the JSON-RPC WebSocket server binds to.
+	DefaultJSONRPCWsAddress = "0.0.0.0:8546"
+
+	// DefaultEVMTracer is the default vm.Tracer type
+	DefaultEVMTracer = "json"
+)
+
+var (
+	evmTracers = []string{DefaultEVMTracer, "markdown", "struct", "access_list"}
 )
 
 // GetDefaultAPINamespaces returns the default list of JSON-RPC namespaces that should be enabled
@@ -45,8 +59,9 @@ func AppConfig(denom string) (string, interface{}) {
 	}
 
 	customAppConfig := Config{
-		Config: *srvCfg,
-		EVMRPC: *DefaultEVMConfig(),
+		Config:  *srvCfg,
+		EVM:     *DefaultEVMConfig(),
+		JSONRPC: *DefaultJSONRPCConfig(),
 	}
 
 	customAppTemplate := config.DefaultConfigTemplate + DefaultConfigTemplate
@@ -57,15 +72,39 @@ func AppConfig(denom string) (string, interface{}) {
 // DefaultConfig returns server's default configuration.
 func DefaultConfig() *Config {
 	return &Config{
-		Config: *config.DefaultConfig(),
-		EVMRPC: *DefaultEVMConfig(),
+		Config:  *config.DefaultConfig(),
+		EVM:     *DefaultEVMConfig(),
+		JSONRPC: *DefaultJSONRPCConfig(),
 	}
 }
 
-// EVMRPCConfig defines configuration for the EVM RPC server.
-type EVMRPCConfig struct {
-	// RPCAddress defines the HTTP server to listen on
-	RPCAddress string `mapstructure:"address"`
+// EVMConfig defines the application configuration values for the EVM.
+type EVMConfig struct {
+	// Tracer defines vm.Tracer type that the EVM will use if the node is run in
+	// trace mode. Default: 'json'.
+	Tracer string `mapstructure:"tracer"`
+}
+
+// DefaultEVMConfig returns the default EVM configuration
+func DefaultEVMConfig() *EVMConfig {
+	return &EVMConfig{
+		Tracer: DefaultEVMTracer,
+	}
+}
+
+// Validate returns an error if the tracer type is invalid.
+func (c EVMConfig) Validate() error {
+	if !strings.StringInSlice(c.Tracer, evmTracers) {
+		return fmt.Errorf("invalid tracer type %s, available types: %v", c.Tracer, evmTracers)
+	}
+
+	return nil
+}
+
+// JSONRPCConfig defines configuration for the EVM RPC server.
+type JSONRPCConfig struct {
+	// Address defines the HTTP server to listen on
+	Address string `mapstructure:"address"`
 	// WsAddress defines the WebSocket server to listen on
 	WsAddress string `mapstructure:"ws-address"`
 	// API defines a list of JSON-RPC namespaces that should be enabled
@@ -76,13 +115,13 @@ type EVMRPCConfig struct {
 	EnableUnsafeCORS bool `mapstructure:"enable-unsafe-cors"`
 }
 
-// DefaultEVMConfig returns an EVM config with the JSON-RPC API enabled by default
-func DefaultEVMConfig() *EVMRPCConfig {
-	return &EVMRPCConfig{
+// DefaultJSONRPCConfig returns an EVM config with the JSON-RPC API enabled by default
+func DefaultJSONRPCConfig() *JSONRPCConfig {
+	return &JSONRPCConfig{
 		Enable:           true,
 		API:              GetDefaultAPINamespaces(),
-		RPCAddress:       DefaultEVMAddress,
-		WsAddress:        DefaultEVMWSAddress,
+		Address:          DefaultJSONRPCAddress,
+		WsAddress:        DefaultJSONRPCWsAddress,
 		EnableUnsafeCORS: false,
 	}
 }
@@ -92,7 +131,8 @@ func DefaultEVMConfig() *EVMRPCConfig {
 type Config struct {
 	config.Config
 
-	EVMRPC EVMRPCConfig `mapstructure:"evm-rpc"`
+	EVM     EVMConfig     `mapstructure:"evm"`
+	JSONRPC JSONRPCConfig `mapstructure:"json-rpc"`
 }
 
 // GetConfig returns a fully parsed Config object.
@@ -101,12 +141,26 @@ func GetConfig(v *viper.Viper) Config {
 
 	return Config{
 		Config: cfg,
-		EVMRPC: EVMRPCConfig{
-			Enable:           v.GetBool("evm-rpc.enable"),
-			API:              v.GetStringSlice("evm-rpc.api"),
-			RPCAddress:       v.GetString("evm-rpc.address"),
-			WsAddress:        v.GetString("evm-rpc.ws-address"),
-			EnableUnsafeCORS: v.GetBool("evm-rpc.enable-unsafe-cors"),
+		EVM: EVMConfig{
+			Tracer: v.GetString("evm.tracer"),
+		},
+		JSONRPC: JSONRPCConfig{
+			Enable:           v.GetBool("json-rpc.enable"),
+			API:              v.GetStringSlice("json-rpc.api"),
+			Address:          v.GetString("json-rpc.address"),
+			WsAddress:        v.GetString("json-rpc.ws-address"),
+			EnableUnsafeCORS: v.GetBool("json-rpc.enable-unsafe-cors"),
 		},
 	}
 }
+
+// ValidateBasic returns an error any of the application configuration fields are invalid
+func (c Config) ValidateBasic() error {
+	if err := c.EVM.Validate(); err != nil {
+		return sdkerrors.Wrapf(sdkerrors.ErrAppConfig, "invalid evm config value: %s", err.Error())
+	}
+
+	// TODO: validate JSON-RPC APIs
+
+	return c.Config.ValidateBasic()
+}

server/config/config_test.go

@@ -7,8 +7,8 @@ import (
 )
 
 func TestDefaultConfig(t *testing.T) {
-	cfg := DefaultEVMConfig()
-	require.True(t, cfg.Enable)
-	require.Equal(t, cfg.RPCAddress, DefaultEVMAddress)
-	require.Equal(t, cfg.WsAddress, DefaultEVMWSAddress)
+	cfg := DefaultConfig()
+	require.True(t, cfg.JSONRPC.Enable)
+	require.Equal(t, cfg.JSONRPC.Address, DefaultJSONRPCAddress)
+	require.Equal(t, cfg.JSONRPC.WsAddress, DefaultJSONRPCWsAddress)
 }

server/config/toml.go

@@ -3,24 +3,35 @@ package config
 // DefaultConfigTemplate defines the configuration template for the EVM RPC configuration
 const DefaultConfigTemplate = `
 ###############################################################################
-###                           EVM RPC Configuration                         ###
+###                             EVM Configuration                           ###
 ###############################################################################
 
-[evm-rpc]
+[evm]
+
+# Tracer defines the 'vm.Tracer' type that the EVM will use when the node is run in
+# debug mode. To enable tracing use the '--trace' flag when starting your node.
+# Valid types are: json|struct|access_list|markdown
+tracer = "{{ .EVM.Tracer }}"
+
+###############################################################################
+###                           JSON RPC Configuration                        ###
+###############################################################################
+
+[json-rpc]
 
 # Enable defines if the gRPC server should be enabled.
-enable = {{ .EVMRPC.Enable }}
+enable = {{ .JSONRPC.Enable }}
 
 # Address defines the EVM RPC HTTP server address to bind to.
-address = "{{ .EVMRPC.RPCAddress }}"
+address = "{{ .JSONRPC.Address }}"
 
 # Address defines the EVM WebSocket server address to bind to.
-ws-address = "{{ .EVMRPC.WsAddress }}"
+ws-address = "{{ .JSONRPC.WsAddress }}"
 
 # API defines a list of JSON-RPC namespaces that should be enabled
 # Example: "eth,txpool,personal,net,debug,web3"
-api = "{{range $index, $elmt := .EVMRPC.API}}{{if $index}},{{$elmt}}{{else}}{{$elmt}}{{end}}{{end}}"
+api = "{{range $index, $elmt := .JSONRPC.API}}{{if $index}},{{$elmt}}{{else}}{{$elmt}}{{end}}{{end}}"
 
 # EnableUnsafeCORS defines if CORS should be enabled (unsafe - use it at your own risk)
-enable-unsafe-cors = "{{ .EVMRPC.EnableUnsafeCORS }}"
+enable-unsafe-cors = "{{ .JSONRPC.EnableUnsafeCORS }}"
 `

server/flags/flags.go

@@ -1,4 +1,4 @@
-package server
+package flags
 
 import (
 	"github.com/cosmos/cosmos-sdk/client/flags"
@@ -7,6 +7,37 @@ import (
 	"github.com/spf13/viper"
 )
 
+// Tendermint full-node start flags
+const (
+	WithTendermint = "with-tendermint"
+	Address        = "address"
+	Transport      = "transport"
+	TraceStore     = "trace-store"
+	CPUProfile     = "cpu-profile"
+)
+
+// GRPC-related flags.
+const (
+	GRPCEnable     = "grpc.enable"
+	GRPCAddress    = "grpc.address"
+	GRPCWebEnable  = "grpc-web.enable"
+	GRPCWebAddress = "grpc-web.address"
+)
+
+// JSON-RPC flags
+const (
+	JSONRPCEnable        = "json-rpc.enable"
+	JSONRPCAPI           = "json-rpc.api"
+	JSONRPCAddress       = "json-rpc.address"
+	JSONWsAddress        = "json-rpc.ws-address"
+	JSONEnableUnsafeCORS = "json-rpc.enable-unsafe-cors"
+)
+
+// EVM flags
+const (
+	EVMTracer = "evm.tracer"
+)
+
 // AddTxFlags adds common flags for commands to post tx
 func AddTxFlags(cmd *cobra.Command) *cobra.Command {
 	cmd.PersistentFlags().String(flags.FlagChainID, "testnet", "Specify Chain ID for sending Tx")

server/json_rpc.go

@@ -17,19 +17,19 @@ import (
 	"github.com/tharsis/ethermint/server/config"
 )
 
-// StartEVMRPC start evm rpc server
-func StartEVMRPC(ctx *server.Context, clientCtx client.Context, tmRPCAddr string, tmEndpoint string, config config.Config) (*http.Server, chan struct{}, error) {
+// StartJSONRPC starts the JSON-RPC server
+func StartJSONRPC(ctx *server.Context, clientCtx client.Context, tmRPCAddr string, tmEndpoint string, config config.Config) (*http.Server, chan struct{}, error) {
 	tmWsClient := ConnectTmWS(tmRPCAddr, tmEndpoint)
 
 	rpcServer := ethrpc.NewServer()
 
-	rpcAPIArr := config.EVMRPC.API
+	rpcAPIArr := config.JSONRPC.API
 	apis := rpc.GetRPCAPIs(ctx, clientCtx, tmWsClient, rpcAPIArr)
 
 	for _, api := range apis {
 		if err := rpcServer.RegisterName(api.Namespace, api.Service); err != nil {
 			ctx.Logger.Error(
-				"failed to register service in EVM RPC namespace",
+				"failed to register service in JSON RPC namespace",
 				"namespace", api.Namespace,
 				"service", api.Service,
 			)
@@ -41,43 +41,43 @@ func StartEVMRPC(ctx *server.Context, clientCtx client.Context, tmRPCAddr string
 	r.HandleFunc("/", rpcServer.ServeHTTP).Methods("POST")
 
 	handlerWithCors := cors.Default()
-	if config.EVMRPC.EnableUnsafeCORS {
+	if config.JSONRPC.EnableUnsafeCORS {
 		handlerWithCors = cors.AllowAll()
 	}
 
 	httpSrv := &http.Server{
-		Addr:    config.EVMRPC.RPCAddress,
+		Addr:    config.JSONRPC.Address,
 		Handler: handlerWithCors.Handler(r),
 	}
 	httpSrvDone := make(chan struct{}, 1)
 
 	errCh := make(chan error)
 	go func() {
-		ctx.Logger.Info("Starting EVM RPC server", "address", config.EVMRPC.RPCAddress)
+		ctx.Logger.Info("Starting JSON-RPC server", "address", config.JSONRPC.Address)
 		if err := httpSrv.ListenAndServe(); err != nil {
 			if err == http.ErrServerClosed {
 				close(httpSrvDone)
 				return
 			}
 
-			ctx.Logger.Error("failed to start EVM RPC server", "error", err.Error())
+			ctx.Logger.Error("failed to start JSON-RPC server", "error", err.Error())
 			errCh <- err
 		}
 	}()
 
 	select {
 	case err := <-errCh:
-		ctx.Logger.Error("failed to boot EVM RPC server", "error", err.Error())
+		ctx.Logger.Error("failed to boot JSON-RPC server", "error", err.Error())
 		return nil, nil, err
-	case <-time.After(types.ServerStartTime): // assume EVM RPC server started successfully
+	case <-time.After(types.ServerStartTime): // assume JSON RPC server started successfully
 	}
 
-	ctx.Logger.Info("Starting EVM WebSocket server", "address", config.EVMRPC.WsAddress)
-	_, port, _ := net.SplitHostPort(config.EVMRPC.RPCAddress)
+	ctx.Logger.Info("Starting JSON WebSocket server", "address", config.JSONRPC.WsAddress)
+	_, port, _ := net.SplitHostPort(config.JSONRPC.Address)
 
 	// allocate separate WS connection to Tendermint
 	tmWsClient = ConnectTmWS(tmRPCAddr, tmEndpoint)
-	wsSrv := rpc.NewWebsocketsServer(ctx.Logger, tmWsClient, "localhost:"+port, config.EVMRPC.WsAddress)
+	wsSrv := rpc.NewWebsocketsServer(ctx.Logger, tmWsClient, "localhost:"+port, config.JSONRPC.WsAddress)
 	wsSrv.Start()
 	return httpSrv, httpSrvDone, nil
 }

server/start.go

@@ -8,6 +8,7 @@ import (
 	"os"
 	"path/filepath"
 	"runtime/pprof"
+	"strings"
 	"time"
 
 	"github.com/cosmos/cosmos-sdk/codec"
@@ -42,48 +43,7 @@ import (
 
 	ethdebug "github.com/tharsis/ethermint/ethereum/rpc/namespaces/debug"
 	"github.com/tharsis/ethermint/server/config"
-)
-
-// Tendermint full-node start flags
-const (
-	flagWithTendermint     = "with-tendermint"
-	flagAddress            = "address"
-	flagTransport          = "transport"
-	flagTraceStore         = "trace-store"
-	flagCPUProfile         = "cpu-profile"
-	FlagMinGasPrices       = "minimum-gas-prices"
-	FlagHaltHeight         = "halt-height"
-	FlagHaltTime           = "halt-time"
-	FlagInterBlockCache    = "inter-block-cache"
-	FlagUnsafeSkipUpgrades = "unsafe-skip-upgrades"
-	FlagTrace              = "trace"
-	FlagInvCheckPeriod     = "inv-check-period"
-
-	FlagPruning           = "pruning"
-	FlagPruningKeepRecent = "pruning-keep-recent"
-	FlagPruningKeepEvery  = "pruning-keep-every"
-	FlagPruningInterval   = "pruning-interval"
-	FlagIndexEvents       = "index-events"
-	FlagMinRetainBlocks   = "min-retain-blocks"
-)
-
-// GRPC-related flags.
-const (
-	flagGRPCEnable          = "grpc.enable"
-	flagGRPCAddress         = "grpc.address"
-	flagEVMRPCEnable        = "evm-rpc.enable"
-	flagEVMRPCAPI           = "evm-rpc.api"
-	flagEVMRPCAddress       = "evm-rpc.address"
-	flagEVMWSAddress        = "evm-rpc.ws-address"
-	flagEVMEnableUnsafeCORS = "evm-rpc.enable-unsafe-cors"
-	flagGRPCWebEnable       = "grpc-web.enable"
-	flagGRPCWebAddress      = "grpc-web.address"
-)
-
-// State sync-related flags.
-const (
-	FlagStateSyncSnapshotInterval   = "state-sync.snapshot-interval"
-	FlagStateSyncSnapshotKeepRecent = "state-sync.snapshot-keep-recent"
+	srvflags "github.com/tharsis/ethermint/server/flags"
 )
 
 // StartCmd runs the service passed in, either stand-alone or in-process with
@@ -134,7 +94,7 @@ which accepts a path for the resulting pprof file.
 				return err
 			}
 
-			withTM, _ := cmd.Flags().GetBool(flagWithTendermint)
+			withTM, _ := cmd.Flags().GetBool(srvflags.WithTendermint)
 			if !withTM {
 				serverCtx.Logger.Info("starting ABCI without Tendermint")
 				return startStandAlone(serverCtx, appCreator)
@@ -155,38 +115,39 @@ which accepts a path for the resulting pprof file.
 	}
 
 	cmd.Flags().String(flags.FlagHome, defaultNodeHome, "The application home directory")
-	cmd.Flags().Bool(flagWithTendermint, true, "Run abci app embedded in-process with tendermint")
-	cmd.Flags().String(flagAddress, "tcp://0.0.0.0:26658", "Listen address")
-	cmd.Flags().String(flagTransport, "socket", "Transport protocol: socket, grpc")
-	cmd.Flags().String(flagTraceStore, "", "Enable KVStore tracing to an output file")
-	cmd.Flags().String(FlagMinGasPrices, "", "Minimum gas prices to accept for transactions; Any fee in a tx must meet this minimum (e.g. 0.01photino;0.0001stake)")
-	cmd.Flags().IntSlice(FlagUnsafeSkipUpgrades, []int{}, "Skip a set of upgrade heights to continue the old binary")
-	cmd.Flags().Uint64(FlagHaltHeight, 0, "Block height at which to gracefully halt the chain and shutdown the node")
-	cmd.Flags().Uint64(FlagHaltTime, 0, "Minimum block time (in Unix seconds) at which to gracefully halt the chain and shutdown the node")
-	cmd.Flags().Bool(FlagInterBlockCache, true, "Enable inter-block caching")
-	cmd.Flags().String(flagCPUProfile, "", "Enable CPU profiling and write to the provided file")
-	cmd.Flags().Bool(FlagTrace, false, "Provide full stack traces for errors in ABCI Log")
-	cmd.Flags().String(FlagPruning, storetypes.PruningOptionDefault, "Pruning strategy (default|nothing|everything|custom)")
-	cmd.Flags().Uint64(FlagPruningKeepRecent, 0, "Number of recent heights to keep on disk (ignored if pruning is not 'custom')")
-	cmd.Flags().Uint64(FlagPruningKeepEvery, 0, "Offset heights to keep on disk after 'keep-every' (ignored if pruning is not 'custom')")
-	cmd.Flags().Uint64(FlagPruningInterval, 0, "Height interval at which pruned heights are removed from disk (ignored if pruning is not 'custom')")
-	cmd.Flags().Uint(FlagInvCheckPeriod, 0, "Assert registered invariants every N blocks")
-	cmd.Flags().Uint64(FlagMinRetainBlocks, 0, "Minimum block height offset during ABCI commit to prune Tendermint blocks")
+	cmd.Flags().Bool(srvflags.WithTendermint, true, "Run abci app embedded in-process with tendermint")
+	cmd.Flags().String(srvflags.Address, "tcp://0.0.0.0:26658", "Listen address")
+	cmd.Flags().String(srvflags.Transport, "socket", "Transport protocol: socket, grpc")
+	cmd.Flags().String(srvflags.TraceStore, "", "Enable KVStore tracing to an output file")
+	cmd.Flags().String(server.FlagMinGasPrices, "", "Minimum gas prices to accept for transactions; Any fee in a tx must meet this minimum (e.g. 0.01photino;0.0001stake)")
+	cmd.Flags().IntSlice(server.FlagUnsafeSkipUpgrades, []int{}, "Skip a set of upgrade heights to continue the old binary")
+	cmd.Flags().Uint64(server.FlagHaltHeight, 0, "Block height at which to gracefully halt the chain and shutdown the node")
+	cmd.Flags().Uint64(server.FlagHaltTime, 0, "Minimum block time (in Unix seconds) at which to gracefully halt the chain and shutdown the node")
+	cmd.Flags().Bool(server.FlagInterBlockCache, true, "Enable inter-block caching")
+	cmd.Flags().String(srvflags.CPUProfile, "", "Enable CPU profiling and write to the provided file")
+	cmd.Flags().Bool(server.FlagTrace, false, "Provide full stack traces for errors in ABCI Log")
+	cmd.Flags().String(server.FlagPruning, storetypes.PruningOptionDefault, "Pruning strategy (default|nothing|everything|custom)")
+	cmd.Flags().Uint64(server.FlagPruningKeepRecent, 0, "Number of recent heights to keep on disk (ignored if pruning is not 'custom')")
+	cmd.Flags().Uint64(server.FlagPruningKeepEvery, 0, "Offset heights to keep on disk after 'keep-every' (ignored if pruning is not 'custom')")
+	cmd.Flags().Uint64(server.FlagPruningInterval, 0, "Height interval at which pruned heights are removed from disk (ignored if pruning is not 'custom')")
+	cmd.Flags().Uint(server.FlagInvCheckPeriod, 0, "Assert registered invariants every N blocks")
+	cmd.Flags().Uint64(server.FlagMinRetainBlocks, 0, "Minimum block height offset during ABCI commit to prune Tendermint blocks")
 
-	cmd.Flags().Bool(flagGRPCEnable, true, "Define if the gRPC server should be enabled")
-	cmd.Flags().String(flagGRPCAddress, serverconfig.DefaultGRPCAddress, "the gRPC server address to listen on")
+	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().Bool(flagGRPCWebEnable, true, "Define if the gRPC-Web server should be enabled. (Note: gRPC must also be enabled.)")
-	cmd.Flags().String(flagGRPCWebAddress, serverconfig.DefaultGRPCWebAddress, "The gRPC-Web server address to listen on")
+	cmd.Flags().Bool(srvflags.JSONRPCEnable, true, "Define if the gRPC server should be enabled")
+	cmd.Flags().StringSlice(srvflags.JSONRPCAPI, config.GetDefaultAPINamespaces(), "Defines a list of JSON-RPC namespaces that should be enabled")
+	cmd.Flags().String(srvflags.JSONRPCAddress, config.DefaultJSONRPCAddress, "the JSON-RPC server address to listen on")
+	cmd.Flags().String(srvflags.JSONWsAddress, config.DefaultJSONRPCWsAddress, "the JSON-RPC WS server address to listen on")
+	cmd.Flags().Bool(srvflags.JSONEnableUnsafeCORS, false, "Define if the JSON-RPC server should enabled CORS (unsafe - use it at your own risk)")
 
-	cmd.Flags().Bool(flagEVMRPCEnable, true, "Define if the gRPC server should be enabled")
-	cmd.Flags().StringSlice(flagEVMRPCAPI, config.GetDefaultAPINamespaces(), "Defines a list of JSON-RPC namespaces that should be enabled")
-	cmd.Flags().String(flagEVMRPCAddress, config.DefaultEVMAddress, "the EVM RPC server address to listen on")
-	cmd.Flags().String(flagEVMWSAddress, config.DefaultEVMWSAddress, "the EVM WS server address to listen on")
-	cmd.Flags().Bool(flagEVMEnableUnsafeCORS, false, "Define if the EVM RPC server should enabled CORS (unsafe - use it at your own risk)")
+	cmd.Flags().String(srvflags.EVMTracer, config.DefaultEVMTracer, "the EVM tracer type to collect execution traces from the EVM transaction execution (json|struct|access_list|markdown)")
 
-	cmd.Flags().Uint64(FlagStateSyncSnapshotInterval, 0, "State sync snapshot interval")
-	cmd.Flags().Uint32(FlagStateSyncSnapshotKeepRecent, 2, "State sync snapshot to keep")
+	cmd.Flags().Uint64(server.FlagStateSyncSnapshotInterval, 0, "State sync snapshot interval")
+	cmd.Flags().Uint32(server.FlagStateSyncSnapshotKeepRecent, 2, "State sync snapshot to keep")
 
 	// add support for all Tendermint-specific command line options
 	tcmd.AddNodeFlags(cmd)
@@ -194,8 +155,8 @@ which accepts a path for the resulting pprof file.
 }
 
 func startStandAlone(ctx *server.Context, appCreator types.AppCreator) error {
-	addr := ctx.Viper.GetString(flagAddress)
-	transport := ctx.Viper.GetString(flagTransport)
+	addr := ctx.Viper.GetString(srvflags.Address)
+	transport := ctx.Viper.GetString(srvflags.Transport)
 	home := ctx.Viper.GetString(flags.FlagHome)
 
 	db, err := openDB(home)
@@ -203,7 +164,7 @@ func startStandAlone(ctx *server.Context, appCreator types.AppCreator) error {
 		return err
 	}
 
-	traceWriterFile := ctx.Viper.GetString(flagTraceStore)
+	traceWriterFile := ctx.Viper.GetString(srvflags.TraceStore)
 	traceWriter, err := openTraceWriter(traceWriterFile)
 	if err != nil {
 		return err
@@ -240,7 +201,7 @@ func startInProcess(ctx *server.Context, clientCtx client.Context, appCreator ty
 	logger := ctx.Logger
 	var cpuProfileCleanup func()
 
-	if cpuProfile := ctx.Viper.GetString(flagCPUProfile); cpuProfile != "" {
+	if cpuProfile := ctx.Viper.GetString(srvflags.CPUProfile); cpuProfile != "" {
 		f, err := os.Create(ethdebug.ExpandHome(cpuProfile))
 		if err != nil {
 			return err
@@ -258,7 +219,7 @@ func startInProcess(ctx *server.Context, clientCtx client.Context, appCreator ty
 		}
 	}
 
-	traceWriterFile := ctx.Viper.GetString(flagTraceStore)
+	traceWriterFile := ctx.Viper.GetString(srvflags.TraceStore)
 	db, err := openDB(home)
 	if err != nil {
 		logger.Error("failed to open DB", "error", err.Error())
@@ -272,10 +233,17 @@ func startInProcess(ctx *server.Context, clientCtx client.Context, appCreator ty
 	}
 
 	config := config.GetConfig(ctx.Viper)
+
 	if err := config.ValidateBasic(); err != nil {
-		ctx.Logger.Error("WARNING: The minimum-gas-prices config in app.toml is set to the empty string. " +
-			"This defaults to 0 in the current version, but will error in the next version " +
-			"(SDK v0.44). Please explicitly put the desired minimum-gas-prices in your app.toml.")
+		if strings.Contains(err.Error(), "set min gas price in app.toml or flag or env variable") {
+			ctx.Logger.Error(
+				"WARNING: The minimum-gas-prices config in app.toml is set to the empty string. " +
+					"This defaults to 0 in the current version, but will error in the next version " +
+					"(SDK v0.44). Please explicitly put the desired minimum-gas-prices in your app.toml.",
+			)
+		} else {
+			return err
+		}
 	}
 
 	app := appCreator(ctx.Logger, db, traceWriter, ctx.Viper)
@@ -405,7 +373,7 @@ func startInProcess(ctx *server.Context, clientCtx client.Context, appCreator ty
 		httpSrv     *http.Server
 		httpSrvDone chan struct{}
 	)
-	if config.EVMRPC.Enable {
+	if config.JSONRPC.Enable {
 		genDoc, err := genDocProvider()
 		if err != nil {
 			return err
@@ -415,7 +383,7 @@ func startInProcess(ctx *server.Context, clientCtx client.Context, appCreator ty
 
 		tmEndpoint := "/websocket"
 		tmRPCAddr := cfg.RPC.ListenAddress
-		httpSrv, httpSrvDone, err = StartEVMRPC(ctx, clientCtx, tmRPCAddr, tmEndpoint, config)
+		httpSrv, httpSrvDone, err = StartJSONRPC(ctx, clientCtx, tmRPCAddr, tmEndpoint, config)
 		if err != nil {
 			return err
 		}