cmd: hyphen case cli and config (#5777)

2026-01-07 13:55:17 +00:00 · 2020-12-11 13:14:04 +01:00
parent c1be58a27b
commit 3283a84ab2
22 changed files with 306 additions and 274 deletions
--- a/config/config.go
+++ b/config/config.go
@@ -63,7 +63,7 @@ type Config struct {
 	StateSync       *StateSyncConfig       `mapstructure:"statesync"`
 	FastSync        *FastSyncConfig        `mapstructure:"fastsync"`
 	Consensus       *ConsensusConfig       `mapstructure:"consensus"`
-	TxIndex         *TxIndexConfig         `mapstructure:"tx_index"`
+	TxIndex         *TxIndexConfig         `mapstructure:"tx-index"`
 	Instrumentation *InstrumentationConfig `mapstructure:"instrumentation"`
 }

@@ -151,7 +151,7 @@ type BaseConfig struct { //nolint: maligned

 	// TCP or UNIX socket address of the ABCI application,
 	// or the name of an ABCI application compiled in with the Tendermint binary
-	ProxyApp string `mapstructure:"proxy_app"`
+	ProxyApp string `mapstructure:"proxy-app"`

 	// A custom human readable name for this node
 	Moniker string `mapstructure:"moniker"`
@@ -159,7 +159,7 @@ type BaseConfig struct { //nolint: maligned
 	// If this node is many blocks behind the tip of the chain, FastSync
 	// allows them to catchup quickly by downloading blocks in parallel
 	// and verifying their commits
-	FastSyncMode bool `mapstructure:"fast_sync"`
+	FastSyncMode bool `mapstructure:"fast-sync"`

 	// Database backend: goleveldb | cleveldb | boltdb | rocksdb
 	// * goleveldb (github.com/syndtr/goleveldb - most popular implementation)
@@ -180,39 +180,39 @@ type BaseConfig struct { //nolint: maligned
 	// * badgerdb (uses github.com/dgraph-io/badger)
 	//   - EXPERIMENTAL
 	//   - use badgerdb build tag (go build -tags badgerdb)
-	DBBackend string `mapstructure:"db_backend"`
+	DBBackend string `mapstructure:"db-backend"`

 	// Database directory
-	DBPath string `mapstructure:"db_dir"`
+	DBPath string `mapstructure:"db-dir"`

 	// Output level for logging
-	LogLevel string `mapstructure:"log_level"`
+	LogLevel string `mapstructure:"log-level"`

 	// Output format: 'plain' (colored text) or 'json'
-	LogFormat string `mapstructure:"log_format"`
+	LogFormat string `mapstructure:"log-format"`

 	// Path to the JSON file containing the initial validator set and other meta data
-	Genesis string `mapstructure:"genesis_file"`
+	Genesis string `mapstructure:"genesis-file"`

 	// Path to the JSON file containing the private key to use as a validator in the consensus protocol
-	PrivValidatorKey string `mapstructure:"priv_validator_key_file"`
+	PrivValidatorKey string `mapstructure:"priv-validator-key-file"`

 	// Path to the JSON file containing the last sign state of a validator
-	PrivValidatorState string `mapstructure:"priv_validator_state_file"`
+	PrivValidatorState string `mapstructure:"priv-validator-state-file"`

 	// TCP or UNIX socket address for Tendermint to listen on for
 	// connections from an external PrivValidator process
-	PrivValidatorListenAddr string `mapstructure:"priv_validator_laddr"`
+	PrivValidatorListenAddr string `mapstructure:"priv-validator-laddr"`

 	// A JSON file containing the private key to use for p2p authenticated encryption
-	NodeKey string `mapstructure:"node_key_file"`
+	NodeKey string `mapstructure:"node-key-file"`

 	// Mechanism to connect to the ABCI application: socket | grpc
 	ABCI string `mapstructure:"abci"`

 	// If true, query the ABCI app on connecting to a new peer
 	// so the app can decide if we should keep the connection or not
-	FilterPeers bool `mapstructure:"filter_peers"` // false
+	FilterPeers bool `mapstructure:"filter-peers"` // false
 }

 // DefaultBaseConfig returns a default base configuration for a Tendermint node
@@ -279,7 +279,7 @@ func (cfg BaseConfig) ValidateBasic() error {
 	switch cfg.LogFormat {
 	case LogFormatPlain, LogFormatJSON:
 	default:
-		return errors.New("unknown log_format (must be 'plain' or 'json')")
+		return errors.New("unknown log format (must be 'plain' or 'json')")
 	}
 	return nil
 }
@@ -309,58 +309,58 @@ type RPCConfig struct {
 	// If the special '*' value is present in the list, all origins will be allowed.
 	// An origin may contain a wildcard (*) to replace 0 or more characters (i.e.: http://*.domain.com).
 	// Only one wildcard can be used per origin.
-	CORSAllowedOrigins []string `mapstructure:"cors_allowed_origins"`
+	CORSAllowedOrigins []string `mapstructure:"cors-allowed-origins"`

 	// A list of methods the client is allowed to use with cross-domain requests.
-	CORSAllowedMethods []string `mapstructure:"cors_allowed_methods"`
+	CORSAllowedMethods []string `mapstructure:"cors-allowed-methods"`

 	// A list of non simple headers the client is allowed to use with cross-domain requests.
-	CORSAllowedHeaders []string `mapstructure:"cors_allowed_headers"`
+	CORSAllowedHeaders []string `mapstructure:"cors-allowed-headers"`

 	// TCP or UNIX socket address for the gRPC server to listen on
 	// NOTE: This server only supports /broadcast_tx_commit
-	GRPCListenAddress string `mapstructure:"grpc_laddr"`
+	GRPCListenAddress string `mapstructure:"grpc-laddr"`

 	// Maximum number of simultaneous connections.
-	// Does not include RPC (HTTP&WebSocket) connections. See max_open_connections
+	// Does not include RPC (HTTP&WebSocket) connections. See max-open-connections
 	// If you want to accept a larger number than the default, make sure
 	// you increase your OS limits.
 	// 0 - unlimited.
-	GRPCMaxOpenConnections int `mapstructure:"grpc_max_open_connections"`
+	GRPCMaxOpenConnections int `mapstructure:"grpc-max-open-connections"`

-	// Activate unsafe RPC commands like /dial_persistent_peers and /unsafe_flush_mempool
+	// Activate unsafe RPC commands like /dial-persistent-peers and /unsafe-flush-mempool
 	Unsafe bool `mapstructure:"unsafe"`

 	// Maximum number of simultaneous connections (including WebSocket).
-	// Does not include gRPC connections. See grpc_max_open_connections
+	// Does not include gRPC connections. See grpc-max-open-connections
 	// If you want to accept a larger number than the default, make sure
 	// you increase your OS limits.
 	// 0 - unlimited.
 	// Should be < {ulimit -Sn} - {MaxNumInboundPeers} - {MaxNumOutboundPeers} - {N of wal, db and other open files}
 	// 1024 - 40 - 10 - 50 = 924 = ~900
-	MaxOpenConnections int `mapstructure:"max_open_connections"`
+	MaxOpenConnections int `mapstructure:"max-open-connections"`

 	// Maximum number of unique clientIDs that can /subscribe
 	// If you're using /broadcast_tx_commit, set to the estimated maximum number
 	// of broadcast_tx_commit calls per block.
-	MaxSubscriptionClients int `mapstructure:"max_subscription_clients"`
+	MaxSubscriptionClients int `mapstructure:"max-subscription-clients"`

 	// Maximum number of unique queries a given client can /subscribe to
 	// If you're using GRPC (or Local RPC client) and /broadcast_tx_commit, set
 	// to the estimated maximum number of broadcast_tx_commit calls per block.
-	MaxSubscriptionsPerClient int `mapstructure:"max_subscriptions_per_client"`
+	MaxSubscriptionsPerClient int `mapstructure:"max-subscriptions-per-client"`

 	// How long to wait for a tx to be committed during /broadcast_tx_commit
 	// WARNING: Using a value larger than 10s will result in increasing the
 	// global HTTP write timeout, which applies to all connections and endpoints.
 	// See https://github.com/tendermint/tendermint/issues/3435
-	TimeoutBroadcastTxCommit time.Duration `mapstructure:"timeout_broadcast_tx_commit"`
+	TimeoutBroadcastTxCommit time.Duration `mapstructure:"timeout-broadcast-tx-commit"`

 	// Maximum size of request body, in bytes
-	MaxBodyBytes int64 `mapstructure:"max_body_bytes"`
+	MaxBodyBytes int64 `mapstructure:"max-body-bytes"`

 	// Maximum size of request header, in bytes
-	MaxHeaderBytes int `mapstructure:"max_header_bytes"`
+	MaxHeaderBytes int `mapstructure:"max-header-bytes"`

 	// The path to a file containing certificate that is used to create the HTTPS server.
 	// Migth be either absolute path or path related to tendermint's config directory.
@@ -369,19 +369,19 @@ type RPCConfig struct {
 	// the certFile should be the concatenation of the server's certificate, any intermediates,
 	// and the CA's certificate.
 	//
-	// NOTE: both tls_cert_file and tls_key_file must be present for Tendermint to create HTTPS server.
+	// NOTE: both tls-cert-file and tls-key-file must be present for Tendermint to create HTTPS server.
 	// Otherwise, HTTP server is run.
-	TLSCertFile string `mapstructure:"tls_cert_file"`
+	TLSCertFile string `mapstructure:"tls-cert-file"`

 	// The path to a file containing matching private key that is used to create the HTTPS server.
 	// Migth be either absolute path or path related to tendermint's config directory.
 	//
-	// NOTE: both tls_cert_file and tls_key_file must be present for Tendermint to create HTTPS server.
+	// NOTE: both tls-cert-file and tls-key-file must be present for Tendermint to create HTTPS server.
 	// Otherwise, HTTP server is run.
-	TLSKeyFile string `mapstructure:"tls_key_file"`
+	TLSKeyFile string `mapstructure:"tls-key-file"`

 	// pprof listen address (https://golang.org/pkg/net/http/pprof)
-	PprofListenAddress string `mapstructure:"pprof_laddr"`
+	PprofListenAddress string `mapstructure:"pprof-laddr"`
 }

 // DefaultRPCConfig returns a default configuration for the RPC server
@@ -422,25 +422,25 @@ func TestRPCConfig() *RPCConfig {
 // returns an error if any check fails.
 func (cfg *RPCConfig) ValidateBasic() error {
 	if cfg.GRPCMaxOpenConnections < 0 {
-		return errors.New("grpc_max_open_connections can't be negative")
+		return errors.New("grpc-max-open-connections can't be negative")
 	}
 	if cfg.MaxOpenConnections < 0 {
-		return errors.New("max_open_connections can't be negative")
+		return errors.New("max-open-connections can't be negative")
 	}
 	if cfg.MaxSubscriptionClients < 0 {
-		return errors.New("max_subscription_clients can't be negative")
+		return errors.New("max-subscription-clients can't be negative")
 	}
 	if cfg.MaxSubscriptionsPerClient < 0 {
-		return errors.New("max_subscriptions_per_client can't be negative")
+		return errors.New("max-subscriptions-per-client can't be negative")
 	}
 	if cfg.TimeoutBroadcastTxCommit < 0 {
-		return errors.New("timeout_broadcast_tx_commit can't be negative")
+		return errors.New("timeout-broadcast-tx-commit can't be negative")
 	}
 	if cfg.MaxBodyBytes < 0 {
-		return errors.New("max_body_bytes can't be negative")
+		return errors.New("max-body-bytes can't be negative")
 	}
 	if cfg.MaxHeaderBytes < 0 {
-		return errors.New("max_header_bytes can't be negative")
+		return errors.New("max-header-bytes can't be negative")
 	}
 	return nil
 }
@@ -481,48 +481,48 @@ type P2PConfig struct { //nolint: maligned
 	ListenAddress string `mapstructure:"laddr"`

 	// Address to advertise to peers for them to dial
-	ExternalAddress string `mapstructure:"external_address"`
+	ExternalAddress string `mapstructure:"external-address"`

 	// Comma separated list of seed nodes to connect to
 	// We only use these if we can’t connect to peers in the addrbook
 	Seeds string `mapstructure:"seeds"`

 	// Comma separated list of nodes to keep persistent connections to
-	PersistentPeers string `mapstructure:"persistent_peers"`
+	PersistentPeers string `mapstructure:"persistent-peers"`

 	// UPNP port forwarding
 	UPNP bool `mapstructure:"upnp"`

 	// Path to address book
-	AddrBook string `mapstructure:"addr_book_file"`
+	AddrBook string `mapstructure:"addr-book-file"`

 	// Set true for strict address routability rules
 	// Set false for private or local networks
-	AddrBookStrict bool `mapstructure:"addr_book_strict"`
+	AddrBookStrict bool `mapstructure:"addr-book-strict"`

 	// Maximum number of inbound peers
-	MaxNumInboundPeers int `mapstructure:"max_num_inbound_peers"`
+	MaxNumInboundPeers int `mapstructure:"max-num-inbound-peers"`

 	// Maximum number of outbound peers to connect to, excluding persistent peers
-	MaxNumOutboundPeers int `mapstructure:"max_num_outbound_peers"`
+	MaxNumOutboundPeers int `mapstructure:"max-num-outbound-peers"`

 	// List of node IDs, to which a connection will be (re)established ignoring any existing limits
-	UnconditionalPeerIDs string `mapstructure:"unconditional_peer_ids"`
+	UnconditionalPeerIDs string `mapstructure:"unconditional-peer-ids"`

 	// Maximum pause when redialing a persistent peer (if zero, exponential backoff is used)
-	PersistentPeersMaxDialPeriod time.Duration `mapstructure:"persistent_peers_max_dial_period"`
+	PersistentPeersMaxDialPeriod time.Duration `mapstructure:"persistent-peers-max-dial-period"`

 	// Time to wait before flushing messages out on the connection
-	FlushThrottleTimeout time.Duration `mapstructure:"flush_throttle_timeout"`
+	FlushThrottleTimeout time.Duration `mapstructure:"flush-throttle-timeout"`

 	// Maximum size of a message packet payload, in bytes
-	MaxPacketMsgPayloadSize int `mapstructure:"max_packet_msg_payload_size"`
+	MaxPacketMsgPayloadSize int `mapstructure:"max-packet-msg-payload-size"`

 	// Rate at which packets can be sent, in bytes/second
-	SendRate int64 `mapstructure:"send_rate"`
+	SendRate int64 `mapstructure:"send-rate"`

 	// Rate at which packets can be received, in bytes/second
-	RecvRate int64 `mapstructure:"recv_rate"`
+	RecvRate int64 `mapstructure:"recv-rate"`

 	// Set true to enable the peer-exchange reactor
 	PexReactor bool `mapstructure:"pex"`
@@ -531,22 +531,22 @@ type P2PConfig struct { //nolint: maligned
 	// peers. If another node asks it for addresses, it responds and disconnects.
 	//
 	// Does not work if the peer-exchange reactor is disabled.
-	SeedMode bool `mapstructure:"seed_mode"`
+	SeedMode bool `mapstructure:"seed-mode"`

 	// Comma separated list of peer IDs to keep private (will not be gossiped to
 	// other peers)
-	PrivatePeerIDs string `mapstructure:"private_peer_ids"`
+	PrivatePeerIDs string `mapstructure:"private-peer-ids"`

 	// Toggle to disable guard against peers connecting from the same ip.
-	AllowDuplicateIP bool `mapstructure:"allow_duplicate_ip"`
+	AllowDuplicateIP bool `mapstructure:"allow-duplicate-ip"`

 	// Peer connection configuration.
-	HandshakeTimeout time.Duration `mapstructure:"handshake_timeout"`
-	DialTimeout      time.Duration `mapstructure:"dial_timeout"`
+	HandshakeTimeout time.Duration `mapstructure:"handshake-timeout"`
+	DialTimeout      time.Duration `mapstructure:"dial-timeout"`

 	// Testing params.
 	// Force dial to fail
-	TestDialFail bool `mapstructure:"test_dial_fail"`
+	TestDialFail bool `mapstructure:"test-dial-fail"`
 }

 // DefaultP2PConfig returns a default configuration for the peer-to-peer layer
@@ -591,25 +591,25 @@ func (cfg *P2PConfig) AddrBookFile() string {
 // returns an error if any check fails.
 func (cfg *P2PConfig) ValidateBasic() error {
 	if cfg.MaxNumInboundPeers < 0 {
-		return errors.New("max_num_inbound_peers can't be negative")
+		return errors.New("max-num-inbound-peers can't be negative")
 	}
 	if cfg.MaxNumOutboundPeers < 0 {
-		return errors.New("max_num_outbound_peers can't be negative")
+		return errors.New("max-num-outbound-peers can't be negative")
 	}
 	if cfg.FlushThrottleTimeout < 0 {
-		return errors.New("flush_throttle_timeout can't be negative")
+		return errors.New("flush-throttle-timeout can't be negative")
 	}
 	if cfg.PersistentPeersMaxDialPeriod < 0 {
-		return errors.New("persistent_peers_max_dial_period can't be negative")
+		return errors.New("persistent-peers-max-dial-period can't be negative")
 	}
 	if cfg.MaxPacketMsgPayloadSize < 0 {
-		return errors.New("max_packet_msg_payload_size can't be negative")
+		return errors.New("max-packet-msg-payload-size can't be negative")
 	}
 	if cfg.SendRate < 0 {
-		return errors.New("send_rate can't be negative")
+		return errors.New("send-rate can't be negative")
 	}
 	if cfg.RecvRate < 0 {
-		return errors.New("recv_rate can't be negative")
+		return errors.New("recv-rate can't be negative")
 	}
 	return nil
 }
@@ -622,21 +622,21 @@ type MempoolConfig struct {
 	RootDir   string `mapstructure:"home"`
 	Recheck   bool   `mapstructure:"recheck"`
 	Broadcast bool   `mapstructure:"broadcast"`
-	WalPath   string `mapstructure:"wal_dir"`
+	WalPath   string `mapstructure:"wal-dir"`
 	// Maximum number of transactions in the mempool
 	Size int `mapstructure:"size"`
 	// Limit the total size of all txs in the mempool.
 	// This only accounts for raw transactions (e.g. given 1MB transactions and
-	// max_txs_bytes=5MB, mempool will only accept 5 transactions).
-	MaxTxsBytes int64 `mapstructure:"max_txs_bytes"`
+	// max-txs-bytes=5MB, mempool will only accept 5 transactions).
+	MaxTxsBytes int64 `mapstructure:"max-txs-bytes"`
 	// Size of the cache (used to filter transactions we saw earlier) in transactions
-	CacheSize int `mapstructure:"cache_size"`
+	CacheSize int `mapstructure:"cache-size"`
 	// Maximum size of a single transaction
-	// NOTE: the max size of a tx transmitted over the network is {max_tx_bytes}.
-	MaxTxBytes int `mapstructure:"max_tx_bytes"`
+	// NOTE: the max size of a tx transmitted over the network is {max-tx-bytes}.
+	MaxTxBytes int `mapstructure:"max-tx-bytes"`
 	// Maximum size of a batch of transactions to send to a peer
 	// Including space needed by encoding (one varint per transaction).
-	MaxBatchBytes int `mapstructure:"max_batch_bytes"`
+	MaxBatchBytes int `mapstructure:"max-batch-bytes"`
 }

 // DefaultMempoolConfig returns a default configuration for the Tendermint mempool
@@ -679,19 +679,19 @@ func (cfg *MempoolConfig) ValidateBasic() error {
 		return errors.New("size can't be negative")
 	}
 	if cfg.MaxTxsBytes < 0 {
-		return errors.New("max_txs_bytes can't be negative")
+		return errors.New("max-txs-bytes can't be negative")
 	}
 	if cfg.CacheSize < 0 {
-		return errors.New("cache_size can't be negative")
+		return errors.New("cache-size can't be negative")
 	}
 	if cfg.MaxTxBytes < 0 {
-		return errors.New("max_tx_bytes can't be negative")
+		return errors.New("max-tx-bytes can't be negative")
 	}
 	if cfg.MaxBatchBytes < 0 {
-		return errors.New("max_batch_bytes can't be negative")
+		return errors.New("max-batch-bytes can't be negative")
 	}
 	if cfg.MaxBatchBytes <= cfg.MaxTxBytes {
-		return errors.New("max_batch_bytes can't be less or equal to max_tx_bytes")
+		return errors.New("max-batch-bytes can't be less or equal to max-tx-bytes")
 	}
 	return nil
 }
@@ -702,12 +702,12 @@ func (cfg *MempoolConfig) ValidateBasic() error {
 // StateSyncConfig defines the configuration for the Tendermint state sync service
 type StateSyncConfig struct {
 	Enable        bool          `mapstructure:"enable"`
-	TempDir       string        `mapstructure:"temp_dir"`
-	RPCServers    []string      `mapstructure:"rpc_servers"`
-	TrustPeriod   time.Duration `mapstructure:"trust_period"`
-	TrustHeight   int64         `mapstructure:"trust_height"`
-	TrustHash     string        `mapstructure:"trust_hash"`
-	DiscoveryTime time.Duration `mapstructure:"discovery_time"`
+	TempDir       string        `mapstructure:"temp-dir"`
+	RPCServers    []string      `mapstructure:"rpc-servers"`
+	TrustPeriod   time.Duration `mapstructure:"trust-period"`
+	TrustHeight   int64         `mapstructure:"trust-height"`
+	TrustHash     string        `mapstructure:"trust-hash"`
+	DiscoveryTime time.Duration `mapstructure:"discovery-time"`
 }

 func (cfg *StateSyncConfig) TrustHashBytes() []byte {
@@ -736,28 +736,28 @@ func TestStateSyncConfig() *StateSyncConfig {
 func (cfg *StateSyncConfig) ValidateBasic() error {
 	if cfg.Enable {
 		if len(cfg.RPCServers) == 0 {
-			return errors.New("rpc_servers is required")
+			return errors.New("rpc-servers is required")
 		}
 		if len(cfg.RPCServers) < 2 {
-			return errors.New("at least two rpc_servers entries is required")
+			return errors.New("at least two rpc-servers entries is required")
 		}
 		for _, server := range cfg.RPCServers {
 			if len(server) == 0 {
-				return errors.New("found empty rpc_servers entry")
+				return errors.New("found empty rpc-servers entry")
 			}
 		}
 		if cfg.TrustPeriod <= 0 {
-			return errors.New("trusted_period is required")
+			return errors.New("trusted-period is required")
 		}
 		if cfg.TrustHeight <= 0 {
-			return errors.New("trusted_height is required")
+			return errors.New("trusted-height is required")
 		}
 		if len(cfg.TrustHash) == 0 {
-			return errors.New("trusted_hash is required")
+			return errors.New("trusted-hash is required")
 		}
 		_, err := hex.DecodeString(cfg.TrustHash)
 		if err != nil {
-			return fmt.Errorf("invalid trusted_hash: %w", err)
+			return fmt.Errorf("invalid trusted-hash: %w", err)
 		}
 	}
 	return nil
@@ -802,39 +802,39 @@ func (cfg *FastSyncConfig) ValidateBasic() error {
 // including timeouts and details about the WAL and the block structure.
 type ConsensusConfig struct {
 	RootDir string `mapstructure:"home"`
-	WalPath string `mapstructure:"wal_file"`
+	WalPath string `mapstructure:"wal-file"`
 	walFile string // overrides WalPath if set

 	// How long we wait for a proposal block before prevoting nil
-	TimeoutPropose time.Duration `mapstructure:"timeout_propose"`
-	// How much timeout_propose increases with each round
-	TimeoutProposeDelta time.Duration `mapstructure:"timeout_propose_delta"`
+	TimeoutPropose time.Duration `mapstructure:"timeout-propose"`
+	// How much timeout-propose increases with each round
+	TimeoutProposeDelta time.Duration `mapstructure:"timeout-propose-delta"`
 	// How long we wait after receiving +2/3 prevotes for “anything” (ie. not a single block or nil)
-	TimeoutPrevote time.Duration `mapstructure:"timeout_prevote"`
-	// How much the timeout_prevote increases with each round
-	TimeoutPrevoteDelta time.Duration `mapstructure:"timeout_prevote_delta"`
+	TimeoutPrevote time.Duration `mapstructure:"timeout-prevote"`
+	// How much the timeout-prevote increases with each round
+	TimeoutPrevoteDelta time.Duration `mapstructure:"timeout-prevote-delta"`
 	// How long we wait after receiving +2/3 precommits for “anything” (ie. not a single block or nil)
-	TimeoutPrecommit time.Duration `mapstructure:"timeout_precommit"`
-	// How much the timeout_precommit increases with each round
-	TimeoutPrecommitDelta time.Duration `mapstructure:"timeout_precommit_delta"`
+	TimeoutPrecommit time.Duration `mapstructure:"timeout-precommit"`
+	// How much the timeout-precommit increases with each round
+	TimeoutPrecommitDelta time.Duration `mapstructure:"timeout-precommit-delta"`
 	// How long we wait after committing a block, before starting on the new
 	// height (this gives us a chance to receive some more precommits, even
 	// though we already have +2/3).
-	// NOTE: when modifying, make sure to update time_iota_ms genesis parameter
-	TimeoutCommit time.Duration `mapstructure:"timeout_commit"`
+	// NOTE: when modifying, make sure to update time-iota-ms genesis parameter
+	TimeoutCommit time.Duration `mapstructure:"timeout-commit"`

 	// Make progress as soon as we have all the precommits (as if TimeoutCommit = 0)
-	SkipTimeoutCommit bool `mapstructure:"skip_timeout_commit"`
+	SkipTimeoutCommit bool `mapstructure:"skip-timeout-commit"`

 	// EmptyBlocks mode and possible interval between empty blocks
-	CreateEmptyBlocks         bool          `mapstructure:"create_empty_blocks"`
-	CreateEmptyBlocksInterval time.Duration `mapstructure:"create_empty_blocks_interval"`
+	CreateEmptyBlocks         bool          `mapstructure:"create-empty-blocks"`
+	CreateEmptyBlocksInterval time.Duration `mapstructure:"create-empty-blocks-interval"`

 	// Reactor sleep duration parameters
-	PeerGossipSleepDuration     time.Duration `mapstructure:"peer_gossip_sleep_duration"`
-	PeerQueryMaj23SleepDuration time.Duration `mapstructure:"peer_query_maj23_sleep_duration"`
+	PeerGossipSleepDuration     time.Duration `mapstructure:"peer-gossip-sleep-duration"`
+	PeerQueryMaj23SleepDuration time.Duration `mapstructure:"peer-query-maj23-sleep-duration"`

-	DoubleSignCheckHeight int64 `mapstructure:"double_sign_check_height"`
+	DoubleSignCheckHeight int64 `mapstructure:"double-sign-check-height"`
 }

 // DefaultConsensusConfig returns a default configuration for the consensus service
@@ -924,37 +924,37 @@ func (cfg *ConsensusConfig) SetWalFile(walFile string) {
 // returns an error if any check fails.
 func (cfg *ConsensusConfig) ValidateBasic() error {
 	if cfg.TimeoutPropose < 0 {
-		return errors.New("timeout_propose can't be negative")
+		return errors.New("timeout-propose can't be negative")
 	}
 	if cfg.TimeoutProposeDelta < 0 {
-		return errors.New("timeout_propose_delta can't be negative")
+		return errors.New("timeout-propose-delta can't be negative")
 	}
 	if cfg.TimeoutPrevote < 0 {
-		return errors.New("timeout_prevote can't be negative")
+		return errors.New("timeout-prevote can't be negative")
 	}
 	if cfg.TimeoutPrevoteDelta < 0 {
-		return errors.New("timeout_prevote_delta can't be negative")
+		return errors.New("timeout-prevote-delta can't be negative")
 	}
 	if cfg.TimeoutPrecommit < 0 {
-		return errors.New("timeout_precommit can't be negative")
+		return errors.New("timeout-precommit can't be negative")
 	}
 	if cfg.TimeoutPrecommitDelta < 0 {
-		return errors.New("timeout_precommit_delta can't be negative")
+		return errors.New("timeout-precommit-delta can't be negative")
 	}
 	if cfg.TimeoutCommit < 0 {
-		return errors.New("timeout_commit can't be negative")
+		return errors.New("timeout-commit can't be negative")
 	}
 	if cfg.CreateEmptyBlocksInterval < 0 {
-		return errors.New("create_empty_blocks_interval can't be negative")
+		return errors.New("create-empty-blocks-interval can't be negative")
 	}
 	if cfg.PeerGossipSleepDuration < 0 {
-		return errors.New("peer_gossip_sleep_duration can't be negative")
+		return errors.New("peer-gossip-sleep-duration can't be negative")
 	}
 	if cfg.PeerQueryMaj23SleepDuration < 0 {
-		return errors.New("peer_query_maj23_sleep_duration can't be negative")
+		return errors.New("peer-query-maj23-sleep-duration can't be negative")
 	}
 	if cfg.DoubleSignCheckHeight < 0 {
-		return errors.New("double_sign_check_height can't be negative")
+		return errors.New("double-sign-check-height can't be negative")
 	}
 	return nil
 }
@@ -1003,13 +1003,13 @@ type InstrumentationConfig struct {
 	Prometheus bool `mapstructure:"prometheus"`

 	// Address to listen for Prometheus collector(s) connections.
-	PrometheusListenAddr string `mapstructure:"prometheus_listen_addr"`
+	PrometheusListenAddr string `mapstructure:"prometheus-listen-addr"`

 	// Maximum number of simultaneous connections.
 	// If you want to accept a larger number than the default, make sure
 	// you increase your OS limits.
 	// 0 - unlimited.
-	MaxOpenConnections int `mapstructure:"max_open_connections"`
+	MaxOpenConnections int `mapstructure:"max-open-connections"`

 	// Instrumentation namespace.
 	Namespace string `mapstructure:"namespace"`
@@ -1036,7 +1036,7 @@ func TestInstrumentationConfig() *InstrumentationConfig {
 // returns an error if any check fails.
 func (cfg *InstrumentationConfig) ValidateBasic() error {
 	if cfg.MaxOpenConnections < 0 {
-		return errors.New("max_open_connections can't be negative")
+		return errors.New("max-open-connections can't be negative")
 	}
 	return nil
 }
--- a/config/toml.go
+++ b/config/toml.go
@@ -83,7 +83,7 @@ const defaultConfigTemplate = `# This is a TOML config file.

 # TCP or UNIX socket address of the ABCI application,
 # or the name of an ABCI application compiled in with the Tendermint binary
-proxy_app = "{{ .BaseConfig.ProxyApp }}"
+proxy-app = "{{ .BaseConfig.ProxyApp }}"

 # A custom human readable name for this node
 moniker = "{{ .BaseConfig.Moniker }}"
@@ -91,7 +91,7 @@ moniker = "{{ .BaseConfig.Moniker }}"
 # If this node is many blocks behind the tip of the chain, FastSync
 # allows them to catchup quickly by downloading blocks in parallel
 # and verifying their commits
-fast_sync = {{ .BaseConfig.FastSyncMode }}
+fast-sync = {{ .BaseConfig.FastSyncMode }}

 # Database backend: goleveldb | cleveldb | boltdb | rocksdb | badgerdb
 # * goleveldb (github.com/syndtr/goleveldb - most popular implementation)
@@ -112,41 +112,41 @@ fast_sync = {{ .BaseConfig.FastSyncMode }}
 # * badgerdb (uses github.com/dgraph-io/badger)
 #   - EXPERIMENTAL
 #   - use badgerdb build tag (go build -tags badgerdb)
-db_backend = "{{ .BaseConfig.DBBackend }}"
+db-backend = "{{ .BaseConfig.DBBackend }}"

 # Database directory
-db_dir = "{{ js .BaseConfig.DBPath }}"
+db-dir = "{{ js .BaseConfig.DBPath }}"

 # Output level for logging, including package level options
-log_level = "{{ .BaseConfig.LogLevel }}"
+log-level = "{{ .BaseConfig.LogLevel }}"

 # Output format: 'plain' (colored text) or 'json'
-log_format = "{{ .BaseConfig.LogFormat }}"
+log-format = "{{ .BaseConfig.LogFormat }}"

 ##### additional base config options #####

 # Path to the JSON file containing the initial validator set and other meta data
-genesis_file = "{{ js .BaseConfig.Genesis }}"
+genesis-file = "{{ js .BaseConfig.Genesis }}"

 # Path to the JSON file containing the private key to use as a validator in the consensus protocol
-priv_validator_key_file = "{{ js .BaseConfig.PrivValidatorKey }}"
+priv-validator-key-file = "{{ js .BaseConfig.PrivValidatorKey }}"

 # Path to the JSON file containing the last sign state of a validator
-priv_validator_state_file = "{{ js .BaseConfig.PrivValidatorState }}"
+priv-validator-state-file = "{{ js .BaseConfig.PrivValidatorState }}"

 # TCP or UNIX socket address for Tendermint to listen on for
 # connections from an external PrivValidator process
-priv_validator_laddr = "{{ .BaseConfig.PrivValidatorListenAddr }}"
+priv-validator-laddr = "{{ .BaseConfig.PrivValidatorListenAddr }}"

 # Path to the JSON file containing the private key to use for node authentication in the p2p protocol
-node_key_file = "{{ js .BaseConfig.NodeKey }}"
+node-key-file = "{{ js .BaseConfig.NodeKey }}"

 # Mechanism to connect to the ABCI application: socket | grpc
 abci = "{{ .BaseConfig.ABCI }}"

 # If true, query the ABCI app on connecting to a new peer
 # so the app can decide if we should keep the connection or not
-filter_peers = {{ .BaseConfig.FilterPeers }}
+filter-peers = {{ .BaseConfig.FilterPeers }}


 #######################################################################
@@ -164,78 +164,78 @@ laddr = "{{ .RPC.ListenAddress }}"
 # A list of origins a cross-domain request can be executed from
 # Default value '[]' disables cors support
 # Use '["*"]' to allow any origin
-cors_allowed_origins = [{{ range .RPC.CORSAllowedOrigins }}{{ printf "%q, " . }}{{end}}]
+cors-allowed-origins = [{{ range .RPC.CORSAllowedOrigins }}{{ printf "%q, " . }}{{end}}]

 # A list of methods the client is allowed to use with cross-domain requests
-cors_allowed_methods = [{{ range .RPC.CORSAllowedMethods }}{{ printf "%q, " . }}{{end}}]
+cors-allowed-methods = [{{ range .RPC.CORSAllowedMethods }}{{ printf "%q, " . }}{{end}}]

 # A list of non simple headers the client is allowed to use with cross-domain requests
-cors_allowed_headers = [{{ range .RPC.CORSAllowedHeaders }}{{ printf "%q, " . }}{{end}}]
+cors-allowed-headers = [{{ range .RPC.CORSAllowedHeaders }}{{ printf "%q, " . }}{{end}}]

 # TCP or UNIX socket address for the gRPC server to listen on
 # NOTE: This server only supports /broadcast_tx_commit
-grpc_laddr = "{{ .RPC.GRPCListenAddress }}"
+grpc-laddr = "{{ .RPC.GRPCListenAddress }}"

 # Maximum number of simultaneous connections.
-# Does not include RPC (HTTP&WebSocket) connections. See max_open_connections
+# Does not include RPC (HTTP&WebSocket) connections. See max-open-connections
 # If you want to accept a larger number than the default, make sure
 # you increase your OS limits.
 # 0 - unlimited.
 # Should be < {ulimit -Sn} - {MaxNumInboundPeers} - {MaxNumOutboundPeers} - {N of wal, db and other open files}
 # 1024 - 40 - 10 - 50 = 924 = ~900
-grpc_max_open_connections = {{ .RPC.GRPCMaxOpenConnections }}
+grpc-max-open-connections = {{ .RPC.GRPCMaxOpenConnections }}

-# Activate unsafe RPC commands like /dial_seeds and /unsafe_flush_mempool
+# Activate unsafe RPC commands like /dial-seeds and /unsafe-flush-mempool
 unsafe = {{ .RPC.Unsafe }}

 # Maximum number of simultaneous connections (including WebSocket).
-# Does not include gRPC connections. See grpc_max_open_connections
+# Does not include gRPC connections. See grpc-max-open-connections
 # If you want to accept a larger number than the default, make sure
 # you increase your OS limits.
 # 0 - unlimited.
 # Should be < {ulimit -Sn} - {MaxNumInboundPeers} - {MaxNumOutboundPeers} - {N of wal, db and other open files}
 # 1024 - 40 - 10 - 50 = 924 = ~900
-max_open_connections = {{ .RPC.MaxOpenConnections }}
+max-open-connections = {{ .RPC.MaxOpenConnections }}

 # Maximum number of unique clientIDs that can /subscribe
 # If you're using /broadcast_tx_commit, set to the estimated maximum number
 # of broadcast_tx_commit calls per block.
-max_subscription_clients = {{ .RPC.MaxSubscriptionClients }}
+max-subscription-clients = {{ .RPC.MaxSubscriptionClients }}

 # Maximum number of unique queries a given client can /subscribe to
 # If you're using GRPC (or Local RPC client) and /broadcast_tx_commit, set to
 # the estimated # maximum number of broadcast_tx_commit calls per block.
-max_subscriptions_per_client = {{ .RPC.MaxSubscriptionsPerClient }}
+max-subscriptions-per-client = {{ .RPC.MaxSubscriptionsPerClient }}

 # How long to wait for a tx to be committed during /broadcast_tx_commit.
 # WARNING: Using a value larger than 10s will result in increasing the
 # global HTTP write timeout, which applies to all connections and endpoints.
 # See https://github.com/tendermint/tendermint/issues/3435
-timeout_broadcast_tx_commit = "{{ .RPC.TimeoutBroadcastTxCommit }}"
+timeout-broadcast-tx-commit = "{{ .RPC.TimeoutBroadcastTxCommit }}"

 # Maximum size of request body, in bytes
-max_body_bytes = {{ .RPC.MaxBodyBytes }}
+max-body-bytes = {{ .RPC.MaxBodyBytes }}

 # Maximum size of request header, in bytes
-max_header_bytes = {{ .RPC.MaxHeaderBytes }}
+max-header-bytes = {{ .RPC.MaxHeaderBytes }}

 # The path to a file containing certificate that is used to create the HTTPS server.
 # Migth be either absolute path or path related to tendermint's config directory.
 # If the certificate is signed by a certificate authority,
 # the certFile should be the concatenation of the server's certificate, any intermediates,
 # and the CA's certificate.
-# NOTE: both tls_cert_file and tls_key_file must be present for Tendermint to create HTTPS server.
+# NOTE: both tls-cert-file and tls-key-file must be present for Tendermint to create HTTPS server.
 # Otherwise, HTTP server is run.
-tls_cert_file = "{{ .RPC.TLSCertFile }}"
+tls-cert-file = "{{ .RPC.TLSCertFile }}"

 # The path to a file containing matching private key that is used to create the HTTPS server.
 # Migth be either absolute path or path related to tendermint's config directory.
-# NOTE: both tls_cert_file and tls_key_file must be present for Tendermint to create HTTPS server.
+# NOTE: both tls-cert-file and tls-key-file must be present for Tendermint to create HTTPS server.
 # Otherwise, HTTP server is run.
-tls_key_file = "{{ .RPC.TLSKeyFile }}"
+tls-key-file = "{{ .RPC.TLSKeyFile }}"

 # pprof listen address (https://golang.org/pkg/net/http/pprof)
-pprof_laddr = "{{ .RPC.PprofListenAddress }}"
+pprof-laddr = "{{ .RPC.PprofListenAddress }}"

 #######################################################
 ###           P2P Configuration Options             ###
@@ -249,47 +249,47 @@ laddr = "{{ .P2P.ListenAddress }}"
 # If empty, will use the same port as the laddr,
 # and will introspect on the listener or use UPnP
 # to figure out the address.
-external_address = "{{ .P2P.ExternalAddress }}"
+external-address = "{{ .P2P.ExternalAddress }}"

 # Comma separated list of seed nodes to connect to
 seeds = "{{ .P2P.Seeds }}"

 # Comma separated list of nodes to keep persistent connections to
-persistent_peers = "{{ .P2P.PersistentPeers }}"
+persistent-peers = "{{ .P2P.PersistentPeers }}"

 # UPNP port forwarding
 upnp = {{ .P2P.UPNP }}

 # Path to address book
-addr_book_file = "{{ js .P2P.AddrBook }}"
+addr-book-file = "{{ js .P2P.AddrBook }}"

 # Set true for strict address routability rules
 # Set false for private or local networks
-addr_book_strict = {{ .P2P.AddrBookStrict }}
+addr-book-strict = {{ .P2P.AddrBookStrict }}

 # Maximum number of inbound peers
-max_num_inbound_peers = {{ .P2P.MaxNumInboundPeers }}
+max-num-inbound-peers = {{ .P2P.MaxNumInboundPeers }}

 # Maximum number of outbound peers to connect to, excluding persistent peers
-max_num_outbound_peers = {{ .P2P.MaxNumOutboundPeers }}
+max-num-outbound-peers = {{ .P2P.MaxNumOutboundPeers }}

 # List of node IDs, to which a connection will be (re)established ignoring any existing limits
-unconditional_peer_ids = "{{ .P2P.UnconditionalPeerIDs }}"
+unconditional-peer-ids = "{{ .P2P.UnconditionalPeerIDs }}"

 # Maximum pause when redialing a persistent peer (if zero, exponential backoff is used)
-persistent_peers_max_dial_period = "{{ .P2P.PersistentPeersMaxDialPeriod }}"
+persistent-peers-max-dial-period = "{{ .P2P.PersistentPeersMaxDialPeriod }}"

 # Time to wait before flushing messages out on the connection
-flush_throttle_timeout = "{{ .P2P.FlushThrottleTimeout }}"
+flush-throttle-timeout = "{{ .P2P.FlushThrottleTimeout }}"

 # Maximum size of a message packet payload, in bytes
-max_packet_msg_payload_size = {{ .P2P.MaxPacketMsgPayloadSize }}
+max-packet-msg-payload-size = {{ .P2P.MaxPacketMsgPayloadSize }}

 # Rate at which packets can be sent, in bytes/second
-send_rate = {{ .P2P.SendRate }}
+send-rate = {{ .P2P.SendRate }}

 # Rate at which packets can be received, in bytes/second
-recv_rate = {{ .P2P.RecvRate }}
+recv-rate = {{ .P2P.RecvRate }}

 # Set true to enable the peer-exchange reactor
 pex = {{ .P2P.PexReactor }}
@@ -298,17 +298,17 @@ pex = {{ .P2P.PexReactor }}
 # peers. If another node asks it for addresses, it responds and disconnects.
 #
 # Does not work if the peer-exchange reactor is disabled.
-seed_mode = {{ .P2P.SeedMode }}
+seed-mode = {{ .P2P.SeedMode }}

 # Comma separated list of peer IDs to keep private (will not be gossiped to other peers)
-private_peer_ids = "{{ .P2P.PrivatePeerIDs }}"
+private-peer-ids = "{{ .P2P.PrivatePeerIDs }}"

 # Toggle to disable guard against peers connecting from the same ip.
-allow_duplicate_ip = {{ .P2P.AllowDuplicateIP }}
+allow-duplicate-ip = {{ .P2P.AllowDuplicateIP }}

 # Peer connection configuration.
-handshake_timeout = "{{ .P2P.HandshakeTimeout }}"
-dial_timeout = "{{ .P2P.DialTimeout }}"
+handshake-timeout = "{{ .P2P.HandshakeTimeout }}"
+dial-timeout = "{{ .P2P.DialTimeout }}"

 #######################################################
 ###          Mempool Configurattion Option          ###
@@ -317,26 +317,26 @@ dial_timeout = "{{ .P2P.DialTimeout }}"

 recheck = {{ .Mempool.Recheck }}
 broadcast = {{ .Mempool.Broadcast }}
-wal_dir = "{{ js .Mempool.WalPath }}"
+wal-dir = "{{ js .Mempool.WalPath }}"

 # Maximum number of transactions in the mempool
 size = {{ .Mempool.Size }}

 # Limit the total size of all txs in the mempool.
 # This only accounts for raw transactions (e.g. given 1MB transactions and
-# max_txs_bytes=5MB, mempool will only accept 5 transactions).
-max_txs_bytes = {{ .Mempool.MaxTxsBytes }}
+# max-txs-bytes=5MB, mempool will only accept 5 transactions).
+max-txs-bytes = {{ .Mempool.MaxTxsBytes }}

 # Size of the cache (used to filter transactions we saw earlier) in transactions
-cache_size = {{ .Mempool.CacheSize }}
+cache-size = {{ .Mempool.CacheSize }}

 # Maximum size of a single transaction.
-# NOTE: the max size of a tx transmitted over the network is {max_tx_bytes}.
-max_tx_bytes = {{ .Mempool.MaxTxBytes }}
+# NOTE: the max size of a tx transmitted over the network is {max-tx-bytes}.
+max-tx-bytes = {{ .Mempool.MaxTxBytes }}

 # Maximum size of a batch of transactions to send to a peer
 # Including space needed by encoding (one varint per transaction).
-max_batch_bytes = {{ .Mempool.MaxBatchBytes }}
+max-batch-bytes = {{ .Mempool.MaxBatchBytes }}

 #######################################################
 ###         State Sync Configuration Options        ###
@@ -353,19 +353,19 @@ enable = {{ .StateSync.Enable }}
 # retrieval of state data for node bootstrapping. Also needs a trusted height and corresponding
 # header hash obtained from a trusted source, and a period during which validators can be trusted.
 #
-# For Cosmos SDK-based chains, trust_period should usually be about 2/3 of the unbonding time (~2
+# For Cosmos SDK-based chains, trust-period should usually be about 2/3 of the unbonding time (~2
 # weeks) during which they can be financially punished (slashed) for misbehavior.
-rpc_servers = "{{ StringsJoin .StateSync.RPCServers "," }}"
-trust_height = {{ .StateSync.TrustHeight }}
-trust_hash = "{{ .StateSync.TrustHash }}"
-trust_period = "{{ .StateSync.TrustPeriod }}"
+rpc-servers = "{{ StringsJoin .StateSync.RPCServers "," }}"
+trust-height = {{ .StateSync.TrustHeight }}
+trust-hash = "{{ .StateSync.TrustHash }}"
+trust-period = "{{ .StateSync.TrustPeriod }}"

 # Time to spend discovering snapshots before initiating a restore.
-discovery_time = "{{ .StateSync.DiscoveryTime }}"
+discovery-time = "{{ .StateSync.DiscoveryTime }}"

 # Temporary directory for state sync snapshot chunks, defaults to the OS tempdir (typically /tmp).
 # Will create a new, randomly named directory within, and remove it when done.
-temp_dir = "{{ .StateSync.TempDir }}"
+temp-dir = "{{ .StateSync.TempDir }}"

 #######################################################
 ###       Fast Sync Configuration Connections       ###
@@ -382,46 +382,46 @@ version = "{{ .FastSync.Version }}"
 #######################################################
 [consensus]

-wal_file = "{{ js .Consensus.WalPath }}"
+wal-file = "{{ js .Consensus.WalPath }}"

 # How long we wait for a proposal block before prevoting nil
-timeout_propose = "{{ .Consensus.TimeoutPropose }}"
-# How much timeout_propose increases with each round
-timeout_propose_delta = "{{ .Consensus.TimeoutProposeDelta }}"
+timeout-propose = "{{ .Consensus.TimeoutPropose }}"
+# How much timeout-propose increases with each round
+timeout-propose-delta = "{{ .Consensus.TimeoutProposeDelta }}"
 # How long we wait after receiving +2/3 prevotes for “anything” (ie. not a single block or nil)
-timeout_prevote = "{{ .Consensus.TimeoutPrevote }}"
-# How much the timeout_prevote increases with each round
-timeout_prevote_delta = "{{ .Consensus.TimeoutPrevoteDelta }}"
+timeout-prevote = "{{ .Consensus.TimeoutPrevote }}"
+# How much the timeout-prevote increases with each round
+timeout-prevote-delta = "{{ .Consensus.TimeoutPrevoteDelta }}"
 # How long we wait after receiving +2/3 precommits for “anything” (ie. not a single block or nil)
-timeout_precommit = "{{ .Consensus.TimeoutPrecommit }}"
-# How much the timeout_precommit increases with each round
-timeout_precommit_delta = "{{ .Consensus.TimeoutPrecommitDelta }}"
+timeout-precommit = "{{ .Consensus.TimeoutPrecommit }}"
+# How much the timeout-precommit increases with each round
+timeout-precommit-delta = "{{ .Consensus.TimeoutPrecommitDelta }}"
 # How long we wait after committing a block, before starting on the new
 # height (this gives us a chance to receive some more precommits, even
 # though we already have +2/3).
-timeout_commit = "{{ .Consensus.TimeoutCommit }}"
+timeout-commit = "{{ .Consensus.TimeoutCommit }}"

 # How many blocks to look back to check existence of the node's consensus votes before joining consensus
 # When non-zero, the node will panic upon restart
-# if the same consensus key was used to sign {double_sign_check_height} last blocks.
+# if the same consensus key was used to sign {double-sign-check-height} last blocks.
 # So, validators should stop the state machine, wait for some blocks, and then restart the state machine to avoid panic.
-double_sign_check_height = {{ .Consensus.DoubleSignCheckHeight }}
+double-sign-check-height = {{ .Consensus.DoubleSignCheckHeight }}

 # Make progress as soon as we have all the precommits (as if TimeoutCommit = 0)
-skip_timeout_commit = {{ .Consensus.SkipTimeoutCommit }}
+skip-timeout-commit = {{ .Consensus.SkipTimeoutCommit }}

 # EmptyBlocks mode and possible interval between empty blocks
-create_empty_blocks = {{ .Consensus.CreateEmptyBlocks }}
-create_empty_blocks_interval = "{{ .Consensus.CreateEmptyBlocksInterval }}"
+create-empty-blocks = {{ .Consensus.CreateEmptyBlocks }}
+create-empty-blocks-interval = "{{ .Consensus.CreateEmptyBlocksInterval }}"

 # Reactor sleep duration parameters
-peer_gossip_sleep_duration = "{{ .Consensus.PeerGossipSleepDuration }}"
-peer_query_maj23_sleep_duration = "{{ .Consensus.PeerQueryMaj23SleepDuration }}"
+peer-gossip-sleep-duration = "{{ .Consensus.PeerGossipSleepDuration }}"
+peer-query-maj23-sleep-duration = "{{ .Consensus.PeerQueryMaj23SleepDuration }}"

 #######################################################
 ###   Transaction Indexer Configuration Options     ###
 #######################################################
-[tx_index]
+[tx-index]

 # What indexer to use for transactions
 #
@@ -445,13 +445,13 @@ indexer = "{{ .TxIndex.Indexer }}"
 prometheus = {{ .Instrumentation.Prometheus }}

 # Address to listen for Prometheus collector(s) connections
-prometheus_listen_addr = "{{ .Instrumentation.PrometheusListenAddr }}"
+prometheus-listen-addr = "{{ .Instrumentation.PrometheusListenAddr }}"

 # Maximum number of simultaneous connections.
 # If you want to accept a larger number than the default, make sure
 # you increase your OS limits.
 # 0 - unlimited.
-max_open_connections = {{ .Instrumentation.MaxOpenConnections }}
+max-open-connections = {{ .Instrumentation.MaxOpenConnections }}

 # Instrumentation namespace
 namespace = "{{ .Instrumentation.Namespace }}"