config

type BaseConfig struct {
	// The version of the CometBFT binary that created
	// or last modified the config file
	Version string `mapstructure:"version"`

	// The root directory for all data.
	// This should be set in viper so it can unmarshal into this struct
	RootDir string `mapstructure:"home"`

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

	// A custom human readable name for this node
	Moniker string `mapstructure:"moniker"`

	// Database backend: badgerdb | goleveldb | pebbledb | rocksdb | cleveldb | boltdb
	// * badgerdb (uses github.com/dgraph-io/badger)
	//   - stable
	//   - pure go
	//   - use badgerdb build tag (go build -tags badgerdb)
	// * goleveldb (github.com/syndtr/goleveldb)
	//   - UNMAINTAINED
	//   - stable
	//   - pure go
	// * pebbledb (uses github.com/cockroachdb/pebble)
	//   - stable
	//   - pure go
	// * rocksdb (uses github.com/linxGnu/grocksdb)
	//   - requires gcc
	//   - use rocksdb build tag (go build -tags rocksdb)
	// * cleveldb (uses levigo wrapper)
	//   - DEPRECATED
	//   - requires gcc
	//   - use cleveldb build tag (go build -tags cleveldb)
	// * boltdb (uses etcd's fork of bolt - github.com/etcd-io/bbolt)
	//   - DEPRECATED
	//   - stable
	//   - use boltdb build tag (go build -tags boltdb)
	DBBackend string `mapstructure:"db_backend"`

	// Database directory
	DBPath string `mapstructure:"db_dir"`

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

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

	// Path to the JSON file containing the initial validator set and other meta data
	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"`

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

	// TCP or UNIX socket address for CometBFT to listen on for
	// connections from an external PrivValidator process
	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"`

	// 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

	// If set, run concurrent consensus instances and state machines
	// Multiplex options use an anonymous struct
	MultiplexConfig `mapstructure:",squash"`
}

type BlockSyncConfig struct {
	Version string `mapstructure:"version"`
}

type Config struct {
	// Top level options use an anonymous struct
	BaseConfig `mapstructure:",squash"`

	// Options for services
	RPC             *RPCConfig             `mapstructure:"rpc"`
	GRPC            *GRPCConfig            `mapstructure:"grpc"`
	P2P             *P2PConfig             `mapstructure:"p2p"`
	Mempool         *MempoolConfig         `mapstructure:"mempool"`
	StateSync       *StateSyncConfig       `mapstructure:"statesync"`
	BlockSync       *BlockSyncConfig       `mapstructure:"blocksync"`
	Consensus       *ConsensusConfig       `mapstructure:"consensus"`
	Storage         *StorageConfig         `mapstructure:"storage"`
	TxIndex         *TxIndexConfig         `mapstructure:"tx_index"`
	Instrumentation *InstrumentationConfig `mapstructure:"instrumentation"`
}

type ConsensusConfig struct {
	RootDir string `mapstructure:"home"`
	WalPath string `mapstructure:"wal_file"`

	// 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"`
	// 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"`
	// 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"`
	// 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
	// Set to 0 if you want to make progress as soon as the node has all the precommits.
	TimeoutCommit time.Duration `mapstructure:"timeout_commit"`

	// Deprecated: set `timeout_commit` to 0 instead.
	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"`

	// Reactor sleep duration parameters
	PeerGossipSleepDuration          time.Duration `mapstructure:"peer_gossip_sleep_duration"`
	PeerQueryMaj23SleepDuration      time.Duration `mapstructure:"peer_query_maj23_sleep_duration"`
	PeerGossipIntraloopSleepDuration time.Duration `mapstructure:"peer_gossip_intraloop_sleep_duration"` // upper bound on randomly selected values

	DoubleSignCheckHeight int64 `mapstructure:"double_sign_check_height"`
	// contains filtered or unexported fields
}

type DBContext struct {
	ID     string
	Config *Config
}

type DBProvider func(*DBContext) (dbm.DB, error)

