fix(exporter): populate dutyStore in all modes — stop blackholing exit/proposer/sync-contribution messages

operator/duties/scheduler.go

@@ -95,6 +95,10 @@ type SchedulerOptions struct {
 	// executing duties (e.g., validator registration). When true, scheduler
 	// still fetches/stores duties for all validators but does not execute them.
 	ExporterMode bool
+	// ArchiveMode indicates this is an archive-mode exporter that needs the Attester handler
+	// for duty tracing. Only meaningful when ExporterMode is true; standard-mode exporters skip
+	// the Attester handler to avoid fetching duties for all network validators.
+	ArchiveMode bool
 }
 
 type Scheduler struct {
@@ -165,19 +169,30 @@ func NewScheduler(logger *zap.Logger, opts *SchedulerOptions) *Scheduler {
 
 	s.exporterMode = opts.ExporterMode
 
-	// These handlers fetch & record duties from the beacon node and are needed in both operator & exporter modes.
-	// When adding a new handler here, ensure it supports both modes.
+	// Proposer, SyncCommittee, and VoluntaryExit are needed in all modes.
+	// Proposer and SyncCommittee populate dutyStore entries consulted by message validation on all
+	// node types. VoluntaryExit populates the per-(slot,pk) duty count also consulted by validation;
+	// in exporter mode all exit descriptors have OwnValidator=false so no exit is ever executed.
 	s.dutyHandlers = append(s.dutyHandlers,
-		NewAttesterHandler(dutyStore.Attester, opts.ExporterMode),
 		NewProposerHandler(dutyStore.Proposer, opts.ExporterMode),
 		NewSyncCommitteeHandler(dutyStore.SyncCommittee, opts.ExporterMode),
+		NewVoluntaryExitHandler(dutyStore.VoluntaryExit, opts.ValidatorExitCh),
 	)
+
+	// Attester is needed for duty execution (operator) and duty tracing (archive exporter).
+	// Standard-mode exporter skips it: the attester store is not checked by message validation,
+	// and fetching duties for all network validators is expensive without the tracing benefit.
+	if !opts.ExporterMode || opts.ArchiveMode {
+		s.dutyHandlers = append(s.dutyHandlers,
+			NewAttesterHandler(dutyStore.Attester, opts.ExporterMode),
+		)
+	}
+
 	// These handlers only execute duties and are not needed in exporter mode.
 	if !opts.ExporterMode {
 		s.dutyHandlers = append(s.dutyHandlers,
 			NewCommitteeHandler(dutyStore.Attester, dutyStore.SyncCommittee),
 			NewValidatorRegistrationHandler(opts.ValidatorRegistrationCh),
-			NewVoluntaryExitHandler(dutyStore.VoluntaryExit, opts.ValidatorExitCh),
 		)
 	}
 	return s

operator/duties/scheduler_test.go

@@ -693,3 +693,61 @@ func TestScheduler_HandleHeadEvent_DoesNotBlockWithoutReorgConsumer(t *testing.T
 		PreviousDutyDependentRootChanged: true,
 	}}, drainReorgEvents(s.reorgCh))
 }
+
+func TestNewScheduler_HandlerRegistration(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name         string
+		exporterMode bool
+		archiveMode  bool
+		wantHandlers []string
+	}{
+		{
+			name:         "operator mode",
+			exporterMode: false,
+			archiveMode:  false,
+			wantHandlers: []string{"PROPOSER", "SYNC_COMMITTEE", "VOLUNTARY_EXIT", "ATTESTER", "CLUSTER", "VALIDATOR_REGISTRATION"},
+		},
+		{
+			name:         "standard exporter",
+			exporterMode: true,
+			archiveMode:  false,
+			// VoluntaryExit is included so the dutyStore is populated for message validation;
+			// Attester is excluded because the standard exporter does not trace duties.
+			wantHandlers: []string{"PROPOSER", "SYNC_COMMITTEE", "VOLUNTARY_EXIT"},
+		},
+		{
+			name:         "archive exporter",
+			exporterMode: true,
+			archiveMode:  true,
+			// Archive exporter needs Attester for full duty tracing but still skips
+			// execution-only handlers (CLUSTER, VALIDATOR_REGISTRATION).
+			wantHandlers: []string{"PROPOSER", "SYNC_COMMITTEE", "VOLUNTARY_EXIT", "ATTESTER"},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+
+			s := NewScheduler(zap.NewNop(), &SchedulerOptions{
+				ExporterMode: tc.exporterMode,
+				ArchiveMode:  tc.archiveMode,
+				SlotTickerProvider: func() slotticker.SlotTicker {
+					return NewMockSlotTicker(ctx)
+				},
+			})
+
+			got := make([]string, 0, len(s.dutyHandlers))
+			for _, h := range s.dutyHandlers {
+				got = append(got, h.Name())
+			}
+
+			require.ElementsMatch(t, tc.wantHandlers, got)
+		})
+	}
+}

operator/node.go

@@ -78,8 +78,8 @@ type Node struct {
 	exporterRead *exporter2.Exporter
 }
 
-func shouldRunDutyScheduler(exporterOpts exporter.Options) bool {
-	return !exporterOpts.Enabled || exporterOpts.Mode == exporter.ModeArchive
+func shouldRunDutyScheduler(_ exporter.Options) bool {
+	return true
 }
 
 // New is the constructor of Node
@@ -105,8 +105,8 @@ func New(logger *zap.Logger, opts Options, exporterOpts exporter.Options, slotTi
 
 	var dutyScheduler *duties.Scheduler
 	if shouldRunDutyScheduler(exporterOpts) {
-		// Prepare scheduler wiring; in exporter archive mode we swap to AllShares provider,
-		// a prefetching beacon adapter, and a no-op executor.
+		// Prepare scheduler wiring; in exporter mode (both standard and archive) swap to AllShares
+		// provider, a prefetching beacon adapter, and a no-op executor.
 		schedulerBeacon := duties.BeaconNode(opts.BeaconNode)
 		validatorProvider := duties.ValidatorProvider(selfValidatorStore)
 		dutyExecutor := duties.DutyExecutor(opts.ValidatorController)
@@ -132,6 +132,7 @@ func New(logger *zap.Logger, opts Options, exporterOpts exporter.Options, slotTi
 			SlotTickerProvider:      slotTickerProvider,
 			P2PNetwork:              opts.P2PNetwork,
 			ExporterMode:            exporterOpts.Enabled,
+			ArchiveMode:             exporterOpts.Mode == exporter.ModeArchive,
 		})
 	}
 
@@ -179,8 +180,6 @@ func (n *Node) Start(ctx context.Context) error {
 		if err := n.dutyScheduler.Start(ctx); err != nil {
 			return fmt.Errorf("failed to run duty scheduler: %w", err)
 		}
-	} else {
-		n.logger.Info("exporter standard mode: skipping duty scheduler")
 	}
 
 	n.validatorsCtrl.StartNetworkHandlers()

operator/node_test.go

@@ -27,7 +27,7 @@ func TestShouldRunDutyScheduler(t *testing.T) {
 				Enabled: true,
 				Mode:    exporter.ModeStandard,
 			},
-			expected: false,
+			expected: true,
 		},
 		{
 			name: "exporter archive",