config

type AppConfig struct {
	GrpcListenAddress  string `mapstructure:"grpc_listen_addr"`
	HTTPListenAddress  string `mapstructure:"http_listen_addr"`
	AdminListenAddress string `mapstructure:"admin_listen_addr"`
	PrivateKeyPath     string `mapstructure:"private_key_path"`

	// PostgreSQL DB settings. DBName is the name if the PostgreSQL database to
	// connect to. The different data stores (e.g. engine, acct store, event
	// store, etc.) are all in the same database. Assuming "kwild" is the
	// DBName, this would be created with psql with the commands:
	//  CREATE USER kwild WITH SUPERUSER REPLICATION;
	//  CREATE DATABASE kwild OWNER kwild;
	//
	// All of these settings are strings and separate, but it is possible to
	// have a single DB "connection string" to pass to the PostgreSQL backend.
	// However, this is less error prone, and prevents passing settings that
	// would alter the functionality of the connection. An advanced option could
	// be added to supplement the conn string if that seems useful.
	DBHost string `mapstructure:"pg_db_host"`
	DBPort string `mapstructure:"pg_db_port"`
	DBUser string `mapstructure:"pg_db_user"`
	DBPass string `mapstructure:"pg_db_pass"`
	DBName string `mapstructure:"pg_db_name"`

	ExtensionEndpoints []string                     `mapstructure:"extension_endpoints"`
	TLSCertFile        string                       `mapstructure:"tls_cert_file"`
	TLSKeyFile         string                       `mapstructure:"tls_key_file"`
	EnableRPCTLS       bool                         `mapstructure:"rpctls"`
	Hostname           string                       `mapstructure:"hostname"`
	ProfileMode        string                       `mapstructure:"profile_mode"`
	ProfileFile        string                       `mapstructure:"profile_file"`
	Extensions         map[string]map[string]string `mapstructure:"extensions"`
}

type BlockParams struct {
	MaxBytes int64 `json:"max_bytes"`
	MaxGas   int64 `json:"max_gas"`
}

type ChainConfig struct {
	Moniker string `mapstructure:"moniker"`

	RPC       *ChainRPCConfig  `mapstructure:"rpc"`
	P2P       *P2PConfig       `mapstructure:"p2p"`
	Mempool   *MempoolConfig   `mapstructure:"mempool"`
	StateSync *StateSyncConfig `mapstructure:"statesync"`
	Consensus *ConsensusConfig `mapstructure:"consensus"`
}

type ChainRPCConfig struct {
	// TCP or UNIX socket address for the RPC server to listen on
	ListenAddress string `mapstructure:"listen_addr"`
}

type ConsensusConfig struct {
	// TimeoutPropose is how long to wait for a proposal block before prevoting
	// nil.
	TimeoutPropose Duration `mapstructure:"timeout_propose"`
	// TimeoutPrevote is how long to wait after receiving +2/3 prevotes for
	// “anything” (i.e. not a single block or nil).
	TimeoutPrevote Duration `mapstructure:"timeout_prevote"`
	// TimeoutPrecommit is how long we wait after receiving +2/3 precommits for
	// “anything” (i.e. not a single block or nil).
	TimeoutPrecommit Duration `mapstructure:"timeout_precommit"`
	// TimeoutCommit is how long to 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).
	TimeoutCommit Duration `mapstructure:"timeout_commit"`
}

type ConsensusParams struct {
	Block     BlockParams     `json:"block"`
	Evidence  EvidenceParams  `json:"evidence"`
	Version   VersionParams   `json:"version"`
	Validator ValidatorParams `json:"validator"`
	Votes     VoteParams      `json:"votes"`

	WithoutNonces   bool `json:"without_nonces"`
	WithoutGasCosts bool `json:"without_gas_costs"`
}

type Duration time.Duration

type EvidenceParams struct {
	MaxAgeNumBlocks int64         `json:"max_age_num_blocks"`
	MaxAgeDuration  time.Duration `json:"max_age_duration"`
	MaxBytes        int64         `json:"max_bytes"`
}

type GenesisAlloc map[string]*big.Int

type GenesisConfig struct {
	GenesisTime   time.Time    `json:"genesis_time"`
	ChainID       string       `json:"chain_id"`
	InitialHeight int64        `json:"initial_height"`
	DataAppHash   []byte       `json:"app_hash"`
	Alloc         GenesisAlloc `json:"alloc,omitempty"`

	/*
	 TODO: Can introduce app state later if needed. Used to specify raw initial state such as tokens etc,
	 abci init will generate a new app hash after applying this state
	*/
	// AppState json.RawMessage `json:"app_state"`
	ConsensusParams *ConsensusParams    `json:"consensus_params,omitempty"`
	Validators      []*GenesisValidator `json:"validators,omitempty"`
}

