Add fallback to selectors and rehydrate actions

Author: sophieqgu

app/core/Engine/controllers/rewards-controller/RewardsController.ts

@@ -52,6 +52,10 @@ import {
   BASE32_REGEX,
   CampaignType,
 } from './types';
+import {
+  defaultRewardsControllerState,
+  getRewardsControllerDefaultState,
+} from './defaultState';
 import type { RewardsControllerMessenger } from '../../messengers/rewards-controller-messenger';
 import {
   storeSubscriptionToken,
@@ -308,36 +312,7 @@ const metadata: StateMetadata<RewardsControllerState> = {
   },
 };
 
-/**
- * Get the default state for the RewardsController
- */
-export const getRewardsControllerDefaultState = (): RewardsControllerState => ({
-  activeAccount: null,
-  accounts: {},
-  subscriptions: {},
-  subscriptionBenefits: {},
-  seasons: {},
-  subscriptionReferralDetails: {},
-  seasonStatuses: {},
-  activeBoosts: {},
-  unlockedRewards: {},
-  pointsEvents: {},
-  offDeviceSubscriptionAccounts: {},
-  campaigns: {},
-  campaignParticipantStatus: {},
-  ondoCampaignLeaderboard: {},
-  ondoCampaignLeaderboardPositions: {},
-  ondoCampaignPortfolio: {},
-  ondoCampaignActivity: {},
-  ondoCampaignDeposits: {},
-  perpsTradingCampaignLeaderboard: {},
-  perpsTradingCampaignLeaderboardPositions: {},
-  perpsTradingCampaignVolume: {},
-  pointsEstimateHistory: [],
-  rewardsEnvUrl: null,
-});
-
-export const defaultRewardsControllerState = getRewardsControllerDefaultState();
+export { defaultRewardsControllerState, getRewardsControllerDefaultState };
 
 type CacheReader<T> = (
   key: string,

app/core/Engine/controllers/rewards-controller/defaultState.ts

@@ -0,0 +1,32 @@
+import type { RewardsControllerState } from './types';
+
+/**
+ * Get the default state for the RewardsController.
+ */
+export const getRewardsControllerDefaultState = (): RewardsControllerState => ({
+  activeAccount: null,
+  accounts: {},
+  subscriptions: {},
+  subscriptionBenefits: {},
+  seasons: {},
+  subscriptionReferralDetails: {},
+  seasonStatuses: {},
+  activeBoosts: {},
+  unlockedRewards: {},
+  pointsEvents: {},
+  offDeviceSubscriptionAccounts: {},
+  campaigns: {},
+  campaignParticipantStatus: {},
+  ondoCampaignLeaderboard: {},
+  ondoCampaignLeaderboardPositions: {},
+  ondoCampaignPortfolio: {},
+  ondoCampaignActivity: {},
+  ondoCampaignDeposits: {},
+  perpsTradingCampaignLeaderboard: {},
+  perpsTradingCampaignLeaderboardPositions: {},
+  perpsTradingCampaignVolume: {},
+  pointsEstimateHistory: [],
+  rewardsEnvUrl: null,
+});
+
+export const defaultRewardsControllerState = getRewardsControllerDefaultState();

app/reducers/rewards/index.test.ts

@@ -2328,6 +2328,27 @@ describe('rewardsReducer', () => {
       );
     });
 
