loop

type BrokerConfig = net.BrokerConfig

type CommitFactoryService struct {
	goplugin.PluginService[*CommitLoop, types.ReportingPluginFactory]
}

type CommitLoop struct {
	plugin.NetRPCUnsupportedPlugin

	BrokerConfig

	PluginServer types.CCIPCommitFactoryGenerator
	// contains filtered or unexported fields
}

type ContextValues struct {
	JobID   any
	JobName any

	ContractID    any
	FeedID        any
	TransmitterID any
}

type EnvConfig struct {
	AppID string

	DatabaseURL                          *config.SecretURL
	DatabaseIdleInTxSessionTimeout       time.Duration
	DatabaseLockTimeout                  time.Duration
	DatabaseQueryTimeout                 time.Duration
	DatabaseListenerFallbackPollInterval time.Duration
	DatabaseLogSQL                       bool
	DatabaseMaxOpenConns                 int
	DatabaseMaxIdleConns                 int
	DatabaseTracingEnabled               bool

	FeatureLogPoller bool

	MercuryCacheLatestReportDeadline time.Duration
	MercuryCacheLatestReportTTL      time.Duration
	MercuryCacheMaxStaleAge          time.Duration

	MercuryTransmitterProtocol             string
	MercuryTransmitterTransmitQueueMaxSize uint32
	MercuryTransmitterTransmitTimeout      time.Duration
	MercuryTransmitterTransmitConcurrency  uint32
	MercuryTransmitterReaperFrequency      time.Duration
	MercuryTransmitterReaperMaxAge         time.Duration
	MercuryVerboseLogging                  bool

	PrometheusPort int

	TracingEnabled         bool
	TracingCollectorTarget string
	TracingSamplingRatio   float64
	TracingTLSCertPath     string
	TracingAttributes      map[string]string

	TelemetryEnabled                   bool
	TelemetryEndpoint                  string
	TelemetryInsecureConnection        bool
	TelemetryCACertFile                string
	TelemetryAttributes                OtelAttributes
	TelemetryTraceSampleRatio          float64
	TelemetryAuthHeaders               map[string]string
	TelemetryAuthPubKeyHex             string
	TelemetryEmitterBatchProcessor     bool
	TelemetryEmitterExportTimeout      time.Duration
	TelemetryEmitterExportInterval     time.Duration
	TelemetryEmitterExportMaxBatchSize int
	TelemetryEmitterMaxQueueSize       int
	TelemetryLogStreamingEnabled       bool

	ChipIngressEndpoint           string
	ChipIngressInsecureConnection bool
}

type ErrorLog = core.ErrorLog

type ExecutionFactoryService struct {
	goplugin.PluginService[*ExecutionLoop, types.ReportingPluginFactory]
}

type ExecutionLoop struct {
	plugin.NetRPCUnsupportedPlugin

	BrokerConfig

	PluginServer types.CCIPExecutionFactoryGenerator
	// contains filtered or unexported fields
}

type GRPCOpts = loopnet.GRPCOpts

type GRPCOptsConfig struct {
	Registerer prometheus.Registerer // leave nil to use default prometheus.Registerer
}

type GRPCPluginKeystore struct {
	plugin.NetRPCUnsupportedPlugin

	BrokerConfig

	PluginServer keystorepb.GRPCService
	// contains filtered or unexported fields
}

type GRPCPluginMedian struct {
	plugin.NetRPCUnsupportedPlugin

	BrokerConfig

	PluginServer core.PluginMedian
	// contains filtered or unexported fields
}

type GRPCPluginMercury struct {
	plugin.NetRPCUnsupportedPlugin

	BrokerConfig

	PluginServer types.PluginMercury
	// contains filtered or unexported fields
}

type GRPCPluginRelayer struct {
	plugin.NetRPCUnsupportedPlugin

	BrokerConfig

	PluginServer PluginRelayer
	// contains filtered or unexported fields
}

type Keystore = core.Keystore

type KeystoreService struct {
	goplugin.PluginService[*GRPCPluginKeystore, keystore.GRPCService]
}

type LogMessageExtraArgs struct {
	Key   string      `json:"key"`
	Value interface{} `json:"value"`
}

type MedianService struct {
	goplugin.PluginService[*GRPCPluginMedian, types.ReportingPluginFactory]
}

type MercuryV1Service struct {
	goplugin.PluginService[*GRPCPluginMercury, types.MercuryPluginFactory]
}

type MercuryV2Service struct {
	goplugin.PluginService[*GRPCPluginMercury, types.MercuryPluginFactory]
}

type MercuryV3Service struct {
	goplugin.PluginService[*GRPCPluginMercury, types.MercuryPluginFactory]
}

type MercuryV4Service struct {
	goplugin.PluginService[*GRPCPluginMercury, types.MercuryPluginFactory]
}

type OtelAttributes = beholder.OtelAttributes

type Plugin struct {
	Logger logger.Logger
	// contains filtered or unexported fields
}

type PluginMedian = core.PluginMedian

type PluginRelayer = looptypes.PluginRelayer

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

type PromServerOpts struct {
	Handler http.Handler
}

type ProviderServer interface {
	Start(context.Context) error
	Close() error
	GetConn() (grpc.ClientConnInterface, error)
}

type Relayer = looptypes.Relayer

type RelayerService struct {
	goplugin.PluginService[*GRPCPluginRelayer, Relayer]
}

type ReportingPluginFactory = types.ReportingPluginFactory

type Server struct {
	EnvConfig EnvConfig
	GRPCOpts  GRPCOpts
	Logger    logger.SugaredLogger

	DataSource sqlutil.DataSource // optional

	LimitsFactory limits.Factory
	// contains filtered or unexported fields
}

type StandardCapabilities interface {
	services.Service
	Initialise(
		ctx context.Context,
		config string,
		telemetryService core.TelemetryService,
		store core.KeyValueStore,
		capabilityRegistry core.CapabilitiesRegistry,
		errorLog core.ErrorLog,
		pipelineRunner core.PipelineRunnerService,
		relayerSet core.RelayerSet,
		oracleFactory core.OracleFactory,
		gatewayConnector core.GatewayConnector,
		p2pKeystore core.Keystore,
	) error
	Infos(ctx context.Context) ([]capabilities.CapabilityInfo, error)
}

type StandardCapabilitiesLoop struct {
	Logger logger.Logger
	plugin.NetRPCUnsupportedPlugin
	BrokerConfig
	PluginServer StandardCapabilities
	// contains filtered or unexported fields
}

type StandardCapabilitiesService struct {
	goplugin.PluginService[*StandardCapabilitiesLoop, StandardCapabilities]
}

type TracingConfig struct {
	// NodeAttributes are the attributes to attach to traces.
	NodeAttributes OtelAttributes

	// Enables tracing; requires a collector to be provided
	Enabled bool

	// Collector is the address of the OTEL collector to send traces to.
	CollectorTarget string

	// SamplingRatio is the ratio of traces to sample. 1.0 means sample all traces.
	SamplingRatio float64

	// TLSCertPath is the path to the TLS certificate to use when connecting to the collector.
	TLSCertPath string

	// OnDialError is called when the dialer fails, providing an opportunity to log.
	OnDialError func(error)

	// Auth
	AuthHeaders map[string]string
}