common

const (
	RollingLogLevelFlag        = "rolling-log-level"
	RollingLogMaxSizeFlag      = "rolling-log-max-size"
	RollingLogMaxAgeFlag       = "rolling-log-max-age"
	RollingLogBackupsFlag      = "rolling-log-backups"
	RollingLogFileLocationFlag = "rolling-log-file-location"
	RollingLogFormat           = "rolling-log-format"
)

const (
	ProcessStartLogText = "Process Started"
	// cors related flags
	CorsHeadersFlag                 = "cors-headers"           // comma separated list of headers, or * for all, default simple cors specification headers
	CorsCredentialsFlag             = "cors-credentials"       // comma separated list of headers, or * for all, default simple cors specification headers
	CorsOriginFlag                  = "cors-origin"            // comma separated list of origins, or * for all, default enabled completely
	CorsMethodsFlag                 = "cors-methods"           // comma separated list of methods, default "GET,POST,PUT,DELETE,OPTIONS"
	CDNCacheDurationFlag            = "cdn-cache-duration"     // how long to cache the preflight response default 24 hours (in seconds) "86400"
	RelaysHealthEnableFlag          = "relays-health-enable"   // enable relays health check, default true
	RelayHealthIntervalFlag         = "relays-health-interval" // interval between each relay health check, default 5m
	SharedStateFlag                 = "shared-state"
	DisableConflictTransactionsFlag = "disable-conflict-transactions" // disable conflict transactions, this will hard the network's data reliability and therefore will harm the service.
	// Disable relay retries when we get node errors.
	// This feature is suppose to help with successful relays in some chains that return node errors on rare race conditions on the serviced chains.
	SetRelayCountOnNodeErrorFlag = "set-retry-count-on-node-error"
	UseStaticSpecFlag            = "use-static-spec" // allows the user to manually load a spec providing a path, this is useful to test spec changes before they hit the blockchain
	GitHubTokenFlag              = "github-token"    // GitHub personal access token for accessing private repositories and higher API rate limits
	EpochDurationFlag            = "epoch-duration"  // duration of each epoch for time-based epoch system (standalone mode)
	DefaultEpochDuration         = 30 * time.Minute  // default epoch duration for regular mode (if using time-based epochs)
	StandaloneEpochDuration      = 15 * time.Minute  // default epoch duration for standalone/static provider mode

	// optimizer flags
	SetProviderOptimizerBestTierPickChance       = "set-provider-optimizer-best-tier-pick-chance"
	SetProviderOptimizerWorstTierPickChance      = "set-provider-optimizer-worst-tier-pick-chance"
	SetProviderOptimizerNumberOfTiersToCreate    = "set-provider-optimizer-number-of-tiers-to-create"
	SetProviderOptimizerNumberOfProvidersPerTier = "set-provider-optimizer-number-of-providers-per-tier"
	// If we have 4 providers for a specific chain, we will put 1 provider in each tier, so we wont have all 4 in tier 1 (which makes no sense.)
	SetProviderOptimizerAutoAdjustTiers        = "enable-provider-optimizer-auto-adjustment-of-tiers"     // will auto adjust the tiers based on the number of providers in pairing
	SetProviderOptimizerQosSelectionInTierFlag = "set-provider-optimizer-qos-based-selection-within-tier" // enables QoS-based selection within tiers instead of stake-based selection

	// optimizer qos server flags
	OptimizerQosServerAddressFlag          = "optimizer-qos-server-address"    // address of the optimizer qos server to send the qos reports
	OptimizerQosListenFlag                 = "optimizer-qos-listen"            // enable listening for qos reports on metrics endpoint
	OptimizerQosServerPushIntervalFlag     = "optimizer-qos-push-interval"     // interval to push the qos reports to the optimizer qos server
	OptimizerQosServerSamplingIntervalFlag = "optimizer-qos-sampling-interval" // interval to sample the qos reports
	// websocket flags
	RateLimitWebSocketFlag                       = "rate-limit-websocket-requests-per-connection"
	BanDurationForWebsocketRateLimitExceededFlag = "ban-duration-for-websocket-rate-limit-exceeded"
	LimitParallelWebsocketConnectionsPerIpFlag   = "limit-parallel-websocket-connections-per-ip"
	LimitWebsocketIdleTimeFlag                   = "limit-websocket-connection-idle-time"
	RateLimitRequestPerSecondFlag                = "rate-limit-requests-per-second"
	SkipPolicyVerificationFlag                   = "skip-policy-verification"
	SkipWebsocketVerificationFlag                = "skip-websocket-verification"
	// specification default flags
	PeriodicProbeProvidersFlagName         = "enable-periodic-probe-providers"
	PeriodicProbeProvidersIntervalFlagName = "periodic-probe-providers-interval"

	ShowProviderEndpointInMetricsFlagName = "show-provider-address-in-metrics"
	EnableMemoryLogsFlag                  = "enable-memory-logs"     // enable memory tracking logs
	MemoryGCThresholdGBFlagName           = "memory-gc-threshold-gb" // Memory GC threshold in GB (0 = disabled)
)