type DataCompanionPruningConfig struct {
	// Whether automatic pruning respects values set by the data companion.
	// Disabled by default. All other parameters in this section are ignored
	// when this is disabled.
	//
	// If disabled, only the application retain height will influence block
	// pruning (but not block results pruning). Only enabling this at a later
	// stage will potentially mean that blocks below the application-set retain
	// height at the time will not be available to the data companion.
	Enabled bool `mapstructure:"enabled"`
	// The initial value for the data companion block retain height if the data
	// companion has not yet explicitly set one. If the data companion has
	// already set a block retain height, this is ignored.
	InitialBlockRetainHeight int64 `mapstructure:"initial_block_retain_height"`
	// The initial value for the data companion block results retain height if
	// the data companion has not yet explicitly set one. If the data companion
	// has already set a block results retain height, this is ignored.
	InitialBlockResultsRetainHeight int64 `mapstructure:"initial_block_results_retain_height"`
}

type ErrDeprecatedBlocksyncVersion struct {
	Version string
	Allowed []string
}

type ErrInSection struct {
	Err     error
	Section string
}

type ErrUnknownBlocksyncVersion struct {
	Version string
}

type FuzzConnConfig struct {
	Mode         int
	MaxDelay     time.Duration
	ProbDropRW   float64
	ProbDropConn float64
	ProbSleep    float64
}

type GRPCBlockResultsServiceConfig struct {
	Enabled bool `mapstructure:"enabled"`
}

type GRPCBlockServiceConfig struct {
	Enabled bool `mapstructure:"enabled"`
}

type GRPCConfig struct {
	// TCP or Unix socket address for the gRPC server to listen on. If empty,
	// the gRPC server will be disabled.
	ListenAddress string `mapstructure:"laddr"`

	// The gRPC version service provides version information about the node and
	// the protocols it uses.
	VersionService *GRPCVersionServiceConfig `mapstructure:"version_service"`

	// The gRPC block service provides block information
	BlockService *GRPCBlockServiceConfig `mapstructure:"block_service"`

	// The gRPC block results service provides the block results for a given height
	// If no height is provided, the block results of the latest height are returned
	BlockResultsService *GRPCBlockResultsServiceConfig `mapstructure:"block_results_service"`

	// The "privileged" section provides configuration for the gRPC server
	// dedicated to privileged clients.
	Privileged *GRPCPrivilegedConfig `mapstructure:"privileged"`
}

type GRPCPrivilegedConfig struct {
	// TCP or Unix socket address for the gRPC server for privileged clients
	// to listen on. If empty, the privileged gRPC server will be disabled.
	ListenAddress string `mapstructure:"laddr"`

	// The gRPC pruning service provides control over the depth of block
	// storage information that the node
	PruningService *GRPCPruningServiceConfig `mapstructure:"pruning_service"`
}

type GRPCPruningServiceConfig struct {
	Enabled bool `mapstructure:"enabled"`
}

type GRPCVersionServiceConfig struct {
	Enabled bool `mapstructure:"enabled"`
}

type InstrumentationConfig struct {
	// When true, Prometheus metrics are served under /metrics on
	// PrometheusListenAddr.
	// Check out the documentation for the list of available metrics.
	Prometheus bool `mapstructure:"prometheus"`

	// Address to listen for Prometheus collector(s) connections.
	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"`

	// Instrumentation namespace.
	Namespace string `mapstructure:"namespace"`
}

