[$250] [Exploratory] Expensify Card - Error displays after delete the Workspace and unfreeze the issued Card

[jponikarchuk]

If you haven’t already, check out our contributing guidelines for onboarding and email contributors@expensify.com to request to join our Slack channel!

---

Version Number: v9.3.60-22
Reproducible in staging?: Yes
Reproducible in production?: Yes
If this was caught during regression testing, add the test name, ID and link from BrowserStack: #81880
Email or phone of affected tester (no customers): leungbratt6+200402@gmail.com
Issue reported by: Applause Internal Team
Bug source: Exploratory - Significant User Experience Deterioration
Device used: Windows 11/Chrome
App Component: User Settings

Action Performed:

Precondition: Workspace has Expensify card feature enabled and a freeze-issued card

1. Open the NewDot app
2. Navigate to the Overview -> More -> Delete the Workspace
3. Navgate to Wallet
4. Click on the freeze card -> Unfreeze the card

Expected Result:

Warning about the Expensify card when deleting Workspace (like when it has an active card)

Actual Result:

After freezing the Expensify card, deleting the Workspace, and unfreezing the card, the error appears: Oops... something went wrong and your request could not be completed. Please try again later.
Auth UnfreezeCard returned an error

Workaround:

Unknown

Platforms:

• Android: App
• Android: mWeb Chrome
• iOS: App
• iOS: mWeb Safari
• iOS: mWeb Chrome
• Windows: Chrome
• MacOS: Chrome / Safari

Screenshots/Videos

Video.mp4

View all open jobs on GitHub

Upwork Automation - Do Not Edit

• Upwork Job URL: https://www.upwork.com/jobs/~022054386392763780823
• Upwork Job ID: 2054386392763780823
• Last Price Increase: 2026-05-20

Issue Owner

Current Issue Owner: @allgandalf

[MelvinBot]

Proposal

What is the root cause of that problem?

When a workspace is deleted via deleteWorkspace(), the optimistic data cleans up policy, card settings, and reports — but it does not remove cards from ONYXKEYS.CARD_LIST. This means frozen cards from deleted workspaces remain visible in the Wallet.

The Wallet's ExpensifyCardPage checks canUnfreezeCard which passes when frozenByAccountID === session?.accountID — it doesn't verify the workspace still exists. So the user sees the "Unfreeze" button, taps it, and unfreezeCard() sends an UnfreezeCard API call with only the cardID. The backend rejects it because the associated workspace/domain no longer exists.

What changes do you think we should make in order to solve the problem?

The fix has two parts:

1. Hide the unfreeze button when the workspace is deleted: In ExpensifyCardPage, add a check that the card's associated policy still exists before allowing canUnfreezeCard to be true. The policyForCurrentCard is already resolved here — guard canManageCardFreeze (or canUnfreezeCard) so it also requires !!policyForCurrentCard.

2. Clean up CARD_LIST on workspace deletion: In deleteWorkspace(), add optimistic data entries that null out the deleted workspace's cards from ONYXKEYS.CARD_LIST, similar to how WORKSPACE_CARDS_LIST entries are already cleaned up. This prevents orphaned cards from appearing in the Wallet at all.

What alternative solutions did you explore? (Optional)

• Backend-only fix (make UnfreezeCard handle deleted workspaces gracefully): This would fix the error but still leave orphaned frozen cards in the Wallet with no way to resolve them — a confusing UX.
• Prevent workspace deletion when frozen cards exist: The workspace deletion flow already shows a generic card warning via hasCardFeedOrExpensifyCard, but it doesn't block deletion. Blocking deletion for frozen cards would be overly restrictive — the user should be able to delete their workspace; we just need to clean up properly.

---

Next Steps for Contributor+ team: Reply with @MelvinBot implement this to create a draft PR, @MelvinBot <your feedback> to refine this analysis, or explain why you are rejecting Melvin's proposal.

[melvin-bot]

Triggered auto assignment to Contributor-plus team member for initial proposal review - @nyomanjyotisa (External)

[melvin-bot]

Job added to Upwork: https://www.upwork.com/jobs/~022054386392763780823

[aswin-s]

Please re-state the problem that we are trying to solve in this issue.