const (
	CONSISTENCY_SELECT_ALL_PROVIDERS = 1
	NO_STATE                         = 0
)

const (
	// CompressionThreshold - only compress payloads larger than this (1 MB)
	// Small payloads have compression overhead > bandwidth savings
	CompressionThreshold = 1024 * 1024 * 1 // 1 MB

	// CompressionLevel - balance between speed and compression ratio
	// BestSpeed = 1 (fastest), BestCompression = 9 (smallest)
	// DefaultCompression = 6 (good balance)
	CompressionLevel = gzip.BestSpeed

	// LavaCompressionHeader - custom header to indicate manual compression
	LavaCompressionHeader = "lava-compression"
	LavaCompressionGzip   = "gzip"

	// LavaCompressionSupportHeader - custom header consumer sends to indicate it supports compression
	// This is different from grpc-accept-encoding which is always sent by gRPC
	LavaCompressionSupportHeader = "lava-compression-support"
)

const (
	PlainTextConnection                = "allow-plaintext-connection"
	EndpointsConfigName                = "endpoints"
	StaticProvidersConfigName          = "static-providers"
	BackupProvidersConfigName          = "backup-providers"
	SaveConfigFlagName                 = "save-conf"
	GeolocationFlag                    = "geolocation"
	TestModeFlagName                   = "test-mode"
	MaximumConcurrentProvidersFlagName = "concurrent-providers"
	StatusCodeMetadataKey              = "status-code"
	VersionMetadataKey                 = "lavap-version"
	LavaChainIdMetadataKey             = "lavap-chain-id"
	TimeOutForFetchingLavaBlocksFlag   = "timeout-for-fetching-lava-blocks"
)

const (
	URL_QUERY_PARAMETERS_SEPARATOR_FROM_PATH        = "?"
	URL_QUERY_PARAMETERS_SEPARATOR_OTHER_PARAMETERS = "&"
	IP_FORWARDING_HEADER_NAME                       = "X-Forwarded-For"
	PROVIDER_ADDRESS_HEADER_NAME                    = "Lava-Provider-Address"
	RETRY_COUNT_HEADER_NAME                         = "Lava-Retries"
	PROVIDER_LATEST_BLOCK_HEADER_NAME               = "Provider-Latest-Block"
	GUID_HEADER_NAME                                = "Lava-Guid"
	ERRORED_PROVIDERS_HEADER_NAME                   = "Lava-Errored-Providers"
	NODE_ERRORS_PROVIDERS_HEADER_NAME               = "Lava-Node-Errors-providers"
	REPORTED_PROVIDERS_HEADER_NAME                  = "Lava-Reported-Providers"
	USER_REQUEST_TYPE                               = "lava-user-request-type"
	STATEFUL_API_HEADER                             = "lava-stateful-api"
	STATEFUL_ALL_PROVIDERS_HEADER_NAME              = "lava-fast-tx-participants"
	REQUESTED_BLOCK_HEADER_NAME                     = "lava-parsed-requested-block"
	LAVA_IDENTIFIED_NODE_ERROR_HEADER               = "lava-identified-node-error"
	LAVAP_VERSION_HEADER_NAME                       = "Lavap-Version"
	LAVA_CONSUMER_PROCESS_GUID                      = "lava-consumer-process-guid"
	// these headers need to be lowercase
	BLOCK_PROVIDERS_ADDRESSES_HEADER_NAME = "lava-providers-block"
	RELAY_TIMEOUT_HEADER_NAME             = "lava-relay-timeout"
	EXTENSION_OVERRIDE_HEADER_NAME        = "lava-extension"
	FORCE_CACHE_REFRESH_HEADER_NAME       = "lava-force-cache-refresh"
	LAVA_DEBUG_RELAY                      = "lava-debug-relay"
	LAVA_LB_UNIQUE_ID_HEADER              = "lava-lb-unique-id"
	STICKINESS_HEADER_NAME                = "lava-stickiness"
	QUORUM_HEADER_RATE                    = "lava-quorum-rate"
	QUORUM_HEADER_MAX                     = "lava-quorum-max"
	QUORUM_HEADER_MIN                     = "lava-quorum-min"
	QUORUM_ALL_PROVIDERS_HEADER_NAME      = "lava-quorum-all-providers"
	// send http request to /lava/health to see if the process is up - (ret code 200)
	DEFAULT_HEALTH_PATH                                       = "/lava/health"
	MAXIMUM_ALLOWED_TIMEOUT_EXTEND_MULTIPLIER_BY_THE_CONSUMER = 4
)