+    it('should default persisted season arrays to empty arrays when absent', () => {
+      const persistedRewardsStateWithoutFields = {
+        ...initialState,
+        seasonTiers: undefined,
+        seasonActivityTypes: undefined,
+        seasonWaysToEarn: undefined,
+      } as unknown as RewardsState;
+      const rehydrateAction = {
+        type: 'persist/REHYDRATE',
+        payload: {
+          rewards: persistedRewardsStateWithoutFields,
+        },
+      };
+
+      const state = rewardsReducer(initialState, rehydrateAction);
+
+      expect(state.seasonTiers).toEqual([]);
+      expect(state.seasonActivityTypes).toEqual([]);
+      expect(state.seasonWaysToEarn).toEqual([]);
+    });
+
     it('should preserve all persisted UI state fields', () => {
       // Arrange
       const persistedRewardsState: RewardsState = {
@@ -4638,6 +4659,17 @@ describe('setBenefits', () => {
     expect(state.benefits).toEqual(mockBenefitsPayload.benefits);
   });
 
+  it('sets benefits to empty array when payload benefits are missing', () => {
+    const action = setBenefits({
+      ...mockBenefitsPayload,
+      benefits: undefined,
+    } as unknown as typeof mockBenefitsPayload);
+
+    const state = rewardsReducer(initialState, action);
+
+    expect(state.benefits).toEqual([]);
+  });
+
   it('replaces existing benefits with new payload benefits', () => {
     const stateWithBenefits: RewardsState = {
       ...initialState,

app/reducers/rewards/index.ts

@@ -687,7 +687,7 @@ const rewardsSlice = createSlice({
     },
 
     setBenefits: (state, action: PayloadAction<SubscriptionBenefitsState>) => {
-      state.benefits = action.payload.benefits;
+      state.benefits = action.payload.benefits ?? [];
     },
 
     setBenefitsLoading: (state, action: PayloadAction<boolean>) => {
@@ -897,9 +897,10 @@ const rewardsSlice = createSlice({
               seasonName: action.payload.rewards.seasonName,
               seasonStartDate: action.payload.rewards.seasonStartDate,
               seasonEndDate: action.payload.rewards.seasonEndDate,
-              seasonTiers: action.payload.rewards.seasonTiers,
-              seasonActivityTypes: action.payload.rewards.seasonActivityTypes,
-              seasonWaysToEarn: action.payload.rewards.seasonWaysToEarn,
+              seasonTiers: action.payload.rewards.seasonTiers ?? [],
+              seasonActivityTypes:
+                action.payload.rewards.seasonActivityTypes ?? [],
+              seasonWaysToEarn: action.payload.rewards.seasonWaysToEarn ?? [],
               referralCode: action.payload.rewards.referralCode,
               refereeCount: action.payload.rewards.refereeCount,
               currentTier: action.payload.rewards.currentTier,

app/reducers/rewards/selectors.test.ts

@@ -46,6 +46,7 @@ import {
   selectBulkLinkFailedAccounts,
   selectBulkLinkWasInterrupted,
   selectBulkLinkAccountProgress,
+  selectBenefits,
   selectCampaigns,
   selectCampaignsLoading,
   selectCampaignsError,
@@ -85,6 +86,7 @@ import {
   SeasonWayToEarnDto,
   PointsEventDto,
   OndoGmActivityEntryDto,
+  SubscriptionBenefitDto,
 } from '../../core/Engine/controllers/rewards-controller/types';
 import { RootState } from '..';
 import { RewardsState, AccountOptInBannerInfoStatus } from '.';
@@ -550,6 +552,16 @@ describe('Rewards selectors', () => {
       expect(result.current).toEqual([]);
     });
 
+    it('returns empty array when season tiers are undefined', () => {
+      const mockState = {
+        rewards: { seasonTiers: undefined },
+      } as unknown as RootState;
+      mockedUseSelector.mockImplementation((selector) => selector(mockState));
+
+      const { result } = renderHook(() => useSelector(selectSeasonTiers));
+      expect(result.current).toEqual([]);
+    });
+
     it('returns season tiers when set', () => {
       const mockTiers: SeasonTierDto[] = [
         {
@@ -605,6 +617,18 @@ describe('Rewards selectors', () => {
       expect(result.current).toEqual([]);
     });
 
+    it('returns empty array when season activity types are undefined', () => {
+      const mockState = {
+        rewards: { seasonActivityTypes: undefined },
+      } as unknown as RootState;
+      mockedUseSelector.mockImplementation((selector) => selector(mockState));
+
+      const { result } = renderHook(() =>
+        useSelector(selectSeasonActivityTypes),
+      );
+      expect(result.current).toEqual([]);
+    });
+
     it('returns season activity types when set', () => {
       const mockActivityTypes: SeasonActivityTypeDto[] = [
         {
@@ -639,6 +663,16 @@ describe('Rewards selectors', () => {
       expect(result.current).toEqual([]);
     });
 
+    it('returns empty array when season ways to earn are undefined', () => {
+      const mockState = {
+        rewards: { seasonWaysToEarn: undefined },
+      } as unknown as RootState;
+      mockedUseSelector.mockImplementation((selector) => selector(mockState));
+
+      const { result } = renderHook(() => useSelector(selectSeasonWaysToEarn));
+      expect(result.current).toEqual([]);
+    });
+
     it('returns season ways to earn when set', () => {
       const mockWaysToEarn: SeasonWayToEarnDto[] = [
         {
@@ -1033,6 +1067,18 @@ describe('Rewards selectors', () => {
       expect(result.current).toHaveLength(0);
     });
 
+    it('returns empty array when account banner config is undefined', () => {
+      const mockState = {
+        rewards: { hideCurrentAccountNotOptedInBanner: undefined },
+      } as unknown as RootState;
+      mockedUseSelector.mockImplementation((selector) => selector(mockState));
+
+      const { result } = renderHook(() =>
+        useSelector(selectHideCurrentAccountNotOptedInBannerArray),
+      );
+      expect(result.current).toEqual([]);
+    });
+
     it('returns single account configuration when set', () => {
       const mockAccountConfig: AccountOptInBannerInfoStatus = {
         accountGroupId: 'keyring:wallet1/1',
@@ -3120,6 +3166,37 @@ describe('Rewards selectors', () => {
     showUpcomingDate: false,
   };
 
+  describe('selectBenefits', () => {
+    const mockBenefit: SubscriptionBenefitDto = {
+      id: 101,
+      longTitle: 'Premium Access',
+      shortDescription: 'Get premium perks',
+      longDescription: 'Unlock premium partner benefits.',
+      thumbnail: 'https://example.com/benefits/premium.png',
+      validFrom: '2026-01-01T00:00:00.000Z',
+      validTo: '2026-12-31T00:00:00.000Z',
+      actionDate: '2026-06-01T00:00:00.000Z',
+      url: 'https://example.com/claim',
+      chain: 'ethereum',
+      type: {
+        id: 1,
+        name: 'Partner',
+      },
+    };
+
+    it('returns empty array when benefits are undefined', () => {
+      const state = createMockRootState({
+        benefits: undefined as unknown as SubscriptionBenefitDto[],
+      });
+      expect(selectBenefits(state)).toEqual([]);
+    });
+
+    it('returns benefits when they exist', () => {
+      const state = createMockRootState({ benefits: [mockBenefit] });
+      expect(selectBenefits(state)).toEqual([mockBenefit]);
+    });
+  });
+
   describe('selectCampaigns', () => {
     it('returns empty array when campaigns is empty', () => {
       const mockState = { rewards: { campaigns: [] } };
@@ -3878,6 +3955,16 @@ describe('Rewards selectors', () => {
       expect(selectDismissedCampaignOutcomeToasts(state)).toEqual({});
     });
 
+    it('returns empty object when dismissed toasts are undefined', () => {
+      const state = createMockRootState({
+        dismissedCampaignOutcomeToasts: undefined as unknown as Record<
+          string,
+          boolean
+        >,
+      });
+      expect(selectDismissedCampaignOutcomeToasts(state)).toEqual({});
+    });
+
     it('returns the dismissed toasts map', () => {
       const dismissed = {
         'campaign-1:sub-1:winner': true,

app/reducers/rewards/selectors.ts

@@ -1,11 +1,8 @@
 import { createSelector } from 'reselect';
-import { RootState } from '..';
+import type { RootState } from '..';
+import { initialState } from '.';
 import { RewardsTab, OnboardingStep } from './types';
 import { hasMinimumRequiredVersion } from '../../util/remoteFeatureFlag';
-import {
-  CampaignDto,
-  SubscriptionBenefitDto,
-} from '../../core/Engine/controllers/rewards-controller/types.ts';
 
 export const selectActiveTab = (state: RootState): RewardsTab =>
   state.rewards.activeTab;
@@ -52,14 +49,20 @@ export const selectSeasonStartDate = (state: RootState) =>
 export const selectSeasonEndDate = (state: RootState) =>
   state.rewards.seasonEndDate;
 
-export const selectSeasonTiers = (state: RootState) =>
-  state.rewards.seasonTiers;
+export const selectSeasonTiers = (
+  state: RootState,
+): RootState['rewards']['seasonTiers'] =>
+  state.rewards.seasonTiers ?? initialState.seasonTiers;
 
-export const selectSeasonActivityTypes = (state: RootState) =>
-  state.rewards.seasonActivityTypes;
+export const selectSeasonActivityTypes = (
+  state: RootState,
+): RootState['rewards']['seasonActivityTypes'] =>
+  state.rewards.seasonActivityTypes ?? initialState.seasonActivityTypes;
 
-export const selectSeasonWaysToEarn = (state: RootState) =>
-  state.rewards.seasonWaysToEarn;
+export const selectSeasonWaysToEarn = (
+  state: RootState,
+): RootState['rewards']['seasonWaysToEarn'] =>
+  state.rewards.seasonWaysToEarn ?? initialState.seasonWaysToEarn;
 
 export const selectOnboardingActiveStep = (state: RootState): OnboardingStep =>
   state.rewards.onboardingActiveStep;
@@ -93,7 +96,9 @@ export const selectHideUnlinkedAccountsBanner = (state: RootState) =>
 
 export const selectHideCurrentAccountNotOptedInBannerArray = (
   state: RootState,
-) => state.rewards.hideCurrentAccountNotOptedInBanner;
+): RootState['rewards']['hideCurrentAccountNotOptedInBanner'] =>
+  state.rewards.hideCurrentAccountNotOptedInBanner ??
+  initialState.hideCurrentAccountNotOptedInBanner;
 
 export const selectActiveBoosts = (state: RootState) =>
   state.rewards.activeBoosts;
@@ -155,16 +160,19 @@ export const selectBulkLinkAccountProgress = (state: RootState) => {
 };
 
 // Benefits selectors
-export const selectBenefits = (state: RootState): SubscriptionBenefitDto[] =>
-  state.rewards.benefits;
+export const selectBenefits = (
+  state: RootState,
+): RootState['rewards']['benefits'] =>
+  state.rewards.benefits ?? initialState.benefits;
 
 export const selectBenefitsLoading = (state: RootState): boolean =>
   state.rewards.benefitsLoading;
 
 // Campaigns selectors
-const EMPTY_CAMPAIGNS: CampaignDto[] = [];
-export const selectCampaigns = (state: RootState): CampaignDto[] =>
-  state.rewards.campaigns ?? EMPTY_CAMPAIGNS;
+export const selectCampaigns = (
+  state: RootState,
+): RootState['rewards']['campaigns'] =>
+  state.rewards.campaigns ?? initialState.campaigns;
 
 export const selectCampaignById = (campaignId: string) => (state: RootState) =>
   state.rewards.campaigns?.find((c) => c.id === campaignId) ?? null;
@@ -322,8 +330,11 @@ export const selectOndoCampaignDepositsError = (state: RootState) =>
 export const selectPendingDeeplink = (state: RootState) =>
   state.rewards.pendingDeeplink;
 
-export const selectDismissedCampaignOutcomeToasts = (state: RootState) =>
-  state.rewards.dismissedCampaignOutcomeToasts;
+export const selectDismissedCampaignOutcomeToasts = (
+  state: RootState,
+): RootState['rewards']['dismissedCampaignOutcomeToasts'] =>
+  state.rewards.dismissedCampaignOutcomeToasts ??
+  initialState.dismissedCampaignOutcomeToasts;
 
 // Perps Trading Campaign leaderboard selectors
 export const selectPerpsTradingCampaignLeaderboard = (state: RootState) =>