When a user deletes a workspace that has an Expensify Card enabled, then navigates to Wallet and attempts to unfreeze a frozen card from that deleted workspace, the app displays an error: "Oops... something went wrong and your request could not be completed. Please try again later. Auth UnfreezeCard returned an error." The expected behavior is that the app should warn users about Expensify Cards when deleting a workspace (similar to warnings for active cards) and prevent orphaned cards from remaining accessible after workspace deletion.

What is the root cause of that problem?

The bug originates in src/libs/actions/Policy/Policy.ts in the deleteWorkspace function (lines 379–686). When a workspace is deleted, the optimisticData cleans up POLICY, SHARED_NVP_PRIVATE_DOMAIN_MEMBER, PRIVATE_EXPENSIFY_CARD_SETTINGS, LAST_SELECTED_FEED, and TRANSACTION_VIOLATIONS — but it never nulls out the deleted workspace's cards from ONYXKEYS.CARD_LIST. After deletion, those orphaned cards remain in CARD_LIST and are loaded by ExpensifyCardPage via useNonPersonalCardList. The canUnfreezeCard predicate in src/pages/settings/Wallet/ExpensifyCardPage/index.tsx (line 178) only checks frozenByAccountID === session.accountID || isWorkspaceAdmin and never validates that the card's workspace still exists. When a user taps Unfreeze on an orphaned card, the action calls unfreezeCard with only the cardID; the backend rejects the request because the workspace/domain no longer exists, producing the 'Auth UnfreezeCard returned an error' message.

App/src/libs/actions/Policy/Policy.ts

