dix

type BlockData struct {
	ID             string          `json:"number"`
	Timestamp      time.Time       `json:"timestamp"`
	Hash           string          `json:"hash"`
	ParentHash     string          `json:"parentHash"`
	StateRoot      string          `json:"stateRoot"`
	ExtrinsicsRoot string          `json:"extrinsicsRoot"`
	AuthorID       string          `json:"authorId"`
	Finalized      bool            `json:"finalized"`
	OnInitialize   json.RawMessage `json:"onInitialize"`
	OnFinalize     json.RawMessage `json:"onFinalize"`
	Logs           json.RawMessage `json:"logs"`
	Extrinsics     json.RawMessage `json:"extrinsics"`
	// Elastic scaling fields (available when useRcBlock parameter is used)
	RcBlockNumber *string `json:"rcBlockNumber,omitempty"`
	RcBlockHash   *string `json:"rcBlockHash,omitempty"`
}

type Bucket struct {
	// contains filtered or unexported fields
}

type BucketStats struct {
	Count, Failures int
	Avg, Min, Max   time.Duration
	Rate            float64
}

type ChainReader interface {
	GetChainHeadID() (int, error)
	FetchBlockRange(ctx context.Context, blockIDs []int) ([]BlockData, error)
	FetchBlock(ctx context.Context, id int) (BlockData, error)
	Ping() error
	GetStats() *MetricsStats
}

type Config struct {
	StartRange     int
	EndRange       int
	ChainReaderURL string
	DatabaseURL    string
	BatchSize      int
	MaxWorkers     int
	FlushTimeout   time.Duration
	Relaychain     string
	Chain          string
	Live           bool
	FrontendIP     string
	FrontendPort   int
	FrontendStatic string
}

type DBDialect string

type DBPoolConfig struct {
	MaxOpenConns    int           // Maximum number of open connections
	MaxIdleConns    int           // Maximum number of idle connections
	ConnMaxLifetime time.Duration // Maximum lifetime of a connection
	ConnMaxIdleTime time.Duration // Maximum idle time of a connection
}

type Database interface {
	CreateTable(relayChain, chain, firstTimestamp, lastTimestamp string) error
	CreateIndex(relayChain, chain string) error
	Save(items []BlockData, relayChain, chain string) error
	GetExistingBlocks(relayChain, chain string, startRange, endRange int) (map[int]bool, error)
	Ping() error
	GetStats() *MetricsStats
	DoUpgrade() error
	Close() error
	GetDatabaseInfo() ([]DatabaseInfo, error)
	ReadTimeNamedQuery(ctx context.Context, relayChain, chain, queryName string, year, month int) (time.Time, error)
	ExecuteNamedQuery(ctx context.Context, relayChain, chain, queryName string, year, month int) (SqlResult, error)
	ExecuteAndStoreNamedQuery(ctx context.Context, relayChain, chain, queryName string, year, month int) error
}

type DatabaseInfo struct {
	Relaychain string
	Chain      string
}

type DotidxBatch struct {
	StartRange   int      `toml:"start_range"`
	EndRange     int      `toml:"end_range"`
	BatchSize    int      `toml:"batch_size"`
	MaxWorkers   int      `toml:"max_workers"`
	FlushTimeout Duration `toml:"flush_timeout"`
}

type DotidxDB struct {
	Type          string   `toml:"type"`
	Version       int      `toml:"version"`
	Name          string   `toml:"name"`
	IP            string   `toml:"ip"`
	User          string   `toml:"user"`
	Port          int      `toml:"port"`
	Password      string   `toml:"password"`
	Memory        string   `toml:"memory"`
	Data          string   `toml:"data"`
	Run           string   `toml:"run"`
	WhitelistedIP []string `toml:"whitelisted_ip"`
}

type DotidxFE struct {
	IP         string `toml:"ip"`
	Port       int    `toml:"port"`
	StaticPath string `toml:"static_path"`
}

type Duration time.Duration

type EncodedBlock struct {
	Block struct {
		Header     EncodedHeader `json:"header"`
		Extrinsics []string      `json:"extrinsics"`
	} `json:"block"`
	Justifications any `json:"justifications"`
}

type EncodedDigest struct {
	Logs []string `json:"logs"`
}

type EncodedHeader struct {
	Number         string        `json:"number"`
	ParentHash     string        `json:"parentHash"`
	StateRoot      string        `json:"stateRoot"`
	ExtrinsicsRoot string        `json:"extrinsicsRoot"`
	Digest         EncodedDigest `json:"digest"`
}

type EventsBalance struct {
	// contains filtered or unexported fields
}

type EventsStaking struct {
	// contains filtered or unexported fields
}

type FallbackChainReader struct {
	// contains filtered or unexported fields
}

type FilesystemConfig struct {
	ZFS bool `toml:"zfs"`
}

type Filter interface {
	ProcessGJson(extrinsics json.RawMessage) (filtered json.RawMessage, err error)
	Process(extrinsics json.RawMessage) (filtered json.RawMessage, found bool, err error)
}

