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"
	// 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"
	// BatchNodeErrorOnAny controls batch request error detection for JSON-RPC batch requests
	BatchNodeErrorOnAnyFlag = "batch-node-error-on-any"

	// UseStaticSpecFlag allows loading specs from various sources instead of the blockchain.
	// This flag can be specified multiple times to aggregate specs from multiple sources.
	// Later sources override earlier ones for the same chain ID (last-wins).
	//
	// Supported formats:
	//   - Local file:      --use-static-spec ./specs/eth.json
	//   - Local directory: --use-static-spec ./specs/mainnet-1/specs/
	//   - GitHub URL:      --use-static-spec https://github.com/owner/repo/tree/branch/path/to/specs
	//   - GitLab URL:      --use-static-spec https://gitlab.com/owner/repo/-/tree/branch/path/to/specs
	//
	// Multiple local files can be specified either as separate flags or comma-separated:
	//   --use-static-spec file1.json --use-static-spec file2.json
	//   --use-static-spec file1.json,file2.json
	//
	// Example with multiple sources (order matters - later overrides earlier):
	//   --use-static-spec https://github.com/lavanet/lava/tree/main/specs \
	//   --use-static-spec https://gitlab.com/myorg/specs/-/tree/main \
	//   --use-static-spec ./local-overrides/
	//
	// For private GitHub/GitLab repositories, use the corresponding token flag.
	UseStaticSpecFlag = "use-static-spec"

	// GitHubTokenFlag is a GitHub personal access token for accessing private repositories.
	// Also provides higher API rate limits (5,000 requests/hour vs 60 for unauthenticated).
	// Required URL format: https://github.com/{owner}/{repo}/tree/{branch}/{path}
	// Example: --github-token ghp_xxxxxxxxxxxx
	GitHubTokenFlag = "github-token"

	// GitLabTokenFlag is a GitLab personal access token for accessing private repositories.
	// Supports both gitlab.com and self-hosted GitLab instances.
	// The token must have at least "Reporter" role with "read_repository" scope.
	// Required URL format: https://gitlab.com/{owner}/{repo}/-/tree/{branch}/{path}
	// Example: --gitlab-token glpat-xxxxxxxxxxxx
	GitLabTokenFlag = "gitlab-token"

	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"
	SkipRelaySigningFlag                         = "skip-relay-signing" // skip signing relay requests/responses (for static providers to save CPU/memory)
	// specification default flags
	PeriodicProbeProvidersFlagName         = "enable-periodic-probe-providers"
	PeriodicProbeProvidersIntervalFlagName = "periodic-probe-providers-interval"

	// batch request size limit
	MaxBatchRequestSizeFlag        = "max-batch-request-size"
	DefaultMaxBatchRequestSize int = 0 // 0 means unlimited

	// DisableBatchRequestRetryFlag prevents batch requests from being retried on consumer/smartrouter side
	DisableBatchRequestRetryFlag = "disable-batch-request-retry"

	ShowProviderEndpointInMetricsFlagName = "show-provider-address-in-metrics"

	MemoryGCThresholdGBFlagName      = "memory-gc-threshold-gb"     // Memory GC threshold in GB (0 = disabled)
	MaxSessionsPerProviderFlagName   = "max-sessions-per-provider"  // Max number of sessions allowed per provider
	DefaultProcessingTimeoutFlagName = "default-processing-timeout" // default timeout for relay processing
)

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"
	CROSS_VALIDATION_HEADER_MAX_PARTICIPANTS    = "lava-cross-validation-max-participants"
	CROSS_VALIDATION_HEADER_AGREEMENT_THRESHOLD = "lava-cross-validation-agreement-threshold"
	CROSS_VALIDATION_ALL_PROVIDERS_HEADER_NAME  = "lava-cross-validation-all-providers"
	CROSS_VALIDATION_STATUS_HEADER_NAME         = "lava-cross-validation-status"
	CROSS_VALIDATION_AGREEING_PROVIDERS_HEADER  = "lava-cross-validation-agreeing-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 (
	// JSON-RPC error patterns
	JSONRPCMethodNotFound     = "method not found"
	JSONRPCMethodNotSupported = "method not supported"
	JSONRPCUnknownMethod      = "unknown method"
	JSONRPCMethodDoesNotExist = "method does not exist"
	JSONRPCInvalidMethod      = "invalid method"
	JSONRPCErrorCode          = "-32601" // JSON-RPC 2.0 method not found error code

	// Generic unsupported patterns (catch-all for "method X not supported" format)
	GenericNotSupported = "not supported"

	// REST API error patterns
	RESTEndpointNotFound = "endpoint not found"
	RESTRouteNotFound    = "route not found"
	RESTPathNotFound     = "path not found"
	RESTMethodNotAllowed = "method not allowed"

	// gRPC error patterns
	GRPCMethodNotImplemented = "method not implemented"
	GRPCUnimplemented        = "unimplemented"
	GRPCNotImplemented       = "not implemented"
	GRPCServiceNotFound      = "service not found"

	// HTTP status codes for unsupported endpoints
	HTTPStatusNotFound         = 404
	HTTPStatusMethodNotAllowed = 405

	// JSON-RPC error code for method not found
	JSONRPCMethodNotFoundCode = -32601

	// JSON-RPC error code for invalid params
	JSONRPCInvalidParamsCode = -32602

	// Solana non-retryable error codes
	// - Error code -32009: Slot was skipped or missing in long-term storage (permanent)
	// Note: -32007 (ledger jump to snapshot) IS retryable as another provider may have the data
	SolanaMissingInLongTermStorageCode = -32009

	// Solana non-retryable error patterns (message-based)
	SolanaMissingInLongTermStorage = "missing in long-term storage"
)

const (
	// MaxIdleConns controls the maximum number of idle (keep-alive) connections across all hosts.
	// For 1000 req/s with ~500ms latency, we need ~500 concurrent connections.
	// Setting higher to allow headroom for spikes.
	// Go default: 100
	DefaultMaxIdleConns = 1000

	// 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.
	// For 1000 req/s to a single host with ~500ms latency, need ~500 idle connections.
	// Go default: 2 (way too low for high-concurrency!)
	DefaultMaxIdleConnsPerHost = 500

	// MaxConnsPerHost limits the total number of connections per host, including those in active use.
	// This is the CRITICAL limit - if too low, requests will queue and cause cascading latency.
	// For 1000 req/s with ~1s worst-case latency, need up to 1000 connections.
	// Go default: 0 (unlimited - can cause node overload)
	DefaultMaxConnsPerHost = 0 // unlimited - let the upstream node enforce its own limits

	// 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

	// DefaultTLSSessionCacheSize is the number of TLS session tickets to cache.
	// This enables TLS session resumption, which skips the expensive certificate
	// verification on subsequent connections to the same host.
	// Each cached session saves ~10-15% CPU on TLS handshakes.
	DefaultTLSSessionCacheSize = 1024
)

const (
	TimePerCU                           = uint64(100 * time.Millisecond)
	MinimumTimePerRelayDelay            = time.Second
	CacheWriteTimeout                   = 5 * time.Second
	AverageWorldLatency                 = 300 * time.Millisecond
	CommunicateWithLocalLavaNodeTimeout = (3 * time.Second) + AverageWorldLatency
	DefaultTimeoutSeconds               = 30 // default timeout in seconds, can be overridden by flag
	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
)