Lines 379 to 686 in d6a8779

	function deleteWorkspace(params: DeleteWorkspaceActionParams) {
	const {
	policies,
	policyID,
	activePolicyID,
	policyName,
	lastAccessedWorkspacePolicyID,
	policyCardFeeds,
	lastSelectedFeed,
	lastSelectedExpensifyCardFeed,
	reportsToArchive,
	transactionViolations,
	reimbursementAccountError,
	lastUsedPaymentMethods,
	localeCompare,
	personalPolicyID,
	hasDeleteWorkspaceExpensifyCardsError,
	currentUserAccountID,
	accountIDToLogin,
	} = params;
	const policy = policies?.[`${ONYXKEYS.COLLECTION.POLICY}${policyID}`];
	const filteredPolicies = Object.values(policies ?? {}).filter((p): p is Policy => p?.id !== policyID);
	const workspaceAccountID = policy?.workspaceAccountID;
	const optimisticData: Array<
	OnyxUpdate<
	| typeof ONYXKEYS.COLLECTION.POLICY
	| typeof ONYXKEYS.COLLECTION.SHARED_NVP_PRIVATE_DOMAIN_MEMBER
	| typeof ONYXKEYS.COLLECTION.PRIVATE_EXPENSIFY_CARD_SETTINGS
	| typeof ONYXKEYS.COLLECTION.LAST_SELECTED_FEED
	| typeof ONYXKEYS.COLLECTION.LAST_SELECTED_EXPENSIFY_CARD_FEED
	| typeof ONYXKEYS.REIMBURSEMENT_ACCOUNT
	| typeof ONYXKEYS.NVP_ACTIVE_POLICY_ID
	| typeof ONYXKEYS.COLLECTION.REPORT
	| typeof ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS
	| typeof ONYXKEYS.COLLECTION.REPORT_ACTIONS_DRAFTS
	| typeof ONYXKEYS.COLLECTION.REPORT_ACTIONS
	| typeof ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS
	| typeof ONYXKEYS.NVP_LAST_PAYMENT_METHOD
	>
	> = [
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.POLICY}${policyID}`,
	value: {
	avatarURL: '',
	pendingAction: CONST.RED_BRICK_ROAD_PENDING_ACTION.DELETE,
	errors: hasDeleteWorkspaceExpensifyCardsError ? ErrorUtils.getMicroSecondOnyxErrorWithTranslationKey('workspace.common.deleteOpenExpensifyCardsError') : null,
	},
	},
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.SHARED_NVP_PRIVATE_DOMAIN_MEMBER}${workspaceAccountID}`,
	value: null,
	},
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.PRIVATE_EXPENSIFY_CARD_SETTINGS}${workspaceAccountID}`,
	value: {pendingAction: CONST.RED_BRICK_ROAD_PENDING_ACTION.DELETE},
	},
	{
	onyxMethod: Onyx.METHOD.SET,
	key: `${ONYXKEYS.COLLECTION.LAST_SELECTED_FEED}${policyID}`,
	value: null,
	},
	{
	onyxMethod: Onyx.METHOD.SET,
	key: `${ONYXKEYS.COLLECTION.LAST_SELECTED_EXPENSIFY_CARD_FEED}${policyID}`,
	value: null,
	},
	...(!hasActiveChatEnabledPolicies(filteredPolicies, true)
	? [
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: ONYXKEYS.REIMBURSEMENT_ACCOUNT,
	value: {
	errors: null,
	},
	},
	]
	: []),
	];
	// Restore the old report stateNum and statusNum
	const failureData: Array<
	OnyxUpdate<
	| typeof ONYXKEYS.REIMBURSEMENT_ACCOUNT
	| typeof ONYXKEYS.COLLECTION.POLICY
	| typeof ONYXKEYS.COLLECTION.SHARED_NVP_PRIVATE_DOMAIN_MEMBER
	| typeof ONYXKEYS.COLLECTION.PRIVATE_EXPENSIFY_CARD_SETTINGS
	| typeof ONYXKEYS.COLLECTION.LAST_SELECTED_FEED
	| typeof ONYXKEYS.COLLECTION.LAST_SELECTED_EXPENSIFY_CARD_FEED
	| typeof ONYXKEYS.NVP_ACTIVE_POLICY_ID
	| typeof ONYXKEYS.COLLECTION.REPORT
	| typeof ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS
	| typeof ONYXKEYS.COLLECTION.REPORT_ACTIONS
	| typeof ONYXKEYS.NVP_LAST_PAYMENT_METHOD
	| typeof ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS
	>
	> = [
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: ONYXKEYS.REIMBURSEMENT_ACCOUNT,
	value: {
	errors: reimbursementAccountError ?? null,
	},
	},
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.POLICY}${policyID}`,
	value: {
	avatarURL: policy?.avatarURL,
	pendingAction: null,
	},
	},
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.SHARED_NVP_PRIVATE_DOMAIN_MEMBER}${workspaceAccountID}`,
	value: policyCardFeeds ?? null,
	},
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.PRIVATE_EXPENSIFY_CARD_SETTINGS}${workspaceAccountID}`,
	value: {pendingAction: null},
	},
	{
	onyxMethod: Onyx.METHOD.SET,
	key: `${ONYXKEYS.COLLECTION.LAST_SELECTED_FEED}${policyID}`,
	value: lastSelectedFeed ?? null,
	},
	{
	onyxMethod: Onyx.METHOD.SET,
	key: `${ONYXKEYS.COLLECTION.LAST_SELECTED_EXPENSIFY_CARD_FEED}${policyID}`,
	value: lastSelectedExpensifyCardFeed ?? null,
	},
	];
	if (policyID === activePolicyID) {
	const mostRecentlyCreatedGroupPolicy = Object.values(policies ?? {})
	.filter((p) => p && p.id !== activePolicyID && p.type !== CONST.POLICY.TYPE.PERSONAL && p.pendingAction !== CONST.RED_BRICK_ROAD_PENDING_ACTION.DELETE)
	.sort((policyA, policyB) => localeCompare(policyB?.created ?? '', policyA?.created ?? ''))
	.at(0);
	const newActivePolicyID = mostRecentlyCreatedGroupPolicy?.id ?? personalPolicyID;
	optimisticData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: ONYXKEYS.NVP_ACTIVE_POLICY_ID,
	value: newActivePolicyID ?? null,
	});
	failureData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: ONYXKEYS.NVP_ACTIVE_POLICY_ID,
	value: activePolicyID,
	});
	}
	const finallyData: Array<OnyxUpdate<never>> = [];
	const currentTime = DateUtils.getDBTime();
	const reportIDToOptimisticCloseReportActionID: Record<string, string> = {};
	for (const report of reportsToArchive) {
	const {reportID, ownerAccountID, oldPolicyName} = report ?? {};
	const isInvoiceReceiverReport = report?.invoiceReceiver && 'policyID' in report.invoiceReceiver && report.invoiceReceiver.policyID === policyID;
	optimisticData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT}${reportID}`,
	value: {
	...(!isInvoiceReceiverReport && {
	oldPolicyName: policy?.name,
	policyName: '',
	}),
	isPinned: false,
	},
	});
	optimisticData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS}${reportID}`,
	value: {
	private_isArchived: currentTime,
	},
	});
	optimisticData.push({
	onyxMethod: Onyx.METHOD.SET,
	key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS_DRAFTS}${reportID}`,
	value: null,
	});
	// Add closed actions to all chat reports linked to this policy
	// Announce & admin chats have FAKE owners, but expense chats w/ users do have owners.
	let emailClosingReport: string = CONST.POLICY.OWNER_EMAIL_FAKE;
	if (!!ownerAccountID && ownerAccountID !== CONST.POLICY.OWNER_ACCOUNT_ID_FAKE) {
	emailClosingReport = accountIDToLogin[ownerAccountID] ?? '';
	}
	const optimisticClosedReportAction = ReportUtils.buildOptimisticClosedReportAction(emailClosingReport, policyName, currentUserAccountID, CONST.REPORT.ARCHIVE_REASON.POLICY_DELETED);
	optimisticData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`,
	value: {
	[optimisticClosedReportAction.reportActionID]: optimisticClosedReportAction,
	},
	});
	failureData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT}${reportID}`,
	value: {
	oldPolicyName,
	policyName: report?.policyName,
	isPinned: report?.isPinned,
	},
	});
	failureData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS}${reportID}`,
	value: {
	private_isArchived: null,
	},
	});
	failureData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`,
	value: {
	[optimisticClosedReportAction.reportActionID]: null,
	},
	});
	if (hasDeleteWorkspaceExpensifyCardsError) {
	failureData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.POLICY}${policyID}`,
	value: {
	errors: null,
	},
	});
	}
	reportIDToOptimisticCloseReportActionID[reportID] = optimisticClosedReportAction.reportActionID;
	for (const transactionViolationKey of Object.keys(transactionViolations ?? {})) {
	const transactionViolation = transactionViolations?.[transactionViolationKey];
	const transactionID = transactionViolationKey.slice(ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS.length);
	optimisticData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS}${transactionID}`,
	value: transactionViolation?.filter((violation) => violation.type !== CONST.VIOLATION_TYPES.VIOLATION) ?? null,
	});
	failureData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS}${transactionID}`,
	value: transactionViolation ?? null,
	});
	}
	}
	for (const paymentMethodKey of Object.keys(lastUsedPaymentMethods ?? {})) {
	const lastUsedPaymentMethod = lastUsedPaymentMethods?.[paymentMethodKey];
	if (typeof lastUsedPaymentMethod === 'string' || !lastUsedPaymentMethod) {
	continue;
	}
	if (lastUsedPaymentMethod?.iou?.name === policyID) {
	optimisticData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: ONYXKEYS.NVP_LAST_PAYMENT_METHOD,
	value: {
	[paymentMethodKey]: {
	iou: {
	name: policyID !== lastUsedPaymentMethod?.lastUsed?.name ? lastUsedPaymentMethod?.lastUsed?.name : '',
	},
	lastUsed: {
	name: policyID !== lastUsedPaymentMethod?.lastUsed?.name ? lastUsedPaymentMethod?.lastUsed?.name : '',
	},
	},
	},
	});
	failureData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: ONYXKEYS.NVP_LAST_PAYMENT_METHOD,
	value: {
	[paymentMethodKey]: {
	iou: {
	name: lastUsedPaymentMethod?.iou?.name,
	},
	lastUsed: {
	name: lastUsedPaymentMethod?.iou?.name,
	},
	},
	},
	});
	}
	}
	const apiParams: DeleteWorkspaceParams = {policyID, reportIDToOptimisticCloseReportActionID: JSON.stringify(reportIDToOptimisticCloseReportActionID)};
	API.write(WRITE_COMMANDS.DELETE_WORKSPACE, apiParams, {optimisticData, finallyData, failureData});
	// Reset the lastAccessedWorkspacePolicyID
	if (policyID === lastAccessedWorkspacePolicyID) {
	updateLastAccessedWorkspace(undefined);
	}
	}

