config

type AggregateStatsConfig struct{}

type AnalysisConfig struct {
	// Source is the configuration for accessing oasis-node(s).
	Source SourceConfig `koanf:"source"`

	// Analyzers is the analyzer configs.
	Analyzers AnalyzersList `koanf:"analyzers"`

	Storage *StorageConfig `koanf:"storage"`
}

type AnalyzersList struct {
	Consensus *BlockBasedAnalyzerConfig `koanf:"consensus"`
	Emerald   *BlockBasedAnalyzerConfig `koanf:"emerald"`
	Sapphire  *BlockBasedAnalyzerConfig `koanf:"sapphire"`
	Cipher    *BlockBasedAnalyzerConfig `koanf:"cipher"`

	EmeraldEvmTokens         *EvmTokensAnalyzerConfig       `koanf:"evm_tokens_emerald"`
	SapphireEvmTokens        *EvmTokensAnalyzerConfig       `koanf:"evm_tokens_sapphire"`
	EmeraldEvmTokenBalances  *EvmTokensAnalyzerConfig       `koanf:"evm_token_balances_emerald"`
	SapphireEvmTokenBalances *EvmTokensAnalyzerConfig       `koanf:"evm_token_balances_sapphire"`
	EmeraldContractCode      *EvmContractCodeAnalyzerConfig `koanf:"evm_contract_code_emerald"`
	SapphireContractCode     *EvmContractCodeAnalyzerConfig `koanf:"evm_contract_code_sapphire"`

	MetadataRegistry     *MetadataRegistryConfig     `koanf:"metadata_registry"`
	NodeStats            *NodeStatsConfig            `koanf:"node_stats"`
	AggregateStats       *AggregateStatsConfig       `koanf:"aggregate_stats"`
	EVMContractsVerifier *EVMContractsVerifierConfig `koanf:"evm_contracts_verifier"`
}

type ArchiveConfig struct {
	// DefaultNode is information about the node to get data from by default.
	DefaultNode *NodeConfig `koanf:"default"`
	// ConsensusNode is information about the node to get consensus data from,
	// instead of the default node.
	ConsensusNode *NodeConfig `koanf:"consensus"`
	// RuntimeNodes is the information about the nodes to get runtime data
	// from, instead of the default node.
	RuntimeNodes map[common.Runtime]*NodeConfig `koanf:"runtimes"`
}

type BlockBasedAnalyzerConfig struct {
	// From is the (inclusive) starting block for this analyzer.
	From uint64 `koanf:"from"`

	// If present, the analyzer will run in fast sync mode for
	// an initial range of blocks, and then switch to slow sync.
	// If absent, the analyzer will only run in "slow", sequential mode.
	//
	// If fast sync mode is enabled:
	// - DB checks and foreign keys are disabled.
	// - Multiple analyzers run in parallel and process blocks out of order.
	// - Analyzers do not perform dead reckoning on state (notably, transfers).
	// After all analyzers finish the fast sync range:
	// - DB checks and foreign keys are re-enabled.
	// - State that would normally be dead-reckoned is fetched directly from the node
	//   via the StateToGenesis() RPC, or recalculated from the relevant DB entries.
	// - A single "slow mode" analyzer (per runtime/consensus) is started, and resumes
	//   to process blocks sequentially, with dead reckoning enabled.
	FastSync *FastSyncConfig `koanf:"fast_sync"`

	// To is the (inclusive) ending block for this analyzer.
	// Omitting this parameter or setting it to 0 means this analyzer will
	// continue processing new blocks forever.
	To uint64 `koanf:"to"`

	// BatchSize determines the maximum number of blocks the block analyzer
	// processes per batch. This is relevant only when the analyzer is
	// still catching up to the latest block.
	// Optimal value depends on block processing speed. Ideally, it should
	// be set to the number of blocks processed within 30-60 seconds.
	//
	// Uses default value of 1000 if unset/set to 0.
	BatchSize uint64 `koanf:"batch_size"`
}

type BlockRange struct {
	From uint64 // Inclusive.
	To   uint64 // Inclusive.
}

type CacheConfig struct {
	// CacheDir is the directory where the cache data is stored
	CacheDir string `koanf:"cache_dir"`

	// If set, the analyzer will query the node upon any cache
	// misses.
	QueryOnCacheMiss bool `koanf:"query_on_cache_miss"`
}

type Config struct {
	Analysis *AnalysisConfig `koanf:"analysis"`
	Server   *ServerConfig   `koanf:"server"`
	Log      *LogConfig      `koanf:"log"`
	Metrics  *MetricsConfig  `koanf:"metrics"`
}

