config

type Config struct {
	// Id is the unique identifier for the node.
	Id string `yaml:"id"`

	// Logger holds the configuration for the logging system, including log level and environment.
	Logger Logger `yaml:"logger"`

	// Pprof is a list of pprof profiling configurations, each tied to a specific service or subsystem.
	Pprof []Pprof `yaml:"pprof"`

	// Observability holds all configurations related to metrics, tracing, and logging.
	Observability Observability `yaml:"observability"`

	// Mdbx contains the configuration for MDBX database nodes, including paths, sizes, and permissions.
	Mdbx Mdbx `yaml:"mdbx"`

	// Transports is a list of various transport configurations (e.g., Dummy, UDS, QUIC).
	// Each transport has its own specific configuration settings.
	Transports []Transport `yaml:"transports"`

	// Networking holds the configuration for the P2P networking.
	Networking Networking `yaml:"networking"`

	// Identity holds the configuration for the identity of the node.
	Identity Identity `yaml:"identity"`

	// Rpc holds the configuration for the RPC protocol.
	Rpc Rpc `yaml:"rpc"`
}

type DTLS struct {
	// Cert is the path to the certificate file used for DTLS encryption.
	Cert string `yaml:"cert" json:"cert" mapstructure:"cert"`

	// Key is the path to the private key file used for DTLS encryption.
	Key string `yaml:"key" json:"key" mapstructure:"key"`

	// RootCA is the path to the root CA file used to validate the peer's certificate.
	RootCA string `yaml:"root_ca" json:"root_ca" mapstructure:"root_ca"`

	// Insecure determines if the DTLS should skip certificate verification.
	Insecure bool `yaml:"insecure" json:"insecure" mapstructure:"insecure"`
}

type DummyTransport struct {
	// Type specifies the transport type, typically represented as types.DummyTransportType.
	Type types.TransportType `yaml:"type" json:"type" mapstructure:"type"`

	// Enabled determines whether this transport configuration is active.
	Enabled bool `yaml:"enabled" json:"enabled" mapstructure:"enabled"`

	// IPv4 defines the IPv4 address the dummy transport will bind to.
	IPv4 string `yaml:"ipv4" json:"ipv4" mapstructure:"ipv4"`

	// Port specifies the port on which the dummy transport will listen.
	Port int `yaml:"port" json:"port" mapstructure:"port"`

	// TLS holds the TLS configuration for the dummy transport.
	// Although this is typically not used in dummy transports, it allows for optional secure communication.
	TLS TLS `yaml:"tls" json:"tls" mapstructure:"tls"`
}

type Identity struct {
	Enabled  bool   `yaml:"enabled"`  // Enable or disable identity management
	BasePath string `yaml:"basePath"` // Base path for storing identity files
	Keys     []Key  `yaml:"keys"`     // List of keys used in identity management
}

type Key struct {
	Name            string                         `yaml:"name"`    // Name of the identity key
	Address         types.Address                  `yaml:"address"` // Hex-encoded address based on the signer that is used
	PeerID          peer.ID                        `yaml:"peerID"`  // Associated peer.ID
	PeerPrivateKey  string                         `yaml:"peerPrivateKey"`
	PeerPublicKey   string                         `yaml:"peerPublicKey"`
	Signers         map[types.SignerType]SignerKey `yaml:"signers"`          // Map of signer types to their keys
	Comment         string                         `yaml:"comment"`          // Optional comment
	ThresholdSigner *ThresholdSignerKey            `yaml:"thresholdSigners"` // Map identifier to ThresholdSignerKey
	RBAC            *KeyRoles                      `yaml:"rbac"`
}

type KeyRoles struct {
	Roles            []types.Role                      `yaml:"roles"`
	ExtraPermissions map[types.Role][]types.Permission `yaml:"extraPermissions"`
}

type Logger struct {
	// Enabled determines whether logging is enabled or disabled in the application.
	// If set to false, logging will be disabled.
	Enabled bool `yaml:"enabled"`

	// Environment defines the environment in which the application is running (e.g., "production" or "development").
	// This field can be used to adjust logging behavior based on the environment (e.g., verbose logging in development, minimal logging in production).
	Environment string `yaml:"environment"`

	// Level specifies the log level (e.g., "debug", "info", "warn", "error"). The log level controls
	// the verbosity of the log output, with higher levels (like "error") showing only critical messages.
	Level string `yaml:"level"`
}

