• Add blockedBackupProviders map to track backup providers blocked this epoch
• blockProvider now blocks backup providers when not in validAddresses
• getValidConsumerSessionsWithProviderFromBackupProviderList filters blocked backups
• UpdateAllProviders persists blocked backup providers across epoch transitions
• checkAndUnblockHealthyReBlockedProviders handles backup providers in health probes

Implement backup provider blocking and health probe tracking

• Added blockedBackupProviders map field to track backup providers blocked this epoch
• Modified blockProvider to add backup providers to blockedBackupProviders when not in
 validAddresses
• Updated getValidConsumerSessionsWithProviderFromBackupProviderList to skip providers in
 blockedBackupProviders
• Enhanced UpdateAllProviders to merge blockedBackupProviders into
 previousEpochBlockedProviders and re-block them in new epoch
• Refactored checkAndUnblockHealthyReBlockedProviders to handle both normal and backup providers
 with new reBlockedProviderInfo struct for cross-role transition support

protocol/lavasession/consumer_session_manager.go

Add comprehensive tests for blocked backup provider behavior

• Added createBackupProviderList helper function to create test backup provider lists
• Added TestBlockedBackupProviderIsTracked to verify blockProvider adds backup providers to
 blockedBackupProviders
• Added TestBlockedBackupProviderFilteredFromSelection to verify blocked backups are excluded from
 selection
• Added TestBlockedBackupProviderPersistedAcrossEpoch to verify blocked backups persist across
 epoch transitions
• Added TestNormalProviderBlockedAsBackupInNextEpoch to verify cross-role transition handling

protocol/lavasession/consumer_session_manager_test.go

Description

checkAndUnblockHealthyReBlockedProviders deletes a re-blocked backup provider from
blockedBackupProviders whenever it is not present in reportedProviders, even though
UpdateAllProviders only probes the main pairingList and resets reportedProviders each update. This
makes previously-blocked backup providers appear “probe succeeded” and get unblocked at epoch
transition without ever being probed/reported.

Code

protocol/lavasession/consumer_session_manager.go[R1903-1930]

	for blockedAddr := range csm.previousEpochBlockedProviders {
		cswp, exists := csm.pairing[blockedAddr]
+		isBackup := false
+		if !exists {
+			cswp, exists = csm.backupProviders[blockedAddr]
+			isBackup = true
+		}
		if !exists {
-			continue // Provider not in current pairing
+			continue // Provider not in current pairing or backup list
		}

		// Check if provider is in reported providers
-		// If probe FAILED in this epoch, provider would be in reportedProviders (line 1208)
+		// If probe FAILED in this epoch, provider would be in reportedProviders
		// If probe SUCCEEDED in this epoch, provider would NOT be in reportedProviders
		if !csm.reportedProviders.IsReported(blockedAddr) {
			// Probe succeeded! Provider is healthy, immediately unblock
			utils.LavaFormatInfo("Re-blocked provider's probe succeeded, immediately unblocking",
				utils.Attribute{Key: "provider", Value: blockedAddr},
+				utils.Attribute{Key: "isBackup", Value: isBackup},
				utils.Attribute{Key: "epoch", Value: epoch},
				utils.LogAttr("GUID", ctx),
			)
-			csm.validateAndReturnBlockedProviderToValidAddressesListLocked(blockedAddr)
-
-			// Clean up: Remove from reported providers if it was there from previous epoch
-			// This prevents periodic reconnection attempts from trying this provider again
+			if isBackup {
+				delete(csm.blockedBackupProviders, blockedAddr)
+			} else {
+				csm.validateAndReturnBlockedProviderToValidAddressesListLocked(blockedAddr)
+			}
			csm.reportedProviders.RemoveReport(blockedAddr)

Evidence

UpdateAllProviders’ deferred post-update goroutine probes only the pairingList parameter and then
calls checkAndUnblockHealthyReBlockedProviders; it does not probe backupProviderList. In the same
UpdateAllProviders call, reportedProviders is Reset(), so backup providers will typically not be
reported in the new epoch; checkAndUnblockHealthyReBlockedProviders interprets “not reported” as
“probe succeeded” and deletes backup entries from blockedBackupProviders.

protocol/lavasession/consumer_session_manager.go[154-164]
protocol/lavasession/consumer_session_manager.go[209-222]
protocol/lavasession/consumer_session_manager.go[451-469]
protocol/lavasession/consumer_session_manager.go[1903-1930]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

### Issue description
`checkAndUnblockHealthyReBlockedProviders` currently treats `!reportedProviders.IsReported(addr)` as a successful probe and unblocks re-blocked backup providers by deleting them from `blockedBackupProviders`. But `UpdateAllProviders` only probes `pairingList` (not `backupProviderList`) and also resets `reportedProviders`, so backup providers can be unblocked without any probe.

### Issue Context
This undermines the PR goal of persisting backup-provider blocked state across epochs: re-blocking happens, but the async re-block check can immediately clear it.

### Fix Focus Areas
- protocol/lavasession/consumer_session_manager.go[154-164]
- protocol/lavasession/consumer_session_manager.go[451-469]
- protocol/lavasession/consumer_session_manager.go[1903-1970]

### Suggested change
Make the re-block health decision based on an actual probe outcome for backup providers (or for all re-blocked providers), not on `reportedProviders` membership.
Options:
1) In the deferred goroutine in `UpdateAllProviders`, probe `backupProviderList` too (or probe the subset in `previousEpochBlockedProviders` that are backups) before running `checkAndUnblockHealthyReBlockedProviders`.
2) Refactor `checkAndUnblockHealthyReBlockedProviders` to explicitly call `probeProvider(..., tryReconnect=false)` for each re-blocked provider (including backups) and only unblock on `err == nil`; run the comprehensive probe (`tryReconnect=true`) on failures.

