diff --git a/core/capabilities/remote/executable/request/server_request.go b/core/capabilities/remote/executable/request/server_request.go index e64aa77c425..883993f77e1 100644 --- a/core/capabilities/remote/executable/request/server_request.go +++ b/core/capabilities/remote/executable/request/server_request.go @@ -396,7 +396,7 @@ func executeCapabilityRequest(ctx context.Context, lggr logger.Logger, capabilit // calling DON so it cannot be spoofed. All F+1 aggregated requests share this // payload (WorkflowDonID is part of the request hash), so a single check here // covers the quorum. The gate is guaranteed non-nil by NewServerRequest. - enabled, gerr := workflowDONBindingGate.Limit(ctx) + enabled, gerr := workflowDONBindingGate.IsOpen(ctx) if gerr != nil { lggr.Errorw("failed to evaluate workflow DON binding gate", "err", gerr) return nil, errors.New("failed to evaluate workflow DON binding gate") diff --git a/core/capabilities/vault/zone_b_restriction.go b/core/capabilities/vault/zone_b_restriction.go index 37ebe864dab..62dab90624a 100644 --- a/core/capabilities/vault/zone_b_restriction.go +++ b/core/capabilities/vault/zone_b_restriction.go @@ -69,7 +69,7 @@ func newZoneBRestrictor(lggr logger.Logger, limitsFactory limits.Factory, capabi // resolves to a zone-b DON. The owner is read from ctx, which must already carry // the (normalized) CRE owner via RequestMetadata.ContextWithCRE. func (z *zoneBRestrictor) enforce(ctx context.Context, workflowDonID uint32) error { - enabled, err := z.restrictEnabled.Limit(ctx) + enabled, err := z.restrictEnabled.IsOpen(ctx) if err != nil { return fmt.Errorf("could not evaluate zone-b vault read restriction gate: %w", err) } diff --git a/core/platform/monitoring.go b/core/platform/monitoring.go index 10324f87843..a37ff4909aa 100644 --- a/core/platform/monitoring.go +++ b/core/platform/monitoring.go @@ -10,6 +10,7 @@ const ( KeyCapabilityID = "capabilityID" KeyTriggerID = "triggerID" KeyTriggerDropReason = "dropReason" + KeyLimitKey = "limitKey" KeyWorkflowID = "workflowID" KeyWorkflowExecutionID = "workflowExecutionID" KeyWorkflowName = "workflowName" diff --git a/core/scripts/go.mod b/core/scripts/go.mod index 0788ad55fef..f85693394e5 100644 --- a/core/scripts/go.mod +++ b/core/scripts/go.mod @@ -38,7 +38,7 @@ require ( github.com/shopspring/decimal v1.4.0 github.com/smartcontractkit/chain-selectors v1.0.109 github.com/smartcontractkit/chainlink-ccip/chains/evm v0.0.0-20260908164107-3de1349d970b - github.com/smartcontractkit/chainlink-common v0.11.2-0.20260914191328-10cc2b41997e + github.com/smartcontractkit/chainlink-common v0.11.2-0.20260915135448-9ec0150ecb5d github.com/smartcontractkit/chainlink-common/keystore v1.3.1-0.20260903141829-ef07b52a737d github.com/smartcontractkit/chainlink-deployments-framework v0.122.2 github.com/smartcontractkit/chainlink-evm v0.3.4-0.20260914143713-424babc506ab diff --git a/core/scripts/go.sum b/core/scripts/go.sum index 5c6daee16df..3da6905ac55 100644 --- a/core/scripts/go.sum +++ b/core/scripts/go.sum @@ -1683,8 +1683,8 @@ github.com/smartcontractkit/chainlink-ccip/chains/solana/gobindings v0.0.0-20260 github.com/smartcontractkit/chainlink-ccip/chains/solana/gobindings v0.0.0-20260908155618-50f521d70e62/go.mod h1:c++Ed0jeYn4w8WIfiAboRwN6ClRRVGglL0qwB/QjJvM= github.com/smartcontractkit/chainlink-ccv v0.12.0 h1:/EbL7S96ItC3YF9pZ/fihbxugYxT1xxLSQSFJT4JQoQ= github.com/smartcontractkit/chainlink-ccv v0.12.0/go.mod h1:yijeTgli1K0e1noV/06/etKFxnYz8kBIe3IVXBaGnQw= -github.com/smartcontractkit/chainlink-common v0.11.2-0.20260914191328-10cc2b41997e h1:T9s34qknjJVSXBUeD0S/RoHu2t+iuoMiUOL0xdkQCk8= -github.com/smartcontractkit/chainlink-common v0.11.2-0.20260914191328-10cc2b41997e/go.mod h1:ks0kniCCg8Siv2XflmwLOq5ib9Ifoh6VHXHwfEWIMQA= +github.com/smartcontractkit/chainlink-common v0.11.2-0.20260915135448-9ec0150ecb5d h1:4heqJxOTXBHR3425SuXe9EzkZq+CqWOdKe4KWzAoGYA= +github.com/smartcontractkit/chainlink-common v0.11.2-0.20260915135448-9ec0150ecb5d/go.mod h1:ks0kniCCg8Siv2XflmwLOq5ib9Ifoh6VHXHwfEWIMQA= github.com/smartcontractkit/chainlink-common/keystore v1.3.1-0.20260903141829-ef07b52a737d h1:M9xuiIvdiHtim4nlxCVajyC/Mk63tAg9ESWb/biAhNA= github.com/smartcontractkit/chainlink-common/keystore v1.3.1-0.20260903141829-ef07b52a737d/go.mod h1:rI2njmTlyTvh+xhmORmK6qX3+V1ycDAqGJLu8LS8WpU= github.com/smartcontractkit/chainlink-common/pkg/chipingress v0.0.11-0.20260724142814-45996a1bcb72 h1:uWEwl7i2ryuRVoV4DmIKm6mqYevf1lH/8cQYhw/JXko= diff --git a/core/services/ocr2/plugins/vault/plugin.go b/core/services/ocr2/plugins/vault/plugin.go index 332f5ed5cc7..3d5db0faf3e 100644 --- a/core/services/ocr2/plugins/vault/plugin.go +++ b/core/services/ocr2/plugins/vault/plugin.go @@ -586,7 +586,7 @@ func (r *ReportingPlugin) prepareObservationPendingQueueBlobs( } func (r *ReportingPlugin) shouldPurgePendingQueue(ctx context.Context) bool { - if gateAllows(ctx, r.lggr, r.cfg.VaultForceEmptyOCRRounds, "VaultForceEmptyOCRRounds") { + if r.forceEmptyOCRRounds(ctx) { return true } stallThreshold, err := r.cfg.VaultPendingQueueStallThreshold.Limit(ctx) @@ -1289,7 +1289,7 @@ func (r *ReportingPlugin) ValidateObservation(ctx context.Context, seqNr uint64, readKV := NewReadStore(keyValueReader, r.metrics) var pendingQueueItems []*vaultcommon.StoredPendingQueueItem - if !gateAllows(ctx, r.lggr, r.cfg.VaultForceEmptyOCRRounds, "VaultForceEmptyOCRRounds") { + if !r.forceEmptyOCRRounds(ctx) { var err error pendingQueueItems, err = readKV.GetPendingQueue(ctx) if err != nil { @@ -1325,7 +1325,7 @@ func (r *ReportingPlugin) ValidateObservation(ctx context.Context, seqNr uint64, // This is because honest nodes may omit tail items when the full Observations proto would exceed the // max observation byte limit. // - that all pending queue items can be fetched as blobs. - if !gateAllows(ctx, r.lggr, r.cfg.VaultForceEmptyOCRRounds, "VaultForceEmptyOCRRounds") { + if !r.forceEmptyOCRRounds(ctx) { if err := r.validatePendingQueueObservationsPrefix(pendingQueueItems, obs); err != nil { return err } @@ -1434,7 +1434,7 @@ func (r *ReportingPlugin) ObservationQuorum(ctx context.Context, seqNr uint64, a return true, nil } - if gateAllows(ctx, r.lggr, r.cfg.VaultForceEmptyOCRRounds, "VaultForceEmptyOCRRounds") { + if r.forceEmptyOCRRounds(ctx) { return true, nil } diff --git a/core/services/ocr2/plugins/vault/plugin_utils.go b/core/services/ocr2/plugins/vault/plugin_utils.go index 1ab2bbb9932..53d6cc965d5 100644 --- a/core/services/ocr2/plugins/vault/plugin_utils.go +++ b/core/services/ocr2/plugins/vault/plugin_utils.go @@ -17,20 +17,6 @@ import ( "github.com/smartcontractkit/chainlink/v2/core/logger" ) -// gateAllows reports whether the given CRE gate allows the gated behavior. -// When evaluation errors for reasons other than ErrorNotAllowed, it logs an error and returns false. -func gateAllows(ctx context.Context, lggr logger.Logger, gate limits.GateLimiter, gateName string) bool { - err := gate.AllowErr(ctx) - if err == nil { - return true - } - if errors.Is(err, limits.ErrorNotAllowed{}) { - return false - } - lggr.Errorw("unexpected error evaluating CRE gate", "gate", gateName, "error", err) - return false -} - // resolveVaultOCRBoundLimitInt builds a short-lived BoundLimiter for an integer-sized CRE setting, reads Limit once, and closes the limiter. func resolveVaultOCRBoundLimitInt[I constraints.Integer]( ctx context.Context, @@ -183,6 +169,17 @@ func initializePluginLimits(ctx context.Context, limitsFactory limits.Factory) ( }, nil } +// forceEmptyOCRRounds reports whether the VaultForceEmptyOCRRounds gate is open, +// treating an unevaluatable gate as closed. +func (r *ReportingPlugin) forceEmptyOCRRounds(ctx context.Context) bool { + open, err := r.cfg.VaultForceEmptyOCRRounds.IsOpen(ctx) + if err != nil { + r.lggr.Errorw("unexpected error evaluating CRE gate", "gate", "VaultForceEmptyOCRRounds", "error", err) + return false + } + return open +} + func (r *ReportingPlugin) roundLggr(seqNr uint64) logger.Logger { return r.lggr.With("seqNr", seqNr) } diff --git a/core/services/workflows/monitoring/monitoring.go b/core/services/workflows/monitoring/monitoring.go index 2ae2b5b0199..1289af6952d 100644 --- a/core/services/workflows/monitoring/monitoring.go +++ b/core/services/workflows/monitoring/monitoring.go @@ -84,6 +84,9 @@ type EngineMetrics struct { donTimeErrorsCounter metric.Int64Counter orgIDMissingCounter metric.Int64Counter + + limitReadFallbackTotal metric.Int64Counter + limitCheckUnenforcedTotal metric.Int64Counter } func InitMonitoringResources() (em *EngineMetrics, err error) { @@ -449,6 +452,22 @@ func InitMonitoringResources() (em *EngineMetrics, err error) { return nil, fmt.Errorf("failed to register org id missing counter: %w", err) } + em.limitReadFallbackTotal, err = beholder.GetMeter().Int64Counter( + "platform_engine_limit_read_fallback_total", + metric.WithDescription("Limit reads that failed and fell back to the static default, by limitKey"), + ) + if err != nil { + return nil, fmt.Errorf("failed to register limit read fallback counter: %w", err) + } + + em.limitCheckUnenforcedTotal, err = beholder.GetMeter().Int64Counter( + "platform_engine_limit_check_unenforced_total", + metric.WithDescription("Limit checks that could not be evaluated, so the limit went unenforced (failed open), by limitKey"), + ) + if err != nil { + return nil, fmt.Errorf("failed to register limit check unenforced counter: %w", err) + } + return em, nil } @@ -823,3 +842,24 @@ func (c WorkflowsMetricLabeler) IncrementOrgIDMissingCounter(ctx context.Context otelLabels = append(otelLabels, attribute.String("reason", reason)) c.em.orgIDMissingCounter.Add(ctx, 1, metric.WithAttributes(otelLabels...)) } + +// IncrementLimitReadFallbackCounter records one limit read that failed and fell back +// to a default instead of dropping the execution/event. limitKey should be the +// canonical settings.Setting.Key for the limit that failed. +func (c WorkflowsMetricLabeler) IncrementLimitReadFallbackCounter(ctx context.Context, limitKey string) { + lc := c.With(platform.KeyLimitKey, limitKey) + otelLabels := beholder.OtelAttributes(lc.Labels).AsStringAttributes() + lc.em.limitReadFallbackTotal.Add(ctx, 1, metric.WithAttributes(otelLabels...)) +} + +// IncrementLimitCheckUnenforcedCounter records one limit Check that could not be +// evaluated (a settings read failure rather than the bound being exceeded), so the +// limit was skipped and the operation allowed through. Distinct from +// IncrementLimitReadFallbackCounter: there is no default to substitute here, the limit +// simply went unenforced, so a non-zero rate means a limit is not being applied. +// limitKey should be the canonical settings.Setting.Key for the limit that failed. +func (c WorkflowsMetricLabeler) IncrementLimitCheckUnenforcedCounter(ctx context.Context, limitKey string) { + lc := c.With(platform.KeyLimitKey, limitKey) + otelLabels := beholder.OtelAttributes(lc.Labels).AsStringAttributes() + lc.em.limitCheckUnenforcedTotal.Add(ctx, 1, metric.WithAttributes(otelLabels...)) +} diff --git a/core/services/workflows/v2/config.go b/core/services/workflows/v2/config.go index ab1d3eb1140..bfeecbe1153 100644 --- a/core/services/workflows/v2/config.go +++ b/core/services/workflows/v2/config.go @@ -4,6 +4,7 @@ import ( "context" "errors" "fmt" + "time" "github.com/jonboulle/clockwork" @@ -92,7 +93,7 @@ type EngineLimiters struct { TriggerRegistrationsTime limits.TimeLimiter TriggerSubscription limits.BoundLimiter[int] TriggerEventQueue limits.QueueLimiter[RoutedTriggerEvent] - TriggerEventQueueTime limits.TimeLimiter + TriggerEventQueueTimeout limits.BoundLimiter[time.Duration] ExecutionConcurrency limits.ResourcePoolLimiter[int] WASMBinarySize limits.BoundLimiter[config.Size] @@ -161,7 +162,7 @@ func (l *EngineLimiters) init(lf limits.Factory, cfgFn func(*cresettings.Workflo if err != nil { return err } - l.TriggerEventQueueTime, err = lf.MakeTimeLimiter(cfg.TriggerEventQueueTimeout) + l.TriggerEventQueueTimeout, err = limits.MakeUpperBoundLimiter(lf, cfg.TriggerEventQueueTimeout) if err != nil { return err } @@ -305,7 +306,7 @@ func (l *EngineLimiters) EvictWorkflow(workflowID string) error { l.TriggerRegistrationsTime, l.TriggerSubscription, l.TriggerEventQueue, - l.TriggerEventQueueTime, + l.TriggerEventQueueTimeout, l.ExecutionConcurrency, l.WASMBinarySize, l.WASMMemorySize, @@ -349,7 +350,7 @@ func (l *EngineLimiters) Close() error { l.TriggerRegistrationsTime, l.TriggerSubscription, l.TriggerEventQueue, - l.TriggerEventQueueTime, + l.TriggerEventQueueTimeout, l.ExecutionConcurrency, l.WASMBinarySize, l.WASMMemorySize, diff --git a/core/services/workflows/v2/engine.go b/core/services/workflows/v2/engine.go index bdeb1879864..69ed918dbf2 100644 --- a/core/services/workflows/v2/engine.go +++ b/core/services/workflows/v2/engine.go @@ -24,6 +24,7 @@ import ( "github.com/smartcontractkit/chainlink-common/pkg/aggregation" "github.com/smartcontractkit/chainlink-common/pkg/capabilities" + "github.com/smartcontractkit/chainlink-common/pkg/config" "github.com/smartcontractkit/chainlink-common/pkg/contexts" "github.com/smartcontractkit/chainlink-common/pkg/custmsg" "github.com/smartcontractkit/chainlink-common/pkg/logger" @@ -410,12 +411,19 @@ func (e *Engine) Put(ctx context.Context, event RoutedTriggerEvent) error { // t if event.ObservedAt.IsZero() { event.ObservedAt = e.cfg.Clock.Now() } - queueTimeout, err := e.cfg.LocalLimiters.TriggerEventQueueTime.Limit(ctx) + queueTimeout, err := e.cfg.LocalLimiters.TriggerEventQueueTimeout.Limit(ctx) if err != nil { - e.logger().Errorw("Failed to get trigger event queue time limit", "err", err) - tm := e.metrics.With(platform.KeyTriggerID, triggerID) - tm.IncrementTriggerEventDroppedTotal(ctx, monitoring.TriggerDropReasonQueueAgeLimitReadFailed) - return ErrEnqueueFailed + if !limits.IsErrRecoverable(err) { + // No value was resolved, so the deadline below would already be expired. + e.logger().Errorw("Failed to get trigger event queue time limit with no usable value", "err", err) + e.metrics.With(platform.KeyTriggerID, triggerID). + IncrementTriggerEventDroppedTotal(ctx, monitoring.TriggerDropReasonQueueAgeLimitReadFailed) + return ErrEnqueueFailed + } + // A settings read failure is not a reason to drop a customer's trigger event: + // the limiter still returns a usable timeout, so stamp the deadline and continue. + e.logger().Errorw("Failed to get trigger event queue time limit; continuing with the value the limiter returned", "err", err) + e.metrics.IncrementLimitReadFallbackCounter(ctx, cresettings.Default.PerWorkflow.TriggerEventQueueTimeout.Key) } event.Deadline = event.ObservedAt.Add(queueTimeout) @@ -940,6 +948,16 @@ func (e *Engine) startExecution(ctx context.Context, event RoutedTriggerEvent) e } }() + // emitDroppedExecution publishes the Started/Finished pair for an execution abandoned + // before the normal Started/Finished emit points below, so the failure reaches the UI + // instead of vanishing. + emitDroppedExecution := func(cause error, class events.ErrorClassification) { + executionStatus = store.StatusErrored + _ = events.EmitExecutionStartedEvent(ctx, loggerLabels, triggerEvent.ID, executionID) + _ = events.EmitExecutionFinishedEvent(ctx, loggerLabels, store.StatusErrored, executionID, cause, class, lggr) + e.metrics.IncrementWorkflowExecutionFinishedCounter(ctx, store.StatusErrored) + } + e.metrics.UpdateTotalWorkflowsGauge(ctx, executingWorkflows.Add(1)) defer e.metrics.UpdateTotalWorkflowsGauge(ctx, executingWorkflows.Add(-1)) @@ -962,11 +980,23 @@ func (e *Engine) startExecution(ctx context.Context, event RoutedTriggerEvent) e e.deductStandardBalances(ctx, meteringReport) } + // WithTimeout returns a usable ctx/cancel even on a read failure; err is advisory. execCtx, execCancel, err := e.cfg.LocalLimiters.ExecutionTime.WithTimeout(ctx) if err != nil { - lggr.Errorw("Failed to get execution time limit", "err", err) - triggerDrop(monitoring.TriggerDropReasonExecutionTimeLimitReadFailed) - return err + if !limits.IsErrRecoverable(err) { + lggr.Errorw("Failed to get execution time limit with no usable value", "err", err) + triggerDrop(monitoring.TriggerDropReasonExecutionTimeLimitReadFailed) + emitDroppedExecution(err, events.ErrorClassificationSystem) + if execCancel != nil { + execCancel() // WithTimeout may still have built a context + } + return err + } + lggr.Errorw("Failed to get execution time limit; continuing with the timeout the limiter returned", "err", err) + e.metrics.IncrementLimitReadFallbackCounter(ctx, cresettings.Default.PerWorkflow.ExecutionTimeout.Key) + if execCtx == nil { // only nil when the limiter is closed and no ctx was built + execCtx, execCancel = context.WithTimeout(ctx, cresettings.Default.PerWorkflow.ExecutionTimeout.DefaultValue) + } } defer execCancel() triggerCapID := event.TriggerCapID @@ -980,11 +1010,18 @@ func (e *Engine) startExecution(ctx context.Context, event RoutedTriggerEvent) e executionLogger := logger.With(lggr, "executionID", executionID, "triggerID", event.TriggerCapID, "triggerIndex", event.TriggerIndex, "eventID", triggerEvent.ID) + // This is only a peek to size the user-log channel's burst buffer; LogEvent.Check + // (called per log line in emitUserLogs) is what actually enforces the cap. maxUserLogEventsPerExecution, err := e.cfg.LocalLimiters.LogEvent.Limit(ctx) if err != nil { - lggr.Errorw("Failed to get log event limit", "err", err) - triggerDrop(monitoring.TriggerDropReasonLogEventLimitReadFailed) - return err + if !limits.IsErrRecoverable(err) { + lggr.Errorw("Failed to get log event limit with no usable value", "err", err) + triggerDrop(monitoring.TriggerDropReasonLogEventLimitReadFailed) + emitDroppedExecution(err, events.ErrorClassificationSystem) + return err + } + lggr.Errorw("Failed to get log event limit; continuing with the value the limiter returned", "err", err) + e.metrics.IncrementLimitReadFallbackCounter(ctx, cresettings.Default.PerWorkflow.LogEventLimit.Key) } userLogChan := make(chan *protoevents.LogLine, maxUserLogEventsPerExecution) defer close(userLogChan) @@ -996,6 +1033,7 @@ func (e *Engine) startExecution(ctx context.Context, event RoutedTriggerEvent) e if err != nil { executionLogger.Errorw("Failed to convert trigger index to uint64", "err", err) triggerDrop(monitoring.TriggerDropReasonTriggerIndexInvalid) + emitDroppedExecution(err, events.ErrorClassificationSystem) return err } @@ -1067,14 +1105,19 @@ func (e *Engine) startExecution(ctx context.Context, event RoutedTriggerEvent) e suspension := &suspensionTracker{} timeProvider = newMeasuredTimeProvider(timeProvider, e.cfg.Clock, suspension) + // Limit is always usable even on a read failure; err is advisory. moduleExecuteMaxResponseSizeBytes, err := e.cfg.LocalLimiters.ExecutionResponse.Limit(ctx) if err != nil { - lggr.Errorw("Failed to get execution response size limit", "err", err) - executionStatus = store.StatusErrored - execErr = err - execErrClass = events.ErrorClassificationSystem - triggerDrop(monitoring.TriggerDropReasonExecutionResponseLimitReadFailed) - return err + if !limits.IsErrRecoverable(err) { + execErr = fmt.Errorf("failed to get execution response size limit with no usable value: %w", err) + lggr.Errorw(execErr.Error()) + executionStatus = store.StatusErrored + execErrClass = events.ErrorClassificationSystem + triggerDrop(monitoring.TriggerDropReasonExecutionResponseLimitReadFailed) + return execErr + } + lggr.Errorw("Failed to get execution response size limit; continuing with the value the limiter returned", "err", err) + e.metrics.IncrementLimitReadFallbackCounter(ctx, cresettings.Default.PerWorkflow.ExecutionResponseLimit.Key) } if moduleExecuteMaxResponseSizeBytes < 0 { execErr = fmt.Errorf("invalid moduleExecuteMaxResponseSizeBytes; must not be negative: %d", moduleExecuteMaxResponseSizeBytes) @@ -1299,10 +1342,15 @@ func (e *Engine) deductStandardBalances(ctx context.Context, meteringReport *met // V2Engine runs the entirety of a module's execution as compute. Ensure that the max execution time can run. // Add an extra second of metering padding for context cancel propagation ctxCancelPadding := (time.Millisecond * 1000).Milliseconds() + // Limit is always usable even on a read failure; err is advisory. workflowExecutionTimeout, err := e.cfg.LocalLimiters.ExecutionTime.Limit(ctx) if err != nil { - e.logger().Errorw("Failed to get execution time limit", "err", err) - return + if !limits.IsErrRecoverable(err) { + e.logger().Errorw("Failed to get execution time limit with no usable value; skipping compute deduction", "err", err) + return + } + e.logger().Errorw("Failed to get execution time limit; continuing with the value the limiter returned", "err", err) + e.metrics.IncrementLimitReadFallbackCounter(ctx, cresettings.Default.PerWorkflow.ExecutionTimeout.Key) } compMs := decimal.NewFromInt(workflowExecutionTimeout.Milliseconds() + ctxCancelPadding) computeUnit := billing.ResourceType_RESOURCE_TYPE_COMPUTE.String() @@ -1327,22 +1375,22 @@ func (e *Engine) emitUserLogs(ctx context.Context, userLogChan chan *protoevents if e.cfg.DebugMode { e.logger().Debugf("User log: <<<%s>>>, local node timestamp: %s", logLine.Message, logLine.NodeTimestamp) } - err := e.cfg.LocalLimiters.LogEvent.Check(emitCtx, count) - if err != nil { + if err := e.cfg.LocalLimiters.LogEvent.Check(emitCtx, count); err != nil { if errBoundLimited, ok := errors.AsType[limits.ErrorBoundLimited[int]](err); ok { e.logger().Warnw("Max user log events per execution reached, dropping event", "maxEvents", errBoundLimited.Limit, "err", err) return false } - e.logger().Errorw("Failed to get user log event limit", "err", err) - return false + // A settings read failure should not stop the drain. Fail open instead. + e.logger().Errorw("Failed to check user log event limit; emitting anyway", "err", err) + e.metrics.IncrementLimitCheckUnenforcedCounter(emitCtx, cresettings.Default.PerWorkflow.LogEventLimit.Key) } - maxUserLogLength, err := e.cfg.LocalLimiters.LogLine.Limit(emitCtx) - if err != nil { - e.logger().Errorw("Failed to get user log line limit", "err", err) - return false - } - if len(logLine.Message) > int(maxUserLogLength) { - logLine.Message = logLine.Message[:maxUserLogLength] + " ...(truncated)" + if err := e.cfg.LocalLimiters.LogLine.Check(emitCtx, config.Size(len(logLine.Message))); err != nil { + if errBoundLimited, ok := errors.AsType[limits.ErrorBoundLimited[config.Size]](err); ok { + logLine.Message = logLine.Message[:errBoundLimited.Limit] + " ...(truncated)" + } else { + e.logger().Errorw("Failed to check user log line limit; emitting untruncated", "err", err) + e.metrics.IncrementLimitCheckUnenforcedCounter(emitCtx, cresettings.Default.PerWorkflow.LogLineLimit.Key) + } } if err := events.EmitUserLogs(emitCtx, executionLabels, []*protoevents.LogLine{logLine}, executionID); err != nil { @@ -1388,18 +1436,18 @@ func (e *Engine) emitUserLogs(ctx context.Context, userLogChan chan *protoevents } func (e *Engine) donTimeRequestTimeout(ctx context.Context, limiter limits.TimeLimiter) time.Duration { - defaultTimeout := cresettings.Default.PerWorkflow.DONTime.RequestTimeout.DefaultValue - if limiter != nil { - limit, err := limiter.Limit(ctx) - if err != nil { - e.logger().Errorw("Failed to get DON time request timeout", "err", err) - return defaultTimeout - } - if limit <= 0 { - e.logger().Warnw("DON time request timeout is less than or equal to 0, using default timeout", "defaultTimeout", defaultTimeout) - return defaultTimeout + if limiter == nil { + return cresettings.Default.PerWorkflow.DONTime.RequestTimeout.DefaultValue + } + // A zero timeout is a valid, explicitly configured limit and is honoured as-is. + limit, err := limiter.Limit(ctx) + if err != nil { + if !limits.IsErrRecoverable(err) { + e.logger().Errorw("Failed to get DON time request timeout with no usable value; using the compiled default", "err", err) + return cresettings.Default.PerWorkflow.DONTime.RequestTimeout.DefaultValue } - return limit + e.logger().Errorw("Failed to get DON time request timeout; continuing with the value the limiter returned", "err", err) + e.metrics.IncrementLimitReadFallbackCounter(ctx, cresettings.Default.PerWorkflow.DONTime.RequestTimeout.Key) } - return defaultTimeout + return limit } diff --git a/core/services/workflows/v2/engine_drop_paths_test.go b/core/services/workflows/v2/engine_drop_paths_test.go new file mode 100644 index 00000000000..6ac3e927827 --- /dev/null +++ b/core/services/workflows/v2/engine_drop_paths_test.go @@ -0,0 +1,404 @@ +package v2_test + +import ( + "context" + "errors" + "sync" + "testing" + "time" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + "github.com/stretchr/testify/require" + "google.golang.org/protobuf/proto" + + "github.com/smartcontractkit/chainlink-common/pkg/beholder/beholdertest" + "github.com/smartcontractkit/chainlink-common/pkg/capabilities" + "github.com/smartcontractkit/chainlink-common/pkg/config" + "github.com/smartcontractkit/chainlink-common/pkg/custmsg" + "github.com/smartcontractkit/chainlink-common/pkg/settings" + "github.com/smartcontractkit/chainlink-common/pkg/settings/limits" + regmocks "github.com/smartcontractkit/chainlink-common/pkg/types/core/mocks" + "github.com/smartcontractkit/chainlink-common/pkg/workflows/wasm/host" + modulemocks "github.com/smartcontractkit/chainlink-common/pkg/workflows/wasm/host/mocks" + sdkpb "github.com/smartcontractkit/chainlink-protos/cre/go/sdk" + pb "github.com/smartcontractkit/chainlink-protos/workflows/go/events" + eventsv2 "github.com/smartcontractkit/chainlink-protos/workflows/go/v2" + capmocks "github.com/smartcontractkit/chainlink/v2/core/capabilities/mocks" + workflowEvents "github.com/smartcontractkit/chainlink/v2/core/services/workflows/events" + metmocks "github.com/smartcontractkit/chainlink/v2/core/services/workflows/metering/mocks" + v2 "github.com/smartcontractkit/chainlink/v2/core/services/workflows/v2" + "github.com/smartcontractkit/chainlink/v2/core/utils/matches" +) + +const ( + v2ExecutionStartedEntity = "workflows.v2." + workflowEvents.WorkflowExecutionStarted + v2ExecutionFinishedEntity = "workflows.v2." + workflowEvents.WorkflowExecutionFinished + v1UserLogsEntity = "workflows.v1." + workflowEvents.UserLogs +) + +// failAfterNBoundLimiter succeeds (returning ok, nil) for the first n calls to Limit, +// then returns (ok, failErr) after that, mirroring the real chainlink-common +// BoundLimiter. LogEvent and ExecutionResponse are both peeked once during +// trigger-subscription init and again per execution, so an always-failing fake would +// break engine initialization before the value-on-error path could be exercised. +type failAfterNBoundLimiter[N limits.Number] struct { + mu sync.Mutex + calls int + n int + ok N + failErr error +} + +func (f *failAfterNBoundLimiter[N]) Limit(context.Context) (N, error) { + f.mu.Lock() + defer f.mu.Unlock() + f.calls++ + if f.calls > f.n { + return f.ok, f.failErr // resolved value, not zero; err is advisory + } + return f.ok, nil +} + +func (f *failAfterNBoundLimiter[N]) Check(context.Context, N) error { return nil } +func (f *failAfterNBoundLimiter[N]) Close() error { return nil } + +// alwaysFailTimeLimiter fails every Limit/WithTimeout call. Safe to use unconditionally +// for ExecutionTime, which is not read during trigger-subscription init. +type alwaysFailTimeLimiter struct{ err error } + +func (f *alwaysFailTimeLimiter) Limit(context.Context) (time.Duration, error) { return 0, f.err } + +func (f *alwaysFailTimeLimiter) WithTimeout(context.Context) (context.Context, func(), error) { + return nil, nil, f.err +} + +func (f *alwaysFailTimeLimiter) Close() error { return nil } + +// alwaysErrCheckLimiter fails every Check with a plain error, standing in for a settings +// read failure rather than the bound actually being exceeded (which would be an +// ErrorBoundLimited). Used to exercise the fail-open branches in processLogLine. +// +// Limit deliberately still succeeds: LogEvent.Limit is peeked during trigger-subscription +// init to size the user-log channel, so failing it too would break engine startup before +// the Check path under test is ever reached. +type alwaysErrCheckLimiter[N limits.Number] struct { + ok N + err error +} + +func (f *alwaysErrCheckLimiter[N]) Limit(context.Context) (N, error) { return f.ok, nil } +func (f *alwaysErrCheckLimiter[N]) Check(context.Context, N) error { return f.err } +func (f *alwaysErrCheckLimiter[N]) Close() error { return nil } + +// latestV2FinishedEvent returns the most recently emitted v2 WorkflowExecutionFinished +// event, or ok=false if none has been emitted yet. +func latestV2FinishedEvent(t *testing.T, observer beholdertest.Observer) (evt *eventsv2.WorkflowExecutionFinished, ok bool) { + t.Helper() + msgs := observer.Messages(t, "beholder_entity", v2ExecutionFinishedEntity) + if len(msgs) == 0 { + return nil, false + } + evt = &eventsv2.WorkflowExecutionFinished{} + require.NoError(t, proto.Unmarshal(msgs[len(msgs)-1].Body, evt)) + return evt, true +} + +// userLogLines returns every user log line emitted so far via the v1 UserLogs event. +func userLogLines(t *testing.T, observer beholdertest.Observer) []string { + t.Helper() + var lines []string + for _, msg := range observer.Messages(t, "beholder_entity", v1UserLogsEntity) { + var payload pb.UserLogs + if err := proto.Unmarshal(msg.Body, &payload); err != nil { + continue + } + for _, l := range payload.LogLines { + lines = append(lines, l.Message) + } + } + return lines +} + +// dropPathHarness is a minimal engine with a single trigger subscription (id_0) +// registered, ready to have a trigger event pushed through eventCh to drive +// startExecution. Callers customize cfg.LocalLimiters / cfg.ShardingEnabled / etc. +// via configure before the harness starts the engine, and set up the second +// Module.Execute expectation (for the per-execution call, if reached) themselves. +type dropPathHarness struct { + module *modulemocks.ModuleV2 + eventCh chan capabilities.TriggerResponse + executionFinishedCh chan string + beholderObserver beholdertest.Observer +} + +func newDropPathHarness(t *testing.T, billingClient *metmocks.BillingClient, configure func(cfg *v2.EngineConfig)) *dropPathHarness { + t.Helper() + + module := modulemocks.NewModuleV2(t) + module.EXPECT().Start() + module.EXPECT().Close() + capreg := regmocks.NewCapabilitiesRegistry(t) + capreg.EXPECT().LocalNode(matches.AnyContext).Return(newNode(t), nil) + + initDoneCh := make(chan error, 1) + subscribedToTriggersCh := make(chan []string, 1) + executionFinishedCh := make(chan string, 1) + + cfg := defaultTestConfig(t, nil) + cfg.Module = module + cfg.CapRegistry = capreg + cfg.BillingClient = billingClient + cfg.OrgResolver = &mockOrgResolver{orgID: "test-org-123"} + cfg.Hooks = v2.LifecycleHooks{ + OnInitialized: func(err error) { + initDoneCh <- err + }, + OnSubscribedToTriggers: func(triggerIDs []string) { + subscribedToTriggersCh <- triggerIDs + }, + OnExecutionFinished: func(executionID string, _ string) { + executionFinishedCh <- executionID + }, + } + beholderObserver := beholdertest.NewObserver(t) + cfg.BeholderEmitter = custmsg.NewLabeler() + + if configure != nil { + configure(cfg) + } + + // Trigger-subscription init always calls Module.Execute once for the Subscribe + // request, regardless of what's under test below. + module.EXPECT().Execute(matches.AnyContext, mock.Anything, mock.Anything).Return(newTriggerSubs(1), nil).Once() + trigger := capmocks.NewTriggerCapability(t) + capreg.EXPECT().GetTrigger(matches.AnyContext, "id_0").Return(trigger, nil) + eventCh := make(chan capabilities.TriggerResponse) + trigger.EXPECT().RegisterTrigger(matches.AnyContext, mock.Anything).Return(eventCh, nil).Once() + trigger.EXPECT().UnregisterTrigger(matches.AnyContext, mock.Anything).Return(nil).Once() + // Some drop paths return before the trigger event is ever ACKed, so this + // must not be a hard requirement across all harness users. + trigger.EXPECT().AckEvent(matches.AnyContext, mock.Anything, mock.Anything, mock.Anything).Return(nil).Maybe() + + engine, err := v2.NewEngine(cfg) + require.NoError(t, err) + require.NoError(t, engine.Start(t.Context())) + t.Cleanup(func() { require.NoError(t, engine.Close()) }) + + require.NoError(t, <-initDoneCh) + require.Equal(t, []string{"id_0"}, <-subscribedToTriggersCh) + + return &dropPathHarness{ + module: module, + eventCh: eventCh, + executionFinishedCh: executionFinishedCh, + beholderObserver: beholderObserver, + } +} + +// TestEngine_LimitReadFallback_ExecutesAnyway covers: an execution proceeds to +// completion (instead of being silently dropped) when a limit read fails, +// falling back to the setting's static default. +func TestEngine_LimitReadFallback_ExecutesAnyway(t *testing.T) { //nolint:paralleltest // uses beholdertest.NewObserver, a global singleton swap + testCases := map[string]func(cfg *v2.EngineConfig){ + "ExecutionTime": func(cfg *v2.EngineConfig) { + cfg.LocalLimiters.ExecutionTime = &alwaysFailTimeLimiter{err: errors.New("limit read boom")} + }, + "LogEvent": func(cfg *v2.EngineConfig) { + cfg.LocalLimiters.LogEvent = &failAfterNBoundLimiter[int]{n: 1, ok: 1000, failErr: errors.New("limit read boom")} + }, + "ExecutionResponse": func(cfg *v2.EngineConfig) { + cfg.LocalLimiters.ExecutionResponse = &failAfterNBoundLimiter[config.Size]{n: 1, ok: config.Size(10 * 1024 * 1024), failErr: errors.New("limit read boom")} + }, + } + + for name, breakLimiter := range testCases { //nolint:paralleltest // shares the package-level beholder singleton + t.Run(name, func(t *testing.T) { + billingClient := setupMockBillingClient(t) + harness := newDropPathHarness(t, billingClient, breakLimiter) + + harness.module.EXPECT().Execute(matches.AnyContext, mock.Anything, mock.Anything).Return(nil, nil).Once() + harness.eventCh <- capabilities.TriggerResponse{ + Event: capabilities.TriggerEvent{TriggerType: "basic-trigger@1.0.0", ID: "event_" + name}, + } + + executionID := <-harness.executionFinishedCh + require.NotEmpty(t, executionID) + + startedMsgs := harness.beholderObserver.Messages(t, "beholder_entity", v2ExecutionStartedEntity) + assert.NotEmpty(t, startedMsgs, "execution should still emit a Started event despite the limit read failure") + + evt, ok := latestV2FinishedEvent(t, harness.beholderObserver) + require.True(t, ok, "execution should still emit a Finished event despite the limit read failure") + assert.Equal(t, eventsv2.ExecutionStatus_EXECUTION_STATUS_SUCCEEDED, evt.Status) + }) + } +} + +// TestEngine_LimitReadNonRecoverable_Drops is the counterpart to +// TestEngine_LimitReadFallback_ExecutesAnyway. A limit read that leaves no usable value — +// ErrMissingTenant, i.e. the CRE context was never populated — is a programming error rather +// than a degraded settings service, so the engine must fail the execution loudly instead of +// enforcing the zero value it got back. +func TestEngine_LimitReadNonRecoverable_Drops(t *testing.T) { //nolint:paralleltest // uses beholdertest.NewObserver, a global singleton swap + missingTenant := limits.ErrMissingTenant{Scope: settings.ScopeWorkflow} + require.False(t, limits.IsErrRecoverable(missingTenant), "precondition") + + testCases := map[string]func(cfg *v2.EngineConfig){ + "ExecutionTime": func(cfg *v2.EngineConfig) { + cfg.LocalLimiters.ExecutionTime = &alwaysFailTimeLimiter{err: missingTenant} + }, + "LogEvent": func(cfg *v2.EngineConfig) { + cfg.LocalLimiters.LogEvent = &failAfterNBoundLimiter[int]{n: 1, ok: 1000, failErr: missingTenant} + }, + "ExecutionResponse": func(cfg *v2.EngineConfig) { + cfg.LocalLimiters.ExecutionResponse = &failAfterNBoundLimiter[config.Size]{n: 1, ok: config.Size(10 * 1024 * 1024), failErr: missingTenant} + }, + } + + for name, breakLimiter := range testCases { //nolint:paralleltest // shares the package-level beholder singleton + t.Run(name, func(t *testing.T) { + // No module.Execute expectation: the execution must never reach WASM. + harness := newDropPathHarness(t, setupMockBillingClient(t), breakLimiter) + + harness.eventCh <- capabilities.TriggerResponse{ + Event: capabilities.TriggerEvent{TriggerType: "basic-trigger@1.0.0", ID: "event_nonrecoverable_" + name}, + } + + var evt *eventsv2.WorkflowExecutionFinished + require.EventuallyWithT(t, func(c *assert.CollectT) { + got, ok := latestV2FinishedEvent(t, harness.beholderObserver) + if !assert.True(c, ok) { + return + } + evt = got + }, 5*time.Second, 50*time.Millisecond) + + assert.Equal(t, eventsv2.ExecutionStatus_EXECUTION_STATUS_FAILED, evt.Status, + "a programming error must not be papered over with the zero value") + assert.Equal(t, eventsv2.ClassifiedExecutionStatus_CLASSIFIED_EXECUTION_STATUS_SYSTEM_ERROR, evt.ClassifiedStatus, + "a missing tenant is our bug, not the user's") + }) + } +} + +// TestEngine_LimitReadFallback_UsesLimiterValue: on a read failure, the engine must use +// whatever value the limiter returns, not substitute its own compiled default. +func TestEngine_LimitReadFallback_UsesLimiterValue(t *testing.T) { //nolint:paralleltest // uses beholdertest.NewObserver, a global singleton swap + const resolvedValue = config.Size(12345) + + harness := newDropPathHarness(t, setupMockBillingClient(t), func(cfg *v2.EngineConfig) { + cfg.LocalLimiters.ExecutionResponse = &failAfterNBoundLimiter[config.Size]{n: 1, ok: resolvedValue, failErr: errors.New("limit read boom")} + }) + + var gotMaxResponseSize uint64 + harness.module.EXPECT().Execute(matches.AnyContext, mock.Anything, mock.Anything). + Run(func(_ context.Context, req *sdkpb.ExecuteRequest, _ host.ExecutionHelper) { + gotMaxResponseSize = req.MaxResponseSize + }). + Return(nil, nil).Once() + harness.eventCh <- capabilities.TriggerResponse{ + Event: capabilities.TriggerEvent{TriggerType: "basic-trigger@1.0.0", ID: "event_limiter_value"}, + } + + executionID := <-harness.executionFinishedCh + require.NotEmpty(t, executionID) + + assert.Equal(t, uint64(resolvedValue), gotMaxResponseSize, + "engine must use the value the limiter returned, not fall back to its own compiled default") +} + +// TestEngine_AdmissionDenial_StaysSilent is a regression guard: an admission layer (e.g. +// shard failover) denies the event on every node that does not own the workflow, so emitting +// Started/Finished there (unlike the other drop paths) would publish a DON-wide failure for a +// run that actually succeeded on the owner. This must stay silent. +func TestEngine_AdmissionDenial_StaysSilent(t *testing.T) { //nolint:paralleltest // uses beholdertest.NewObserver, a global singleton swap + billingClient := metmocks.NewBillingClient(t) // no billing calls expected: admission runs before metering + + harness := newDropPathHarness(t, billingClient, func(cfg *v2.EngineConfig) { + cfg.Hooks.OnTriggerAdmission = func(context.Context, v2.RoutedTriggerEvent) error { + return errors.New("not owned by this node") + } + }) + + harness.eventCh <- capabilities.TriggerResponse{ + Event: capabilities.TriggerEvent{TriggerType: "basic-trigger@1.0.0", ID: "event_admission_denied"}, + } + + require.Never(t, func() bool { + started := harness.beholderObserver.Messages(t, "beholder_entity", v2ExecutionStartedEntity) + finished := harness.beholderObserver.Messages(t, "beholder_entity", v2ExecutionFinishedEntity) + return len(started) > 0 || len(finished) > 0 + }, 500*time.Millisecond, 25*time.Millisecond) +} + +// TestEngine_UserLog_LogLineCheck covers the LogLine Limit()->Check() swap: the bound is +// now enforced by the limiter (so it records usage/denied), truncation is driven by the +// bound carried on the returned ErrorBoundLimited, and a settings read failure fails open +// by emitting the line untruncated instead of falling back to a hardcoded default. +func TestEngine_UserLog_LogLineCheck(t *testing.T) { //nolint:paralleltest // uses beholdertest.NewObserver, a global singleton swap + t.Run("over-long message truncated to the bound", func(t *testing.T) { //nolint:paralleltest // shares the package-level beholder singleton + harness := newDropPathHarness(t, setupMockBillingClient(t), func(cfg *v2.EngineConfig) { + cfg.LocalLimiters.LogLine = limits.NewUpperBoundLimiter[config.Size](10) + }) + + harness.module.EXPECT().Execute(matches.AnyContext, mock.Anything, mock.Anything). + Run(func(_ context.Context, _ *sdkpb.ExecuteRequest, executor host.ExecutionHelper) { + require.NoError(t, executor.EmitUserLog("0123456789ABCDEF")) + }). + Return(nil, nil).Once() + harness.eventCh <- capabilities.TriggerResponse{ + Event: capabilities.TriggerEvent{TriggerType: "basic-trigger@1.0.0", ID: "event_truncated"}, + } + + require.EventuallyWithT(t, func(c *assert.CollectT) { + assert.Contains(c, userLogLines(t, harness.beholderObserver), "0123456789 ...(truncated)") + }, 5*time.Second, 50*time.Millisecond) + }) + + t.Run("settings read failure emits untruncated", func(t *testing.T) { //nolint:paralleltest // shares the package-level beholder singleton + harness := newDropPathHarness(t, setupMockBillingClient(t), func(cfg *v2.EngineConfig) { + cfg.LocalLimiters.LogLine = &alwaysErrCheckLimiter[config.Size]{err: errors.New("settings unavailable")} + }) + + const message = "this message is not over any real bound" + harness.module.EXPECT().Execute(matches.AnyContext, mock.Anything, mock.Anything). + Run(func(_ context.Context, _ *sdkpb.ExecuteRequest, executor host.ExecutionHelper) { + require.NoError(t, executor.EmitUserLog(message)) + }). + Return(nil, nil).Once() + harness.eventCh <- capabilities.TriggerResponse{ + Event: capabilities.TriggerEvent{TriggerType: "basic-trigger@1.0.0", ID: "event_untruncated"}, + } + + require.EventuallyWithT(t, func(c *assert.CollectT) { + assert.Contains(c, userLogLines(t, harness.beholderObserver), message) + }, 5*time.Second, 50*time.Millisecond) + }) +} + +// TestEngine_UserLog_LogEventCheckFailure_KeepsDraining covers the fail-open fix in the +// LogEvent.Check branch: a settings read failure (a plain error, not ErrorBoundLimited) +// used to return false from processLogLine, which ended the emitUserLogs drain goroutine +// and silently discarded every remaining user log for the execution. Both lines must land. +func TestEngine_UserLog_LogEventCheckFailure_KeepsDraining(t *testing.T) { //nolint:paralleltest // uses beholdertest.NewObserver, a global singleton swap + harness := newDropPathHarness(t, setupMockBillingClient(t), func(cfg *v2.EngineConfig) { + cfg.LocalLimiters.LogEvent = &alwaysErrCheckLimiter[int]{ok: 1000, err: errors.New("settings unavailable")} + }) + + harness.module.EXPECT().Execute(matches.AnyContext, mock.Anything, mock.Anything). + Run(func(_ context.Context, _ *sdkpb.ExecuteRequest, executor host.ExecutionHelper) { + require.NoError(t, executor.EmitUserLog("first line")) + require.NoError(t, executor.EmitUserLog("second line")) + }). + Return(nil, nil).Once() + harness.eventCh <- capabilities.TriggerResponse{ + Event: capabilities.TriggerEvent{TriggerType: "basic-trigger@1.0.0", ID: "event_log_event_check_fails"}, + } + + require.EventuallyWithT(t, func(c *assert.CollectT) { + lines := userLogLines(t, harness.beholderObserver) + assert.Contains(c, lines, "first line") + assert.Contains(c, lines, "second line") + }, 5*time.Second, 50*time.Millisecond) +} diff --git a/core/services/workflows/v2/engine_limit_metrics_test.go b/core/services/workflows/v2/engine_limit_metrics_test.go new file mode 100644 index 00000000000..e1ab48903ad --- /dev/null +++ b/core/services/workflows/v2/engine_limit_metrics_test.go @@ -0,0 +1,92 @@ +package v2 + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "go.opentelemetry.io/otel/attribute" + sdkmetric "go.opentelemetry.io/otel/sdk/metric" + "go.opentelemetry.io/otel/sdk/metric/metricdata" + + "github.com/smartcontractkit/chainlink-common/pkg/metrics" + "github.com/smartcontractkit/chainlink/v2/core/services/workflows/monitoring" +) + +// collectCounterByAttr sums the named counter and returns the values observed for +// attrKey. Companion to collectCounterValue (engine_org_id_missing_test.go), which +// reads the "reason" attribute instead. +func collectCounterByAttr(t *testing.T, reader *sdkmetric.ManualReader, name, attrKey string) (int64, []string) { + t.Helper() + + var rm metricdata.ResourceMetrics + require.NoError(t, reader.Collect(context.Background(), &rm)) + + var total int64 + var attrs []string + for _, sm := range rm.ScopeMetrics { + for _, m := range sm.Metrics { + if m.Name != name { + continue + } + data, ok := m.Data.(metricdata.Sum[int64]) + require.True(t, ok, "expected Sum[int64] for %s, got %T", name, m.Data) + for _, dp := range data.DataPoints { + total += dp.Value + if v, ok := dp.Attributes.Value(attribute.Key(attrKey)); ok { + attrs = append(attrs, v.AsString()) + } + } + } + } + return total, attrs +} + +// TestEngine_LimitDegradationCounters covers the two ways a CRE settings read failure +// degrades a limiter at a call site, which are tracked separately on purpose: +// +// - read fallback: the limit could not be read, so the static default was substituted. +// The limit is still applied. +// - check unenforced: the Check could not be evaluated, so the limit was skipped and +// the operation allowed through. The limit is NOT applied, which is the more serious +// of the two and warrants its own alert rather than a label on the other counter. +// +//nolint:paralleltest // setupTestMeter swaps the global beholder client +func TestEngine_LimitDegradationCounters(t *testing.T) { + const ( + unenforcedCounter = "platform_engine_limit_check_unenforced_total" + fallbackCounter = "platform_engine_limit_read_fallback_total" + limitKeyAttr = "limitKey" + ) + + t.Run("check unenforced records the limit key", func(t *testing.T) { + reader := setupTestMeter(t) + em, err := monitoring.InitMonitoringResources() + require.NoError(t, err) + labeler := monitoring.NewWorkflowsMetricLabeler(metrics.NewLabeler(), em) + + labeler.IncrementLimitCheckUnenforcedCounter(t.Context(), "PerWorkflow.LogLineLimit") + labeler.IncrementLimitCheckUnenforcedCounter(t.Context(), "PerWorkflow.LogEventLimit") + + total, keys := collectCounterByAttr(t, reader, unenforcedCounter, limitKeyAttr) + assert.Equal(t, int64(2), total) + assert.ElementsMatch(t, []string{"PerWorkflow.LogLineLimit", "PerWorkflow.LogEventLimit"}, keys) + }) + + t.Run("the two degradation modes are separate series", func(t *testing.T) { + reader := setupTestMeter(t) + em, err := monitoring.InitMonitoringResources() + require.NoError(t, err) + labeler := monitoring.NewWorkflowsMetricLabeler(metrics.NewLabeler(), em) + + labeler.IncrementLimitReadFallbackCounter(t.Context(), "PerWorkflow.ExecutionTimeout") + + unenforced, _ := collectCounterByAttr(t, reader, unenforcedCounter, limitKeyAttr) + fallback, fallbackKeys := collectCounterByAttr(t, reader, fallbackCounter, limitKeyAttr) + + assert.Equal(t, int64(1), fallback) + assert.Equal(t, []string{"PerWorkflow.ExecutionTimeout"}, fallbackKeys) + assert.Zero(t, unenforced, "a read fallback must not be counted as an unenforced check") + }) +} diff --git a/deployment/go.mod b/deployment/go.mod index ecbf22f1adc..d8dc488a798 100644 --- a/deployment/go.mod +++ b/deployment/go.mod @@ -50,7 +50,7 @@ require ( github.com/smartcontractkit/chainlink-ccip/chains/solana/deployment v0.0.0-20260908155618-50f521d70e62 github.com/smartcontractkit/chainlink-ccip/chains/solana/gobindings v0.0.0-20260908155618-50f521d70e62 github.com/smartcontractkit/chainlink-ccip/deployment v0.0.0-20260908155618-50f521d70e62 - github.com/smartcontractkit/chainlink-common v0.11.2-0.20260914191328-10cc2b41997e + github.com/smartcontractkit/chainlink-common v0.11.2-0.20260915135448-9ec0150ecb5d github.com/smartcontractkit/chainlink-common/keystore v1.3.1-0.20260903141829-ef07b52a737d github.com/smartcontractkit/chainlink-data-streams v1.1.1 github.com/smartcontractkit/chainlink-deployments-framework v0.122.2 diff --git a/deployment/go.sum b/deployment/go.sum index a80b7d33238..87fb4ad8522 100644 --- a/deployment/go.sum +++ b/deployment/go.sum @@ -1405,8 +1405,8 @@ github.com/smartcontractkit/chainlink-ccip/deployment v0.0.0-20260908155618-50f5 github.com/smartcontractkit/chainlink-ccip/deployment v0.0.0-20260908155618-50f521d70e62/go.mod h1:Dm/Abz0vr7F2v9TygUX947q8HIwJEJikDfSdanX1Cic= github.com/smartcontractkit/chainlink-ccv v0.12.0 h1:/EbL7S96ItC3YF9pZ/fihbxugYxT1xxLSQSFJT4JQoQ= github.com/smartcontractkit/chainlink-ccv v0.12.0/go.mod h1:yijeTgli1K0e1noV/06/etKFxnYz8kBIe3IVXBaGnQw= -github.com/smartcontractkit/chainlink-common v0.11.2-0.20260914191328-10cc2b41997e h1:T9s34qknjJVSXBUeD0S/RoHu2t+iuoMiUOL0xdkQCk8= -github.com/smartcontractkit/chainlink-common v0.11.2-0.20260914191328-10cc2b41997e/go.mod h1:ks0kniCCg8Siv2XflmwLOq5ib9Ifoh6VHXHwfEWIMQA= +github.com/smartcontractkit/chainlink-common v0.11.2-0.20260915135448-9ec0150ecb5d h1:4heqJxOTXBHR3425SuXe9EzkZq+CqWOdKe4KWzAoGYA= +github.com/smartcontractkit/chainlink-common v0.11.2-0.20260915135448-9ec0150ecb5d/go.mod h1:ks0kniCCg8Siv2XflmwLOq5ib9Ifoh6VHXHwfEWIMQA= github.com/smartcontractkit/chainlink-common/keystore v1.3.1-0.20260903141829-ef07b52a737d h1:M9xuiIvdiHtim4nlxCVajyC/Mk63tAg9ESWb/biAhNA= github.com/smartcontractkit/chainlink-common/keystore v1.3.1-0.20260903141829-ef07b52a737d/go.mod h1:rI2njmTlyTvh+xhmORmK6qX3+V1ycDAqGJLu8LS8WpU= github.com/smartcontractkit/chainlink-common/pkg/chipingress v0.0.11-0.20260724142814-45996a1bcb72 h1:uWEwl7i2ryuRVoV4DmIKm6mqYevf1lH/8cQYhw/JXko= diff --git a/devenv/go.mod b/devenv/go.mod index d2aee0067a0..696d66c4b79 100644 --- a/devenv/go.mod +++ b/devenv/go.mod @@ -17,7 +17,7 @@ require ( github.com/pkg/errors v0.9.1 github.com/rs/zerolog v1.35.1 github.com/shopspring/decimal v1.4.0 - github.com/smartcontractkit/chainlink-common v0.11.2-0.20260828143819-eb996f0a6c8b + github.com/smartcontractkit/chainlink-common v0.11.2-0.20260915135448-9ec0150ecb5d github.com/smartcontractkit/chainlink-evm v0.3.4-0.20260519095745-ddfc812d06a0 github.com/smartcontractkit/chainlink-evm/gethwrappers v0.0.0-20251211123524-f0c4fe7cfc0a github.com/smartcontractkit/chainlink-protos/job-distributor v0.12.0 diff --git a/devenv/go.sum b/devenv/go.sum index b6c3f254dd8..4d7fc45fb8d 100644 --- a/devenv/go.sum +++ b/devenv/go.sum @@ -1003,8 +1003,8 @@ github.com/sirupsen/logrus v1.9.4 h1:TsZE7l11zFCLZnZ+teH4Umoq5BhEIfIzfRDZ1Uzql2w github.com/sirupsen/logrus v1.9.4/go.mod h1:ftWc9WdOfJ0a92nsE2jF5u5ZwH8Bv2zdeOC42RjbV2g= github.com/smartcontractkit/chain-selectors v1.0.104 h1:/n9pPGM5W/+r1eHoWZv4VwX9LNS1af4+ICyhM8zKRNM= github.com/smartcontractkit/chain-selectors v1.0.104/go.mod h1:qy7whtgG5g+7z0jt0nRyii9bLND9m15NZTzuQPkMZ5w= -github.com/smartcontractkit/chainlink-common v0.11.2-0.20260828143819-eb996f0a6c8b h1:3q0/l6dHYbulSIYR1Kij+tDipl5qKbSEoyw3rv6Fr3E= -github.com/smartcontractkit/chainlink-common v0.11.2-0.20260828143819-eb996f0a6c8b/go.mod h1:wTx4k3Yka5bc5lBgQiPeoIbrqelvn2YKa4J8K2w7uok= +github.com/smartcontractkit/chainlink-common v0.11.2-0.20260915135448-9ec0150ecb5d h1:4heqJxOTXBHR3425SuXe9EzkZq+CqWOdKe4KWzAoGYA= +github.com/smartcontractkit/chainlink-common v0.11.2-0.20260915135448-9ec0150ecb5d/go.mod h1:ks0kniCCg8Siv2XflmwLOq5ib9Ifoh6VHXHwfEWIMQA= github.com/smartcontractkit/chainlink-common/keystore v1.0.2 h1:AWisx4JT3QV8tcgh6J5NCrex+wAgTYpWyHsyNPSXzsQ= github.com/smartcontractkit/chainlink-common/keystore v1.0.2/go.mod h1:rSkIHdomyak3YnUtXLenl6poIq8q0V3UZPiiyYqPdGA= github.com/smartcontractkit/chainlink-common/pkg/chipingress v0.0.11-0.20260724142814-45996a1bcb72 h1:uWEwl7i2ryuRVoV4DmIKm6mqYevf1lH/8cQYhw/JXko= diff --git a/go.mod b/go.mod index 0b7285a4b31..90d9c02f7b9 100644 --- a/go.mod +++ b/go.mod @@ -82,7 +82,7 @@ require ( github.com/smartcontractkit/chainlink-ccip/chains/solana v0.0.0-20260908155618-50f521d70e62 github.com/smartcontractkit/chainlink-ccip/chains/solana/gobindings v0.0.0-20260908155618-50f521d70e62 github.com/smartcontractkit/chainlink-ccv v0.12.0 - github.com/smartcontractkit/chainlink-common v0.11.2-0.20260914191328-10cc2b41997e + github.com/smartcontractkit/chainlink-common v0.11.2-0.20260915135448-9ec0150ecb5d github.com/smartcontractkit/chainlink-common/keystore v1.3.1-0.20260903141829-ef07b52a737d github.com/smartcontractkit/chainlink-common/pkg/chipingress v0.0.11-0.20260724142814-45996a1bcb72 github.com/smartcontractkit/chainlink-data-streams v1.1.1 diff --git a/go.sum b/go.sum index 907ca49509a..90ac950258a 100644 --- a/go.sum +++ b/go.sum @@ -1106,8 +1106,8 @@ github.com/smartcontractkit/chainlink-ccip/chains/solana/gobindings v0.0.0-20260 github.com/smartcontractkit/chainlink-ccip/chains/solana/gobindings v0.0.0-20260908155618-50f521d70e62/go.mod h1:c++Ed0jeYn4w8WIfiAboRwN6ClRRVGglL0qwB/QjJvM= github.com/smartcontractkit/chainlink-ccv v0.12.0 h1:/EbL7S96ItC3YF9pZ/fihbxugYxT1xxLSQSFJT4JQoQ= github.com/smartcontractkit/chainlink-ccv v0.12.0/go.mod h1:yijeTgli1K0e1noV/06/etKFxnYz8kBIe3IVXBaGnQw= -github.com/smartcontractkit/chainlink-common v0.11.2-0.20260914191328-10cc2b41997e h1:T9s34qknjJVSXBUeD0S/RoHu2t+iuoMiUOL0xdkQCk8= -github.com/smartcontractkit/chainlink-common v0.11.2-0.20260914191328-10cc2b41997e/go.mod h1:ks0kniCCg8Siv2XflmwLOq5ib9Ifoh6VHXHwfEWIMQA= +github.com/smartcontractkit/chainlink-common v0.11.2-0.20260915135448-9ec0150ecb5d h1:4heqJxOTXBHR3425SuXe9EzkZq+CqWOdKe4KWzAoGYA= +github.com/smartcontractkit/chainlink-common v0.11.2-0.20260915135448-9ec0150ecb5d/go.mod h1:ks0kniCCg8Siv2XflmwLOq5ib9Ifoh6VHXHwfEWIMQA= github.com/smartcontractkit/chainlink-common/keystore v1.3.1-0.20260903141829-ef07b52a737d h1:M9xuiIvdiHtim4nlxCVajyC/Mk63tAg9ESWb/biAhNA= github.com/smartcontractkit/chainlink-common/keystore v1.3.1-0.20260903141829-ef07b52a737d/go.mod h1:rI2njmTlyTvh+xhmORmK6qX3+V1ycDAqGJLu8LS8WpU= github.com/smartcontractkit/chainlink-common/pkg/chipingress v0.0.11-0.20260724142814-45996a1bcb72 h1:uWEwl7i2ryuRVoV4DmIKm6mqYevf1lH/8cQYhw/JXko= diff --git a/integration-tests/go.mod b/integration-tests/go.mod index 4d2fdde815f..54f31ba7de8 100644 --- a/integration-tests/go.mod +++ b/integration-tests/go.mod @@ -33,7 +33,7 @@ require ( github.com/smartcontractkit/chainlink-ccip/chains/evm v0.0.0-20260908164107-3de1349d970b github.com/smartcontractkit/chainlink-ccip/chains/solana v0.0.0-20260908155618-50f521d70e62 github.com/smartcontractkit/chainlink-ccip/chains/solana/gobindings v0.0.0-20260908155618-50f521d70e62 - github.com/smartcontractkit/chainlink-common v0.11.2-0.20260914191328-10cc2b41997e + github.com/smartcontractkit/chainlink-common v0.11.2-0.20260915135448-9ec0150ecb5d github.com/smartcontractkit/chainlink-common/keystore v1.3.1-0.20260903141829-ef07b52a737d github.com/smartcontractkit/chainlink-deployments-framework v0.122.2 github.com/smartcontractkit/chainlink-evm v0.3.4-0.20260914143713-424babc506ab diff --git a/integration-tests/go.sum b/integration-tests/go.sum index 06245c83670..34e2cb8a62e 100644 --- a/integration-tests/go.sum +++ b/integration-tests/go.sum @@ -1394,8 +1394,8 @@ github.com/smartcontractkit/chainlink-ccip/deployment v0.0.0-20260908155618-50f5 github.com/smartcontractkit/chainlink-ccip/deployment v0.0.0-20260908155618-50f521d70e62/go.mod h1:Dm/Abz0vr7F2v9TygUX947q8HIwJEJikDfSdanX1Cic= github.com/smartcontractkit/chainlink-ccv v0.12.0 h1:/EbL7S96ItC3YF9pZ/fihbxugYxT1xxLSQSFJT4JQoQ= github.com/smartcontractkit/chainlink-ccv v0.12.0/go.mod h1:yijeTgli1K0e1noV/06/etKFxnYz8kBIe3IVXBaGnQw= -github.com/smartcontractkit/chainlink-common v0.11.2-0.20260914191328-10cc2b41997e h1:T9s34qknjJVSXBUeD0S/RoHu2t+iuoMiUOL0xdkQCk8= -github.com/smartcontractkit/chainlink-common v0.11.2-0.20260914191328-10cc2b41997e/go.mod h1:ks0kniCCg8Siv2XflmwLOq5ib9Ifoh6VHXHwfEWIMQA= +github.com/smartcontractkit/chainlink-common v0.11.2-0.20260915135448-9ec0150ecb5d h1:4heqJxOTXBHR3425SuXe9EzkZq+CqWOdKe4KWzAoGYA= +github.com/smartcontractkit/chainlink-common v0.11.2-0.20260915135448-9ec0150ecb5d/go.mod h1:ks0kniCCg8Siv2XflmwLOq5ib9Ifoh6VHXHwfEWIMQA= github.com/smartcontractkit/chainlink-common/keystore v1.3.1-0.20260903141829-ef07b52a737d h1:M9xuiIvdiHtim4nlxCVajyC/Mk63tAg9ESWb/biAhNA= github.com/smartcontractkit/chainlink-common/keystore v1.3.1-0.20260903141829-ef07b52a737d/go.mod h1:rI2njmTlyTvh+xhmORmK6qX3+V1ycDAqGJLu8LS8WpU= github.com/smartcontractkit/chainlink-common/pkg/chipingress v0.0.11-0.20260724142814-45996a1bcb72 h1:uWEwl7i2ryuRVoV4DmIKm6mqYevf1lH/8cQYhw/JXko= diff --git a/integration-tests/load/go.mod b/integration-tests/load/go.mod index 63bf279f982..4af4c2d7e7d 100644 --- a/integration-tests/load/go.mod +++ b/integration-tests/load/go.mod @@ -24,7 +24,7 @@ require ( github.com/smartcontractkit/chainlink-ccip/chains/evm v0.0.0-20260908164107-3de1349d970b github.com/smartcontractkit/chainlink-ccip/chains/solana v0.0.0-20260908155618-50f521d70e62 github.com/smartcontractkit/chainlink-ccip/chains/solana/gobindings v0.0.0-20260908155618-50f521d70e62 - github.com/smartcontractkit/chainlink-common v0.11.2-0.20260914191328-10cc2b41997e + github.com/smartcontractkit/chainlink-common v0.11.2-0.20260915135448-9ec0150ecb5d github.com/smartcontractkit/chainlink-deployments-framework v0.122.2 github.com/smartcontractkit/chainlink-evm v0.3.4-0.20260914143713-424babc506ab github.com/smartcontractkit/chainlink-testing-framework/framework v0.16.8 diff --git a/integration-tests/load/go.sum b/integration-tests/load/go.sum index 09697622f59..b54e445e941 100644 --- a/integration-tests/load/go.sum +++ b/integration-tests/load/go.sum @@ -1632,8 +1632,8 @@ github.com/smartcontractkit/chainlink-ccip/deployment v0.0.0-20260908155618-50f5 github.com/smartcontractkit/chainlink-ccip/deployment v0.0.0-20260908155618-50f521d70e62/go.mod h1:Dm/Abz0vr7F2v9TygUX947q8HIwJEJikDfSdanX1Cic= github.com/smartcontractkit/chainlink-ccv v0.12.0 h1:/EbL7S96ItC3YF9pZ/fihbxugYxT1xxLSQSFJT4JQoQ= github.com/smartcontractkit/chainlink-ccv v0.12.0/go.mod h1:yijeTgli1K0e1noV/06/etKFxnYz8kBIe3IVXBaGnQw= -github.com/smartcontractkit/chainlink-common v0.11.2-0.20260914191328-10cc2b41997e h1:T9s34qknjJVSXBUeD0S/RoHu2t+iuoMiUOL0xdkQCk8= -github.com/smartcontractkit/chainlink-common v0.11.2-0.20260914191328-10cc2b41997e/go.mod h1:ks0kniCCg8Siv2XflmwLOq5ib9Ifoh6VHXHwfEWIMQA= +github.com/smartcontractkit/chainlink-common v0.11.2-0.20260915135448-9ec0150ecb5d h1:4heqJxOTXBHR3425SuXe9EzkZq+CqWOdKe4KWzAoGYA= +github.com/smartcontractkit/chainlink-common v0.11.2-0.20260915135448-9ec0150ecb5d/go.mod h1:ks0kniCCg8Siv2XflmwLOq5ib9Ifoh6VHXHwfEWIMQA= github.com/smartcontractkit/chainlink-common/keystore v1.3.1-0.20260903141829-ef07b52a737d h1:M9xuiIvdiHtim4nlxCVajyC/Mk63tAg9ESWb/biAhNA= github.com/smartcontractkit/chainlink-common/keystore v1.3.1-0.20260903141829-ef07b52a737d/go.mod h1:rI2njmTlyTvh+xhmORmK6qX3+V1ycDAqGJLu8LS8WpU= github.com/smartcontractkit/chainlink-common/pkg/chipingress v0.0.11-0.20260724142814-45996a1bcb72 h1:uWEwl7i2ryuRVoV4DmIKm6mqYevf1lH/8cQYhw/JXko= diff --git a/system-tests/lib/go.mod b/system-tests/lib/go.mod index dd336816545..105424c6779 100644 --- a/system-tests/lib/go.mod +++ b/system-tests/lib/go.mod @@ -37,7 +37,7 @@ require ( github.com/smartcontractkit/chain-selectors v1.0.109 github.com/smartcontractkit/chainlink-aptos v0.0.0-20260828090428-9828cc37ebc2 github.com/smartcontractkit/chainlink-ccip/chains/solana v0.0.0-20260908155618-50f521d70e62 - github.com/smartcontractkit/chainlink-common v0.11.2-0.20260914191328-10cc2b41997e + github.com/smartcontractkit/chainlink-common v0.11.2-0.20260915135448-9ec0150ecb5d github.com/smartcontractkit/chainlink-common/keystore v1.3.1-0.20260903141829-ef07b52a737d github.com/smartcontractkit/chainlink-confidential-compute v1.3.0 github.com/smartcontractkit/chainlink-deployments-framework v0.122.2 diff --git a/system-tests/lib/go.sum b/system-tests/lib/go.sum index 464a8667a5f..879d5a2e1ff 100644 --- a/system-tests/lib/go.sum +++ b/system-tests/lib/go.sum @@ -1654,8 +1654,8 @@ github.com/smartcontractkit/chainlink-ccip/chains/solana/gobindings v0.0.0-20260 github.com/smartcontractkit/chainlink-ccip/chains/solana/gobindings v0.0.0-20260908155618-50f521d70e62/go.mod h1:c++Ed0jeYn4w8WIfiAboRwN6ClRRVGglL0qwB/QjJvM= github.com/smartcontractkit/chainlink-ccv v0.12.0 h1:/EbL7S96ItC3YF9pZ/fihbxugYxT1xxLSQSFJT4JQoQ= github.com/smartcontractkit/chainlink-ccv v0.12.0/go.mod h1:yijeTgli1K0e1noV/06/etKFxnYz8kBIe3IVXBaGnQw= -github.com/smartcontractkit/chainlink-common v0.11.2-0.20260914191328-10cc2b41997e h1:T9s34qknjJVSXBUeD0S/RoHu2t+iuoMiUOL0xdkQCk8= -github.com/smartcontractkit/chainlink-common v0.11.2-0.20260914191328-10cc2b41997e/go.mod h1:ks0kniCCg8Siv2XflmwLOq5ib9Ifoh6VHXHwfEWIMQA= +github.com/smartcontractkit/chainlink-common v0.11.2-0.20260915135448-9ec0150ecb5d h1:4heqJxOTXBHR3425SuXe9EzkZq+CqWOdKe4KWzAoGYA= +github.com/smartcontractkit/chainlink-common v0.11.2-0.20260915135448-9ec0150ecb5d/go.mod h1:ks0kniCCg8Siv2XflmwLOq5ib9Ifoh6VHXHwfEWIMQA= github.com/smartcontractkit/chainlink-common/keystore v1.3.1-0.20260903141829-ef07b52a737d h1:M9xuiIvdiHtim4nlxCVajyC/Mk63tAg9ESWb/biAhNA= github.com/smartcontractkit/chainlink-common/keystore v1.3.1-0.20260903141829-ef07b52a737d/go.mod h1:rI2njmTlyTvh+xhmORmK6qX3+V1ycDAqGJLu8LS8WpU= github.com/smartcontractkit/chainlink-common/pkg/chipingress v0.0.11-0.20260724142814-45996a1bcb72 h1:uWEwl7i2ryuRVoV4DmIKm6mqYevf1lH/8cQYhw/JXko= diff --git a/system-tests/tests/canaries_sentinels/proof-of-reserve/cron-based/go.mod b/system-tests/tests/canaries_sentinels/proof-of-reserve/cron-based/go.mod index 8acb6313152..b2507cd18d4 100644 --- a/system-tests/tests/canaries_sentinels/proof-of-reserve/cron-based/go.mod +++ b/system-tests/tests/canaries_sentinels/proof-of-reserve/cron-based/go.mod @@ -1,17 +1,17 @@ module main -go 1.26.5 +go 1.26.6 require ( - github.com/ethereum/go-ethereum v1.17.1 - github.com/smartcontractkit/chain-selectors v1.0.100 - github.com/smartcontractkit/chainlink-common v0.11.2-0.20260722120418-c1a1e0e75034 - github.com/smartcontractkit/chainlink-protos/cre/go v0.0.0-20260622152157-c8e129347b8b + github.com/ethereum/go-ethereum v1.17.4 + github.com/smartcontractkit/chain-selectors v1.0.104 + github.com/smartcontractkit/chainlink-common v0.11.2-0.20260915135448-9ec0150ecb5d + github.com/smartcontractkit/chainlink-protos/cre/go v0.0.0-20260804191526-b7a850ae7648 github.com/smartcontractkit/cre-sdk-go v1.5.0 github.com/smartcontractkit/cre-sdk-go/capabilities/blockchain/evm v0.10.0 github.com/smartcontractkit/cre-sdk-go/capabilities/networking/http v1.3.0 github.com/smartcontractkit/cre-sdk-go/capabilities/scheduler/cron v1.3.0 - google.golang.org/protobuf v1.36.11 + google.golang.org/protobuf v1.36.12 gopkg.in/yaml.v3 v3.0.1 ) @@ -24,17 +24,16 @@ require ( github.com/cespare/xxhash/v2 v2.3.0 // indirect github.com/cloudevents/sdk-go/binding/format/protobuf/v2 v2.16.2 // indirect github.com/cloudevents/sdk-go/v2 v2.16.2 // indirect - github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0 // indirect github.com/gabriel-vasile/mimetype v1.4.13 // indirect - github.com/go-logr/logr v1.4.3 // indirect + github.com/go-logr/logr v1.4.4 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/go-playground/locales v0.14.1 // indirect github.com/go-playground/universal-translator v0.18.1 // indirect github.com/go-playground/validator/v10 v10.30.1 // indirect github.com/go-viper/mapstructure/v2 v2.5.0 // indirect github.com/google/uuid v1.6.0 // indirect - github.com/grpc-ecosystem/grpc-gateway/v2 v2.28.0 // indirect + github.com/grpc-ecosystem/grpc-gateway/v2 v2.30.0 // indirect github.com/holiman/uint256 v1.3.2 // indirect github.com/invopop/jsonschema v0.13.0 // indirect github.com/json-iterator/go v1.1.12 // indirect @@ -47,47 +46,47 @@ require ( github.com/pelletier/go-toml v1.9.5 // indirect github.com/pelletier/go-toml/v2 v2.2.4 // indirect github.com/pkg/errors v0.9.1 // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect github.com/prometheus/client_golang v1.23.2 // indirect github.com/prometheus/client_model v0.6.2 // indirect github.com/prometheus/common v0.67.5 // indirect github.com/prometheus/procfs v0.20.1 // indirect github.com/santhosh-tekuri/jsonschema/v5 v5.3.1 // indirect github.com/shopspring/decimal v1.4.0 // indirect - github.com/smartcontractkit/chainlink-common/pkg/chipingress v0.0.11-0.20260716165322-7f2edff6e954 // indirect - github.com/smartcontractkit/libocr v0.0.0-20260403184524-b6409238958d // indirect - github.com/stretchr/testify v1.11.1 // indirect + github.com/smartcontractkit/chainlink-common/pkg/chipingress v0.0.11-0.20260724142814-45996a1bcb72 // indirect + github.com/smartcontractkit/libocr v0.0.0-20260810200708-618b5bf7f342 // indirect + github.com/stretchr/testify v1.12.1 // indirect github.com/wk8/go-ordered-map/v2 v2.1.8 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect - go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.63.0 // indirect - go.opentelemetry.io/otel v1.44.0 // indirect - go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc v0.12.2 // indirect - go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp v0.19.0 // indirect - go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.38.0 // indirect - go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.43.0 // indirect - go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.43.0 // indirect - go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.41.0 // indirect - go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.43.0 // indirect - go.opentelemetry.io/otel/exporters/stdout/stdoutlog v0.13.0 // indirect - go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.36.0 // indirect - go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.36.0 // indirect - go.opentelemetry.io/otel/log v0.19.0 // indirect - go.opentelemetry.io/otel/metric v1.44.0 // indirect - go.opentelemetry.io/otel/sdk v1.44.0 // indirect - go.opentelemetry.io/otel/sdk/log v0.19.0 // indirect - go.opentelemetry.io/otel/sdk/metric v1.44.0 // indirect - go.opentelemetry.io/otel/trace v1.44.0 // indirect - go.opentelemetry.io/proto/otlp v1.10.0 // indirect + go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.70.0 // indirect + go.opentelemetry.io/otel v1.46.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc v0.22.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp v0.22.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.46.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.46.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.46.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.46.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.46.0 // indirect + go.opentelemetry.io/otel/exporters/stdout/stdoutlog v0.22.0 // indirect + go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.46.0 // indirect + go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.46.0 // indirect + go.opentelemetry.io/otel/log v0.22.0 // indirect + go.opentelemetry.io/otel/metric v1.46.0 // indirect + go.opentelemetry.io/otel/sdk v1.46.0 // indirect + go.opentelemetry.io/otel/sdk/log v0.22.0 // indirect + go.opentelemetry.io/otel/sdk/metric v1.46.0 // indirect + go.opentelemetry.io/otel/trace v1.46.0 // indirect + go.opentelemetry.io/proto/otlp v1.11.0 // indirect go.uber.org/multierr v1.11.0 // indirect - go.uber.org/zap v1.27.1 // indirect + go.uber.org/zap v1.28.0 // indirect go.yaml.in/yaml/v2 v2.4.4 // indirect - golang.org/x/crypto v0.52.0 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect + golang.org/x/crypto v0.55.0 // indirect golang.org/x/exp v0.0.0-20260508232706-74f9aab9d74a // indirect - golang.org/x/net v0.55.0 // indirect - golang.org/x/sys v0.45.0 // indirect - golang.org/x/text v0.37.0 // indirect + golang.org/x/net v0.58.0 // indirect + golang.org/x/sys v0.47.0 // indirect + golang.org/x/text v0.41.0 // indirect golang.org/x/time v0.15.0 // indirect - google.golang.org/genproto/googleapis/api v0.0.0-20260526163538-3dc84a4a5aaa // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20260526163538-3dc84a4a5aaa // indirect + google.golang.org/genproto/googleapis/api v0.0.0-20260819154853-08b0e4226688 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20260819154853-08b0e4226688 // indirect google.golang.org/grpc v1.83.1 // indirect ) diff --git a/system-tests/tests/canaries_sentinels/proof-of-reserve/cron-based/go.sum b/system-tests/tests/canaries_sentinels/proof-of-reserve/cron-based/go.sum index 8e4cf78ded9..f2c5a1118b6 100644 --- a/system-tests/tests/canaries_sentinels/proof-of-reserve/cron-based/go.sum +++ b/system-tests/tests/canaries_sentinels/proof-of-reserve/cron-based/go.sum @@ -22,13 +22,13 @@ github.com/decred/dcrd/crypto/blake256 v1.1.0 h1:zPMNGQCm0g4QTY27fOCorQW7EryeQ/U github.com/decred/dcrd/crypto/blake256 v1.1.0/go.mod h1:2OfgNZ5wDpcsFmHmCK5gZTPcCXqlm2ArzUIkw9czNJo= github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0 h1:NMZiJj8QnKe1LgsbDayM4UoHwbvwDRwnI3hwNaAHRnc= github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0/go.mod h1:ZXNYxsqcloTdSy/rNShjYzMhyjf0LaoftYK0p+A3h40= -github.com/ethereum/go-ethereum v1.17.1 h1:IjlQDjgxg2uL+GzPRkygGULPMLzcYWncEI7wbaizvho= -github.com/ethereum/go-ethereum v1.17.1/go.mod h1:7UWOVHL7K3b8RfVRea022btnzLCaanwHtBuH1jUCH/I= +github.com/ethereum/go-ethereum v1.17.4 h1:uA4q+qiLp7QImBsjdRbINu8iX6OEVmj4DPc5/E5Fsxc= +github.com/ethereum/go-ethereum v1.17.4/go.mod h1:qMdgwqqRAen+aT8P7KKQKi0Qt6RzG4cfejVAbCpJgqA= github.com/gabriel-vasile/mimetype v1.4.13 h1:46nXokslUBsAJE/wMsp5gtO500a4F3Nkz9Ufpk2AcUM= github.com/gabriel-vasile/mimetype v1.4.13/go.mod h1:d+9Oxyo1wTzWdyVUPMmXFvp4F9tea18J8ufA774AB3s= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= -github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8= +github.com/go-logr/logr v1.4.4/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s= @@ -50,8 +50,8 @@ github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0= github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/grpc-ecosystem/grpc-gateway/v2 v2.28.0 h1:HWRh5R2+9EifMyIHV7ZV+MIZqgz+PMpZ14Jynv3O2Zs= -github.com/grpc-ecosystem/grpc-gateway/v2 v2.28.0/go.mod h1:JfhWUomR1baixubs02l85lZYYOm7LV6om4ceouMv45c= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.30.0 h1:/Tnpcb2E0Pz/tN9s3bfEY2Q8ePCEX9iuS+cneUwncnw= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.30.0/go.mod h1:zOBXOsUaBSjKgmH4OGzV1esUpR3oUSCPYVd2cUBjKYY= github.com/holiman/uint256 v1.3.2 h1:a9EgMPSC1AAaj1SZL5zIQD3WbwTuHrMGOerLjGmM/TA= github.com/holiman/uint256 v1.3.2/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E= github.com/invopop/jsonschema v0.13.0 h1:KvpoAJWEjR3uD9Kbm2HWJmqsEaHt8lBUpd0qHcIi21E= @@ -82,8 +82,6 @@ github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o= github.com/prometheus/client_golang v1.23.2/go.mod h1:Tb1a6LWHB3/SPIzCoaDXI4I8UHKeFTEQ1YCr+0Gyqmg= github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk= @@ -98,14 +96,14 @@ github.com/santhosh-tekuri/jsonschema/v5 v5.3.1 h1:lZUw3E0/J3roVtGQ+SCrUrg3ON6Ng github.com/santhosh-tekuri/jsonschema/v5 v5.3.1/go.mod h1:uToXkOrWAZ6/Oc07xWQrPOhJotwFIyu2bBVN41fcDUY= github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k= github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME= -github.com/smartcontractkit/chain-selectors v1.0.100 h1:wpiSpmI/eFjY+wx/nPr5VuNF4hki0prIBMKEaQWn3g4= -github.com/smartcontractkit/chain-selectors v1.0.100/go.mod h1:qy7whtgG5g+7z0jt0nRyii9bLND9m15NZTzuQPkMZ5w= -github.com/smartcontractkit/chainlink-common v0.11.2-0.20260722120418-c1a1e0e75034 h1:XCnmvCaSuOXKShpfcmyrHskHnXDzjACxI37WiEFdJDI= -github.com/smartcontractkit/chainlink-common v0.11.2-0.20260722120418-c1a1e0e75034/go.mod h1:DGvW2Opi/qcOWNkOq18xTI5ZqByoxfPTL9H5M1bC4Ls= -github.com/smartcontractkit/chainlink-common/pkg/chipingress v0.0.11-0.20260716165322-7f2edff6e954 h1:QhTMiEn3s+AB4xBoScuQglsqHGJYxheYrgpxdIdqNAI= -github.com/smartcontractkit/chainlink-common/pkg/chipingress v0.0.11-0.20260716165322-7f2edff6e954/go.mod h1:UYcRMb4dZcoaIPgZJ3hckCySTqtJc9K4Q+tOKErwTq0= -github.com/smartcontractkit/chainlink-protos/cre/go v0.0.0-20260622152157-c8e129347b8b h1:VDgJWDipihV9f7M5+d21d1RzSsg5rEv+iI12oN1VQbo= -github.com/smartcontractkit/chainlink-protos/cre/go v0.0.0-20260622152157-c8e129347b8b/go.mod h1:vTFHTCbLui4Vn8fTmAadfE3rdnvfrDwOmMujmW857D0= +github.com/smartcontractkit/chain-selectors v1.0.104 h1:/n9pPGM5W/+r1eHoWZv4VwX9LNS1af4+ICyhM8zKRNM= +github.com/smartcontractkit/chain-selectors v1.0.104/go.mod h1:qy7whtgG5g+7z0jt0nRyii9bLND9m15NZTzuQPkMZ5w= +github.com/smartcontractkit/chainlink-common v0.11.2-0.20260915135448-9ec0150ecb5d h1:4heqJxOTXBHR3425SuXe9EzkZq+CqWOdKe4KWzAoGYA= +github.com/smartcontractkit/chainlink-common v0.11.2-0.20260915135448-9ec0150ecb5d/go.mod h1:ks0kniCCg8Siv2XflmwLOq5ib9Ifoh6VHXHwfEWIMQA= +github.com/smartcontractkit/chainlink-common/pkg/chipingress v0.0.11-0.20260724142814-45996a1bcb72 h1:uWEwl7i2ryuRVoV4DmIKm6mqYevf1lH/8cQYhw/JXko= +github.com/smartcontractkit/chainlink-common/pkg/chipingress v0.0.11-0.20260724142814-45996a1bcb72/go.mod h1:UYcRMb4dZcoaIPgZJ3hckCySTqtJc9K4Q+tOKErwTq0= +github.com/smartcontractkit/chainlink-protos/cre/go v0.0.0-20260804191526-b7a850ae7648 h1:WEUMkKQPAgcNMRgES6CBWrRUiII+HKEWQjulKQBSuMA= +github.com/smartcontractkit/chainlink-protos/cre/go v0.0.0-20260804191526-b7a850ae7648/go.mod h1:/i8hjTPFdVWHiY+QjeSiVS2Z3GB3WAZznGgXHstC02E= github.com/smartcontractkit/cre-sdk-go v1.5.0 h1:kepW3QDKARrOOHjXwWAZ9j5KLk6bxLzvi6OMrLsFwVo= github.com/smartcontractkit/cre-sdk-go v1.5.0/go.mod h1:yYrQFz1UH7hhRbPO0q4fgo1tfsJNd4yXnI3oCZE0RzM= github.com/smartcontractkit/cre-sdk-go/capabilities/blockchain/evm v0.10.0 h1:G0w0cLzHy/5m74IzSGz1Ynjffym4ZxLeUrRLp8EFP5w= @@ -114,92 +112,94 @@ github.com/smartcontractkit/cre-sdk-go/capabilities/networking/http v1.3.0 h1:m0 github.com/smartcontractkit/cre-sdk-go/capabilities/networking/http v1.3.0/go.mod h1:QpLhMGMa//e4G9qMmmCK4NPMcadRBaWC2FDV9hniMrI= github.com/smartcontractkit/cre-sdk-go/capabilities/scheduler/cron v1.3.0 h1:qBZ4y6qlTOynSpU1QAi2Fgr3tUZQ332b6hit9EVZqkk= github.com/smartcontractkit/cre-sdk-go/capabilities/scheduler/cron v1.3.0/go.mod h1:Rzhy75vD3FqQo/SV6lypnxIwjWac6IOWzI5BYj3tYMU= -github.com/smartcontractkit/libocr v0.0.0-20260403184524-b6409238958d h1:PvXor5Fjer7FIONSqYXbpd1LkA14hWrlAyxXzOrC9t8= -github.com/smartcontractkit/libocr v0.0.0-20260403184524-b6409238958d/go.mod h1:PLdNK6GlqfxIWXzziPkU7dCAVlVFeYkyyW7AQY0R+4Q= +github.com/smartcontractkit/libocr v0.0.0-20260810200708-618b5bf7f342 h1:pEcgcjTGA83MzpqbTbyIg9AJrOs62s77SooDdJGIg9w= +github.com/smartcontractkit/libocr v0.0.0-20260810200708-618b5bf7f342/go.mod h1:5JPtsRwjugpyfsdEALC4RopfvohqK/G+3DHaR8uv+Bc= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= -github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= +github.com/stretchr/objx v0.5.3 h1:jmXUvGomnU1o3W/V5h2VEradbpJDwGrzugQQvL0POH4= +github.com/stretchr/objx v0.5.3/go.mod h1:rDQraq+vQZU7Fde9LOZLr8Tax6zZvy4kuNKF+QYS+U0= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw= github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= github.com/wk8/go-ordered-map/v2 v2.1.8 h1:5h/BUHu93oj4gIdvHHHGsScSTMijfx5PeYkE/fJgbpc= github.com/wk8/go-ordered-map/v2 v2.1.8/go.mod h1:5nJHM5DyteebpVlHnWMV0rPz6Zp7+xBAnxjb1X5vnTw= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= -go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.63.0 h1:YH4g8lQroajqUwWbq/tr2QX1JFmEXaDLgG+ew9bLMWo= -go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.63.0/go.mod h1:fvPi2qXDqFs8M4B4fmJhE92TyQs9Ydjlg3RvfUp+NbQ= -go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= -go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= -go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc v0.12.2 h1:06ZeJRe5BnYXceSM9Vya83XXVaNGe3H1QqsvqRANQq8= -go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc v0.12.2/go.mod h1:DvPtKE63knkDVP88qpatBj81JxN+w1bqfVbsbCbj1WY= -go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp v0.19.0 h1:HIBTQ3VO5aupLKjC90JgMqpezVXwFuq6Ryjn0/izoag= -go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp v0.19.0/go.mod h1:ji9vId85hMxqfvICA0Jt8JqEdrXaAkcpkI9HPXya0ro= -go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.38.0 h1:vl9obrcoWVKp/lwl8tRE33853I8Xru9HFbw/skNeLs8= -go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.38.0/go.mod h1:GAXRxmLJcVM3u22IjTg74zWBrRCKq8BnOqUVLodpcpw= -go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.43.0 h1:w1K+pCJoPpQifuVpsKamUdn9U0zM3xUziVOqsGksUrY= -go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.43.0/go.mod h1:HBy4BjzgVE8139ieRI75oXm3EcDN+6GhD88JT1Kjvxg= -go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.43.0 h1:88Y4s2C8oTui1LGM6bTWkw0ICGcOLCAI5l6zsD1j20k= -go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.43.0/go.mod h1:Vl1/iaggsuRlrHf/hfPJPvVag77kKyvrLeD10kpMl+A= -go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.41.0 h1:mq/Qcf28TWz719lE3/hMB4KkyDuLJIvgJnFGcd0kEUI= -go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.41.0/go.mod h1:yk5LXEYhsL2htyDNJbEq7fWzNEigeEdV5xBF/Y+kAv0= -go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.43.0 h1:3iZJKlCZufyRzPzlQhUIWVmfltrXuGyfjREgGP3UUjc= -go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.43.0/go.mod h1:/G+nUPfhq2e+qiXMGxMwumDrP5jtzU+mWN7/sjT2rak= -go.opentelemetry.io/otel/exporters/stdout/stdoutlog v0.13.0 h1:yEX3aC9KDgvYPhuKECHbOlr5GLwH6KTjLJ1sBSkkxkc= -go.opentelemetry.io/otel/exporters/stdout/stdoutlog v0.13.0/go.mod h1:/GXR0tBmmkxDaCUGahvksvp66mx4yh5+cFXgSlhg0vQ= -go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.36.0 h1:rixTyDGXFxRy1xzhKrotaHy3/KXdPhlWARrCgK+eqUY= -go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.36.0/go.mod h1:dowW6UsM9MKbJq5JTz2AMVp3/5iW5I/TStsk8S+CfHw= -go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.36.0 h1:G8Xec/SgZQricwWBJF/mHZc7A02YHedfFDENwJEdRA0= -go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.36.0/go.mod h1:PD57idA/AiFD5aqoxGxCvT/ILJPeHy3MjqU/NS7KogY= -go.opentelemetry.io/otel/log v0.19.0 h1:KUZs/GOsw79TBBMfDWsXS+KZ4g2Ckzksd1ymzsIEbo4= -go.opentelemetry.io/otel/log v0.19.0/go.mod h1:5DQYeGmxVIr4n0/BcJvF4upsraHjg6vudJJpnkL6Ipk= -go.opentelemetry.io/otel/metric v1.44.0 h1:1w0gILTcHdr3YI+ixLyjemwrVnsMURbTZFrSYCdDdmc= -go.opentelemetry.io/otel/metric v1.44.0/go.mod h1:8O7hanEPBNgEMmybD3s2VBKcgWOCsA6tzHBPODAiquo= -go.opentelemetry.io/otel/metric/x v0.66.0 h1:YkCrx1zLOChi9ZcZ6euupOcsgzbVlec7D/xoEU1+cTA= -go.opentelemetry.io/otel/metric/x v0.66.0/go.mod h1:d1+BDj9t96do0/1LoU1ayfCv79ZgNE41qbhBvnMOBZk= -go.opentelemetry.io/otel/sdk v1.44.0 h1:nHYwb9lK+fJPU/dnT6s7W7Z8itMWyqrnVfbheVYrZ58= -go.opentelemetry.io/otel/sdk v1.44.0/go.mod h1:Osuydd3Se74nqjAKxid74N5eC+jfEqfTegHRnq58oK0= -go.opentelemetry.io/otel/sdk/log v0.19.0 h1:scYVLqT22D2gqXItnWiocLUKGH9yvkkeql5dBDiXyko= -go.opentelemetry.io/otel/sdk/log v0.19.0/go.mod h1:vFBowwXGLlW9AvpuF7bMgnNI95LiW10szrOdvzBHlAg= -go.opentelemetry.io/otel/sdk/log/logtest v0.19.0 h1:BEbF7ZBB6qQloV/Ub1+3NQoOUnVtcGkU3XX4Ws3GQfk= -go.opentelemetry.io/otel/sdk/log/logtest v0.19.0/go.mod h1:Lua81/3yM0wOmoHTokLj9y9ADeA02v1naRrVrkAZuKk= -go.opentelemetry.io/otel/sdk/metric v1.44.0 h1:3LlKgI+VjbVsjNRFZJZAJ30WjXC5VkNRks6si09iEfI= -go.opentelemetry.io/otel/sdk/metric v1.44.0/go.mod h1:5B5pMARnXxKhltooO4xUuCBorl65a4EpnTalObqOigA= -go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= -go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= -go.opentelemetry.io/proto/otlp v1.10.0 h1:IQRWgT5srOCYfiWnpqUYz9CVmbO8bFmKcwYxpuCSL2g= -go.opentelemetry.io/proto/otlp v1.10.0/go.mod h1:/CV4QoCR/S9yaPj8utp3lvQPoqMtxXdzn7ozvvozVqk= +go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.70.0 h1:oECp5f+hN7nkwjU/8BxQ/q23bGPb8FIrD839owX222E= +go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.70.0/go.mod h1:DqEFwLumhzMBDQv9PcWbyoDxHI/4lAk6CM4nJBH39sc= +go.opentelemetry.io/otel v1.46.0 h1:FHt5/CDyVxi/8IM1CH7VE/rRgq3kLHa2mSTVMO8AWyc= +go.opentelemetry.io/otel v1.46.0/go.mod h1:Gj3SEScelsNC45tp4nSxRYlS+f5iez7W8XPMCt905kE= +go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc v0.22.0 h1:Bu39F5tzJct+f2IZbB8989fwyTps3c8e7EsUQsz+vs8= +go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc v0.22.0/go.mod h1:dJUwod88EsFgYCqrDHaSPzhiY9pBUpt0d85/qSfua7k= +go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp v0.22.0 h1:lYk7RmxdLK865qLwibroNGldHa1U7SWKYYvNjlK7PIo= +go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp v0.22.0/go.mod h1:6GvlND0H0xdUJanOtIAn0xfwLkauh1tmsYEEVSMDdqY= +go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.46.0 h1:qkDYCAFiZXLcs1L4aY+tP2wguQ4kURANqHOQMA2et2s= +go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.46.0/go.mod h1:tkipS4DRzmpAmvg+Gw4++O1IdDq6TVDnvnYU6cmbQVs= +go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.46.0 h1:AP23h/mFgb/lc7tdck1Kfn9qxsM8TAeNPCU5C3pzaps= +go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.46.0/go.mod h1:K4EqCe1b4kGk5WR690ntg9LaBfsPoV32FwthbyoptuA= +go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.46.0 h1:OFnwLJr+pF3iHrlGSzbxyuo6/6HyBlnlN1CWEJmBVcw= +go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.46.0/go.mod h1:716wFneO0ov19A2beH5hjfh9AK5z/VWNAtDijp1Y0/g= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.46.0 h1:w53CDeOA/Kurp7yRsegSr6pbbr759dOvJ+yNmWM6Hxs= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.46.0/go.mod h1:BOmGMCbAtvcJiSJ+hLuhgPLdDbimnraSl8irz3iY8sY= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.46.0 h1:KrC1YrQeSt46ITMWAbgQx1M1eV1/1TKzttrBzymPmss= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.46.0/go.mod h1:zDSEzoEqsOrgBeGvH66KRgxh90VonFyJqBHA0Pk3+rM= +go.opentelemetry.io/otel/exporters/stdout/stdoutlog v0.22.0 h1:kvMAiLEudKmk+CSG+iYbU8vTUGNNDaf/V09OO5lrTwI= +go.opentelemetry.io/otel/exporters/stdout/stdoutlog v0.22.0/go.mod h1:L9Dlksri+MdT1cb2gIiA1cJJYW3Y92ipvDjNxYEyaDI= +go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.46.0 h1:PR9eAf7o0dQs3hshZNZpE9aW2dXWX/KdDf6pJilVD3U= +go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.46.0/go.mod h1:2Z4KyNdH1uuzivdinyfGsxzNNT/Rl45pwtVwfYVI0xk= +go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.46.0 h1:KdRxPiAoMptR3vfWzvjjvutTsSiwbC2uG0496rzZNfo= +go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.46.0/go.mod h1:K/qSA+3G7Eovxi4K09wzrAgkWRnosS0DAOZeEpve7sM= +go.opentelemetry.io/otel/log v0.22.0 h1:5DBNnfvaJ6CVdkJ+Jle8Tzs50aSSv49TXGj9XRsEYw0= +go.opentelemetry.io/otel/log v0.22.0/go.mod h1:gzOt/R67vF2GniAqWu8Qv0SXy89f71muHcrkz76PCdc= +go.opentelemetry.io/otel/metric v1.46.0 h1:yBnkXvgV7AXFILZc5K6IZe/CBFF3OS7BJ8ov6/lj0K8= +go.opentelemetry.io/otel/metric v1.46.0/go.mod h1:iPmdWqifKUdzziPkvvzIJXITl56fQx2mGM/DHLB3/2o= +go.opentelemetry.io/otel/metric/x v0.68.0 h1:TA/cBT23D3MnxYPwHL7YFOdYGdx0A0v+s7Mzotpd1dU= +go.opentelemetry.io/otel/metric/x v0.68.0/go.mod h1:agudOmvWhwUTjgibWDzxD2PoWYnpw5Ht5jISYOD2Hd4= +go.opentelemetry.io/otel/sdk v1.46.0 h1:h5CNQQjEbuQXY/JfZtgt3i7HVFV3aHPO2OAwO2eTYPI= +go.opentelemetry.io/otel/sdk v1.46.0/go.mod h1:GAERFXFt5SYCEB+YiKUbMBeza6UaDH7GmGOZEfh2gSM= +go.opentelemetry.io/otel/sdk/log v0.22.0 h1:PRL+s6P63XT4E/bheEflopPUpVxuvANqZwtt89yhoGk= +go.opentelemetry.io/otel/sdk/log v0.22.0/go.mod h1:JNp0sBELrjCTcu5W3GzABVypeU6vDJjBS+X0JISuz+g= +go.opentelemetry.io/otel/sdk/log/logtest v0.22.0 h1:infPnfNrhCNgOUZRs3gWUg8vhoBUHihq02gwK05gzlg= +go.opentelemetry.io/otel/sdk/log/logtest v0.22.0/go.mod h1:gkQZA3z15Bv3KU9vigBTi8dFechSozRP7v94X4VZv+s= +go.opentelemetry.io/otel/sdk/metric v1.46.0 h1:0piZ26EG4RBfebb2jhDH6ERCYHoVWduc3kLgPCwSnSE= +go.opentelemetry.io/otel/sdk/metric v1.46.0/go.mod h1:I1PbKrdVc8Qu8HYVDNtqVIwLwjNrhsV/uFuxfwg8mO4= +go.opentelemetry.io/otel/trace v1.46.0 h1:OULy7ccdJnZtJ0UDYFOIGaCmiWzJ8Vi2G/Rsu60qs1c= +go.opentelemetry.io/otel/trace v1.46.0/go.mod h1:J7GAXweO77XSFkB/rmAqk9D6ihszhFjLU+d9WuUxDLI= +go.opentelemetry.io/proto/otlp v1.11.0 h1:5rrYs0Ykyj50sdU/JU0x8etU+LubXWb+gED6TbEdMIk= +go.opentelemetry.io/proto/otlp v1.11.0/go.mod h1:SmVizdCOAm3XBtG1g1NnOdhW6jtddT72hLMhv8VwA8E= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= -go.uber.org/zap v1.27.1 h1:08RqriUEv8+ArZRYSTXy1LeBScaMpVSTBhCeaZYfMYc= -go.uber.org/zap v1.27.1/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E= +go.uber.org/zap v1.28.0 h1:IZzaP1Fv73/T/pBMLk4VutPl36uNC+OSUh3JLG3FIjo= +go.uber.org/zap v1.28.0/go.mod h1:rDLpOi171uODNm/mxFcuYWxDsqWSAVkFdX4XojSKg/Q= go.yaml.in/yaml/v2 v2.4.4 h1:tuyd0P+2Ont/d6e2rl3be67goVK4R6deVxCUX5vyPaQ= go.yaml.in/yaml/v2 v2.4.4/go.mod h1:gMZqIpDtDqOfM0uNfy0SkpRhvUryYH0Z6wdMYcacYXQ= -golang.org/x/crypto v0.52.0 h1:RMs7fP2rXdep0CftQlK8Uf+kibLm7qkCcradZWYz988= -golang.org/x/crypto v0.52.0/go.mod h1:1QgfPxDqh0T2M/elOJtp9RvuR95kVjir0e6/BvEmGbc= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= +golang.org/x/crypto v0.55.0 h1:+KWHjbgOaAQ66dh/YlkZKHlz9ZUlq61AFirAR9ntP8M= +golang.org/x/crypto v0.55.0/go.mod h1:uq0V9dE/fzQuJtbnL+2EhWOE63vo164FY8xqEnV9xis= golang.org/x/exp v0.0.0-20260508232706-74f9aab9d74a h1:+3jdDGGB8NGb1Zktc737jlt3/A5f6UlwSzmvqUuufxw= golang.org/x/exp v0.0.0-20260508232706-74f9aab9d74a/go.mod h1:d2fgXJLVs4dYDHUk5lwMIfzRzSrWCfGZb0ZqeLa/Vcw= -golang.org/x/net v0.55.0 h1:bcvxaJn3e1U6InsFWt1JUq1aSjnRxLzT2rtD2KfkDF8= -golang.org/x/net v0.55.0/go.mod h1:L5U2KuzuOe1lY7Z+aWVIKK6qEeJXnXV9yzGA+WCHJww= -golang.org/x/sys v0.45.0 h1:dO4czNzziLiiXplLQgBCEpCvXQ3dnkn0SdaZSYdQ+FY= -golang.org/x/sys v0.45.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= -golang.org/x/text v0.37.0 h1:Cqjiwd9eSg8e0QAkyCaQTNHFIIzWtidPahFWR83rTrc= -golang.org/x/text v0.37.0/go.mod h1:a5sjxXGs9hsn/AJVwuElvCAo9v8QYLzvavO5z2PiM38= +golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To= +golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU= +golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= +golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= +golang.org/x/text v0.41.0 h1:vz/seA0lnX87Othu2f/0L24RcgrXD9/YFTSuGjj3rH8= +golang.org/x/text v0.41.0/go.mod h1:jvf1O8ajNzZqhSrQBPbutR/EB83Cc0CFrezNQIwbb5M= golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U= golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno= gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4= gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E= -google.golang.org/genproto/googleapis/api v0.0.0-20260526163538-3dc84a4a5aaa h1:Kjn0N0tCrDgiAFW+lGO4JZ3ck44CehvJQMAwj9QF0G8= -google.golang.org/genproto/googleapis/api v0.0.0-20260526163538-3dc84a4a5aaa/go.mod h1:q4lMZS6kskjT5HvCPrnnypcDPVJqT/f4nfxmkE7gryY= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260526163538-3dc84a4a5aaa h1:mZHHdPZl0dbGHCflZgAq/Q468DWVFcU2whhB2KAo8fk= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260526163538-3dc84a4a5aaa/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= +google.golang.org/genproto/googleapis/api v0.0.0-20260819154853-08b0e4226688 h1:ax2KzoSRIZU/M0cIxri3pKxy99vniH1PVxWC6si/eZI= +google.golang.org/genproto/googleapis/api v0.0.0-20260819154853-08b0e4226688/go.mod h1:1RJ9BQGyNdZwkGc1eTqkErfRZ6RJyYPHZo73BZ1vQqI= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260819154853-08b0e4226688 h1:cYNAzI2sUwhmCcoj9TxvihSrqsxt6uIkj3rDRhSDmW4= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260819154853-08b0e4226688/go.mod h1:DjtHYE8FKJLivXcBEjGwndXfIC23G0VpXiXKqG179uA= google.golang.org/grpc v1.83.1 h1:HIO0+BEtBP6soyqvqC8sNUjZ7bTs+0hFQuFF+RAy++Y= google.golang.org/grpc v1.83.1/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= -google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE= -google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= +google.golang.org/protobuf v1.36.12 h1:pJOKDDOyeXErUroCihFAd5LQuwXBSpVnKGrj5o/fwxc= +google.golang.org/protobuf v1.36.12/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= diff --git a/system-tests/tests/go.mod b/system-tests/tests/go.mod index b7ec75436d9..22144985dd4 100644 --- a/system-tests/tests/go.mod +++ b/system-tests/tests/go.mod @@ -64,7 +64,7 @@ require ( github.com/rs/zerolog v1.35.1 github.com/smartcontractkit/chain-selectors v1.0.109 github.com/smartcontractkit/chainlink-ccip/chains/solana v0.0.0-20260908155618-50f521d70e62 - github.com/smartcontractkit/chainlink-common v0.11.2-0.20260914191328-10cc2b41997e + github.com/smartcontractkit/chainlink-common v0.11.2-0.20260915135448-9ec0150ecb5d github.com/smartcontractkit/chainlink-common/keystore v1.3.1-0.20260903141829-ef07b52a737d github.com/smartcontractkit/chainlink-confidential-compute v1.3.0 github.com/smartcontractkit/chainlink-confidential-compute/tests/testhelpers v0.0.0-20260812145307-d77342c53d7d diff --git a/system-tests/tests/go.sum b/system-tests/tests/go.sum index 0dbd74317e3..36c257a8631 100644 --- a/system-tests/tests/go.sum +++ b/system-tests/tests/go.sum @@ -1833,8 +1833,8 @@ github.com/smartcontractkit/chainlink-ccip/chains/solana/gobindings v0.0.0-20260 github.com/smartcontractkit/chainlink-ccip/chains/solana/gobindings v0.0.0-20260908155618-50f521d70e62/go.mod h1:c++Ed0jeYn4w8WIfiAboRwN6ClRRVGglL0qwB/QjJvM= github.com/smartcontractkit/chainlink-ccv v0.12.0 h1:/EbL7S96ItC3YF9pZ/fihbxugYxT1xxLSQSFJT4JQoQ= github.com/smartcontractkit/chainlink-ccv v0.12.0/go.mod h1:yijeTgli1K0e1noV/06/etKFxnYz8kBIe3IVXBaGnQw= -github.com/smartcontractkit/chainlink-common v0.11.2-0.20260914191328-10cc2b41997e h1:T9s34qknjJVSXBUeD0S/RoHu2t+iuoMiUOL0xdkQCk8= -github.com/smartcontractkit/chainlink-common v0.11.2-0.20260914191328-10cc2b41997e/go.mod h1:ks0kniCCg8Siv2XflmwLOq5ib9Ifoh6VHXHwfEWIMQA= +github.com/smartcontractkit/chainlink-common v0.11.2-0.20260915135448-9ec0150ecb5d h1:4heqJxOTXBHR3425SuXe9EzkZq+CqWOdKe4KWzAoGYA= +github.com/smartcontractkit/chainlink-common v0.11.2-0.20260915135448-9ec0150ecb5d/go.mod h1:ks0kniCCg8Siv2XflmwLOq5ib9Ifoh6VHXHwfEWIMQA= github.com/smartcontractkit/chainlink-common/keystore v1.3.1-0.20260903141829-ef07b52a737d h1:M9xuiIvdiHtim4nlxCVajyC/Mk63tAg9ESWb/biAhNA= github.com/smartcontractkit/chainlink-common/keystore v1.3.1-0.20260903141829-ef07b52a737d/go.mod h1:rI2njmTlyTvh+xhmORmK6qX3+V1ycDAqGJLu8LS8WpU= github.com/smartcontractkit/chainlink-common/pkg/chipingress v0.0.11-0.20260724142814-45996a1bcb72 h1:uWEwl7i2ryuRVoV4DmIKm6mqYevf1lH/8cQYhw/JXko=