type MempoolConfig struct {
	// The type of mempool for this node to use.
	//
	//  Possible types:
	//  - "flood" : concurrent linked list mempool with flooding gossip protocol
	//  (default)
	//  - "nop"   : nop-mempool (short for no operation; the ABCI app is
	//  responsible for storing, disseminating and proposing txs).
	//  "create_empty_blocks=false" is not supported.
	Type string `mapstructure:"type"`
	// RootDir is the root directory for all data. This should be configured via
	// the $CMTHOME env variable or --home cmd flag rather than overriding this
	// struct field.
	RootDir string `mapstructure:"home"`
	// Recheck (default: true) defines whether CometBFT should recheck the
	// validity for all remaining transaction in the mempool after a block.
	// Since a block affects the application state, some transactions in the
	// mempool may become invalid. If this does not apply to your application,
	// you can disable rechecking.
	Recheck bool `mapstructure:"recheck"`
	// RecheckTimeout is the time the application has during the rechecking process
	// to return CheckTx responses, once all requests have been sent. Responses that
	// arrive after the timeout expires are discarded. It only applies to
	// non-local ABCI clients and when recheck is enabled.
	RecheckTimeout time.Duration `mapstructure:"recheck_timeout"`
	// Broadcast (default: true) defines whether the mempool should relay
	// transactions to other peers. Setting this to false will stop the mempool
	// from relaying transactions to other peers until they are included in a
	// block. In other words, if Broadcast is disabled, only the peer you send
	// the tx to will see it until it is included in a block.
	Broadcast bool `mapstructure:"broadcast"`
	// WalPath (default: "") configures the location of the Write Ahead Log
	// (WAL) for the mempool. The WAL is disabled by default. To enable, set
	// WalPath to where you want the WAL to be written (e.g.
	// "data/mempool.wal").
	WalPath string `mapstructure:"wal_dir"`
	// Maximum number of transactions in the mempool
	Size int `mapstructure:"size"`
	// Maximum size in bytes of a single transaction accepted into the mempool.
	MaxTxBytes int `mapstructure:"max_tx_bytes"`
	// The maximum size in bytes of all transactions stored in the mempool.
	// This is the raw, total transaction size. For example, given 1MB
	// transactions and a 5MB maximum mempool byte size, the mempool will
	// only accept five 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"`
	// Do not remove invalid transactions from the cache (default: false)
	// Set to true if it's not possible for any invalid transaction to become
	// valid again in the future.
	KeepInvalidTxsInCache bool `mapstructure:"keep-invalid-txs-in-cache"`
	// Experimental parameters to limit gossiping txs to up to the specified number of peers.
	// We use two independent upper values for persistent and non-persistent peers.
	// Unconditional peers are not affected by this feature.
	// If we are connected to more than the specified number of persistent peers, only send txs to
	// ExperimentalMaxGossipConnectionsToPersistentPeers of them. If one of those
	// persistent peers disconnects, activate another persistent peer.
	// Similarly for non-persistent peers, with an upper limit of
	// ExperimentalMaxGossipConnectionsToNonPersistentPeers.
	// If set to 0, the feature is disabled for the corresponding group of peers, that is, the
	// number of active connections to that group of peers is not bounded.
	// For non-persistent peers, if enabled, a value of 10 is recommended based on experimental
	// performance results using the default P2P configuration.
	ExperimentalMaxGossipConnectionsToPersistentPeers    int `mapstructure:"experimental_max_gossip_connections_to_persistent_peers"`
	ExperimentalMaxGossipConnectionsToNonPersistentPeers int `mapstructure:"experimental_max_gossip_connections_to_non_persistent_peers"`
}

type MultiplexConfig struct {
	// Strategy contains a replication mode which determines the *type* of node
	// that will be run with this multiplex instance.
	//
	// Note that when setting this value to "History", the node will *not*
	// synchronize with replicated chains but instead it will download snapshots
	// that contain historical data.
	//
	// Note that when setting this value to "Disable", the node will *not*
	// run concurrent instances using the multiplex and it will instead run the
	// legacy node implementation, without multiplex.
	//
	// More details about available values can be found in [ReplicationStrategy].
	Strategy ReplicationStrategy `mapstructure:"replication"`

	// SyncConfig contains *trust options* as required by state-sync, this
	// includes a trusted app hash and trusted height which are mapped to
	// a ChainID.
	// If the trust period is left empty, it will use the default trust period
	// of 168 hours (7 days).
	//
	// IMPORTANT: Both trusted values are required for state-sync.
	SyncConfig map[string]*StateSyncConfig `mapstructure:"sync_config"`

	// ChainSeeds contains comma-separeted seed nodes mapped to ChainIDs
	// such that these seed nodes are used when connecting to a network,
	// and permit to provide trusted values necessary to start state-sync.
	//
	// This configuration can be provided using a `seeds.json` file and/or
	// the `--seeds-file` option as implemented with the `cometbft init`
	// command. The list of seeds is required if you are trying to connect
	// to *existing* replicated chains.
	//
	// IMPORTANT: A minimum of 2 RPC servers are required for state-sync.
	ChainSeeds map[string]string `mapstructure:"chain_seeds"`

	// UserChains contains ChainID arrays, e.g. {"mx-chain-%address%-%scope%"}
	// mapped to user addresses such that state is replicated per-each chain
	// and consensus instances run concurrently on the node.
	UserChains map[string][]string `mapstructure:"user_chains"`

	// P2PStartPort contains a network port number which defaults to 30001
	// and which is used as the first node's P2P listen address port in the
	// multiplex. Other nodes in the multiplex *increment* this value by their
	// respective *index* in a slice of ChainIDs sorted lexicographically.
	P2PStartPort uint16 `mapstructure:"p2p_listen_port"`

	// RPCStartPort contains a network port number which defaults to 40001
	// and which is used as the first node's RPC listen address port in the
	// multiplex. Other nodes in the multiplex *increment* this value by their
	// respective *index* in a slice of ChainIDs sorted lexicographically.
	RPCStartPort uint16 `mapstructure:"p2p_listen_port"`

	// SnapshotOptions contains the configuration for state-sync snapshots
	// including the currently tracked *format*, blocks *interval* and the
	// *keep recent* option.
	//
	// This property maps snapshot options to a [ReplicationStrategy], thus
	// permitting to have different configuration for the *historical data*
	// snapshots and for the *network data* snapshots.
	SnapshotOptions map[ReplicationStrategy]SnapshotOptions `mapstructure:"snapshot_options"`
}