Ensure the logic cannot conclude “probe succeeded” for a provider that was never probed in this epoch.

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

Description

blockProvider writes to csm.blockedBackupProviders when blocking a backup provider that is not in
validAddresses, but NewConsumerSessionManager does not initialize blockedBackupProviders. If
blockProvider is called before the first successful UpdateAllProviders (or after an early-return
error path), this will panic with “assignment to entry in nil map”.

Code

protocol/lavasession/consumer_session_manager.go[R1557-1561]

+			// Address not in validAddresses — check if it's a backup provider and block it there
+			if _, isBackup := csm.backupProviders[address]; isBackup {
+				csm.blockedBackupProviders[address] = struct{}{}
+				utils.LavaFormatInfo("🔒 BLOCKING BACKUP PROVIDER", utils.LogAttr("address", address), utils.LogAttr("GUID", ctx))
+			} else {

Evidence

The new backup-provider blocking path assigns into blockedBackupProviders. The constructor
NewConsumerSessionManager does not initialize blockedBackupProviders (or other maps), so the field
is nil until UpdateAllProviders sets it, making early calls unsafe.

protocol/lavasession/consumer_session_manager.go[1554-1563]
protocol/lavasession/consumer_session_manager.go[1982-2001]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

### Issue description
`blockedBackupProviders` can be nil until `UpdateAllProviders` runs, but `blockProvider` now writes to it for backup providers. Writing to a nil map panics.

### Issue Context
Even if the “normal” lifecycle calls `UpdateAllProviders` first, defensive initialization avoids crashes during startup, error paths, or unexpected call ordering.

### Fix Focus Areas
- protocol/lavasession/consumer_session_manager.go[1982-2001]
- protocol/lavasession/consumer_session_manager.go[1554-1563]

### Suggested change
Initialize `blockedBackupProviders: make(map[string]struct{})` in `NewConsumerSessionManager`.
Additionally (optional hardening): in `blockProvider`, before writing, guard with `if csm.blockedBackupProviders == nil { csm.blockedBackupProviders = make(map[string]struct{}) }` under the existing `csm.lock`.

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

Description

New unit tests are named without the required TestComponent_Scenario underscore format, reducing
consistency and discoverability. This violates the standardized test naming requirement for
new/modified tests.

Code

protocol/lavasession/consumer_session_manager_test.go[R1686-1796]

+// TestBlockedBackupProviderIsTracked verifies that calling blockProvider for a backup provider
+// adds it to blockedBackupProviders (not silently dropped because it's not in validAddresses).
+func TestBlockedBackupProviderIsTracked(t *testing.T) {
+	csm := CreateConsumerSessionManager()
+	backupList := createBackupProviderList(grpcListener)
+	err := csm.UpdateAllProviders(firstEpochHeight, nil, backupList)
+	require.NoError(t, err)
+
+	backupAddr := backupList[0].PublicLavaAddress
+
+	// Block the backup provider
+	err = csm.blockProvider(context.Background(), backupAddr, false, firstEpochHeight, 0, 0, false, nil, nil)
+	require.NoError(t, err)
+
+	csm.lock.RLock()
+	_, blocked := csm.blockedBackupProviders[backupAddr]
+	csm.lock.RUnlock()
+
+	require.True(t, blocked, "backup provider should be in blockedBackupProviders after blockProvider call")
+}
+
+// TestBlockedBackupProviderFilteredFromSelection verifies that a blocked backup provider is
+// not returned by getValidConsumerSessionsWithProviderFromBackupProviderList.
+func TestBlockedBackupProviderFilteredFromSelection(t *testing.T) {
+	csm := CreateConsumerSessionManager()
+	backupList := createBackupProviderList(grpcListener)
+	err := csm.UpdateAllProviders(firstEpochHeight, nil, backupList)
+	require.NoError(t, err)
+
+	backupAddr := backupList[0].PublicLavaAddress
+
+	// Directly mark it blocked
+	csm.lock.Lock()
+	csm.blockedBackupProviders[backupAddr] = struct{}{}
+	csm.lock.Unlock()
+
+	// Attempting to get backup sessions should fail — no eligible backup providers
+	ignored := &ignoredProviders{providers: make(map[string]struct{}), currentEpoch: firstEpochHeight}
+	_, err = csm.getValidConsumerSessionsWithProviderFromBackupProviderList(
+		context.Background(), ignored, 1, servicedBlockNumber, "", nil, 0, 0, NewUsedProviders(nil),
+	)
+	require.Error(t, err, "blocked backup provider should not be selectable")
+}
+
+// TestBlockedBackupProviderPersistedAcrossEpoch verifies that a backup provider blocked in
+// epoch N is re-blocked in epoch N+1 via previousEpochBlockedProviders.
+func TestBlockedBackupProviderPersistedAcrossEpoch(t *testing.T) {
+	csm := CreateConsumerSessionManager()
+	backupList := createBackupProviderList(grpcListener)
+	err := csm.UpdateAllProviders(firstEpochHeight, nil, backupList)
+	require.NoError(t, err)
+
+	backupAddr := backupList[0].PublicLavaAddress
+
+	// Block it in the first epoch
+	err = csm.blockProvider(context.Background(), backupAddr, false, firstEpochHeight, 0, 0, false, nil, nil)
+	require.NoError(t, err)
+
+	csm.lock.RLock()
+	_, blocked := csm.blockedBackupProviders[backupAddr]
+	csm.lock.RUnlock()
+	require.True(t, blocked, "backup provider should be blocked before epoch transition")
+
+	// Transition to next epoch with the same backup provider
+	err = csm.UpdateAllProviders(secondEpochHeight, nil, backupList)
+	require.NoError(t, err)
+
+	// Should still be blocked in the new epoch
+	csm.lock.RLock()
+	_, stillBlocked := csm.blockedBackupProviders[backupAddr]
+	csm.lock.RUnlock()
+	require.True(t, stillBlocked, "backup provider should remain blocked after epoch transition")
+}
+
+// TestNormalProviderBlockedAsBackupInNextEpoch verifies that a provider blocked as a normal
+// provider in epoch N is re-blocked as a backup provider in epoch N+1 if it moves to the backup list.
+func TestNormalProviderBlockedAsBackupInNextEpoch(t *testing.T) {
+	csm := CreateConsumerSessionManager()
+	pairingList := createPairingList("", true)
+	err := csm.UpdateAllProviders(firstEpochHeight, pairingList, nil)
+	require.NoError(t, err)
+
+	// Block a normal provider
+	normalAddr := pairingList[0].PublicLavaAddress
+	err = csm.blockProvider(context.Background(), normalAddr, false, firstEpochHeight, 0, 0, false, nil, nil)
+	require.NoError(t, err)
+
+	csm.lock.RLock()
+	_, inBlockedList := func() (int, bool) {
+		for _, addr := range csm.currentlyBlockedProviderAddresses {
+			if addr == normalAddr {
+				return 0, true
+			}
+		}
+		return 0, false
+	}()
+	csm.lock.RUnlock()
+	require.True(t, inBlockedList, "normal provider should be in currentlyBlockedProviderAddresses")
+
+	// In next epoch the same provider appears only in the backup list
+	backupList := map[uint64]*ConsumerSessionsWithProvider{
+		0: NewConsumerSessionWithProvider(normalAddr, pairingList[0].Endpoints, 1000, secondEpochHeight, sdk.NewCoin("ulava", sdk.NewInt(100))),
+	}
+	err = csm.UpdateAllProviders(secondEpochHeight, nil, backupList)
+	require.NoError(t, err)
+
+	csm.lock.RLock()
+	_, blockedAsBackup := csm.blockedBackupProviders[normalAddr]
+	csm.lock.RUnlock()
+	require.True(t, blockedAsBackup, "previously-blocked normal provider should be re-blocked as backup in new epoch")
+}

Evidence

PR Compliance ID 5 requires new/modified tests to follow the TestComponent_Scenario naming
convention. The newly-added tests (TestBlockedBackupProviderIsTracked,
TestBlockedBackupProviderFilteredFromSelection, etc.) do not include an underscore separator.

AGENTS.md
protocol/lavasession/consumer_session_manager_test.go[1686-1796]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
New tests added in `consumer_session_manager_test.go` do not follow the required `TestComponent_Scenario` naming convention (underscore-separated).

## Issue Context
Compliance requires standardized test naming for new/modified tests to improve consistency and discoverability.

## Fix Focus Areas
- protocol/lavasession/consumer_session_manager_test.go[1686-1796]

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

Description

The new tests assert blockedBackupProviders immediately after UpdateAllProviders, but
UpdateAllProviders runs a deferred sleep and then asynchronously probes/unblocks providers, mutating
blockedBackupProviders after the call returns. This makes the tests timing-dependent and can hide
the real post-transition state.

Code

protocol/lavasession/consumer_session_manager_test.go[R1730-1758]

+// TestBlockedBackupProviderPersistedAcrossEpoch verifies that a backup provider blocked in
+// epoch N is re-blocked in epoch N+1 via previousEpochBlockedProviders.
+func TestBlockedBackupProviderPersistedAcrossEpoch(t *testing.T) {
+	csm := CreateConsumerSessionManager()
+	backupList := createBackupProviderList(grpcListener)
+	err := csm.UpdateAllProviders(firstEpochHeight, nil, backupList)
+	require.NoError(t, err)
+
+	backupAddr := backupList[0].PublicLavaAddress
+
+	// Block it in the first epoch
+	err = csm.blockProvider(context.Background(), backupAddr, false, firstEpochHeight, 0, 0, false, nil, nil)
+	require.NoError(t, err)
+
+	csm.lock.RLock()
+	_, blocked := csm.blockedBackupProviders[backupAddr]
+	csm.lock.RUnlock()
+	require.True(t, blocked, "backup provider should be blocked before epoch transition")
+
+	// Transition to next epoch with the same backup provider
+	err = csm.UpdateAllProviders(secondEpochHeight, nil, backupList)
+	require.NoError(t, err)
+
+	// Should still be blocked in the new epoch
+	csm.lock.RLock()
+	_, stillBlocked := csm.blockedBackupProviders[backupAddr]
+	csm.lock.RUnlock()
+	require.True(t, stillBlocked, "backup provider should remain blocked after epoch transition")
+}

Evidence

UpdateAllProviders defers a sleep and then launches an async goroutine that calls
checkAndUnblockHealthyReBlockedProviders, which can delete from blockedBackupProviders. The tests
check blockedBackupProviders state right after UpdateAllProviders without synchronizing with that
goroutine.

protocol/lavasession/consumer_session_manager.go[154-164]
protocol/lavasession/consumer_session_manager_test.go[1730-1758]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

### Issue description
Tests read `blockedBackupProviders` immediately after `UpdateAllProviders`, but `UpdateAllProviders` triggers async probe/unblock work after a deferred sleep. Assertions can be invalid depending on scheduling.

### Issue Context
These tests should either:
- assert the *pre-async* state deterministically (requires a hook/flag to disable async goroutines in tests), or
- wait for the async epoch-transition work to complete and then assert the expected *post-async* state.

### Fix Focus Areas
- protocol/lavasession/consumer_session_manager.go[154-164]
- protocol/lavasession/consumer_session_manager_test.go[1686-1796]

### Suggested change
Introduce a test-only mechanism to control epoch-transition goroutines (e.g., inject a sleeper/hook, or a `DisableAsyncProbes` flag), or have tests wait on a deterministic signal (e.g., poll until `previousEpochBlockedProviders` is cleared, since `checkAndUnblockHealthyReBlockedProviders` clears it in a deferred cleanup) before asserting final blocked/unblocked state.

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.