config

type ApiConfig struct {
	RootDir string `mapstructure:"home" toml:"home"`

	// TCP or UNIX socket address for the RPC server to listen on
	ListenAddress string `mapstructure:"laddr" toml:"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" toml:"cors_allowed_origins"`

	// A list of methods the client is allowed to use with cross-domain requests.
	CORSAllowedMethods []string `mapstructure:"cors_allowed_methods" toml:"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" toml:"cors_allowed_headers"`

	CORSAllowedCredentials bool `mapstructure:"cors_allowed_credentials" toml:"cors_allowed_credentials"`
	CORSAMaxAge            int  `mapstructure:"cors_max_age" toml:"cors_max_age"`

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

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

	// The number of events that can be buffered per subscription before
	// returning `ErrOutOfCapacity`.
	SubscriptionBufferSize int `mapstructure:"experimental_subscription_buffer_size" toml:"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" toml:"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" toml:"experimental_close_on_slow_client"`

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

	// Maximum size of request header, in bytes
	MaxHeaderBytes int `mapstructure:"max_header_bytes" toml:"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 aaexplorer 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 aaexplorer to create HTTPS server.
	// Otherwise, HTTP server is run.
	TLSCertFile string `mapstructure:"tls_cert_file" toml:"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 aaexplorer config directory.
	//
	// NOTE: both tls_cert_file and tls_key_file must be present for aaexplorer to create HTTPS server.
	// Otherwise, HTTP server is run.
	TLSKeyFile string `mapstructure:"tls_key_file" toml:"tls_key_file"`

	// no set no enable.
	// /debug/pprof/
	PprofPrefix string `mapstructure:"pprof_prefix" toml:"pprof_prefix"`

	Prefork bool `mapstructure:"prefork" toml:"prefork"`
}

type BaseConfig struct {

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

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

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

	MoralisApiKey string `mapstructure:"moralis_api_key" toml:"moralis_api_key"`

	Mode string `mapstructure:"mode" toml:"mode"`
}

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

	// Options for services
	Api       *ApiConfig       `mapstructure:"api" toml:"api"`
	Databases []*DbConfig      `mapstructure:"databases" toml:"databases"`
	EvmParser *EvmParserConfig `mapstructure:"evmparser" toml:"evmparser"`
	MemoCache *MemoConfig      `mapstructure:"memoCache" toml:"memoCache"`
	Task      *TaskConfig      `mapstructure:"task" toml:"task" json:"task"`
}

type DbConfig struct {
	Group           string            `mapstructure:"group" toml:"group"`
	Schema          *ent.SchemaConfig `mapstructure:"schema" toml:"schema"`
	Type            string            `mapstructure:"type" toml:"type"`
	Host            string            `mapstructure:"host" toml:"host"`
	Port            int               `mapstructure:"port" toml:"port"`
	User            string            `mapstructure:"user" toml:"user"`
	Pass            string            `mapstructure:"pass" toml:"pass"`
	Name            string            `mapstructure:"name" toml:"name"`
	ApplicationName string            `mapstructure:"applicationName" toml:"applicationName"`
	MaxIdleCount    int               `mapstructure:"maxIdleCount" toml:"maxIdleCount"`
	MaxOpenConns    int               `mapstructure:"maxOpenConns" toml:"maxOpenConns"`
	MaxLifetime     int64             `mapstructure:"maxLifetime" toml:"maxLifetime"`
	Debug           bool              `mapstructure:"debug" toml:"debug"`
	AutoStart       bool              `mapstructure:"autoStart" toml:"autoStart"`
	SslMode         string            `mapstructure:"sslMode" toml:"sslMode"`
}

type EvmParserConfig struct {
	StartBlock map[string]int64 `mapstructure:"startBlock" toml:"startBlock"` // -1 start by latest , 0 start by first , >0 start by set
	Multi      int              `mapstructure:"multi" toml:"multi"`
	Batch      int              `mapstructure:"batch" toml:"batch"`
}

type MemoConfig struct {
	// NumCounters determines the number of counters (keys) to keep that hold
	// access frequency information. It's generally a good idea to have more
	// counters than the max cache capacity, as this will improve eviction
	// accuracy and subsequent hit ratios.
	//
	// For example, if you expect your cache to hold 1,000,000 items when full,
	// NumCounters should be 10,000,000 (10x). Each counter takes up roughly
	// 3 bytes (4 bits for each counter * 4 copies plus about a byte per
	// counter for the bloom filter). Note that the number of counters is
	// internally rounded up to the nearest power of 2, so the space usage
	// may be a little larger than 3 bytes * NumCounters.
	NumCounters int64
	// MaxCost can be considered as the cache capacity, in whatever units you
	// choose to use.
	//
	// For example, if you want the cache to have a max capacity of 100MB, you
	// would set MaxCost to 100,000,000 and pass an item's number of bytes as
	// the `cost` parameter for calls to Set. If new items are accepted, the
	// eviction process will take care of making room for the new item and not
	// overflowing the MaxCost value.
	MaxCost int64
	// BufferItems determines the size of Get buffers.
	//
	// Unless you have a rare use case, using `64` as the BufferItems value
	// results in good performance.
	BufferItems int64
	// Metrics determines whether cache statistics are kept during the cache's
	// lifetime. There *is* some overhead to keeping statistics, so you should
	// only set this flag to true when testing or throughput performance isn't a
	// major factor.
	Metrics bool

	// IgnoreInternalCost set to true indicates to the cache that the cost of
	// internally storing the value should be ignored. This is useful when the
	// cost passed to set is not using bytes as units. Keep in mind that setting
	// this to true will increase the memory usage.
	IgnoreInternalCost bool
}

type TaskConfig struct {
	Networks         []string `mapstructure:"networks" toml:"networks" json:"networks"`
	BlockScanThreads int      `mapstructure:"blockScanThreads" toml:"blockScanThreads" json:"blockScanThreads"`
}