more fixes

cmd/ethermintd/config/config.go

@@ -0,0 +1,242 @@
+package config
+
+import (
+	"fmt"
+	"github.com/cosmos/cosmos-sdk/telemetry"
+	"strings"
+
+	"github.com/spf13/viper"
+
+	serverconfig "github.com/cosmos/cosmos-sdk/server/config"
+	storetypes "github.com/cosmos/cosmos-sdk/store/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+const (
+	defaultMinGasPrices = ""
+
+	// 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:1317"
+
+	// DefaultEVMWSAddress is the default address the EVM WebSocket server binds to.
+	DefaultEVMWSAddress = "0.0.0.0:1318"
+)
+
+// BaseConfig defines the server's basic configuration
+type BaseConfig struct {
+	// The minimum gas prices a validator is willing to accept for processing a
+	// transaction. A transaction's fees must meet the minimum of any denomination
+	// specified in this config (e.g. 0.25token1;0.0001token2).
+	MinGasPrices string `mapstructure:"minimum-gas-prices"`
+
+	Pruning           string `mapstructure:"pruning"`
+	PruningKeepRecent string `mapstructure:"pruning-keep-recent"`
+	PruningKeepEvery  string `mapstructure:"pruning-keep-every"`
+	PruningInterval   string `mapstructure:"pruning-interval"`
+
+	// HaltHeight contains a non-zero block height at which a node will gracefully
+	// halt and shutdown that can be used to assist upgrades and testing.
+	//
+	// Note: Commitment of state will be attempted on the corresponding block.
+	HaltHeight uint64 `mapstructure:"halt-height"`
+
+	// HaltTime contains a non-zero minimum block time (in Unix seconds) at which
+	// a node will gracefully halt and shutdown that can be used to assist
+	// upgrades and testing.
+	//
+	// Note: Commitment of state will be attempted on the corresponding block.
+	HaltTime uint64 `mapstructure:"halt-time"`
+
+	// MinRetainBlocks defines the minimum block height offset from the current
+	// block being committed, such that blocks past this offset may be pruned
+	// from Tendermint. It is used as part of the process of determining the
+	// ResponseCommit.RetainHeight value during ABCI Commit. A value of 0 indicates
+	// that no blocks should be pruned.
+	//
+	// This configuration value is only responsible for pruning Tendermint blocks.
+	// It has no bearing on application state pruning which is determined by the
+	// "pruning-*" configurations.
+	//
+	// Note: Tendermint block pruning is dependant on this parameter in conunction
+	// with the unbonding (safety threshold) period, state pruning and state sync
+	// snapshot parameters to determine the correct minimum value of
+	// ResponseCommit.RetainHeight.
+	MinRetainBlocks uint64 `mapstructure:"min-retain-blocks"`
+
+	// InterBlockCache enables inter-block caching.
+	InterBlockCache bool `mapstructure:"inter-block-cache"`
+
+	// IndexEvents defines the set of events in the form {eventType}.{attributeKey},
+	// which informs Tendermint what to index. If empty, all events will be indexed.
+	IndexEvents []string `mapstructure:"index-events"`
+}
+
+// APIConfig defines the API listener configuration.
+type APIConfig = serverconfig.APIConfig
+
+// GRPCConfig defines configuration for the gRPC server.
+type GRPCConfig struct {
+	// Enable defines if the gRPC server should be enabled.
+	Enable bool `mapstructure:"enable"`
+
+	// Address defines the API server to listen on
+	Address string `mapstructure:"address"`
+}
+
+// EVMRPCConfig defines configuration for the EVM RPC server.
+type EVMRPCConfig struct {
+	// Enable defines if the EVM RPC server should be enabled.
+	Enable bool `mapstructure:"enable"`
+	// Address defines the HTTP server to listen on
+	RpcAddress string `mapstructure:"address"`
+	// Address defines the WebSocket server to listen on
+	WsAddress string `mapstructure:"ws-address"`
+}
+
+// StateSyncConfig defines the state sync snapshot configuration.
+type StateSyncConfig struct {
+	// SnapshotInterval sets the interval at which state sync snapshots are taken.
+	// 0 disables snapshots. Must be a multiple of PruningKeepEvery.
+	SnapshotInterval uint64 `mapstructure:"snapshot-interval"`
+
+	// SnapshotKeepRecent sets the number of recent state sync snapshots to keep.
+	// 0 keeps all snapshots.
+	SnapshotKeepRecent uint32 `mapstructure:"snapshot-keep-recent"`
+}
+
+// Config defines the server's top level configuration
+type Config struct {
+	BaseConfig `mapstructure:",squash"`
+
+	// Telemetry defines the application telemetry configuration
+	Telemetry telemetry.Config `mapstructure:"telemetry"`
+	API       APIConfig        `mapstructure:"api"`
+	GRPC      GRPCConfig       `mapstructure:"grpc"`
+	EVMRPC    EVMRPCConfig     `mapstructure:"evm-rpc"`
+	StateSync StateSyncConfig  `mapstructure:"state-sync"`
+}
+
+// SetMinGasPrices sets the validator's minimum gas prices.
+func (c *Config) SetMinGasPrices(gasPrices sdk.DecCoins) {
+	c.MinGasPrices = gasPrices.String()
+}
+
+// GetMinGasPrices returns the validator's minimum gas prices based on the set
+// configuration.
+func (c *Config) GetMinGasPrices() sdk.DecCoins {
+	if c.MinGasPrices == "" {
+		return sdk.DecCoins{}
+	}
+
+	gasPricesStr := strings.Split(c.MinGasPrices, ";")
+	gasPrices := make(sdk.DecCoins, len(gasPricesStr))
+
+	for i, s := range gasPricesStr {
+		gasPrice, err := sdk.ParseDecCoin(s)
+		if err != nil {
+			panic(fmt.Errorf("failed to parse minimum gas price coin (%s): %s", s, err))
+		}
+
+		gasPrices[i] = gasPrice
+	}
+
+	return gasPrices
+}
+
+// DefaultConfig returns server's default configuration.
+func DefaultConfig() *Config {
+
+	return &Config{
+		BaseConfig: BaseConfig{
+			MinGasPrices:      defaultMinGasPrices,
+			InterBlockCache:   true,
+			Pruning:           storetypes.PruningOptionNothing,
+			PruningKeepRecent: "0",
+			PruningKeepEvery:  "0",
+			PruningInterval:   "0",
+			MinRetainBlocks:   0,
+			IndexEvents:       make([]string, 0),
+		},
+		Telemetry: telemetry.Config{
+			Enabled:      false,
+			GlobalLabels: [][]string{},
+		},
+		API: APIConfig{
+			Enable:             true,
+			Swagger:            true,
+			Address:            "tcp://0.0.0.0:10337",
+			MaxOpenConnections: 1000,
+			RPCReadTimeout:     10,
+			RPCMaxBodyBytes:    1000000,
+		},
+		GRPC: GRPCConfig{
+			Enable:  true,
+			Address: DefaultGRPCAddress,
+		},
+		EVMRPC: EVMRPCConfig{
+			Enable:     true,
+			RpcAddress: DefaultEVMAddress,
+			WsAddress:  DefaultEVMWSAddress,
+		},
+		StateSync: StateSyncConfig{
+			SnapshotInterval:   0,
+			SnapshotKeepRecent: 2,
+		},
+	}
+}
+
+// GetConfig returns a fully parsed Config object.
+func GetConfig(v *viper.Viper) Config {
+	globalLabelsRaw := v.Get("telemetry.global-labels").([]interface{})
+	globalLabels := make([][]string, 0, len(globalLabelsRaw))
+
+	return Config{
+		BaseConfig: BaseConfig{
+			MinGasPrices:      v.GetString("minimum-gas-prices"),
+			InterBlockCache:   v.GetBool("inter-block-cache"),
+			Pruning:           v.GetString("pruning"),
+			PruningKeepRecent: v.GetString("pruning-keep-recent"),
+			PruningKeepEvery:  v.GetString("pruning-keep-every"),
+			PruningInterval:   v.GetString("pruning-interval"),
+			HaltHeight:        v.GetUint64("halt-height"),
+			HaltTime:          v.GetUint64("halt-time"),
+			IndexEvents:       v.GetStringSlice("index-events"),
+			MinRetainBlocks:   v.GetUint64("min-retain-blocks"),
+		},
+		Telemetry: telemetry.Config{
+			ServiceName:             v.GetString("telemetry.service-name"),
+			Enabled:                 v.GetBool("telemetry.enabled"),
+			EnableHostname:          v.GetBool("telemetry.enable-hostname"),
+			EnableHostnameLabel:     v.GetBool("telemetry.enable-hostname-label"),
+			EnableServiceLabel:      v.GetBool("telemetry.enable-service-label"),
+			PrometheusRetentionTime: v.GetInt64("telemetry.prometheus-retention-time"),
+			GlobalLabels:            globalLabels,
+		},
+		API: APIConfig{
+			Enable:             v.GetBool("api.enable"),
+			Swagger:            v.GetBool("api.swagger"),
+			Address:            v.GetString("api.address"),
+			MaxOpenConnections: v.GetUint("api.max-open-connections"),
+			RPCReadTimeout:     v.GetUint("api.rpc-read-timeout"),
+			RPCWriteTimeout:    v.GetUint("api.rpc-write-timeout"),
+			RPCMaxBodyBytes:    v.GetUint("api.rpc-max-body-bytes"),
+			EnableUnsafeCORS:   v.GetBool("api.enabled-unsafe-cors"),
+		},
+		GRPC: GRPCConfig{
+			Enable:  v.GetBool("grpc.enable"),
+			Address: v.GetString("grpc.address"),
+		},
+		EVMRPC: EVMRPCConfig{
+			Enable:     v.GetBool("evm-rpc.enable"),
+			RpcAddress: v.GetString("evm-rpc.address"),
+			WsAddress:  v.GetString("evm-rpc.ws-address"),
+		},
+		StateSync: StateSyncConfig{
+			SnapshotInterval:   v.GetUint64("state-sync.snapshot-interval"),
+			SnapshotKeepRecent: v.GetUint32("state-sync.snapshot-keep-recent"),
+		},
+	}
+}

