Multi program expensify card feeds

src/ONYXKEYS.ts

@@ -923,6 +923,9 @@ const ONYXKEYS = {
         /** Currently displaying Expensify Card feed */
         LAST_SELECTED_EXPENSIFY_CARD_FEED: 'lastSelectedExpensifyCardFeed_',
 
+        /** Currently displaying Expensify Card program within the selected feed (US/GB), for domains provisioned with more than one program */
+        LAST_SELECTED_EXPENSIFY_CARD_PROGRAM: 'lastSelectedExpensifyCardProgram_',
+
         /**  Whether the bank account chosen for Expensify Card in on verification waitlist */
         NVP_EXPENSIFY_ON_CARD_WAITLIST: 'nvp_expensify_onCardWaitlist_',
 
@@ -1454,6 +1457,7 @@ type OnyxCollectionValuesMapping = {
     [ONYXKEYS.COLLECTION.TRAVEL_INVOICING_RECONCILIATION_BANK_ACCOUNT_ID]: string;
     [ONYXKEYS.COLLECTION.LAST_SELECTED_FEED]: OnyxTypes.CompanyCardFeedWithDomainID;
     [ONYXKEYS.COLLECTION.LAST_SELECTED_EXPENSIFY_CARD_FEED]: OnyxTypes.FundID;
+    [ONYXKEYS.COLLECTION.LAST_SELECTED_EXPENSIFY_CARD_PROGRAM]: string;
     [ONYXKEYS.COLLECTION.NVP_EXPENSIFY_ON_CARD_WAITLIST]: OnyxTypes.CardOnWaitlist;
     [ONYXKEYS.COLLECTION.RAM_ONLY_ISSUE_NEW_EXPENSIFY_CARD]: OnyxTypes.IssueNewCard;
     [ONYXKEYS.COLLECTION.SAML_METADATA]: OnyxTypes.SamlMetadata;

src/ROUTES.ts

@@ -2943,11 +2943,13 @@ const ROUTES = {
     },
     WORKSPACE_EXPENSIFY_CARD_ADD_WORK_EMAIL: {
         route: 'workspaces/:policyID/expensify-card/:fundID/work-email',
-        getRoute: (policyID: string, fundID: number) => `workspaces/${policyID}/expensify-card/${encodeURIComponent(fundID)}/work-email` as const,
+        getRoute: (policyID: string, fundID: number, feedCountry?: string) =>
+            `workspaces/${policyID}/expensify-card/${encodeURIComponent(fundID)}/work-email${feedCountry ? `?feedCountry=${feedCountry}` : ''}` as const,
     },
     WORKSPACE_EXPENSIFY_CARD_VERIFY_WORK_EMAIL: {
         route: 'workspaces/:policyID/expensify-card/:fundID/verify-work-email',
-        getRoute: (policyID: string, fundID: number) => `workspaces/${policyID}/expensify-card/${encodeURIComponent(fundID)}/verify-work-email` as const,
+        getRoute: (policyID: string, fundID: number, feedCountry?: string) =>
+            `workspaces/${policyID}/expensify-card/${encodeURIComponent(fundID)}/verify-work-email${feedCountry ? `?feedCountry=${feedCountry}` : ''}` as const,
     },
     WORKSPACE_EXPENSIFY_CARD_SETTINGS_FREQUENCY: {
         route: 'workspaces/:policyID/expensify-card/settings/frequency',

src/hooks/useCurrencyForExpensifyCard.ts

@@ -1,4 +1,5 @@
-import {getCardOrFeedCurrency} from '@libs/CardUtils';
+import type {CardProgramKey} from '@libs/CardUtils';
+import {getCardOrFeedCurrency, getCardSettings} from '@libs/CardUtils';
 
 import CONST from '@src/CONST';
 import ONYXKEYS from '@src/ONYXKEYS';
@@ -7,14 +8,23 @@ import useExpensifyCardUkEuSupported from './useExpensifyCardUkEuSupported';
 import useOnyx from './useOnyx';
 import usePolicy from './usePolicy';
 
-export default function useCurrencyForExpensifyCard({policyID, fundID}: {policyID?: string; fundID?: number}) {
+// `programKey` is required (not optional) so callers can't silently fall back to the collapsed, US-first currency on a
+// feed that also holds a GB program. Pass the selected program (`useSelectedExpensifyCardProgram`) for feed-level currency,
+// or the card's own program (`getProgramKeyForCard`) for a specific card.
+export default function useCurrencyForExpensifyCard({policyID, fundID, programKey}: {policyID?: string; fundID?: number; programKey: CardProgramKey}) {
     const policy = usePolicy(policyID);
     const isUkEuCurrencySupported = useExpensifyCardUkEuSupported(policyID);
     const [cardSettings] = useOnyx(`${ONYXKEYS.COLLECTION.PRIVATE_EXPENSIFY_CARD_SETTINGS}${fundID}`);
 
     // The selected feed can belong to a different policy/domain than the one being viewed
     // (e.g. a US feed linked to a GBP policy), so derive the currency from the feed itself.
+    // A feed can also hold more than one program (US/GB) — when a program is given, read that program's currency
+    // so, for example, the US row shows USD even when a GB program is also provisioned on the same feed.
     if (fundID && cardSettings) {
+        const programSettings = getCardSettings(cardSettings, programKey);
+        if (programSettings?.currency) {
+            return programSettings.currency;
+        }
         return getCardOrFeedCurrency(undefined, cardSettings);
     }
 

src/hooks/useSelectedExpensifyCardProgram.ts

@@ -0,0 +1,28 @@
+import type {CardProgramKey} from '@libs/CardUtils';
+import {getConfiguredExpensifyCardProgramKeys, getSelectableCardProgramKey} from '@libs/CardUtils';
+
+import CONST from '@src/CONST';
+import ONYXKEYS from '@src/ONYXKEYS';
+
+import useOnyx from './useOnyx';
+
+/**
+ * Hook to get the currently selected Expensify Card program (US/GB) for a given policyID and feed (fundID).
+ * A single feed holds both programs' cards in one Onyx list, so this pairs with `useDefaultFundID` to identify
+ * which program's cards/currency/settings to display.
+ *
+ * When nothing is stored yet, it falls back to the feed's first configured program (US before GB) so a feed that only
+ * has a GB program still shows its cards on first load, while a US (or single-program) feed keeps behaving exactly as before.
+ */
+function useSelectedExpensifyCardProgram(policyID: string | undefined, fundID: number | undefined): CardProgramKey {
+    const [lastSelectedExpensifyCardProgram] = useOnyx(`${ONYXKEYS.COLLECTION.LAST_SELECTED_EXPENSIFY_CARD_PROGRAM}${policyID}`);
+    const [cardSettings] = useOnyx(`${ONYXKEYS.COLLECTION.PRIVATE_EXPENSIFY_CARD_SETTINGS}${fundID}`);
+
+    if (lastSelectedExpensifyCardProgram) {
+        return getSelectableCardProgramKey(lastSelectedExpensifyCardProgram);
+    }
+
+    return getConfiguredExpensifyCardProgramKeys(cardSettings).at(0) ?? CONST.COUNTRY.US;
+}
+
+export default useSelectedExpensifyCardProgram;

src/libs/API/types.ts

@@ -1223,7 +1223,7 @@ type WriteCommandParameters = {
     [WRITE_COMMANDS.CONFIGURE_EXPENSIFY_CARDS_FOR_POLICY]: Parameters.ConfigureExpensifyCardsForPolicyParams;
     [WRITE_COMMANDS.SET_EXPENSIFY_CARD_RULE]: Parameters.SetExpensifyCardRuleParams;
     [WRITE_COMMANDS.CREATE_EXPENSIFY_CARD]: Omit<Parameters.CreateExpensifyCardParams, 'validFrom' | 'validThru'>;
-    [WRITE_COMMANDS.CREATE_ADMIN_ISSUED_VIRTUAL_CARD]: Omit<Parameters.CreateExpensifyCardParams, 'feedCountry'>;
+    [WRITE_COMMANDS.CREATE_ADMIN_ISSUED_VIRTUAL_CARD]: Parameters.CreateExpensifyCardParams;
     [WRITE_COMMANDS.QUEUE_EXPENSIFY_CARD_FOR_BILLING]: Parameters.QueueExpensifyCardForBillingParams;
     [WRITE_COMMANDS.ADD_DELEGATE]: Parameters.AddDelegateParams;
     [WRITE_COMMANDS.UPDATE_DELEGATE_ROLE]: Parameters.UpdateDelegateRoleParams;

src/libs/CardUtils.ts

@@ -1403,6 +1403,104 @@ function getCardProgramKey(cardSettings: OnyxEntry<ExpensifyCardSettings>): Card
     });
 }
 
+/**
+ * A single settings NVP can hold more than one provisioned Expensify Card program (e.g. a domain with both a US and a GB feed).
+ * The user-selectable programs are US and GB; CURRENT is deprecated and TRAVEL_US is backend-managed, so neither is offered as its own row.
+ * Returns the configured program keys in display order (US before GB).
+ */
+function getConfiguredExpensifyCardProgramKeys(cardSettings: OnyxEntry<ExpensifyCardSettings>): CardProgramKey[] {
+    if (!cardSettings) {
+        return [];
+    }
+
+    const selectableProgramKeys: CardProgramKey[] = [CONST.COUNTRY.US, CONST.COUNTRY.GB];
+    return selectableProgramKeys.filter((key) => {
+        const nested = cardSettings[key];
+        return nested != null && typeof nested === 'object' && !Array.isArray(nested) && nested.paymentBankAccountID != null;
+    });
+}
+
+/**
+ * Maps a card to the program it belongs to. Cards on the UK/EU program carry `feedCountry === 'GB'`; every other card
+ * (US program, or pre-2024 cards that omit `feedCountry`/use the deprecated `CURRENT` value) is treated as US.
+ */
+function getProgramKeyForCard(card: Card | undefined): CardProgramKey {
+    return card?.nameValuePairs?.feedCountry === CONST.COUNTRY.GB ? CONST.COUNTRY.GB : CONST.COUNTRY.US;
+}
+
+/** Whether a card belongs to the given program, so a single `cards_{fundID}_Expensify Card` list can be split per program. */
+function isCardInProgram(card: Card | undefined, programKey: CardProgramKey): boolean {
+    return getProgramKeyForCard(card) === programKey;
+}
+
+/**
+ * A single `cards_{fundID}_Expensify Card` Onyx list holds every card for the feed regardless of program (the backend keys
+ * Expensify Card settings/cards by fundID, not by country). This keeps only the cards belonging to `programKey`, preserving the
+ * `cardList` meta entry. When no program is given, the list is returned unchanged.
+ */
+function filterCardsListByProgram(cardsList: WorkspaceCardsList | undefined, programKey: CardProgramKey | undefined): WorkspaceCardsList | undefined {
+    if (!cardsList || !programKey) {
+        return cardsList;
+    }
+
+    const result: WorkspaceCardsList = {};
+    if (cardsList.cardList) {
+        result.cardList = cardsList.cardList;
+    }
+    forEachAssignedCard(cardsList, (card) => {
+        if (!isCardInProgram(card, programKey)) {
+            return;
+        }
+        result[card.cardID.toString()] = card;
+    });
+    return result;
+}
+
+/**
+ * Resolves the settlement currency for an Expensify Card program. Prefers an explicit `currency` (from the card or the
+ * program's settings NVP), then falls back to the program itself: the US (and deprecated CURRENT) program is always USD,
+ * the GB program is GBP for the UK/Gibraltar/unset country and EUR elsewhere. Defaults to USD when the program is unknown.
+ */
+function getExpensifyCardProgramCurrency(programKey: CardProgramKey | undefined, country: string | undefined, explicitCurrency: string | undefined): string {
+    if (explicitCurrency) {
+        return explicitCurrency;
+    }
+
+    if (programKey === CONST.COUNTRY.US || programKey === CONST.EXPENSIFY_CARD.CARD_PROGRAM.CURRENT) {
+        return CONST.CURRENCY.USD;
+    }
+
+    if (programKey === CONST.COUNTRY.GB) {
+        // Only Gibraltar and UK use GBP. If country is not set at all, also assume GBP.
+        if (!country || country === CONST.COUNTRY.GB || country === CONST.COUNTRY.GI) {
+            return CONST.CURRENCY.GBP;
+        }
+
+        // All other countries on this program use EUR
+        return CONST.CURRENCY.EUR;
+    }
+
+    return CONST.CURRENCY.USD;
+}
+
+/**
+ * Parenthetical qualifier appended to a feed's label so that, when a domain is provisioned with more than one program
+ * (e.g. both US and GB), each program's row is distinguishable by its settlement currency (e.g. `expensify.com (GBP)`).
+ */
+function getExpensifyCardProgramLabelSuffix(cardSettings: OnyxEntry<ExpensifyCardSettings>, programKey: CardProgramKey): string {
+    const programSettings = getCardSettings(cardSettings, programKey);
+    const currency = getExpensifyCardProgramCurrency(programKey, programSettings?.country, programSettings?.currency);
+    return `(${currency})`;
+}
+
+/**
+ * Narrows a stored program value (e.g. the `lastSelectedExpensifyCardProgram` Onyx string) to a selectable program key.
+ * Only US and GB are user-selectable; anything else (including undefined) falls back to US so single-program feeds are unaffected.
+ */
+function getSelectableCardProgramKey(programKey: string | undefined): CardProgramKey {
+    return programKey === CONST.COUNTRY.GB ? CONST.COUNTRY.GB : CONST.COUNTRY.US;
+}
+
 function getCardSettings(cardSettings: OnyxEntry<ExpensifyCardSettings>, programKey?: CardProgramKey): NestedExpensifyCardSettings | undefined {
     if (!cardSettings) {
         return undefined;
@@ -1435,6 +1533,15 @@ function getCardSettings(cardSettings: OnyxEntry<ExpensifyCardSettings>, program
     );
 }
 
+/**
+ * Resolves the settings for the display page's currently-selected program, falling back to auto-detect when that program
+ * is not nested on the NVP. This keeps legacy domains the backend still sends flat (or single-program feeds that default to
+ * US) working, without changing `getCardSettings`, whose strict-`programKey` behavior other callers (e.g. currency resolution) rely on.
+ */
+function getCardSettingsForSelectedProgram(cardSettings: OnyxEntry<ExpensifyCardSettings>, programKey: CardProgramKey | undefined): NestedExpensifyCardSettings | undefined {
+    return getCardSettings(cardSettings, programKey) ?? getCardSettings(cardSettings);
+}
+
 /** Backend may nest linkedPolicyIDs under each program block (not only on the settings root). */
 const NESTED_EXPENSIFY_CARD_PROGRAM_KEYS: readonly CardProgramKey[] = [CONST.COUNTRY.US, CONST.EXPENSIFY_CARD.CARD_PROGRAM.CURRENT, CONST.COUNTRY.GB, CONST.TRAVEL.PROGRAM_TRAVEL_US];
 
@@ -1484,6 +1591,26 @@ function getLinkedPolicyIDsFromExpensifyCardSettings(settings: ExpensifyCardSett
     return dedupePolicyIDsCaseInsensitive(ids);
 }
 
+/**
+ * Linked workspace IDs for a single program on the feed. A domain provisioned with more than one program (e.g. US and GB)
+ * keeps a separate `linkedPolicyIDs` on each program's nested block, so a workspace linked to only the US program must not
+ * appear linked to the GB program. Root-level `linkedPolicyIDs` still apply to the program because legacy/single-program
+ * feeds store the links flat on the root rather than nested.
+ */
+function getLinkedPolicyIDsForExpensifyCardProgram(settings: ExpensifyCardSettings | OnyxEntry<ExpensifyCardSettings>, programKey: CardProgramKey): string[] | undefined {
+    if (!settings) {
+        return undefined;
+    }
+    const ids: string[] = [
+        ...collectLinkedPolicyIDsFromBase(settings as ExpensifyCardSettingsBase),
+        ...collectLinkedPolicyIDsFromBase(getNestedExpensifyCardProgramSettings(settings, programKey)),
+    ];
+    if (ids.length === 0) {
+        return undefined;
+    }
+    return dedupePolicyIDsCaseInsensitive(ids);
+}
+
 /** True if `policyID` is in the linked list (case-insensitive). */
 function isPolicyIDInLinkedExpensifyCardPolicyList(linkedPolicyIDs: string[] | undefined, policyID: string): boolean {
     return !!linkedPolicyIDs?.some((id) => id.toUpperCase() === policyID.toUpperCase());
@@ -1898,30 +2025,7 @@ function getCardOrFeedCurrency(card?: OnyxEntry<Card>, cardSettings?: OnyxEntry<
     // If not, attempt to get currency from the card settings.
     const programKey = card?.nameValuePairs?.feedCountry as CardProgramKey | undefined;
     const settings = getCardSettings(cardSettings, programKey);
-    if (settings?.currency) {
-        return settings.currency;
-    }
-
-    // Fall back to the program and country to try to determine the correct currency.
-    // US programs are always USD
-    if (programKey === CONST.COUNTRY.US || programKey === CONST.EXPENSIFY_CARD.CARD_PROGRAM.CURRENT) {
-        return CONST.CURRENCY.USD;
-    }
-
-    // For UK/EU cards, determine currency by country
-    const country = card?.nameValuePairs?.country;
-    if (programKey === CONST.COUNTRY.GB) {
-        // Only Gibraltar and UK use GBP. If country is not set at all, also assume GBP.
-        if (!country || country === CONST.COUNTRY.GB || country === CONST.COUNTRY.GI) {
-            return CONST.CURRENCY.GBP;
-        }
-
-        // All other countries on this program use EUR
-        return CONST.CURRENCY.EUR;
-    }
-
-    // Finally if all else fails, default to USD
-    return CONST.CURRENCY.USD;
+    return getExpensifyCardProgramCurrency(programKey, card?.nameValuePairs?.country, settings?.currency);
 }
 
 /**
@@ -2065,8 +2169,16 @@ export {
     hasIssuedExpensifyCard,
     isExpensifyCardFullySetUp,
     getCardSettings,
+    getCardSettingsForSelectedProgram,
     getCardProgramKey,
+    getConfiguredExpensifyCardProgramKeys,
+    getProgramKeyForCard,
+    isCardInProgram,
+    filterCardsListByProgram,
+    getExpensifyCardProgramLabelSuffix,
+    getSelectableCardProgramKey,
     getLinkedPolicyIDsFromExpensifyCardSettings,
+    getLinkedPolicyIDsForExpensifyCardProgram,
     getPreferredPolicyFromExpensifyCardSettings,
     getDomainNameFromExpensifyCardSettings,
     getDomainByFundID,

src/libs/ExpensifyCardFeedSelectorUtils.ts

@@ -7,10 +7,14 @@ import type {OnyxCollection, OnyxEntry} from 'react-native-onyx';
 
 import {Str} from 'expensify-common';
 
+import type {CardProgramKey} from './CardUtils';
+
 import {
+    getConfiguredExpensifyCardProgramKeys,
     getDomainByFundID,
     getDomainNameFromExpensifyCardSettings,
     getFundIdFromSettingsKey,
+    getLinkedPolicyIDsForExpensifyCardProgram,
     getLinkedPolicyIDsFromExpensifyCardSettings,
     getPreferredPolicyFromExpensifyCardSettings,
     isPolicyIDInLinkedExpensifyCardPolicyList,
@@ -21,6 +25,12 @@ type ExpensifyCardFeedEntry = {
     settingsKey: string;
     fundID: number;
     settings: ExpensifyCardSettings;
+
+    /**
+     * The program (US/GB) this entry represents. A single settings NVP can hold more than one provisioned program,
+     * in which case each program gets its own entry (and its own selector row) that shares the same `fundID`.
+     */
+    programKey: CardProgramKey;
 };
 
 /** A feed qualifies only when its settings NVP has a US or GB program block with a configured settlement bank account. */
@@ -76,9 +86,13 @@ function isExpensifyCardFeedVisibleToAdmin(
     );
 }
 
-/** A feed shows as available for a policy when that policy is in the feed's `linkedPolicyIDs`; otherwise it shows under "From other workspaces". */
+/**
+ * A feed shows as available for a policy when that policy is in the linked list for the entry's own program; otherwise it
+ * shows under "From other workspaces". A domain with more than one program links each program independently, so linking a
+ * policy to the US program must not make the GB program show as available for that policy (and vice versa).
+ */
 function isFeedPrimaryForPolicy(entry: ExpensifyCardFeedEntry, policyID: string): boolean {
-    return isPolicyIDInLinkedExpensifyCardPolicyList(getLinkedPolicyIDsFromExpensifyCardSettings(entry.settings), policyID);
+    return isPolicyIDInLinkedExpensifyCardPolicyList(getLinkedPolicyIDsForExpensifyCardProgram(entry.settings, entry.programKey), policyID);
 }
 
 function getAdminExpensifyCardFeedEntries(
@@ -95,7 +109,11 @@ function getAdminExpensifyCardFeedEntries(
         if (!isExpensifyCardFeedVisibleToAdmin(settings, policies, fundID, domains, currentUserAccountID)) {
             return [];
         }
-        return [{settingsKey, fundID, settings}];
+
+        // A domain provisioned with more than one program (e.g. both US and GB) yields one entry per program so each
+        // renders as its own selector row. `getConfiguredExpensifyCardProgramKeys` only returns US/GB, both of which pass
+        // the `hasConfiguredExpensifyCardFeed` gate above, so there is always at least one program here.
+        return getConfiguredExpensifyCardProgramKeys(settings).map((programKey) => ({settingsKey, fundID, settings, programKey}));
     });
 }
 

src/libs/ExportOnyxState/common.ts

@@ -144,6 +144,7 @@ const safeOnyxKeys = new Set<string>([
     ONYXKEYS.COLLECTION.EXPENSIFY_CARD_USE_CONTINUOUS_RECONCILIATION,
     ONYXKEYS.COLLECTION.EXPENSIFY_CARD_USE_CONTINUOUS_RECONCILIATION_PENDING_ACTION,
     ONYXKEYS.COLLECTION.LAST_SELECTED_EXPENSIFY_CARD_FEED,
+    ONYXKEYS.COLLECTION.LAST_SELECTED_EXPENSIFY_CARD_PROGRAM,
     ONYXKEYS.COLLECTION.LAST_SELECTED_FEED,
     ONYXKEYS.COLLECTION.NVP_EXPENSIFY_REPORT_PDF_FILENAME,
     ONYXKEYS.COLLECTION.POLICY_HAS_CONNECTIONS_DATA_BEEN_FETCHED,

src/libs/Navigation/types.ts

@@ -1348,6 +1348,7 @@ type SettingsNavigatorParamList = {
     [SCREENS.WORKSPACE.EXPENSIFY_CARD_ADD_WORK_EMAIL]: {
         policyID: string;
         fundID: number;
+        feedCountry?: string;
     };
     [SCREENS.WORKSPACE.DYNAMIC_WORKSPACE_EXPENSIFY_CARD_ISSUE_NEW_SPEND_RULE_SELECTION]: {
         policyID: string;
@@ -1371,6 +1372,7 @@ type SettingsNavigatorParamList = {
     [SCREENS.WORKSPACE.EXPENSIFY_CARD_VERIFY_WORK_EMAIL]: {
         policyID: string;
         fundID: number;
+        feedCountry?: string;
     };
     [SCREENS.WORKSPACE.TRAVEL_SETTINGS_ACCOUNT]: {
         policyID: string;