type GenesisValidator struct {
	PubKey HexBytes `json:"pub_key"`
	Power  int64    `json:"power"`
	Name   string   `json:"name"`
}

type HexBytes = types.HexBytes

type KwildConfig struct {
	RootDir string

	AppCfg   *AppConfig   `mapstructure:"app"`
	ChainCfg *ChainConfig `mapstructure:"chain"`
	Logging  *Logging     `mapstructure:"log"`
}

type Logging struct {
	Level        string   `mapstructure:"level"`
	Format       string   `mapstructure:"format"`
	TimeEncoding string   `mapstructure:"time_format"`
	OutputPaths  []string `mapstructure:"output_paths"`
}

type MempoolConfig struct {
	// Maximum number of transactions in the mempool
	Size int `mapstructure:"size"`
	// Size of the cache (used to filter transactions we saw earlier) in transactions
	CacheSize int `mapstructure:"cache_size"`

	// MaxTxBytes limits the size of any one transaction in mempool.
	MaxTxBytes int `mapstructure:"max_tx_bytes"`

	// MaxTxsBytes limits 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 int `mapstructure:"max_txs_bytes"`
}

type P2PConfig struct {
	// ListenAddress is the address on which to listen for incoming connections.
	ListenAddress string `mapstructure:"listen_addr"`
	// ExternalAddress is the address to advertise to peers to dial us.
	ExternalAddress string `mapstructure:"external_address"`
	// PersistentPeers is a comma separated list of nodes to keep persistent
	// connections to.
	PersistentPeers string `mapstructure:"persistent_peers"`
	// AddrBookStrict enforces strict address routability rules. This must be
	// false for private or local networks.
	AddrBookStrict bool `mapstructure:"addr_book_strict"`
	// MaxNumInboundPeers is the maximum number of inbound peers.
	MaxNumInboundPeers int `mapstructure:"max_num_inbound_peers"`
	// MaxNumOutboundPeers is the maximum number of outbound peers to connect
	// to, excluding persistent peers.
	MaxNumOutboundPeers int `mapstructure:"max_num_outbound_peers"`
	// UnconditionalPeerIDs are the node IDs to which a connection will be
	// (re)established ignoring any existing limits.
	UnconditionalPeerIDs string `mapstructure:"unconditional_peer_ids"`
	// PexReactor enables the peer-exchange reactor.
	PexReactor bool `mapstructure:"pex"`
	// AllowDuplicateIP permits peers connecting from the same IP.
	AllowDuplicateIP bool `mapstructure:"allow_duplicate_ip"`
	// HandshakeTimeout is the peer connection handshake timeout.
	HandshakeTimeout Duration `mapstructure:"handshake_timeout"`
	// DialTimeout is the peer connection establishment timeout.
	DialTimeout Duration `mapstructure:"dial_timeout"`
	// SeedMode makes the node constantly crawls the network looking for peers.
	// If another node asks it for addresses, it responds and disconnects.
	// Requires peer-exchange.
	SeedMode bool `mapstructure:"seed_mode"`
	// Seeds is a comma-separated separated list of seed nodes to query for peer
	// addresses. Only used if the peers in the address book are unreachable.
	Seeds string `mapstructure:"seeds"`
}

type SnapshotConfig struct {
	Enabled         bool   `mapstructure:"enabled"`
	RecurringHeight uint64 `mapstructure:"snapshot_heights"`
	MaxSnapshots    uint64 `mapstructure:"max_snapshots"`
	SnapshotDir     string `mapstructure:"snapshot_dir"`
}

type StateSyncConfig struct {
	Enable              bool     `mapstructure:"enable"`
	TempDir             string   `mapstructure:"temp_dir"`
	RPCServers          []string `mapstructure:"rpc_servers"`
	DiscoveryTime       Duration `mapstructure:"discovery_time"`
	ChunkRequestTimeout Duration `mapstructure:"chunk_request_timeout"`
}

type ValidatorParams struct {
	PubKeyTypes []string `json:"pub_key_types"`

	// JoinExpiry is the number of blocks after which the validators join
	// request expires if not approved.
	JoinExpiry int64 `json:"join_expiry"`
}

type VersionParams struct {
	App uint64 `json:"app"`
}

type VoteParams struct {
	// VoteExpiry is the number of blocks after which the resolution expires if
	// consensus is not reached.
	VoteExpiry int64 `json:"vote_expiry"`
}