const (
	// MaxIdleConns controls the maximum number of idle (keep-alive) connections across all hosts.
	// Setting this higher prevents constantly creating new TCP connections.
	// Go default: 100
	DefaultMaxIdleConns = 200

	// MaxIdleConnsPerHost controls the maximum idle (keep-alive) connections to keep per-host.
	// This is critical for blockchain node connections where we repeatedly connect to the same node.
	// Go default: 2 (way too low for high-concurrency!)
	DefaultMaxIdleConnsPerHost = 50

	// MaxConnsPerHost limits the total number of connections per host, including those in active use.
	// This prevents overwhelming a single blockchain node with too many connections.
	// Go default: 0 (unlimited - can cause node overload)
	DefaultMaxConnsPerHost = 100

	// IdleConnTimeout is the maximum amount of time an idle connection will remain idle before closing.
	// Keeps connections alive for reuse but eventually closes them to avoid resource leaks.
	// Go default: 90s
	DefaultIdleConnTimeout = 90 * time.Second

	// TLSHandshakeTimeout is the maximum amount of time waiting to perform a TLS handshake.
	// Go default: 10s
	DefaultTLSHandshakeTimeout = 10 * time.Second

	// ExpectContinueTimeout limits the time the client will wait between sending the request headers
	// and receiving the go-ahead to send the request body.
	// Go default: 1s
	DefaultExpectContinueTimeout = 1 * time.Second

	// ResponseHeaderTimeout is the amount of time to wait for a server's response headers.
	// This should be relatively high for blockchain nodes as they may be slow under load.
	// Go default: 0 (no timeout - can hang forever)
	DefaultResponseHeaderTimeout = 0

	// DialTimeout is the maximum amount of time a dial will wait for a connect to complete.
	// Go default: 30s
	DefaultDialTimeout = 10 * time.Second

	// KeepAlive specifies the interval between keep-alive probes for an active network connection.
	// Go default: 30s
	DefaultKeepAlive = 30 * time.Second

	// DefaultHTTPTimeout is the default timeout for the entire request/response cycle.
	// Set to 5 minutes to handle slow blockchain node operations like trace_block.
	// Go default: 0 (no timeout - requests can hang forever)
	DefaultHTTPTimeout = 5 * time.Minute
)

const (
	TimePerCU                           = uint64(100 * time.Millisecond)
	MinimumTimePerRelayDelay            = time.Second
	DataReliabilityTimeoutIncrease      = 5 * time.Second
	AverageWorldLatency                 = 300 * time.Millisecond
	CommunicateWithLocalLavaNodeTimeout = (3 * time.Second) + AverageWorldLatency
	DefaultTimeout                      = 30 * time.Second
	DefaultTimeoutLongIsh               = 1 * time.Minute
	DefaultTimeoutLong                  = 3 * time.Minute
	CacheTimeout                        = 50 * time.Millisecond
	// On subscriptions we must use context.Background(),
	// we cant have a context.WithTimeout() context, meaning we can hang for ever.
	// to avoid that we introduced a first reply timeout using a routine.
	// if the first reply doesn't return after the specified timeout a timeout error will occur
	SubscriptionFirstReplyTimeout = 10 * time.Second
)