cmd/ethermintd/config/config_test.go

@@ -0,0 +1,20 @@
+package config
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+func TestDefaultConfig(t *testing.T) {
+	cfg := DefaultConfig()
+	require.True(t, cfg.GetMinGasPrices().IsZero())
+}
+
+func TestSetMinimumFees(t *testing.T) {
+	cfg := DefaultConfig()
+	cfg.SetMinGasPrices(sdk.DecCoins{sdk.NewInt64DecCoin("foo", 5)})
+	require.Equal(t, "5.000000000000000000foo", cfg.MinGasPrices)
+}

cmd/ethermintd/config/toml.go

@@ -0,0 +1,212 @@
+package config
+
+import (
+	"bytes"
+	"text/template"
+
+	"github.com/spf13/viper"
+	tmos "github.com/tendermint/tendermint/libs/os"
+)
+
+const defaultConfigTemplate = `# This is a TOML config file.
+# For more information, see https://github.com/toml-lang/toml
+
+###############################################################################
+###                           Base Configuration                            ###
+###############################################################################
+
+# The minimum gas prices a validator is willing to accept for processing a
+# transaction. A transaction's fees must meet the minimum of any denomination
+# specified in this config (e.g. 0.25token1;0.0001token2).
+minimum-gas-prices = "{{ .BaseConfig.MinGasPrices }}"
+
+# default: the last 100 states are kept in addition to every 500th state; pruning at 10 block intervals
+# nothing: all historic states will be saved, nothing will be deleted (i.e. archiving node)
+# everything: all saved states will be deleted, storing only the current state; pruning at 10 block intervals
+# custom: allow pruning options to be manually specified through 'pruning-keep-recent', 'pruning-keep-every', and 'pruning-interval'
+pruning = "{{ .BaseConfig.Pruning }}"
+
+# These are applied if and only if the pruning strategy is custom.
+pruning-keep-recent = "{{ .BaseConfig.PruningKeepRecent }}"
+pruning-keep-every = "{{ .BaseConfig.PruningKeepEvery }}"
+pruning-interval = "{{ .BaseConfig.PruningInterval }}"
+
+# HaltHeight contains a non-zero block height at which a node will gracefully
+# halt and shutdown that can be used to assist upgrades and testing.
+#
+# Note: Commitment of state will be attempted on the corresponding block.
+halt-height = {{ .BaseConfig.HaltHeight }}
+
+# HaltTime contains a non-zero minimum block time (in Unix seconds) at which
+# a node will gracefully halt and shutdown that can be used to assist upgrades
+# and testing.
+#
+# Note: Commitment of state will be attempted on the corresponding block.
+halt-time = {{ .BaseConfig.HaltTime }}
+
+# MinRetainBlocks defines the minimum block height offset from the current
+# block being committed, such that all blocks past this offset are pruned
+# from Tendermint. It is used as part of the process of determining the
+# ResponseCommit.RetainHeight value during ABCI Commit. A value of 0 indicates
+# that no blocks should be pruned.
+#
+# This configuration value is only responsible for pruning Tendermint blocks.
+# It has no bearing on application state pruning which is determined by the
+# "pruning-*" configurations.
+#
+# Note: Tendermint block pruning is dependant on this parameter in conunction
+# with the unbonding (safety threshold) period, state pruning and state sync
+# snapshot parameters to determine the correct minimum value of
+# ResponseCommit.RetainHeight.
+min-retain-blocks = {{ .BaseConfig.MinRetainBlocks }}
+
+# InterBlockCache enables inter-block caching.
+inter-block-cache = {{ .BaseConfig.InterBlockCache }}
+
+# IndexEvents defines the set of events in the form {eventType}.{attributeKey},
+# which informs Tendermint what to index. If empty, all events will be indexed.
+#
+# Example:
+# ["message.sender", "message.recipient"]
+index-events = {{ .BaseConfig.IndexEvents }}
+
+###############################################################################
+###                         Telemetry Configuration                         ###
+###############################################################################
+
+[telemetry]
+
+# Prefixed with keys to separate services.
+service-name = "{{ .Telemetry.ServiceName }}"
+
+# Enabled enables the application telemetry functionality. When enabled,
+# an in-memory sink is also enabled by default. Operators may also enabled
+# other sinks such as Prometheus.
+enabled = {{ .Telemetry.Enabled }}
+
+# Enable prefixing gauge values with hostname.
+enable-hostname = {{ .Telemetry.EnableHostname }}
+
+# Enable adding hostname to labels.
+enable-hostname-label = {{ .Telemetry.EnableHostnameLabel }}
+
+# Enable adding service to labels.
+enable-service-label = {{ .Telemetry.EnableServiceLabel }}
+
+# PrometheusRetentionTime, when positive, enables a Prometheus metrics sink.
+prometheus-retention-time = {{ .Telemetry.PrometheusRetentionTime }}
+
+# GlobalLabels defines a global set of name/value label tuples applied to all
+# metrics emitted using the wrapper functions defined in telemetry package.
+#
+# Example:
+# [["chain_id", "cosmoshub-1"]]
+global-labels = [{{ range $k, $v := .Telemetry.GlobalLabels }}
+  ["{{index $v 0 }}", "{{ index $v 1}}"],{{ end }}
+]
+
+###############################################################################
+###                           API Configuration                             ###
+###############################################################################
+
+[api]
+
+# Enable defines if the API server should be enabled.
+enable = {{ .API.Enable }}
+
+# Swagger defines if swagger documentation should automatically be registered.
+swagger = {{ .API.Swagger }}
+
+# Address defines the API server to listen on.
+address = "{{ .API.Address }}"
+
+# MaxOpenConnections defines the number of maximum open connections.
+max-open-connections = {{ .API.MaxOpenConnections }}
+
+# RPCReadTimeout defines the Tendermint RPC read timeout (in seconds).
+rpc-read-timeout = {{ .API.RPCReadTimeout }}
+
+# RPCWriteTimeout defines the Tendermint RPC write timeout (in seconds).
+rpc-write-timeout = {{ .API.RPCWriteTimeout }}
+
+# RPCMaxBodyBytes defines the Tendermint maximum response body (in bytes).
+rpc-max-body-bytes = {{ .API.RPCMaxBodyBytes }}
+
+# EnableUnsafeCORS defines if CORS should be enabled (unsafe - use it at your own risk).
+enabled-unsafe-cors = {{ .API.EnableUnsafeCORS }}
+
+###############################################################################
+###                           gRPC Configuration                            ###
+###############################################################################
+
+[grpc]
+
+# Enable defines if the gRPC server should be enabled.
+enable = {{ .GRPC.Enable }}
+
+# Address defines the gRPC server address to bind to.
+address = "{{ .GRPC.Address }}"
+
+###############################################################################
+###                           EVM RPC Configuration                         ###
+###############################################################################
+
+[evm-rpc]
+
+# Enable defines if the gRPC server should be enabled.
+enable = {{ .EVMRPC.Enable }}
+
+# Address defines the EVM RPC HTTP server address to bind to.
+address = "{{ .EVMRPC.RpcAddress }}"
+
+# Address defines the EVM WebSocket server address to bind to.
+ws-address = "{{ .EVMRPC.WsAddress }}"
+
+###############################################################################
+###                        State Sync Configuration                         ###
+###############################################################################
+
+# State sync snapshots allow other nodes to rapidly join the network without replaying historical
+# blocks, instead downloading and applying a snapshot of the application state at a given height.
+[state-sync]
+
+# snapshot-interval specifies the block interval at which local state sync snapshots are
+# taken (0 to disable). Must be a multiple of pruning-keep-every.
+snapshot-interval = {{ .StateSync.SnapshotInterval }}
+
+# snapshot-keep-recent specifies the number of recent snapshots to keep and serve (0 to keep all).
+snapshot-keep-recent = {{ .StateSync.SnapshotKeepRecent }}
+`
+
+var configTemplate *template.Template
+
+func init() {
+	var err error
+
+	tmpl := template.New("appConfigFileTemplate")
+
+	if configTemplate, err = tmpl.Parse(defaultConfigTemplate); err != nil {
+		panic(err)
+	}
+}
+
+// ParseConfig retrieves the default environment configuration for the
+// application.
+func ParseConfig(v *viper.Viper) (*Config, error) {
+	conf := DefaultConfig()
+	err := v.Unmarshal(conf)
+
+	return conf, err
+}
+
+// WriteConfigFile renders config using the template and writes it to
+// configFilePath.
+func WriteConfigFile(configFilePath string, config *Config) {
+	var buffer bytes.Buffer
+
+	if err := configTemplate.Execute(&buffer, config); err != nil {
+		panic(err)
+	}
+
+	tmos.MustWriteFile(configFilePath, buffer.Bytes(), 0644)
+}