type Matcher struct {
	Address string
	Method  string
	Pallet  string
}

type Metrics struct {
	Buckets []*Bucket
}

type MetricsStats struct {
	BucketsStats [4]BucketStats
}

type MgrConfig struct {
	TargetDir             string                                `toml:"target_dir"`
	Name                  string                                `toml:"name"`
	UnixUser              string                                // Runtime: set from environment
	SystemMemoryGB        int                                   // Runtime: detected system memory in GB
	MaintenanceWorkMemory string                                // Runtime: calculated maintenance_work_mem
	MaxWalSize            string                                // Runtime: calculated max_wal_size
	DbCache               int                                   // Runtime: calculated db_cache
	RpcMaxConnections     int                                   // Runtime: calculated rpc_max_connections
	DotidxRoot            string                                `toml:"dotidx_root"`
	DotidxBackup          string                                `toml:"dotidx_backup"`
	DotidxRun             string                                `toml:"dotidx_run"`
	DotidxRuntime         string                                `toml:"dotidx_runtime"`
	DotidxLogs            string                                `toml:"dotidx_logs"`
	DotidxBin             string                                `toml:"dotidx_bin"`
	DotidxStatic          string                                `toml:"dotidx_static"`
	DotidxBatch           DotidxBatch                           `toml:"dotidx_batch"`
	DotidxDB              DotidxDB                              `toml:"dotidx_db"`
	DotidxFE              DotidxFE                              `toml:"dotidx_fe"`
	Parachains            map[string]map[string]ParaChainConfig `toml:"parachains"`
	Filesystem            FilesystemConfig                      `toml:"filesystem"`
	Monitoring            MonitoringConfig                      `toml:"monitoring"`
	Watcher               OrchestratorConfig                    `toml:"watcher"`
	Temporal              TemporalConfig                        `toml:"temporal"`
}

type MonitoringConfig struct {
	User           string `toml:"user"`
	PrometheusIP   string `toml:"prometheus_ip"`
	PrometheusPort int    `toml:"prometheus_port"`
	GrafanaIP      string `toml:"grafana_ip"`
	GrafanaPort    int    `toml:"grafana_port"`
}

type NamedQuery struct {
	Name        string
	SQLTemplate *template.Template
	Description string
}

type NamedQueryParameters struct {
	Relaychain string
	Chain      string
	Year       int
	Month      int
}

type OrchestratorConfig struct {
	WatchInterval    time.Duration `toml:"watch_interval"`
	MaxRestarts      int           `toml:"max_restarts"`
	RestartBackoff   time.Duration `toml:"restart_backoff"`
	OperationTimeout time.Duration `toml:"operation_timeout"`
}

type ParaChainConfig struct {
	Name                  string `toml:"name"`
	Bin                   string `toml:"bin"`
	PortRPC               int    `toml:"port_rpc"`
	PortWS                int    `toml:"port_ws"`
	Basepath              string `toml:"basepath"`
	ChainreaderIP         string `toml:"chainreader_ip"`
	ChainreaderPort       int    `toml:"chainreader_port"`
	SidecarIP             string `toml:"sidecar_ip"`
	SidecarPort           int    `toml:"sidecar_port"`
	SidecarPrometheusPort int    `toml:"sidecar_prometheus_port"`
	SidecarCount          int    `toml:"sidecar_count"`
	PrometheusPort        int    `toml:"prometheus_port"`
	RelayIP               string `toml:"relay_ip"`
	NodeIP                string `toml:"node_ip"`
	BootNodes             string `toml:"bootnodes"`
}

type RuntimeVersion struct {
	SpecName           string  `json:"specName"`
	SpecVersion        int     `json:"specVersion"`
	ImplName           string  `json:"implName"`
	ImplVersion        int     `json:"implVersion"`
	AuthoringVersion   int     `json:"authoringVersion"`
	TransactionVersion int     `json:"transactionVersion"`
	StateVersion       int     `json:"stateVersion"`
	APIs               [][]any `json:"apis"`
}

type SQLDatabase struct {
	// contains filtered or unexported fields
}

type ServiceHealthStatus string

type ServiceManager struct {
	RootNodes []*ServiceNode
	// contains filtered or unexported fields
}

type ServiceNode struct {
	Name        string // Logical name for this node
	SystemdUnit string // Actual systemd unit name (if this node is a manageable service)
	IsLeaf      bool   // True if this is a leaf node that should be directly managed/watched
	Children    []*ServiceNode
	// contains filtered or unexported fields
}

type Sidecar struct {
	// contains filtered or unexported fields
}

type SqlResult []map[string]interface{}

type SubstrateRPCReader struct {
	// contains filtered or unexported fields
}

type TemporalConfig struct {
	HostPort  string `toml:"hostport"`  // Temporal server address (e.g., "localhost:7233")
	Namespace string `toml:"namespace"` // Temporal namespace (e.g., "dotidx")
	TaskQueue string `toml:"taskqueue"` // Task queue name (e.g., "dotidx-watcher")
}