type P2PConfig struct {
	RootDir string `mapstructure:"home"`

	// Address to listen for incoming connections
	ListenAddress string `mapstructure:"laddr"`

	// Address to advertise to peers for them to dial
	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"`

	// Path to address book
	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"`

	// Maximum number of 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"`

	// List of node IDs, to which a connection will be (re)established ignoring any existing limits
	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"`

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

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

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

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

	// Set true to enable the peer-exchange reactor
	PexReactor bool `mapstructure:"pex"`

	// Seed mode, in which node constantly crawls the network and looks for
	// 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"`

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

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

	// Peer connection configuration.
	HandshakeTimeout time.Duration `mapstructure:"handshake_timeout"`
	DialTimeout      time.Duration `mapstructure:"dial_timeout"`

	// Testing params.
	// Force dial to fail
	TestDialFail bool `mapstructure:"test_dial_fail"`
	// Fuzz connection
	TestFuzz       bool            `mapstructure:"test_fuzz"`
	TestFuzzConfig *FuzzConnConfig `mapstructure:"test_fuzz_config"`
}

type PruningConfig struct {
	// The time period between automated background pruning operations.
	Interval time.Duration `mapstructure:"interval"`
	// Data companion-related pruning configuration.
	DataCompanion *DataCompanionPruningConfig `mapstructure:"data_companion"`
}

type RPCConfig struct {
	RootDir string `mapstructure:"home"`

	// TCP or UNIX socket address for the RPC server to listen on
	ListenAddress string `mapstructure:"laddr"`

	// A list of origins a cross-domain request can be executed from.
	// 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"`

	// A list of methods the client is allowed to use with cross-domain requests.
	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"`

	// Activate unsafe RPC commands like /dial_persistent_peers and /unsafe_flush_mempool
	Unsafe bool `mapstructure:"unsafe"`

	// Maximum number of simultaneous connections (including WebSocket).
	// 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"`

	// 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"`

	// Maximum number of unique queries a given client can /subscribe to. If
	// you're using /broadcast_tx_commit, set to the estimated maximum number
	// of broadcast_tx_commit calls per block.
	MaxSubscriptionsPerClient int `mapstructure:"max_subscriptions_per_client"`

	// The number of events that can be buffered per subscription before
	// returning `ErrOutOfCapacity`.
	SubscriptionBufferSize int `mapstructure:"experimental_subscription_buffer_size"`

	// The maximum number of responses that can be buffered per WebSocket
	// client. If clients cannot read from the WebSocket endpoint fast enough,
	// they will be disconnected, so increasing this parameter may reduce the
	// chances of them being disconnected (but will cause the node to use more
	// memory).
	//
	// Must be at least the same as `SubscriptionBufferSize`, otherwise
	// connections may be dropped unnecessarily.
	WebSocketWriteBufferSize int `mapstructure:"experimental_websocket_write_buffer_size"`

	// If a WebSocket client cannot read fast enough, at present we may
	// silently drop events instead of generating an error or disconnecting the
	// client.
	//
	// Enabling this parameter will cause the WebSocket connection to be closed
	// instead if it cannot read fast enough, allowing for greater
	// predictability in subscription behavior.
	CloseOnSlowClient bool `mapstructure:"experimental_close_on_slow_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"`

	// Maximum number of requests that can be sent in a batch
	// https://www.jsonrpc.org/specification#batch
	MaxRequestBatchSize int `mapstructure:"max_request_batch_size"`

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

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

	// The path to a file containing certificate that is used to create the HTTPS server.
	// Might be either absolute path or path related to CometBFT'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 CometBFT to create HTTPS server.
	// Otherwise, HTTP server is run.
	TLSCertFile string `mapstructure:"tls_cert_file"`

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

	// pprof listen address (https://golang.org/pkg/net/http/pprof)
	// FIXME: This should be moved under the instrumentation section
	PprofListenAddress string `mapstructure:"pprof_laddr"`
}