cmd/ethermintd/flags.go

@@ -0,0 +1,90 @@
+package main
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	"github.com/cosmos/cosmos-sdk/crypto/keyring"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+
+	"github.com/cosmos/ethermint/version"
+)
+
+const (
+	flagLong     = "long"
+	flagLogLevel = "log_level"
+)
+
+func init() {
+	infoCmd.Flags().Bool(flagLong, false, "Print full information")
+}
+
+var (
+	infoCmd = &cobra.Command{
+		Use:   "info",
+		Short: "Print version info",
+		RunE: func(_ *cobra.Command, _ []string) error {
+			fmt.Println(version.Version())
+			return nil
+		},
+	}
+)
+
+var (
+	fromPassphrase  string
+	ethNodeWS       string
+	ethNodeHTTP     string
+	statsdEnabled   bool
+	statsdPrefix    string
+	statsdAddress   string
+	statsdStuckFunc string
+	evmDebug        bool
+	logJSON         bool
+	logLevel        string
+)
+
+// 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")
+	cmd.PersistentFlags().String(flags.FlagFrom, "", "Name or address of private key with which to sign")
+	cmd.PersistentFlags().StringVar(&fromPassphrase, "from-passphrase", "12345678", "Passphrase for private key specified with 'from'")
+	cmd.PersistentFlags().StringVar(&ethNodeWS, "eth-node-ws", "ws://localhost:1317", "WebSocket endpoint for an Ethereum node.")
+	cmd.PersistentFlags().StringVar(&ethNodeHTTP, "eth-node-http", "http://localhost:1317", "HTTP endpoint for an Ethereum node.")
+	cmd.PersistentFlags().BoolVar(&statsdEnabled, "statsd-enabled", false, "Enabled StatsD reporting.")
+	cmd.PersistentFlags().StringVar(&statsdPrefix, "statsd-prefix", "ethermintd", "Specify StatsD compatible metrics prefix.")
+	cmd.PersistentFlags().StringVar(&statsdAddress, "statsd-address", "localhost:8125", "UDP address of a StatsD compatible metrics aggregator.")
+	cmd.PersistentFlags().StringVar(&statsdStuckFunc, "statsd-stuck-func", "5m", "Sets a duration to consider a function to be stuck (e.g. in deadlock).")
+	cmd.PersistentFlags().String(flags.FlagFees, "", "Fees to pay along with transaction; eg: 10uatom")
+	cmd.PersistentFlags().String(flags.FlagGasPrices, "", "Gas prices to determine the transaction fee (e.g. 10uatom)")
+	cmd.PersistentFlags().String(flags.FlagNode, "tcp://localhost:26657", "<host>:<port> to tendermint rpc interface for this chain")
+	cmd.PersistentFlags().Float64(flags.FlagGasAdjustment, flags.DefaultGasAdjustment, "adjustment factor to be multiplied against the estimate returned by the tx simulation; if the gas limit is set manually this flag is ignored ")
+	cmd.PersistentFlags().StringP(flags.FlagBroadcastMode, "b", flags.BroadcastSync, "Transaction broadcasting mode (sync|async|block)")
+	cmd.PersistentFlags().BoolVar(&logJSON, "log-json", false, "Use JSON as the output format of the own logger (default: text)")
+	cmd.PersistentFlags().BoolVar(&evmDebug, "evm-debug", false, "Enable EVM debug traces")
+	cmd.PersistentFlags().StringVar(&logLevel, "log-level", "info", "Sets the level of the own logger (error, warn, info, debug)")
+	//cmd.PersistentFlags().Bool(flags.FlagTrustNode, true, "Trust connected full node (don't verify proofs for responses)")
+	cmd.PersistentFlags().String(flags.FlagKeyringBackend, keyring.BackendFile, "Select keyring's backend")
+
+	// --gas can accept integers and "simulate"
+	//cmd.PersistentFlags().Var(&flags.GasFlagVar, "gas", fmt.Sprintf(
+	//	"gas limit to set per-transaction; set to %q to calculate required gas automatically (default %d)",
+	//	flags.GasFlagAuto, flags.DefaultGasLimit,
+	//))
+
+	//viper.BindPFlag(flags.FlagTrustNode, cmd.Flags().Lookup(flags.FlagTrustNode))
+	viper.BindPFlag(flags.FlagNode, cmd.Flags().Lookup(flags.FlagNode))
+	viper.BindPFlag(flags.FlagKeyringBackend, cmd.Flags().Lookup(flags.FlagKeyringBackend))
+
+	cmd.MarkFlagRequired(flags.FlagChainID)
+	return cmd
+}
+
+func duration(s string, defaults time.Duration) time.Duration {
+	dur, err := time.ParseDuration(s)
+	if err != nil {
+		dur = defaults
+	}
+	return dur
+}