App/src/pages/settings/Wallet/ExpensifyCardPage/index.tsx

Line 173 in d6a8779

[currentCard?.fundID],

What changes do you think we should make in order to solve the problem?

1. File: src/libs/actions/Policy/Policy.ts
   Function: deleteWorkspace
   Description: In the optimisticData array (after the PRIVATE_EXPENSIFY_CARD_SETTINGS entry), add entries that null out all cards belonging to the deleted workspace in ONYXKEYS.CARD_LIST. The function already resolves workspaceAccountID from policy?.workspaceAccountID. Guard the iteration with a null check on both cardList and workspaceAccountID before iterating. For each entry in cardList whose card.fundID equals String(workspaceAccountID), push a SET-to-null optimisticData entry keyed by ${ONYXKEYS.COLLECTION.CARD_LIST}${cardID} and a restore entry in failureData. Because CardList is typed as Record<string, Card> (indexed by string cardID), the key for each card is its string cardID as it appears in the collection.

   // After the LAST_SELECTED_EXPENSIFY_CARD_FEED entry in optimisticData
   if (workspaceAccountID && cardList) {
       for (const [cardID, card] of Object.entries(cardList)) {
           if (card?.fundID === String(workspaceAccountID)) {
               optimisticData.push({
                   onyxMethod: Onyx.METHOD.SET,
                   key: `${ONYXKEYS.COLLECTION.CARD_LIST}${cardID}`,
                   value: null,
               });
               failureData.push({
                   onyxMethod: Onyx.METHOD.SET,
                   key: `${ONYXKEYS.COLLECTION.CARD_LIST}${cardID}`,
                   value: card,
               });
           }
       }
   }

   cardList must be passed in as a new field on DeleteWorkspaceActionParams and subscribed to via Onyx at the call site (the same pattern used for transactionViolations and lastUsedPaymentMethods). The optimistic write happens synchronously before the API call, so by the time API.write fires the cards are already absent from the local store — no async ordering issue between the CARD_LIST update and workspace deletion.