type CustomChainConfig struct {
	// History is the sequence of networks in the chain.
	History *History `koanf:"history"`
	// SDKNetwork is the oasis-sdk Network configuration of the latest
	// network in the chain.
	SDKNetwork *sdkConfig.Network `koanf:"sdk_network"`
}

type EVMContractsVerifierConfig struct {
	IntervalBasedAnalyzerConfig `koanf:",squash"`

	// ChainName is the name of the chain (e.g. mainnet/testnet).
	// The analyzer only supports testnet/mainnet chains.
	ChainName common.ChainName `koanf:"chain_name"`

	// SourcifyServerUrl is the base URL of the Sourcify server.
	SourcifyServerUrl string `koanf:"sourcify_server_url"`
}

type EvmContractCodeAnalyzerConfig struct{}

type EvmTokensAnalyzerConfig struct{}

type FastSyncConfig struct {
	// To is the block (inclusive) to which the analyzer
	// will run in fast sync mode. From this block onwards (exclusive),
	// the analyzer will run in slow mode.
	To uint64 `koanf:"to"`

	// The number of parallel analyzers to run in fast sync mode.
	Parallelism int `koanf:"parallelism"`
}

type History struct {
	Records []*Record `koanf:"records"`
}

type IntervalBasedAnalyzerConfig struct {
	// Interval is the time interval at which to run the analyzer.
	Interval time.Duration `koanf:"interval"`
}

type LogConfig struct {
	Format string `koanf:"format"`
	Level  string `koanf:"level"`
	File   string `koanf:"file"`
}

type MetadataRegistryConfig struct {
	IntervalBasedAnalyzerConfig `koanf:",squash"`
}

type MetricsConfig struct {
	PullEndpoint string `koanf:"pull_endpoint"`
}

type NodeConfig struct {
	// RPC is the node endpoint.
	RPC string `koanf:"rpc"`
}

type NodeStatsConfig struct {
	IntervalBasedAnalyzerConfig `koanf:",squash"`
}

type Record struct {
	ArchiveName   string `koanf:"archive_name"`
	GenesisHeight int64  `koanf:"genesis_height"`
	// RuntimeStartRounds has entries for runtimes that already exist at the
	// genesis of this network. Look these up in the genesis document's
	// .roothash.runtime_states[runtime_id_hex].round. For clarity, add an
	// entry stating round 0 in the first network where a runtime is available
	// (although code does not differentiate between the presence or absence
	// of a zero entry).
	RuntimeStartRounds map[common.Runtime]uint64 `koanf:"runtime_start_rounds"`
	ChainContext       string                    `koanf:"chain_context"`
}

type ServerConfig struct {
	// ChainName is the name of the chain (i.e. mainnet/testnet). Custom/local nets are not supported.
	// This is only used for the runtime status endpoint.
	ChainName common.ChainName `koanf:"chain_name"`

	// Endpoint is the service endpoint from which to serve the API.
	Endpoint string `koanf:"endpoint"`

	Storage *StorageConfig `koanf:"storage"`
}

type SourceConfig struct {
	// Cache holds the configuration for a file-based caching backend.
	Cache *CacheConfig `koanf:"cache"`

	// ChainName is the name of the chain (e.g. mainnet/testnet). Set
	// this to use one of the default chains.
	ChainName common.ChainName `koanf:"chain_name"`
	// CustomChain is information about a custom chain. Set this to use a
	// chain other than the default chains, e.g. a local testnet.
	CustomChain *CustomChainConfig `koanf:"custom_chain"`

	// Nodes describe the oasis-node(s) to connect to. Keys are "archive
	// names," which are named after mainnet releases, in lowercase e.g.
	// "cobalt" and "damask."
	Nodes map[string]*ArchiveConfig `koanf:"nodes"`

	// If set, the analyzer will skip some initial checks, e.g. that
	// `rpc` really serves the chain with the chain context we expect.
	// NOT RECOMMENDED in production; intended for faster testing.
	FastStartup bool `koanf:"fast_startup"`
}

type StorageBackend uint

type StorageConfig struct {
	// Endpoint is the storage endpoint from which to read/write indexed data.
	Endpoint string `koanf:"endpoint"`

	// Backend is the storage backend to select.
	Backend string `koanf:"backend"`

	// Migrations is the directory containing schema migrations.
	Migrations string `koanf:"migrations"`

	// If true, we'll first delete all tables in the DB to
	// force a full re-index of the blockchain.
	WipeStorage bool `koanf:"DANGER__WIPE_STORAGE_ON_STARTUP"`
}