cmd/ethermintd/start.go

@@ -0,0 +1,467 @@
+package main
+
+import (
+	"context"
+	"io"
+	"net"
+	"net/http"
+	"os"
+	"path/filepath"
+	"runtime/pprof"
+	"time"
+
+	"github.com/gorilla/mux"
+	"github.com/improbable-eng/grpc-web/go/grpcweb"
+	"github.com/rs/cors"
+	"github.com/spf13/cobra"
+	"github.com/xlab/closer"
+	log "github.com/xlab/suplog"
+	"google.golang.org/grpc"
+
+	tcmd "github.com/tendermint/tendermint/cmd/tendermint/commands"
+	"github.com/tendermint/tendermint/node"
+	"github.com/tendermint/tendermint/p2p"
+	pvm "github.com/tendermint/tendermint/privval"
+	"github.com/tendermint/tendermint/proxy"
+	"github.com/tendermint/tendermint/rpc/client/local"
+	rpcclient "github.com/tendermint/tendermint/rpc/jsonrpc/client"
+	dbm "github.com/tendermint/tm-db"
+
+	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	"github.com/cosmos/cosmos-sdk/server"
+	"github.com/cosmos/cosmos-sdk/server/api"
+	sdkconfig "github.com/cosmos/cosmos-sdk/server/config"
+	servergrpc "github.com/cosmos/cosmos-sdk/server/grpc"
+	"github.com/cosmos/cosmos-sdk/server/types"
+	storetypes "github.com/cosmos/cosmos-sdk/store/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	ethrpc "github.com/ethereum/go-ethereum/rpc"
+
+	"github.com/cosmos/ethermint/cmd/ethermintd/config"
+	"github.com/cosmos/ethermint/ethereum/rpc"
+)
+
+// 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"
+	flagEVMRPCAddress = "evm-rpc.address"
+	flagEVMWSAddress  = "evm-rpc.ws-address"
+)
+
+// State sync-related flags.
+const (
+	FlagStateSyncSnapshotInterval   = "state-sync.snapshot-interval"
+	FlagStateSyncSnapshotKeepRecent = "state-sync.snapshot-keep-recent"
+)
+
+// StartCmd runs the service passed in, either stand-alone or in-process with
+// Tendermint.
+func StartCmd(appCreator types.AppCreator, defaultNodeHome string) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "start",
+		Short: "Run the full node",
+		Long: `Run the full node application with Tendermint in or out of process. By
+default, the application will run with Tendermint in process.
+
+Pruning options can be provided via the '--pruning' flag or alternatively with '--pruning-keep-recent',
+'pruning-keep-every', and 'pruning-interval' together.
+
+For '--pruning' the options are as follows:
+
+default: the last 100 states are kept in addition to every 500th state; pruning at 10 block intervals
+nothing: all historic states will be saved, nothing will be deleted (i.e. archiving node)
+everything: all saved states will be deleted, storing only the current state; pruning at 10 block intervals
+custom: allow pruning options to be manually specified through 'pruning-keep-recent', 'pruning-keep-every', and 'pruning-interval'
+
+Node halting configurations exist in the form of two flags: '--halt-height' and '--halt-time'. During
+the ABCI Commit phase, the node will check if the current block height is greater than or equal to
+the halt-height or if the current block time is greater than or equal to the halt-time. If so, the
+node will attempt to gracefully shutdown and the block will not be committed. In addition, the node
+will not be able to commit subsequent blocks.
+
+For profiling and benchmarking purposes, CPU profiling can be enabled via the '--cpu-profile' flag
+which accepts a path for the resulting pprof file.
+`,
+		PreRunE: func(cmd *cobra.Command, _ []string) error {
+			serverCtx := server.GetServerContextFromCmd(cmd)
+
+			// Bind flags to the Context's Viper so the app construction can set
+			// options accordingly.
+			serverCtx.Viper.BindPFlags(cmd.Flags())
+
+			_, err := server.GetPruningOptionsFromFlags(serverCtx.Viper)
+			return err
+		},
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			serverCtx := server.GetServerContextFromCmd(cmd)
+			clientCtx := client.GetClientContextFromCmd(cmd)
+
+			serverCtx.Logger.Info("starting ABCI with Tendermint")
+
+			// amino is needed here for backwards compatibility of REST routes
+			err := startInProcess(serverCtx, clientCtx, appCreator)
+			return err
+		},
+	}
+
+	cmd.Flags().String(flags.FlagHome, defaultNodeHome, "The application home directory")
+	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(flagGRPCEnable, true, "Define if the gRPC server should be enabled")
+	cmd.Flags().String(flagGRPCAddress, config.DefaultGRPCAddress, "the gRPC server address to listen on")
+
+	cmd.Flags().Bool(flagEVMRPCEnable, true, "Define if the gRPC server 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().Uint64(FlagStateSyncSnapshotInterval, 0, "State sync snapshot interval")
+	cmd.Flags().Uint32(FlagStateSyncSnapshotKeepRecent, 2, "State sync snapshot to keep")
+
+	// add support for all Tendermint-specific command line options
+	tcmd.AddNodeFlags(cmd)
+	return cmd
+}
+
+func startInProcess(ctx *server.Context, clientCtx client.Context, appCreator types.AppCreator) error {
+	cfg := ctx.Config
+	home := cfg.RootDir
+
+	envName := "chain-" + ctx.Viper.GetString(flags.FlagChainID)
+	if env := os.Getenv("APP_ENV"); len(env) > 0 {
+		envName = env
+	}
+
+	if statsdEnabled {
+		hostname, _ := os.Hostname()
+		metrics.Init(statsdAddress, statsdPrefix, &metrics.StatterConfig{
+			EnvName:              envName,
+			HostName:             hostname,
+			StuckFunctionTimeout: duration(statsdStuckFunc, 5*time.Minute),
+			MockingEnabled:       false,
+		})
+		closer.Bind(func() {
+			metrics.Close()
+		})
+	}
+
+	traceWriterFile := ctx.Viper.GetString(flagTraceStore)
+	db, err := openDB(home)
+	if err != nil {
+		log.WithError(err).Errorln("failed to open DB")
+		return err
+	}
+
+	traceWriter, err := openTraceWriter(traceWriterFile)
+	if err != nil {
+		log.WithError(err).Errorln("failed to open trace writer")
+		return err
+	}
+
+	app := appCreator(ctx.Logger, db, traceWriter, ctx.Viper)
+
+	nodeKey, err := p2p.LoadOrGenNodeKey(cfg.NodeKeyFile())
+	if err != nil {
+		log.WithError(err).Errorln("failed load or gen node key")
+		return err
+	}
+
+	genDocProvider := node.DefaultGenesisDocProviderFunc(cfg)
+	tmNode, err := node.NewNode(
+		cfg,
+		pvm.LoadOrGenFilePV(cfg.PrivValidatorKeyFile(), cfg.PrivValidatorStateFile()),
+		nodeKey,
+		proxy.NewLocalClientCreator(app),
+		genDocProvider,
+		node.DefaultDBProvider,
+		node.DefaultMetricsProvider(cfg.Instrumentation),
+		ctx.Logger.With("module", "node"),
+	)
+	if err != nil {
+		log.WithError(err).Errorln("failed init node")
+		return err
+	}
+
+	if err := tmNode.Start(); err != nil {
+		log.WithError(err).Errorln("failed start tendermint server")
+		return err
+	}
+
+	genDoc, err := genDocProvider()
+	if err != nil {
+		return err
+	}
+
+	clientCtx = clientCtx.
+		WithHomeDir(home).
+		WithChainID(genDoc.ChainID).
+		WithClient(local.New(tmNode))
+
+	var apiSrv *api.Server
+	config := config.GetConfig(ctx.Viper)
+
+	var grpcSrv *grpc.Server
+	if config.GRPC.Enable {
+		grpcSrv, err = servergrpc.StartGRPCServer(app, config.GRPC.Address)
+		if err != nil {
+			log.WithError(err).Errorln("failed to boot GRPC server")
+		}
+	}
+
+	var httpSrv *http.Server
+	var httpSrvDone = make(chan struct{}, 1)
+	var wsSrv rpc.WebsocketsServer
+
+	if config.EVMRPC.Enable {
+		tmEndpoint := "/websocket"
+		tmRPCAddr := cfg.RPC.ListenAddress
+		log.Infoln("EVM RPC Connecting to Tendermint WebSocket at", tmRPCAddr+tmEndpoint)
+		tmWsClient := connectTmWS(tmRPCAddr, tmEndpoint)
+
+		rpcServer := ethrpc.NewServer()
+		apis := rpc.GetRPCAPIs(clientCtx, tmWsClient)
+
+		for _, api := range apis {
+			if err := rpcServer.RegisterName(api.Namespace, api.Service); err != nil {
+				log.WithFields(log.Fields{
+					"namespace": api.Namespace,
+					"service":   api.Service,
+				}).WithError(err).Fatalln("failed to register service in EVM RPC namespace")
+			}
+		}
+
+		r := mux.NewRouter()
+		r.HandleFunc("/", rpcServer.ServeHTTP).Methods("POST")
+		if grpcSrv != nil {
+			grpcWeb := grpcweb.WrapServer(grpcSrv)
+			mountGrpcWebServices(r, grpcWeb, grpcweb.ListGRPCResources(grpcSrv))
+		}
+
+		handlerWithCors := cors.New(cors.Options{
+			AllowedOrigins: []string{"*"},
+			AllowedMethods: []string{
+				http.MethodHead,
+				http.MethodGet,
+				http.MethodPost,
+				http.MethodPut,
+				http.MethodPatch,
+				http.MethodDelete,
+			},
+			AllowedHeaders:     []string{"*"},
+			AllowCredentials:   false,
+			OptionsPassthrough: false,
+		})
+
+		httpSrv = &http.Server{
+			Addr:    config.EVMRPC.RpcAddress,
+			Handler: handlerWithCors.Handler(r),
+		}
+
+		errCh := make(chan error)
+		go func() {
+			log.Infoln("Starting EVM RPC server on", config.EVMRPC.RpcAddress)
+			if err := httpSrv.ListenAndServe(); err != nil {
+				if err == http.ErrServerClosed {
+					close(httpSrvDone)
+					return
+				}
+
+				log.WithError(err).Errorln("failed to start EVM RPC server")
+				errCh <- err
+			}
+		}()
+
+		select {
+		case err := <-errCh:
+			log.WithError(err).Errorln("failed to boot EVM RPC server")
+			return err
+		case <-time.After(1 * time.Second): // assume EVM RPC server started successfully
+		}
+
+		log.Infoln("Starting EVM WebSocket server on", config.EVMRPC.WsAddress)
+		_, port, _ := net.SplitHostPort(config.EVMRPC.RpcAddress)
+
+		// allocate separate WS connection to Tendermint
+		tmWsClient = connectTmWS(tmRPCAddr, tmEndpoint)
+		wsSrv = rpc.NewWebsocketsServer(tmWsClient, "localhost:"+port, config.EVMRPC.WsAddress)
+		go wsSrv.Start()
+	}
+
+	sdkcfg := sdkconfig.GetConfig(ctx.Viper)
+	sdkcfg.API = config.API
+	if sdkcfg.API.Enable {
+		apiSrv = api.New(clientCtx, ctx.Logger.With("module", "api-server"))
+		app.RegisterAPIRoutes(apiSrv, sdkcfg.API)
+		errCh := make(chan error)
+
+		go func() {
+			if err := apiSrv.Start(sdkcfg); err != nil {
+				errCh <- err
+			}
+		}()
+
+		select {
+		case err := <-errCh:
+			log.WithError(err).Errorln("failed to boot API server")
+			return err
+		case <-time.After(5 * time.Second): // assume server started successfully
+		}
+	}
+
+	var cpuProfileCleanup func()
+
+	if cpuProfile := ctx.Viper.GetString(flagCPUProfile); cpuProfile != "" {
+		f, err := os.Create(cpuProfile)
+		if err != nil {
+			log.WithError(err).Errorln("failed to create CP profile")
+			return err
+		}
+
+		log.WithField("profile", cpuProfile).Infoln("starting CPU profiler")
+		if err := pprof.StartCPUProfile(f); err != nil {
+			return err
+		}
+
+		cpuProfileCleanup = func() {
+			log.WithField("profile", cpuProfile).Infoln("stopping CPU profiler")
+			pprof.StopCPUProfile()
+			f.Close()
+		}
+	}
+
+	closer.Bind(func() {
+		if tmNode.IsRunning() {
+			_ = tmNode.Stop()
+		}
+
+		if cpuProfileCleanup != nil {
+			cpuProfileCleanup()
+		}
+
+		if httpSrv != nil {
+			shutdownCtx, cancelFn := context.WithTimeout(context.Background(), 10*time.Second)
+			defer cancelFn()
+
+			if err := httpSrv.Shutdown(shutdownCtx); err != nil {
+				log.WithError(err).Warningln("HTTP server shutdown produced a warning")
+			} else {
+				log.Infoln("HTTP server shut down, waiting 5 sec")
+				select {
+				case <-time.Tick(5 * time.Second):
+				case <-httpSrvDone:
+				}
+			}
+		}
+
+		if grpcSrv != nil {
+			grpcSrv.Stop()
+		}
+
+		log.Infoln("Bye!")
+	})
+
+	closer.Hold()
+
+	return nil
+}
+
+func connectTmWS(tmRPCAddr, tmEndpoint string) *rpcclient.WSClient {
+	tmWsClient, err := rpcclient.NewWS(tmRPCAddr, tmEndpoint,
+		rpcclient.MaxReconnectAttempts(256),
+		rpcclient.ReadWait(120*time.Second),
+		rpcclient.WriteWait(120*time.Second),
+		rpcclient.PingPeriod(50*time.Second),
+		rpcclient.OnReconnect(func() {
+			log.WithField("tendermint_rpc", tmRPCAddr+tmEndpoint).
+				Debugln("EVM RPC reconnects to Tendermint WS")
+		}),
+	)
+
+	if err != nil {
+		log.WithError(err).Fatalln("Tendermint WS client could not be created for ", tmRPCAddr+tmEndpoint)
+	} else if err := tmWsClient.OnStart(); err != nil {
+		log.WithError(err).Fatalln("Tendermint WS client could not start for ", tmRPCAddr+tmEndpoint)
+	}
+
+	return tmWsClient
+}
+
+func mountGrpcWebServices(
+	router *mux.Router,
+	grpcWeb *grpcweb.WrappedGrpcServer,
+	grpcResources []string,
+) {
+	for _, res := range grpcResources {
+		log.Printf("[GRPC Web] HTTP POST mounted on %s", res)
+
+		s := router.Methods("POST").Subrouter()
+		s.HandleFunc(res, func(resp http.ResponseWriter, req *http.Request) {
+			if grpcWeb.IsGrpcWebSocketRequest(req) {
+				grpcWeb.HandleGrpcWebsocketRequest(resp, req)
+				return
+			}
+
+			if grpcWeb.IsGrpcWebRequest(req) {
+				grpcWeb.HandleGrpcWebRequest(resp, req)
+				return
+			}
+		})
+	}
+}
+
+func openDB(rootDir string) (dbm.DB, error) {
+	dataDir := filepath.Join(rootDir, "data")
+	return sdk.NewLevelDB("application", dataDir)
+}
+
+func openTraceWriter(traceWriterFile string) (w io.Writer, err error) {
+	if traceWriterFile == "" {
+		return
+	}
+	return os.OpenFile(
+		traceWriterFile,
+		os.O_WRONLY|os.O_APPEND|os.O_CREATE,
+		0666,
+	)
+}