2. File: src/pages/settings/Wallet/ExpensifyCardPage/index.tsx
   Function: ExpensifyCardPage
   Description: The component already derives policyForCurrentCard via a useOnyx selector that looks up the policy by workspaceAccountID (lines 164–175). Because policyForCurrentCard resolves to undefined when no matching policy exists in the Onyx store — which is guaranteed once the optimistic CARD_LIST cleanup above runs — adding !!policyForCurrentCard to the canUnfreezeCard predicate at line 178 is sufficient. This is not a race/hydration risk: useOnyx with a selector is synchronous with the store; if the card itself is null (removed by fix 1) the page will not render the action at all.

   Change line 178 from:

   const canUnfreezeCard = canManageCardFreeze && (frozenByAccountID === session?.accountID || isWorkspaceAdmin);

   to:

   const canUnfreezeCard = canManageCardFreeze && !!policyForCurrentCard && (frozenByAccountID === session?.accountID || isWorkspaceAdmin);

   This provides defence-in-depth: even if a card somehow survives in CARD_LIST after workspace deletion (e.g. the optimistic update is rolled back on API failure), the Unfreeze button is hidden until policyForCurrentCard is truthy again, preventing the user from triggering the backend error.

Blast radius: This is a minimal fix with no callers of canUnfreezeCard outside ExpensifyCardPage. The CARD_LIST cleanup in deleteWorkspace affects all surfaces that display workspace cards but only removes orphaned cards that belong to the deleted workspace, so no regressions are expected.

What alternative solutions did you explore? (Optional)

• Backend-only fix: make UnfreezeCard API gracefully handle deleted workspaces. Rejected because this is a frontend-only repository in scope. Additionally, even if the backend silently succeeded, orphaned frozen cards would still appear in the Wallet with no resolution path, creating confusing UX. Cleaning CARD_LIST at the source removes the root cause and prevents orphaned cards from appearing anywhere in the app.