type Mdbx struct {
	// Enabled determines if MDBX is enabled for the application.
	Enabled bool `yaml:"enabled"`

	// Nodes is a list of MDBX nodes. Each node contains its own configuration, allowing
	// multiple MDBX databases to be configured with different paths, sizes, and performance settings.
	Nodes []MdbxNode `yaml:"nodes"`
}

type MdbxNode struct {
	// Name is the identifier for the MDBX node, allowing the system to distinguish between multiple nodes.
	Name string `yaml:"name"`

	// Path specifies the file system path where the MDBX database files are stored.
	Path string `yaml:"path"`

	// MaxReaders defines the maximum number of readers allowed for the MDBX instance.
	// This controls how many concurrent read transactions can be active at the same time.
	MaxReaders int `yaml:"maxReaders"`

	// MaxSize defines the maximum size of the MDBX database in bytes. This is the upper limit
	// on the size the database can grow to on disk.
	MaxSize int64 `yaml:"maxSize"`

	// MinSize defines the minimum size of the MDBX database in bytes. The database will allocate
	// at least this amount of space on disk.
	MinSize int64 `yaml:"minSize"`

	// GrowthStep specifies the size in bytes by which the MDBX database will grow when it needs more space.
	// This controls how efficiently the database expands on disk.
	GrowthStep int64 `yaml:"growthStep"`

	// FilePermissions sets the file system permissions for the MDBX database files. It defaults to 0600,
	// which grants read and write access to the file owner only.
	FilePermissions uint `yaml:"filePermissions"`
}

type MetricsConfig struct {
	Enable         bool              `yaml:"enable"`
	Exporter       string            `yaml:"exporter"` // e.g., "otlp", "prometheus"
	Endpoint       string            `yaml:"endpoint"`
	Headers        map[string]string `yaml:"headers"`
	ExportInterval time.Duration     `yaml:"export_interval"`
	SampleRate     float64           `yaml:"sample_rate"` // For sampling strategies if applicable
}

type Networking struct {
	ListenAddrs    []string `yaml:"listenAddrs"`    // Addresses to listen on
	ProtocolID     string   `yaml:"protocolId"`     // Protocol ID for P2P communication
	PeerID         peer.ID  `yaml:"peerId"`         // PeerID for the node's identity (must be provided)
	BootstrapPeers []string `yaml:"bootstrapPeers"` // Bootstrap peers for discovery
	BootstrapNode  bool     `yaml:"bootstrapNode"`  // Indicates if this node should be a bootstrap node
	EnableMDNS     bool     `yaml:"mdns"`           // Enable mDNS for local peer discovery

	// Additional fields
	EnableRelay   bool   `yaml:"enableRelay"`    // Enable relay connections
	InterfaceName string `yaml:"interface_name"` // Network interface name for eBPF
}

type Observability struct {
	// MetricsConfig holds the configuration for metrics collection and exporting.
	Metrics MetricsConfig `yaml:"metrics"`

	// TracingConfig holds the configuration for tracing collection and exporting.
	Tracing TracingConfig `yaml:"tracing"`
}

type Pprof struct {
	// Enabled determines if pprof profiling is enabled for the service.
	Enabled bool `yaml:"enabled"`

	// Name is the name of the service that uses pprof for profiling.
	// This allows the configuration to be tied to a specific service.
	Name string `yaml:"name"`

	// Addr is the address where the pprof server will be hosted.
	// Typically, this will be in the form of an IP address and port (e.g., "127.0.0.1:6060").
	Addr string `yaml:"addr"`
}

type QuicTransport struct {
	// Type defines the transport type, typically represented as types.QUICTransportType.
	Type types.TransportType `yaml:"type" json:"type" mapstructure:"type"`

	// Enabled determines if the QUIC transport is enabled.
	Enabled bool `yaml:"enabled" json:"enabled" mapstructure:"enabled"`

	// IPv4 is the IPv4 address where the QUIC server or client will bind.
	IPv4 string `yaml:"ipv4" json:"ipv4" mapstructure:"ipv4"`

	// Port is the port number on which the QUIC transport will operate.
	Port int `yaml:"port" json:"port" mapstructure:"port"`

	// TLS holds the TLS configuration for the QUIC transport, as QUIC requires
	// TLS for secure communication.
	TLS TLS `yaml:"tls" json:"tls" mapstructure:"tls"`
}

