[Due for payment 2026-03-17] [$250] Expense details - Two expenses appears in report for user invuted to chat only

[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.25-13
Reproducible in staging?: Yes
Reproducible in production?: Yes
If this was caught during regression testing, add the test name, ID and link from BrowserStack: Retest KI #75754
Email or phone of affected tester (no customers): -
Issue reported by: Applause Internal Team
Bug source: Regression TC Execution
Device used: MacOS Monterey 12.7.4 / Chrome
App Component: Money Requests

Action Performed:

1. As user A create a workspace
2. Go to workspace chat
3. Click on header > Members > Invite a new user > Invite User B
4. Return to workspace chat > Click invite to chat only
5. Login to new dot as User B > Open the workspace chat
6. As User A submit a new expense
7. As User B, open the newly submitted expense

Expected Result:

Expense details are displayed

Actual Result:

2 equal expenses are displayed

Workaround:

Unknown

Platforms:

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

Screenshots/Videos

1.mp4

View all open jobs on GitHub

Issue Owner

Current Issue Owner: @mallenexpensify

Upwork Automation - Do Not Edit

• Upwork Job URL: https://www.upwork.com/jobs/~022026630654198063486
• Upwork Job ID: 2026630654198063486
• Last Price Increase: 2026-02-25

[melvin-bot]

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

[melvin-bot]

Triggered auto assignment to @stephanieelliott (Bug), see https://stackoverflow.com/c/expensify/questions/14418 for more details. Please add this bug to a GH project, as outlined in the SO.

[melvin-bot]

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

[MelvinBot]

🔍 Issue Analysis

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

When User B is invited to a workspace chat as "chat only" (via the ACTIONABLE_MENTION_WHISPER resolution 'invited'), and User A (the admin) submits a new expense, User B sees two duplicate expenses when opening the expense from the workspace chat. The expected behavior is that only one expense should be displayed.

What is the root cause of that problem?

The most likely root cause is a race condition in ReportScreen.tsx involving the includeOrphanedTransactions=true flag and the legacy transaction thread creation logic.

Here's the sequence that causes duplicates:

1. The "invite to chat only" flow sends ResolveActionableMentionWhisper with resolution='invited' to the backend (src/libs/actions/Report/index.ts:4703). All member setup happens server-side — there is no "chat only" role in the frontend. The backend likely provides this user with limited report action data compared to a full workspace member.

2. When the chat-only member opens the expense report (via REPORT_PREVIEW → MoneyRequestReportPreview.openReportFromPreview() at src/components/ReportActionItem/MoneyRequestReportPreview/index.tsx:101-117), ReportScreen loads.

3. ReportScreen collects transactions via useReportTransactionsCollection (derived from COLLECTION.TRANSACTION keyed by transaction.reportID) — this is independent of report actions.

4. getAllNonDeletedTransactions is called with includeOrphanedTransactions=true at src/pages/inbox/ReportScreen.tsx:342. This means transactions are included even when no matching IOU action exists in the loaded report actions (src/libs/MoneyRequestReportUtils.ts:86-104).

5. The legacy transaction thread creation effect at src/pages/inbox/ReportScreen.tsx:937-968 fires because getIOUActionForReportID() returns undefined (the IOU action hasn't loaded yet for this limited-access user). This creates a new optimistic IOU action + transaction thread.

6. When the original IOU action arrives from the server, the report now has two IOU actions pointing to the same transaction — the optimistic one from step 5 and the real one from the server.

7. This results in the expense appearing twice in the expense report view.

A contributing factor is the dual-display architecture: MoneyRequestReportActionsList renders transactions in a table header (MoneyRequestReportTransactionList) and report actions in a FlatList below. The deduplication filter (IOU_ACTIONS_TO_FILTER_OUT at src/libs/MoneyRequestReportUtils.ts:34) only filters CREATE and TRACK types. If the optimistic IOU action has a different type, it could bypass the filter and appear alongside the transaction table entry.

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

The fix should address the root cause — the legacy thread creation firing prematurely for chat-only members who have transaction data but delayed/missing IOU actions:

1. In ReportScreen.tsx (lines 937-968): Add a guard to the legacy transaction thread creation effect that checks whether report actions have finished loading (e.g., check isLoadingInitialReportActions or verify the report actions collection is not empty) before deciding that an IOU action is missing. This prevents the race condition where the effect creates a duplicate optimistic IOU action before the real one arrives.

2. Alternatively, in getAllNonDeletedTransactions at src/libs/MoneyRequestReportUtils.ts:86-104, consider not including orphaned transactions while report actions are still loading — only fall back to includeOrphanedTransactions behavior when report actions have definitively loaded and the IOU action is confirmed missing.

What alternative solutions did you explore? (Optional)

• Deduplication by transactionID: Adding a post-filter that ensures each IOUTransactionID appears at most once across both the transaction table and report actions list. This would be a safety net but doesn't fix the underlying race condition.
• Server-side fix: Ensuring the backend returns complete IOU actions for chat-only members when they open an expense report. This would prevent the orphaned-transaction scenario entirely, but the client-side race condition should still be guarded against.

Detailed Investigation

Root Cause Analysis

The investigation traced the data flow across three dimensions:

1. Chat-only invite flow (src/libs/actions/Report/index.ts:4703-4785):

• "Invite to chat only" sends resolution='invited' via WRITE_COMMANDS.RESOLVE_ACTIONABLE_MENTION_WHISPER
• The backend handles all member creation — no optimistic data for the membership is created client-side
• There is no "chat only" role in the frontend (CONST.POLICY.ROLE only has ADMIN, AUDITOR, USER); it's a billing-level concept (confirmed by chatOnlyActorList in src/types/onyx/PurchaseList.ts)

2. Expense display architecture (src/components/MoneyRequestReportView/MoneyRequestReportActionsList.tsx):

• Uses a dual display: transaction table header + report actions FlatList
• isActionVisibleOnMoneyRequestReport (src/libs/MoneyRequestReportUtils.ts:34-53) filters CREATE and TRACK IOU types from the FlatList to prevent duplication with the table
• Transaction data comes from DERIVED.REPORT_TRANSACTIONS_AND_VIOLATIONS (keyed by transaction.reportID), independent of report actions

3. View selection and race conditions (src/pages/inbox/ReportScreen.tsx):

• shouldDisplayReportTableView (src/libs/MoneyRequestReportUtils.ts:113-129) decides between single-transaction view and table view
• includeOrphanedTransactions=true (line 342) includes transactions without matching IOU actions
• Legacy thread creation (lines 937-968) fires when getIOUActionForReportID returns undefined, creating optimistic IOU actions

Evidence Chain

1. Chat-only user data arrives with transactions (via derived values) but potentially limited/delayed IOU actions
2. getAllNonDeletedTransactions includes orphaned transactions → transaction is visible
3. Legacy thread creation fires because IOU action not found → creates duplicate optimistic IOU action
4. Original IOU action arrives from server → now TWO IOU actions for same transaction
5. User sees duplicate expenses

Relevant Code

• src/pages/inbox/ReportScreen.tsx:342 - includeOrphanedTransactions=true
• src/pages/inbox/ReportScreen.tsx:937-968 - Legacy transaction thread creation
• src/libs/MoneyRequestReportUtils.ts:86-104 - getAllNonDeletedTransactions
• src/libs/MoneyRequestReportUtils.ts:34-53 - IOU_ACTIONS_TO_FILTER_OUT filter
• src/components/ReportActionItem/MoneyRequestReportPreview/index.tsx:101-117 - Navigation from preview
• src/libs/actions/Report/index.ts:4703-4785 - resolveActionableMentionWhisper

Confidence: Medium

This analysis is based on code tracing without production log confirmation. The exact data the backend sends to chat-only members is unknown (server-side code is not available). Production logs would confirm whether duplicate IOU actions are being created and which display path is taken.

---

Next Steps for Contributor+ team: Reply with @MelvinBot implement this to create a draft PR, or @MelvinBot <your feedback> to refine this analysis.

[nkdengineer]

Proposal

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

2 equal expenses are displayed

What is the root cause of that problem?

When the invited user opens the expense report, reportActions isn't loaded fulled which causes this useEffect create the transaction thread report with iouAction is undefined. Then another iouAction is created for this transaction and the duplicate preview appears.

App/src/pages/Search/SearchMoneyRequestReportPage.tsx

Lines 229 to 270 in 3ecc7fd

	useEffect(() => {
	if (hasCreatedLegacyThreadRef.current || transactionThreadReportID || (Object.keys(allReportTransactions).length !== 1 && !snapshotTransaction)) {
	return;
	}
	// Because when switching between reports, reportActions may contain data from the previous report.
	// So we need to check that reportActions belongs to the current report.
	const isFirstActionBelongsToCurrentReport = !!getReportAction(reportIDFromRoute, reportActions.at(0)?.reportActionID);
	if (report?.reportID && reportActions.length === 1 && !isFirstActionBelongsToCurrentReport) {
	return;
	}
	// Use main collection transaction or fallback to snapshot
	const transaction = Object.values(allReportTransactions).at(0) ?? snapshotTransaction;
	if (!transaction || (transaction && transaction.reportID !== reportIDFromRoute)) {
	return;
	}
	// Check that reportActions belong to the current report to avoid using stale data from the previous report
	const hasMatchingReportActions = reportActions.some((action) => {
	const iouReportID = isMoneyRequestAction(action) ? getOriginalMessage(action)?.IOUReportID : undefined;
	return iouReportID?.toString() === reportIDFromRoute;
	});
	if (!hasMatchingReportActions && reportActions.length > 1) {
	return;
	}
	const iouAction = getIOUActionForTransactionID(reportActions, transaction.transactionID);
	if (iouAction || transaction?.pendingAction === CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD || !!transaction.linkedTrackedExpenseReportAction?.childReportID) {
	return;
	}
	hasCreatedLegacyThreadRef.current = true;
	const violations = allReportViolations[transaction.transactionID] ?? snapshotViolations;
	createTransactionThreadReport(introSelected, report, undefined, transaction, violations);
	}, [
	allReportTransactions,
	allReportViolations,
	introSelected,
	report,

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

We should return early if the reportActions aren't loaded fully

if (hasCreatedLegacyThreadRef.current || transactionThreadReportID || (Object.keys(allReportTransactions).length !== 1 && !snapshotTransaction) || !reportMetadata?.hasOnceLoadedReportActions || reportActions.length === 0) {
            return;
        }

App/src/pages/Search/SearchMoneyRequestReportPage.tsx

Lines 229 to 270 in 3ecc7fd

	useEffect(() => {
	if (hasCreatedLegacyThreadRef.current || transactionThreadReportID || (Object.keys(allReportTransactions).length !== 1 && !snapshotTransaction)) {
	return;
	}
	// Because when switching between reports, reportActions may contain data from the previous report.
	// So we need to check that reportActions belongs to the current report.
	const isFirstActionBelongsToCurrentReport = !!getReportAction(reportIDFromRoute, reportActions.at(0)?.reportActionID);
	if (report?.reportID && reportActions.length === 1 && !isFirstActionBelongsToCurrentReport) {
	return;
	}
	// Use main collection transaction or fallback to snapshot
	const transaction = Object.values(allReportTransactions).at(0) ?? snapshotTransaction;
	if (!transaction || (transaction && transaction.reportID !== reportIDFromRoute)) {
	return;
	}
	// Check that reportActions belong to the current report to avoid using stale data from the previous report
	const hasMatchingReportActions = reportActions.some((action) => {
	const iouReportID = isMoneyRequestAction(action) ? getOriginalMessage(action)?.IOUReportID : undefined;
	return iouReportID?.toString() === reportIDFromRoute;
	});
	if (!hasMatchingReportActions && reportActions.length > 1) {
	return;
	}
	const iouAction = getIOUActionForTransactionID(reportActions, transaction.transactionID);
	if (iouAction || transaction?.pendingAction === CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD || !!transaction.linkedTrackedExpenseReportAction?.childReportID) {
	return;
	}
	hasCreatedLegacyThreadRef.current = true;
	const violations = allReportViolations[transaction.transactionID] ?? snapshotViolations;
	createTransactionThreadReport(introSelected, report, undefined, transaction, violations);
	}, [
	allReportTransactions,
	allReportViolations,
	introSelected,
	report,

What alternative solutions did you explore? (Optional)

N/A

Reminder: Please use plain English, be brief and avoid jargon. Feel free to use images, charts or pseudo-code if necessary. Do not post large multi-line diffs or write walls of text. Do not create PRs unless you have been hired for this job.

[abbasifaizan70]

Proposal

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

When User B (invited with “Invite to chat only”) opens a newly submitted expense from the workspace chat, the expense details screen shows two identical expenses instead of one.

What is the root cause of that problem?

The transaction list shown on the expense report is built from the derived report transactions. For a single-expense report, the backend or client state can sometimes yield more than one transaction record for the same logical expense (e.g. for invite-to-chat-only users or due to timing). The UI does not deduplicate in this case, so every transaction for that report is shown and the user sees two identical rows.

Transaction list is built here:

App/src/pages/inbox/ReportScreen.tsx

Lines 341 to 342 in a8bf508

	const reportTransactions = useMemo(() => getAllNonDeletedTransactions(allReportTransactions, reportActions, isOffline, true), [allReportTransactions, reportActions, isOffline]);

App/src/components/MoneyRequestReportView/MoneyRequestReportView.tsx

Lines 117 to 119 in a8bf508

	const reportTransactions = useReportTransactionsCollection(reportID);
	const hasPendingDeletionTransaction = Object.values(reportTransactions ?? {}).some((transaction) => transaction?.pendingAction === CONST.RED_BRICK_ROAD_PENDING_ACTION.DELETE);
	const transactions = useMemo(() => getAllNonDeletedTransactions(reportTransactions, reportActions, isOffline, true), [reportTransactions, reportActions, isOffline]);

Filtering is done by getAllNonDeletedTransactions, which does not consider single-expense reports:

App/src/libs/MoneyRequestReportUtils.ts

Lines 86 to 105 in a8bf508

	function getAllNonDeletedTransactions(transactions: OnyxCollection<Transaction>, reportActions: ReportAction[], isOffline = false, includeOrphanedTransactions = false) {
	return Object.values(transactions ?? {}).filter((transaction): transaction is Transaction => {
	if (!transaction) {
	return false;
	}
	if (transaction?.pendingAction === CONST.RED_BRICK_ROAD_PENDING_ACTION.DELETE) {
	return true;
	}
	const action = getIOUActionForTransactionID(reportActions, transaction.transactionID);
	if (!action && includeOrphanedTransactions) {
	return true;
	}
	if (action?.pendingAction === CONST.RED_BRICK_ROAD_PENDING_ACTION.DELETE && isOffline) {
	return true;
	}
	return !isDeletedParentAction(action) && (reportActions.length === 0 || !isDeletedAction(action));
	});
	}

When report.transactionCount === 1 but the collection has more than one transaction for that report, all of them are still displayed.

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

Deduplicate the transaction list when the report represents a single expense (report.transactionCount === 1) but the list has more than one transaction: keep only the transaction that matches the most recent IOU report action’s IOUTransactionID. Add a helper in MoneyRequestReportUtils and use it in both ReportScreen and MoneyRequestReportView when building the list passed to the UI.

Solution – new code (git diff):

1. App/src/libs/MoneyRequestReportUtils.ts – Add import for getMostRecentIOURequestActionID and add helper, then export it.

--- a/App/src/libs/MoneyRequestReportUtils.ts
+++ b/App/src/libs/MoneyRequestReportUtils.ts
@@ -6,7 +6,7 @@ import CONST from '@src/CONST';
 import type {OriginalMessageIOU, Policy, Report, ReportAction, ReportMetadata, Transaction} from '@src/types/onyx';
 import {convertToDisplayString} from './CurrencyUtils';
 import {isPaidGroupPolicy} from './PolicyUtils';
-import {getIOUActionForTransactionID, getOriginalMessage, isDeletedAction, isDeletedParentAction, isMoneyRequestAction} from './ReportActionsUtils';
+import {getIOUActionForTransactionID, getMostRecentIOURequestActionID, getOriginalMessage, isDeletedAction, isDeletedParentAction, isMoneyRequestAction} from './ReportActionsUtils';
 import {
     getMoneyRequestSpendBreakdown,
     getNonHeldAndFullAmount,
@@ -82,6 +82,28 @@ function getReportIDForTransaction(transactionItem: TransactionListItemType, IO
 }

 /**
+ * For single-expense reports, when the transaction list has more than one entry (e.g. duplicate for invite-to-chat-only),
+ * return only the transaction that matches the most recent IOU report action so the UI shows one expense.
+ */
+function getDeduplicatedTransactionsForSingleExpenseReport(
+    report: OnyxEntry<Report>,
+    transactions: Transaction[],
+    reportActions: ReportAction[],
+): Transaction[] {
+    if (!report || report.transactionCount !== 1 || transactions.length <= 1) {
+        return transactions;
+    }
+    const mostRecentIOUActionID = getMostRecentIOURequestActionID(reportActions);
+    const mostRecentAction = reportActions.find((action) => action.reportActionID === mostRecentIOUActionID);
+    const transactionIDFromAction = getOriginalMessage(mostRecentAction)?.IOUTransactionID;
+    if (!transactionIDFromAction) {
+        return transactions;
+    }
+    const filtered = transactions.filter((transaction) => transaction.transactionID === transactionIDFromAction);
+    return filtered.length > 0 ? filtered : transactions;
+}
+
+/**
  * Filters all available transactions and returns the ones that belong to not removed action and not removed parent action.
  */
 function getAllNonDeletedTransactions(transactions: OnyxCollection<Transaction>, reportActions: ReportAction[], isOffline = false, includeOrphanedTransactions = false) {
@@ -184,6 +206,7 @@ const getTotalAmountForIOUReportPreviewButton = (report: OnyxEntry<Report>, polic
export {
    isActionVisibleOnMoneyRequestReport,
    getThreadReportIDsForTransactions,
    getReportIDForTransaction,
+    getDeduplicatedTransactionsForSingleExpenseReport,
     getTotalAmountForIOUReportPreviewButton,
     getAllNonDeletedTransactions,

2. App/src/pages/inbox/ReportScreen.tsx – Use the deduplication helper when building reportTransactions.

--- a/App/src/pages/inbox/ReportScreen.tsx
+++ b/App/src/pages/inbox/ReportScreen.tsx
@@ -47,7 +47,7 @@ import {
 } from '@libs/MoneyRequestReportUtils';
 import Navigation, {navigationRef} from '@libs/Navigation/Navigation';

(Add import for getDeduplicatedTransactionsForSingleExpenseReport in the existing MoneyRequestReportUtils import block.)

-import {getAllNonDeletedTransactions, shouldDisplayReportTableView, shouldWaitForTransactions as shouldWaitForTransactionsUtil} from '@libs/MoneyRequestReportUtils';
+import {getAllNonDeletedTransactions, getDeduplicatedTransactionsForSingleExpenseReport, shouldDisplayReportTableView, shouldWaitForTransactions as shouldWaitForTransactionsUtil} from '@libs/MoneyRequestReportUtils';

-    const reportTransactions = useMemo(() => getAllNonDeletedTransactions(allReportTransactions, reportActions, isOffline, true), [allReportTransactions, reportActions, isOffline]);
+    const reportTransactions = useMemo(() => {
+        const list = getAllNonDeletedTransactions(allReportTransactions, reportActions, isOffline, true);
+        return getDeduplicatedTransactionsForSingleExpenseReport(report, list, reportActions);
+    }, [allReportTransactions, reportActions, isOffline, report]);

3. App/src/components/MoneyRequestReportView/MoneyRequestReportView.tsx – Use the deduplication helper when building transactions.

--- a/App/src/components/MoneyRequestReportView/MoneyRequestReportView.tsx
+++ b/App/src/components/MoneyRequestReportView/MoneyRequestReportView.tsx
@@ -23,7 +23,7 @@ import Log from '@libs/Log';
 import {getAllNonDeletedTransactions, shouldDisplayReportTableView, shouldWaitForTransactions as shouldWaitForTransactionsUtil} from '@libs/MoneyRequestReportUtils';

(Add import for getDeduplicatedTransactionsForSingleExpenseReport in the existing MoneyRequestReportUtils import.)

-import {getAllNonDeletedTransactions, shouldDisplayReportTableView, shouldWaitForTransactions as shouldWaitForTransactionsUtil} from '@libs/MoneyRequestReportUtils';
+import {getAllNonDeletedTransactions, getDeduplicatedTransactionsForSingleExpenseReport, shouldDisplayReportTableView, shouldWaitForTransactions as shouldWaitForTransactionsUtil} from '@libs/MoneyRequestReportUtils';

-    const transactions = useMemo(() => getAllNonDeletedTransactions(reportTransactions, reportActions, isOffline, true), [reportTransactions, reportActions, isOffline]);
+    const transactions = useMemo(() => {
+        const list = getAllNonDeletedTransactions(reportTransactions, reportActions, isOffline, true);
+        return getDeduplicatedTransactionsForSingleExpenseReport(report, list, reportActions);
+    }, [reportTransactions, reportActions, isOffline, report]);

[webbygit]

🚫 Duplicated proposal withdrawn by 🤖 ProposalPolice.