type ReplicationStrategy interface {
	fmt.Stringer
}

type ServiceProvider func(context.Context, *Config, log.Logger) (service.Service, error)

type SnapshotOptions struct {
	// Format defines the type of snapshot being taken.
	Format uint32 `mapstructure:"format"`

	// Interval defines at which heights the snapshot is taken.
	Interval uint64 `mapstructure:"interval"`

	// KeepRecent defines how many snapshots to keep in heights.
	KeepRecent uint32 `mapstructure:"keep_recent"`
}

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"`
	ChunkRequestTimeout time.Duration `mapstructure:"chunk_request_timeout"`
	ChunkFetchers       int32         `mapstructure:"chunk_fetchers"`
}

type StorageConfig struct {
	// Set to false to ensure ABCI responses are persisted. ABCI responses are
	// required for `/block_results` RPC queries, and to reindex events in the
	// command-line tool.
	DiscardABCIResponses bool `mapstructure:"discard_abci_responses"`
	// Configuration related to storage pruning.
	Pruning *PruningConfig `mapstructure:"pruning"`
	// Compaction on pruning - enable or disable in-process compaction.
	// If the DB backend supports it, this will force the DB to compact
	// the database levels and save on storage space. Setting this to true
	// is most beneficial when used in combination with pruning as it will
	// phyisically delete the entries marked for deletion.
	// false by default (forcing compaction is disabled).
	Compact bool `mapstructure:"compact"`
	// Compaction interval - number of blocks to try explicit compaction on.
	// This parameter should be tuned depending on the number of items
	// you expect to delete between two calls to forced compaction.
	// If your retain height is 1 block, it is too much of an overhead
	// to try compaction every block. But it should also not be a very
	// large multiple of your retain height as it might occur bigger overheads.
	// 1000 by default.
	CompactionInterval int64 `mapstructure:"compaction_interval"`

	// The representation of keys in the database.
	// The current representation of keys in Comet's stores is considered to be v1
	// Users can experiment with a different layout by setting this field to v2.
	// Not that this is an experimental feature and switching back from v2 to v1
	// is not supported by CometBFT.
	ExperimentalKeyLayout string `mapstructure:"experimental_db_key_layout"`
}

type TxIndexConfig struct {
	// What indexer to use for transactions
	//
	// Options:
	//   1) "null"
	//   2) "kv" (default) - the simplest possible indexer,
	//      backed by key-value storage (defaults to levelDB; see DBBackend).
	//   3) "psql" - the indexer services backed by PostgreSQL.
	Indexer string `mapstructure:"indexer"`

	// The PostgreSQL connection configuration, the connection format:
	// postgresql://<user>:<password>@<host>:<port>/<db>?<opts>
	PsqlConn string `mapstructure:"psql-conn"`

	// The PostgreSQL table that stores indexed blocks.
	TableBlocks string `mapstructure:"table_blocks"`
	// The PostgreSQL table that stores indexed transaction results.
	TableTxResults string `mapstructure:"table_tx_results"`
	// The PostgreSQL table that stores indexed events.
	TableEvents string `mapstructure:"table_events"`
	// The PostgreSQL table that stores indexed attributes.
	TableAttributes string `mapstructure:"table_attributes"`
}