type Rpc struct {
	Transport   TcpTransport `yaml:"transport" json:"transport" mapstructure:"transport"`
	PoolMaxSize int          `yaml:"poolMaxSize" json:"pool_size" mapstructure:"pool_size"`
}

type SignerKey struct {
	SigningPrivateKey string `yaml:"privateKey"` // Hex-encoded private key
	SigningPublicKey  string `yaml:"publicKey"`  // Hex-encoded public key
}

type TLS struct {
	// Insecure determines whether to skip verifying the server's TLS certificate.
	Insecure bool `yaml:"insecure"`

	// Cert is the path to the TLS certificate used for encryption.
	Cert string `json:"cert"`

	// Key is the path to the private key corresponding to the TLS certificate.
	Key string `json:"key"`

	// RootCA is the path to the Root Certificate Authority used for validating the server's TLS certificate.
	RootCA string `json:"rootCa"`
}

type TcpTransport struct {
	// Type defines the transport type, typically represented as types.TCPTransportType.
	Type types.TransportType `yaml:"type" json:"type" mapstructure:"type"`

	// Enabled determines if the TCP transport is enabled.
	Enabled bool `yaml:"enabled" json:"enabled" mapstructure:"enabled"`

	// IPv4 is the IPv4 address where the TCP server or client will bind.
	IPv4 string `yaml:"ipv4" json:"ipv4" mapstructure:"ipv4"`

	// Port is the port number on which the TCP transport will operate.
	Port int `yaml:"port" json:"port" mapstructure:"port"`

	// TLS holds the TLS configuration for the TCP transport, if TLS is required.
	TLS *TLS `yaml:"tls" json:"tls" mapstructure:"tls"`
}

type ThresholdSignerKey struct {
	Shares      map[int]string `yaml:"shares"`
	Threshold   int            `yaml:"threshold"`
	Commitments string         `yaml:"commitments"` // Add this field
}

type TracingConfig struct {
	Enable         bool              `yaml:"enable"`
	Exporter       string            `yaml:"exporter"` // e.g., "otlp", "jaeger"
	Endpoint       string            `yaml:"endpoint"`
	Headers        map[string]string `yaml:"headers"`
	Sampler        string            `yaml:"sampler"`       // e.g., "always_on", "probability"
	SamplingRate   float64           `yaml:"sampling_rate"` // Used if Sampler is "probability"
	ExportInterval time.Duration     `yaml:"export_interval"`
}

type Transport struct {
	// Type defines the type of transport being used (e.g., UDS, Dummy, QUIC).
	Type types.TransportType `yaml:"type"`

	// Enabled indicates whether the transport is enabled or disabled.
	Enabled bool `yaml:"enabled"`

	// Config holds the specific configuration for the given transport type.
	// This is populated dynamically based on the Type field during unmarshalling.
	Config TransportConfig `yaml:"-"`
}

type TransportConfig interface {
	// GetTransportType returns the type of transport (e.g., UDS, Dummy).
	GetTransportType() types.TransportType
}

type UdpTransport struct {
	// Type defines the transport type, typically represented as types.UDPTransportType.
	Type types.TransportType `yaml:"type" json:"type" mapstructure:"type"`

	// Enabled determines if the UDP transport is enabled.
	Enabled bool `yaml:"enabled" json:"enabled" mapstructure:"enabled"`

	// IPv4 is the IPv4 address where the UDP server or client will bind.
	IPv4 string `yaml:"ipv4" json:"ipv4" mapstructure:"ipv4"`

	// Port is the port number on which the UDP transport will operate.
	Port int `yaml:"port" json:"port" mapstructure:"port"`

	// DTLS holds the DTLS configuration for the UDP transport, if DTLS is required.
	DTLS *DTLS `yaml:"dtls" json:"dtls" mapstructure:"dtls"`
}

type UdsTransport struct {
	// Type defines the transport type, typically represented as types.TransportTypeUDS for UDS.
	Type types.TransportType `yaml:"type" json:"type" mapstructure:"type"`

	// Enabled determines if this transport configuration is active or not.
	Enabled bool `yaml:"enabled" json:"enabled" mapstructure:"enabled"`

	// Socket is the file path to the Unix Domain Socket. This field is required to establish
	// UDS communication, representing the location where the socket is created.
	Socket string `yaml:"socket" json:"socket" mapstructure:"socket"`
}