[Due for payment 2026-05-29] [$250] Option to pay non-USD report with USD bank account

[m-natarajan]

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: 9.3.69-0
Reproducible in staging?: Y
Reproducible in production?: Y
If this was caught during regression testing, add the test name, ID and link from BrowserStack:
Email or phone of affected tester (no customers):
Logs: https://stackoverflow.com/c/expensify/questions/4856
Expensify/Expensify Issue URL:
Issue reported by: @joekaufmanexpensify
Slack conversation (hyperlinked to channel name): #Expensify Bugs

Action Performed:

1. Create USD, EUR workspaces.
2. Add a USD bank account.
3. Submit a report on the EUR workspace.
4. Go to Spend > Reports.
5. Select the EUR report
6. Open bulk pay menu

Expected Result:

You see option to add new business bank account and mark as paid. You can only pay a report with a bank account matching the report currency. Only EUR bank account or mark as paid. If you had existing EUR bank accounts, we'd show those here.

Actual Result:

You see option to pay with USD bank account, in addition to option to add new bank account and mark as paid

Workaround:

Unknown

Platforms:

Select the officially supported platforms where the issue was reproduced:

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

Screenshots/Videos

589073790-7451fd4d-e8c1-4143-b36c-9a68f71a01aa.mp4

Recording.2844.mp4

View all open jobs on GitHub

Upwork Automation - Do Not Edit

• Upwork Job URL: https://www.upwork.com/jobs/~022052836395802118415
• Upwork Job ID: 2052836395802118415
• Last Price Increase: 2026-05-15

Issue Owner

Current Issue Owner: @mallenexpensify

[MelvinBot]

Proposal

What is the root cause of that problem?

Neither getBusinessBankAccountOptions() nor the getPaymentSubItems() helper in useBulkPayOptions filter bank accounts by currency. They only check account type and state, so every business (or personal) bank account is shown regardless of whether its bankCurrency matches the report's currency.

The currency prop is already passed into useBulkPayOptions but is never used to filter the bank account list.

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

Add a currency parameter to getBusinessBankAccountOptions() in PaymentUtils.ts and filter accounts where bankCurrency matches the provided currency. Pass the report currency from useBulkPayOptions when calling it. Apply the same bankCurrency filter inside getPaymentSubItems() in useBulkPayOptions.ts:86-92 for personal bank accounts.

This pattern already exists in WorkflowUtils.getEligibleExistingBusinessBankAccounts and PaymentMethodList, which both compare bankCurrency against a target currency.

What alternative solutions did you explore? (Optional)

Could filter earlier in formatPaymentMethods(), but that function is shared across contexts that may not need currency filtering. Filtering at the point of use (getBusinessBankAccountOptions and getPaymentSubItems) is more targeted and avoids unintended side effects.

Investigation details

• formatPaymentMethods() at PaymentUtils.ts:108-147 returns all non-wallet bank accounts with no currency check
• getBusinessBankAccountOptions() at PaymentUtils.ts:160-183 filters by type=BUSINESS and state=OPEN/LOCKED only
• useBulkPayOptions at useBulkPayOptions.ts:81 calls these without passing currency
• BankAccount type has bankCurrency: string available for filtering
• The same bug likely affects SettlementButton for single-report pay at index.tsx:158

Related issues: Expensify/App#79387 (SettlementButton cleanup, on hold)

---

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 - @situchan (External)

[dilshodmackbook-sketch]

Proposal

What is the root cause of that problem?

When the bulk-pay popover is opened for a non-USD expense report, the list of business bank account options is built from every business bank account the admin has access to, with no filter on the bank's bankCurrency.

In useBulkPayOptions, the currency of the selected report (selectedBulkCurrency, set in useSearchBulkActions.ts) is already passed in but is only used for the invoice-via-Expensify check. It is never applied to the business bank account list:

https://github.com/Expensify/App/blob/main/src/hooks/useBulkPayOptions.ts#L111-L154

The list is produced by getBusinessBankAccountOptions, which only filters on account type and state — it does not look at currency at all:

https://github.com/Expensify/App/blob/main/src/libs/PaymentUtils.ts#L156-L183

So if the admin has a USD business bank account on one workspace and submits an EUR expense report on another, the USD account is offered as a payment option, even though the bulk reimbursement requires the bank currency to match the report currency. We already enforce this match elsewhere (e.g., in WorkflowUtils.ts):

https://github.com/Expensify/App/blob/main/src/libs/WorkflowUtils.ts#L660-L673

The single-pay flow in SettlementButton consumes getBusinessBankAccountOptions the same way, so the same mismatch leaks through there:

https://github.com/Expensify/App/blob/main/src/components/SettlementButton/index.tsx#L272-L277

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

I think we should make getBusinessBankAccountOptions currency-aware, then pass the report currency from both pay flows. That keeps the filter in one place and fixes single-pay at the same time.

1. Add an optional reportCurrency filter to the util — src/libs/PaymentUtils.ts:

- function getBusinessBankAccountOptions(formattedPaymentMethods: PaymentMethod[]): BusinessBankAccountOption[] {
+ function getBusinessBankAccountOptions(formattedPaymentMethods: PaymentMethod[], reportCurrency?: string): BusinessBankAccountOption[] {
      return formattedPaymentMethods
          .filter((method) => {
              if (!isAccountData(method?.accountData)) {
                  return false;
              }
              const accountData = method.accountData;
              const isPartiallySetup = isBankAccountPartiallySetup(accountData.state);
              return (
                  accountData.type === CONST.BANK_ACCOUNT.TYPE.BUSINESS &&
                  (accountData.state === CONST.BANK_ACCOUNT.STATE.OPEN || accountData.state === CONST.BANK_ACCOUNT.STATE.LOCKED) &&
                  method?.methodID != null &&
-                 !isPartiallySetup
+                 !isPartiallySetup &&
+                 // Only show bank accounts whose currency matches the report being paid.
+                 (!reportCurrency || method.bankCurrency === reportCurrency)
              );
          })

2. Pass the report currency from the bulk-pay hook — src/hooks/useBulkPayOptions.ts:

- const businessBankAccountOptionList = getBusinessBankAccountOptions(formattedPaymentMethods);
+ const businessBankAccountOptionList = getBusinessBankAccountOptions(formattedPaymentMethods, currency);

The same one-line change applies to SettlementButton/index.tsx:273, where we already have currency in scope from props. With this in place:

• An EUR expense report's bulk-pay menu will only list EUR business bank accounts.
• If no matching bank account exists, the existing fallback at useBulkPayOptions.ts:133 (businessBankAccountOptionList.length === 0) already pushes the generic "Pay with business bank account" entry that routes to "Add a bank account", which matches the issue's expected behavior of seeing the option to add a new EUR account.

I'd also add a unit test covering the mismatch case so we don't regress (a USD account in bankAccountList should not appear in getBusinessBankAccountOptions(..., 'EUR')).

What alternative solutions did you explore?

• Filter at the call site only (inside useBulkPayOptions) without touching PaymentUtils: this fixes the reported bulk-pay screen but leaves the identical bug in SettlementButton's single-pay popover. Centralizing in getBusinessBankAccountOptions covers both with one change.
• Filter by policy.outputCurrency instead of report currency: works in most cases but is less correct than report.currency. The report's currency is what the backend actually validates the bank against (mirroring WorkflowUtils.ts:619/:669), and reports can briefly diverge from policy currency during currency changes.
• Show the mismatched options but disable them with an explanation: more discoverable, but it conflicts with the reporter's expected behavior ("only display payment options matching the report currency") and would clutter the popover for the common case where most users only have one bank account anyway.

[MobileMage]

🚫 Duplicated proposal withdrawn by 🤖 ProposalPolice.

[melvin-bot]

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

[github-actions]

⚠️ @dilshodmackbook-sketch Thanks for your proposal. Please update it to follow the proposal template, as proposals are only reviewed if they follow that format (note the mandatory sections).

[github-actions]

⚠️ @MobileMage Your proposal is a duplicate of an already existing proposal and has been automatically withdrawn to prevent spam. Please review the existing proposals before submitting a new one.

[KJ21-ENG]

Proposal

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

When an admin opens the bulk pay menu for an EUR expense report, the menu includes USD business bank accounts. The pay menu should only list bank accounts whose currency matches the report currency, while still leaving the add-bank-account and Mark as paid options available when no matching bank account exists.

What is the root cause of that problem?

The bulk pay menu gets its account options from getBusinessBankAccountOptions(). That helper filters formatted payment methods by business account type, open/locked state, non-null method ID, and partial-setup status, but it never checks the payment method's bankCurrency against the report currency:

App/src/libs/PaymentUtils.ts

Lines 160 to 183 in fc1a858

	function getBusinessBankAccountOptions(formattedPaymentMethods: PaymentMethod[]): BusinessBankAccountOption[] {
	return formattedPaymentMethods
	.filter((method) => {
	if (!isAccountData(method?.accountData)) {
	return false;
	}
	const accountData = method.accountData;
	const isPartiallySetup = isBankAccountPartiallySetup(accountData.state);
	return (
	accountData.type === CONST.BANK_ACCOUNT.TYPE.BUSINESS &&
	(accountData.state === CONST.BANK_ACCOUNT.STATE.OPEN || accountData.state === CONST.BANK_ACCOUNT.STATE.LOCKED) &&
	method?.methodID != null &&
	!isPartiallySetup
	);
	})
	.map((formattedPaymentMethod) => ({
	text: formattedPaymentMethod?.title ?? '',
	description: formattedPaymentMethod?.description ?? '',
	icon: formattedPaymentMethod?.icon,
	iconStyles: formattedPaymentMethod?.iconStyles,
	iconSize: formattedPaymentMethod?.iconSize,
	methodID: formattedPaymentMethod?.methodID,
	}));
	}

useBulkPayOptions() already receives the selected report currency, but it calls the helper without passing that value, so an EUR report receives every otherwise-valid business bank account, including USD accounts:

App/src/hooks/useBulkPayOptions.ts

Lines 51 to 58 in fc1a858

	function useBulkPayOptions({
	selectedPolicyID,
	selectedReportID,
	isCurrencySupportedWallet,
	currency,
	formattedAmount,
	onlyShowPayElsewhere,
	}: UseBulkPayOptionProps): UseBulkPayOptionReturnType {

App/src/hooks/useBulkPayOptions.ts

Lines 111 to 121 in fc1a858

	const businessBankAccountOptionList = getBusinessBankAccountOptions(formattedPaymentMethods);
	const businessBankAccountOptions =
	shouldShowBusinessBankAccountOptions && businessBankAccountOptionList.length
	? businessBankAccountOptionList.map((account) => ({
	text: account.text,
	description: account.description,
	icon: account.icon,
	methodID: account.methodID,
	value: CONST.PAYMENT_METHODS.BUSINESS_BANK_ACCOUNT,
	}))
	: undefined;

The same currency invariant is already enforced in the workspace reimbursement helpers, where business bank accounts are eligible only when account.bankCurrency === policyCurrency / policy.outputCurrency:

App/src/libs/WorkflowUtils.ts

Lines 612 to 624 in fc1a858

	function getEligibleExistingBusinessBankAccounts(bankAccountList: BankAccountList | undefined, policyCurrency: string | undefined, shouldIncludePartiallySetup?: boolean) {
	if (!bankAccountList || policyCurrency === undefined) {
	return [];
	}
	return Object.values(bankAccountList).filter((account) => {
	return (
	account.bankCurrency === policyCurrency &&
	(account.accountData?.state === CONST.BANK_ACCOUNT.STATE.OPEN || (shouldIncludePartiallySetup && isBankAccountPartiallySetup(account.accountData?.state))) &&
	account.accountData?.type === CONST.BANK_ACCOUNT.TYPE.BUSINESS
	);
	});
	}

App/src/libs/WorkflowUtils.ts

Lines 662 to 675 in fc1a858

	function getOpenConnectedToPolicyBusinessBankAccounts(bankAccountList: BankAccountList | undefined, policy: OnyxEntry<Policy> | undefined) {
	if (!bankAccountList || policy === undefined) {
	return [];
	}
	return Object.values(bankAccountList).filter((account) => {
	return (
	account.bankCurrency === policy?.outputCurrency &&
	account.accountData?.state === CONST.BANK_ACCOUNT.STATE.OPEN &&
	account.accountData?.type === CONST.BANK_ACCOUNT.TYPE.BUSINESS &&
	account?.accountData?.bankAccountID === policy?.achAccount?.bankAccountID
	);
	});
	}

The single-report settlement menu has the same underlying helper call without currency narrowing, so it can leak the same mismatched business bank accounts outside the bulk-pay repro:

App/src/components/SettlementButton/index.tsx

Lines 272 to 277 in fc1a858

	const personalBankAccountList = getLatestPersonalBankAccount();
	const businessBankAccountOptionList = getBusinessBankAccountOptions(formattedPaymentMethods);
	const businessBankAccountOptions =
	isExpenseReport && businessBankAccountOptionList.length
	? businessBankAccountOptionList.map((account) => ({...account, value: CONST.PAYMENT_METHODS.BUSINESS_BANK_ACCOUNT}))
	: undefined;

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

Add an optional reportCurrency argument to getBusinessBankAccountOptions() and, when it is provided, include method.bankCurrency === reportCurrency in the existing eligibility predicate. Keeping the parameter optional preserves existing callers/tests that intentionally do not narrow by currency.

Pass the existing currency prop from useBulkPayOptions() into getBusinessBankAccountOptions(formattedPaymentMethods, currency). Once the USD account is filtered out for an EUR report, the existing empty-list branch at useBulkPayOptions.ts lines 132-135 will show the generic business-bank-account option, which routes to adding a matching account, and the existing Mark as paid option remains visible.

Pass the existing currency prop from SettlementButton into the same helper call so the single-report pay surface follows the same rule. Add a unit test in tests/unit/PaymentUtilsTest.ts under getBusinessBankAccountOptions that creates USD and EUR business bank accounts and verifies that getBusinessBankAccountOptions(methods, CONST.CURRENCY.EUR) returns only the EUR account.

Scope boundaries: files touched are src/libs/PaymentUtils.ts (getBusinessBankAccountOptions, line 160), src/hooks/useBulkPayOptions.ts (bulk-pay helper call, line 111), src/components/SettlementButton/index.tsx (single-report helper call, line 273), and tests/unit/PaymentUtilsTest.ts (getBusinessBankAccountOptions tests, line 338). Platforms affected are web/desktop and native via the shared payment-option helpers. Code paths not touched: invoice getPaymentSubItems() branches and canIOUBePaid(), because this issue is about which already-payable bank accounts are listed, not whether the report can be paid at all. API/backend changes: none.

What alternative solutions did you explore? (Optional)

Filtering in formatPaymentMethods() would over-filter shared wallet/payment-method surfaces that need to show all accounts. Filtering only inside useBulkPayOptions() would fix the reported menu but leave the same helper call in SettlementButton unchanged. Gating the click handler or canIOUBePaid() would still render the wrong USD option or hide the whole pay menu, while the expected behavior is to trim only the mismatched bank-account rows and keep Add bank account / Mark as paid available.