[$250] Android - Wallet - KYC error not displayed

[applause-bot]

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.4.36-0
Reproducible in staging?: Yes
Reproducible in production?: Yes
If this was caught during regression testing, add the test name, ID and link from BrowserStack: https://test-management.browserstack.com/projects/2219752/folder/13176687/test-cases/56153521
Email or phone of affected tester (no customers): sintayewhaylu01@gmail.com
Issue reported by: Applause Internal Team
Bug source: Regression TC Execution
Device used: Samsung A16/ Android 15
App Component: Other

Action Performed:

Preconditions:
Run the following script in the web console:
Onyx.merge('userWallet', {errorCode: 'kycFailed',});

1. Open hybrid app.
2. Navigate to the Wallet page.
3. Tap Enable Wallet.

Expected Result:

KYC Failed error message is displayed.
The message includes a clickable Concierge email link for support.

Actual Result:

No error message is displayed after tapping Enable Wallet.

Workaround:

Unknown

Platforms:

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

Screenshots/Videos

Bug7210905_1784313306246.video_2026-07-17_21-25-50.mp4

View all open jobs on GitHub

Applause Internal Information
Exported by: Svetlana Lazutkina
Bug ID: 7210905

Upwork Automation - Do Not Edit

• Upwork Job URL: https://www.upwork.com/jobs/~022078204379639475385
• Upwork Job ID: 2078204379639475385
• Last Price Increase: 2026-07-17

[applause-bot]

While Applause doesn't embed attachments for this bug, here are the links for quick view:
https://platform.applause.com/services/links/v1/external/682c26dcee78e14fbeb55277c6ce1567d4bf7f51b8bacd2205f0745e9f242f52

[MelvinBot]

Issue Analysis

Root cause: The Enable Wallet page forces a wallet-data refetch on mount, and the server response replaces userWallet — overwriting the errorCode: 'kycFailed' that the repro injects via Onyx.merge. So the KYC branch that renders the error can never be satisfied through this repro. The rendering code itself is correct; whether a real KYC‑failed user sees the message depends entirely on the backend, not App.

Flow (confirmed):

1. Tapping Enable Wallet navigates to SETTINGS_ENABLE_PAYMENTS (WalletPage/index.tsx:889), which renders Wallet/EnablePayments.tsx (not the Pay/ variant).
2. On mount it calls openEnablePaymentsPage(), which optimistically sets userWallet.isLoading = true and issues an OpenEnablePaymentsPage server read (Wallet.ts:220-251).
3. While loading, shouldWaitForWalletData is true, so a loading spinner renders before the KYC check.
4. When the read resolves, userWallet is replaced with authoritative server state. The manually‑injected kycFailed is gone, so the KYC branch is skipped and nothing is shown.

This means the repro (Onyx.merge('userWallet', {errorCode: 'kycFailed'})) can't work by design — the mandatory refetch overwrites the injected value on any fresh open. It reproduces "on all platforms" precisely because the overwrite is client logic, not platform-specific (though the report only ticks the native apps).

The open question that decides whether this is a real user-facing bug: does the OpenEnablePaymentsPage backend command return errorCode: 'kycFailed' in its userWallet payload for a genuinely KYC‑failed account?

• If yes → the error does display for real users, and this repro is simply invalid. QA should re-test with an account the backend actually flags as kycFailed, not a manual Onyx injection.
• If no → it's a genuine bug, but the fix is on the backend (OpenEnablePaymentsPage must return the errorCode), which is outside the Expensify/App repo and needs an internal engineer.

I could not verify the backend response shape from the App repo, so I'm not proposing an App code change — the render logic in App is already correct.

Investigation details

• FailedKYC renders correctly (message + Concierge link): shared/FailedKYC.tsx:11-24.
• openEnablePaymentsPage touches only isLoading and RAM_ONLY_HAS_FRESH_WALLET_DATA optimistically (Wallet.ts:221-246); it does not preserve or re-inject errorCode — that comes from the server response.
• RAM_ONLY_HAS_FRESH_WALLET_DATA is a RAM-only key (empty on every fresh app open), which guarantees the refetch fires and the loading gate is hit on the first visit.
• Not a recent refactor regression: the pre-refactor EnablePaymentsPage.tsx (@557d88bda) had the identical structure — openEnablePaymentsPage() on mount, loading gate before the errorCode === KYC check. So the manual-injection repro would have been overwritten before the May–June 2026 refactor too.

Alternative explanations considered: (a) wrong component rendered — ruled out, the Settings/Wallet flow maps to Wallet/EnablePayments.tsx, the Pay/ variant is for IOU_SEND/ENABLE_PAYMENTS_ROOT; (b) FailedKYC broken — ruled out, component is correct; (c) a render race clearing errorCode after it appears — possible but secondary to the refetch overwrite.

---

Next Steps:

• QA: re-verify using an account the backend genuinely returns kycFailed for, rather than a manual Onyx.merge (which is always overwritten by the on-mount refetch). If the error shows, this can be closed as an invalid repro.
• If it still fails with a real account: the fix is in the backend OpenEnablePaymentsPage response and needs an internal engineer — it is not fixable in Expensify/App.

Reply with @MelvinBot <feedback> to refine this analysis.

[aswin-s]

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

On Android (and iOS) hybrid app, when userWallet.shouldShowFailedKYC is set to true by the failed-KYC path (or errorCode = 'kycFailed' via the console repro), tapping Enable Wallet on the Wallet page navigates to the Enable Payments screen but does NOT display the "KYC Failed" error message with the Concierge email link. Expected: the FailedKYC screen renders and shows the Concierge contact link.

What is the root cause of that problem?

There are two compounding bugs, one in each EnablePayments implementation.

Wallet flow (src/pages/EnablePayments/Wallet/EnablePayments.tsx): The render guard at line 144 reads userWallet?.errorCode === CONST.WALLET.ERROR.KYC. The producer — acceptWalletTerms failureData in src/libs/actions/Wallet.ts:192 — writes shouldShowFailedKYC: true, not errorCode: 'kycFailed'. The client no longer writes errorCode on this path, so the render guard never fires. In addition, openEnablePaymentsPage() (Wallet.ts:220) fires on mount and its server response merges a fresh userWallet, which overwrites the console-set errorCode before the render branch ever sees it. Net effect: the FailedKYC branch is unreachable from the real KYC-failure signal, so nothing is displayed.

Pay flow (src/pages/EnablePayments/Pay/EnablePaymentsPage.tsx): This file has the same mismatched render guard at line 82 (errorCode === CONST.WALLET.ERROR.KYC). But it also contains a second useEffect (lines 56–64) that runs after fresh data loads and redirects away to ROUTES.SETTINGS_WALLET whenever isPendingOnfidoResult || hasFailedOnfido is true:

useEffect(() => {
    if (isOffline || !hasFreshData) {
        return;
    }
    if (isPendingOnfidoResult || hasFailedOnfido) {
        Navigation.navigate(ROUTES.SETTINGS_WALLET, {forceReplace: true});
    }
}, [isOffline, isPendingOnfidoResult, hasFailedOnfido, hasFreshData]);

When acceptWalletTerms failureData fires it sets shouldShowFailedKYC: true alongside hasFailedOnfido: true. Because hasFailedOnfido is true when fresh data arrives, this useEffect redirects the user back to the Wallet settings page before the render body (line 82) ever has a chance to show <FailedKYC />. The render guard is therefore doubly broken in this flow: it reads the wrong field and the redirect fires first.

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

1. src/pages/EnablePayments/Wallet/EnablePayments.tsx line 144 — widen the FailedKYC render guard to match both the current producer flag and the legacy errorCode value:

// Before
if (userWallet?.errorCode === CONST.WALLET.ERROR.KYC) {

// After
if (userWallet?.shouldShowFailedKYC || userWallet?.errorCode === CONST.WALLET.ERROR.KYC) {

2. src/pages/EnablePayments/Pay/EnablePaymentsPage.tsx line 61 — add shouldShowFailedKYC to the redirect guard's escape hatch so that a KYC-failed wallet is not silently bounced away before the FailedKYC screen can render:

// Before
if (isPendingOnfidoResult || hasFailedOnfido) {
    Navigation.navigate(ROUTES.SETTINGS_WALLET, {forceReplace: true});
}

// After
if ((isPendingOnfidoResult || hasFailedOnfido) && !userWallet?.shouldShowFailedKYC) {
    Navigation.navigate(ROUTES.SETTINGS_WALLET, {forceReplace: true});
}

Then apply the same render guard fix as step 1 to the FailedKYC branch at line 82:

// Before
if (userWallet?.errorCode === CONST.WALLET.ERROR.KYC) {

// After
if (userWallet?.shouldShowFailedKYC || userWallet?.errorCode === CONST.WALLET.ERROR.KYC) {

3. src/libs/actions/Wallet.ts:220 (openEnablePaymentsPage) — do not let the server read overwrite the local KYC signal: preserve shouldShowFailedKYC (and errorCode) across the fetch by not clearing them in optimistic/finally data, and if the backend response omits them, retain the prior value (guard the merge on the server side of the response schema, or set them explicitly to their prior values in successData).

4. src/pages/EnablePayments/shared/FailedKYC.tsx — confirm this is the single source of truth for the "KYC Failed" copy and the Concierge mailto link, shared by both flows. Both the Wallet and Pay EnablePaymentsPage already import from here, so no duplication is needed; the fix is purely in the guard and redirect conditions above.

5. Grep the repo for any remaining errorCode === CONST.WALLET.ERROR.KYC call-sites (confirmed hits: EnablePayments.tsx:144, EnablePaymentsPage.tsx:82); update each one or explicitly document why it is intentionally excluded.

What alternative solutions did you explore? (Optional)

Alternatively, standardize on a single flag by having acceptWalletTerms failureData set errorCode: CONST.WALLET.ERROR.KYC in addition to (or instead of) shouldShowFailedKYC, keeping the render guards unchanged — smaller surface but drops the more descriptive boolean.

[dilshodmackbook-sketch]

🚨 Edited by proposal-police: This proposal was edited at 2026-07-17 19:48:38 UTC.

Proposal

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

When userWallet.errorCode is kycFailed, tapping Enable Wallet shows no error at all — the KYC Failed message (with the Concierge link) never renders.

What is the root cause of that problem?

Enable Wallet from the Wallet page opens src/pages/EnablePayments/Wallet/EnablePayments.tsx. In that component the KYC branch is only reached after the fresh‑data loading gate:

const shouldWaitForWalletData = isUserWalletEmpty || !!userWallet?.isLoading || (!hasFreshData && !isOffline);
...
if (shouldWaitForWalletData) {
    return <FullScreenLoadingIndicator reasonAttributes={reasonAttributes} />;
}

if (userWallet?.errorCode === CONST.WALLET.ERROR.KYC) {
    return ( ... <FailedKYC /> ... );
}

See L108 and L136-L158.

shouldWaitForWalletData stays true until hasFreshData (RAM_ONLY_HAS_FRESH_WALLET_DATA) becomes true. That key is RAM‑only, so it is false on every app launch, which means the very first visit always shows the loader and fires openEnablePaymentsPage():

useEffect(() => {
    if (isOffline) {
        return;
    }
    if (hasFreshData) {
        return;
    }
    if (userWallet?.isLoading) {
        return;
    }
    openEnablePaymentsPage();
    // eslint-disable-next-line react-hooks/exhaustive-deps
}, [isOffline, hasFreshData]);

(L90-L105)

The OpenEnablePaymentsPage response then rewrites userWallet with the account's real wallet state, which does not carry errorCode: 'kycFailed'. So by the time the loading gate opens (hasFreshData === true), userWallet.errorCode no longer equals KYC, the branch at L144 never matches, and the user is left with a blank/next‑step page instead of the KYC message. The error state that exists in Onyx before the fetch is effectively thrown away before it can ever be rendered.

The Pay variant src/pages/EnablePayments/Pay/EnablePaymentsPage.tsx has the same ordering and the same defect.

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

Render the KYC failure from the wallet we already have before the fresh‑data gate, and don't let the routine page‑open refetch wipe a terminal KYC error.

1. Short‑circuit the KYC branch above the shouldWaitForWalletData gate, so the error renders straight from cached Onyx:

// A KYC failure is terminal state we can render immediately; don't wait on (and get overwritten by) a refetch.
if (userWallet?.errorCode === CONST.WALLET.ERROR.KYC) {
    return (
        <ScreenWrapper
            testID="EnablePaymentsPage"
            includeSafeAreaPaddingBottom={false}
            shouldEnablePickerAvoiding={false}
        >
            <HeaderWithBackButton
                title={translate('personalInfoStep.personalInfo')}
                onBackButtonPress={() => Navigation.goBack(ROUTES.SETTINGS_WALLET)}
            />
            <FailedKYC />
        </ScreenWrapper>
    );
}

if (shouldWaitForWalletData) {
    ...
}

2. Skip the refetch when the KYC error is already present, so the OpenEnablePaymentsPage response can't overwrite errorCode (the useEffect still runs even though the render returns early, so guarding the render alone would cause the message to flash and disappear):

useEffect(() => {
    if (isOffline) {
        return;
    }
    if (hasFreshData) {
        return;
    }
    if (userWallet?.isLoading) {
        return;
    }
    if (userWallet?.errorCode === CONST.WALLET.ERROR.KYC) {
        return;
    }

    openEnablePaymentsPage();
    // eslint-disable-next-line react-hooks/exhaustive-deps
}, [isOffline, hasFreshData]);

The same two changes should be applied to Pay/EnablePaymentsPage.tsx, which shares the pattern.

What specific scenarios should we cover in automated tests to prevent reintroducing this issue in the future?

• Render EnablePayments with userWallet = {errorCode: 'kycFailed'} and hasFreshWalletData unset (fresh launch): assert the FailedKYC message (and Concierge link) is shown and the loading indicator is not.
• Assert openEnablePaymentsPage/OpenEnablePaymentsPage is not dispatched while errorCode === 'kycFailed', so the error is not overwritten.
• Regression guard: after a wallet refetch that returns no errorCode, a KYC error already in Onyx still keeps the KYC screen visible.

What alternative solutions did you explore? (Optional)

• Only reorder the KYC check above the gate, without guarding the fetch effect — rejected: hooks run regardless of the early return, so openEnablePaymentsPage() still fires, the response overwrites userWallet without errorCode, and FailedKYC flashes and then disappears.
• Persist errorCode in the OpenEnablePaymentsPage back‑end response — a server‑side change outside the scope of this front‑end regression, and it would not cover the reproduction that sets errorCode purely on the client.

[lorretheboy]

Note: This isn't a duplicate — Different fix: ours changes the loading-gate release semantics in the shared openEnablePaymentsPage/shouldWaitForWalletData so the spinner clears once any read attempt completes (via finallyData, regardless of success) — it never touches the KYC render order. The flagged proposal keeps the gate as-is and instead adds a KYC-specific carve-out (hasKYCError) to shouldWaitForWalletData and reorders the FailedKYC branch above the loading return, mirroring the !isOffline exemption. Different root cause emphasis too: ours pinpoints the failed-read-can't-retry regression (the successData/dropped-isLoading-deps combo leaves hasFreshData false for the whole session), whereas the flagged one centers on the on-mount fetch overwriting the cached errorCode and the KYC case lacking an offline-style carve-out. Ours fixes every wallet state stuck behind a failed read, not just KYC.

Proposal

What is the root cause of that problem?

Opening the Wallet → Enable Payments screen renders the Wallet/EnablePayments page. It shows only a loading spinner until RAM_ONLY_HAS_FRESH_WALLET_DATA is true, and the KYC error (FailedKYC) is rendered after that gate:

App/src/pages/EnablePayments/Wallet/EnablePayments.tsx

Line 108 in 0097920

const shouldWaitForWalletData = isUserWalletEmpty || !!userWallet?.isLoading || (!hasFreshData && !isOffline);

App/src/pages/EnablePayments/Wallet/EnablePayments.tsx

Lines 136 to 158 in 0097920

	if (shouldWaitForWalletData) {
	const reasonAttributes: SkeletonSpanReasonAttributes = {
	context: 'EnablePaymentsPage',
	isUserWalletEmpty,
	};
	return <FullScreenLoadingIndicator reasonAttributes={reasonAttributes} />;
	}
	if (userWallet?.errorCode === CONST.WALLET.ERROR.KYC) {
	return (
	<ScreenWrapper
	testID="EnablePaymentsPage"
	includeSafeAreaPaddingBottom={false}
	shouldEnablePickerAvoiding={false}
	>
	<HeaderWithBackButton
	title={translate('personalInfoStep.personalInfo')}
	onBackButtonPress={() => Navigation.goBack(ROUTES.SETTINGS_WALLET)}
	/>
	<FailedKYC />
	</ScreenWrapper>
	);
	}

RAM_ONLY_HAS_FRESH_WALLET_DATA is a session-only flag set only in the successData of the OpenEnablePaymentsPage read, while the fetch effect deliberately drops userWallet.isLoading from its dependencies so it never re-runs:

App/src/libs/actions/Wallet.ts

Lines 233 to 251 in 0097920

	const successData: Array<OnyxUpdate<typeof ONYXKEYS.RAM_ONLY_HAS_FRESH_WALLET_DATA>> = [
	{
	onyxMethod: Onyx.METHOD.SET,
	key: ONYXKEYS.RAM_ONLY_HAS_FRESH_WALLET_DATA,
	value: true,
	},
	];
	const finallyData: Array<OnyxUpdate<typeof ONYXKEYS.USER_WALLET>> = [
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: ONYXKEYS.USER_WALLET,
	value: {
	isLoading: false,
	},
	},
	];
	API.read(READ_COMMANDS.OPEN_ENABLE_PAYMENTS_PAGE, null, {optimisticData, successData, finallyData});

App/src/pages/EnablePayments/Wallet/EnablePayments.tsx

Lines 90 to 105 in 0097920

	useEffect(() => {
	if (isOffline) {
	return;
	}
	if (hasFreshData) {
	return;
	}
	if (userWallet?.isLoading) {
	return;
	}
	openEnablePaymentsPage();
	// userWallet.isLoading is intentionally omitted from the dependencies,
	// as reacting to it would endlessly retry a failed fetch
	// eslint-disable-next-line react-hooks/exhaustive-deps
	}, [isOffline, hasFreshData]);

Causal chain: the page mounts with userWallet.errorCode: 'kycFailed' but hasFreshData false → it fires openEnablePaymentsPage() and shows the spinner → if that read does not succeed (transient/hybrid failure), finallyData flips isLoading back to false but hasFreshData stays false, and the effect can't retry (its deps didn't change) → shouldWaitForWalletData stays true for the rest of the session → the page is stuck on the spinner and the errorCode === KYC branch is never reached → no KYC message appears.

This is a regression from moving the fresh flag from finallyData to successData (commit 94c4865). Previously the flag was set on every completion, so a failed read still released the gate and the existing userWallet.errorCode rendered.

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

Release the loading gate once a read attempt completes, not only when it succeeds, so the already-present userWallet (including its KYC error) can render. Keep hasFreshData success-only for the URL-redirect/refetch logic, but base the spinner on a read actually being in flight rather than on hasFreshData being permanently false — e.g. mark the attempt finished in finallyData and stop the spinner when userWallet is non-empty and no read is pending. That keeps the stale-data protection the original change intended while ensuring a failed read no longer hides the page forever.

The fix belongs in the shared openEnablePaymentsPage / the loading condition both pages use. Pay/EnablePaymentsPage has the identical (!hasFreshData && !isOffline) gate in front of its own KYC branch and is affected the same way:

App/src/pages/EnablePayments/Pay/EnablePaymentsPage.tsx

Lines 67 to 92 in 0097920

	if (isUserWalletEmpty || userWallet?.isLoading || (!hasFreshData && !isOffline)) {
	const reasonAttributes: SkeletonSpanReasonAttributes = {
	context: 'EnablePaymentsPage',
	isUserWalletEmpty,
	};
	return <FullScreenLoadingIndicator reasonAttributes={reasonAttributes} />;
	}
	return (
	<ScreenWrapper
	shouldShowOfflineIndicator={userWallet?.currentStep !== CONST.WALLET.STEP.ONFIDO}
	includeSafeAreaPaddingBottom
	testID="EnablePaymentsPage"
	>
	{() => {
	if (userWallet?.errorCode === CONST.WALLET.ERROR.KYC) {
	return (
	<>
	<HeaderWithBackButton
	title={translate('additionalDetailsStep.headerTitle')}
	onBackButtonPress={() => Navigation.goBack(ROUTES.SETTINGS_WALLET)}
	/>
	<FailedKYC />
	</>
	);
	}

What alternative solutions did you explore? (Optional)

Add failureData to the OpenEnablePaymentsPage read that surfaces an error/retry state instead of leaving the page spinning; or evaluate the errorCode === KYC branch directly from userWallet before the shouldWaitForWalletData gate so a KYC failure is shown even while fresh data hasn't loaded.

[melvin-bot]

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

[KJ21-ENG]

Proposal

What is the root cause of that problem?

The Wallet Enable Payments screen only evaluates the kycFailed branch after it has completed the fresh-wallet loading gate. The June wallet-flow changes added shouldWaitForWalletData and made the refresh freshness flag success-only, so a cached userWallet.errorCode can remain behind the loading path (or never become renderable after a failed refresh). This is why the error state supplied by the reproduction script does not reliably reach FailedKYC on Android.

App/src/pages/EnablePayments/Wallet/EnablePayments.tsx

Lines 90 to 145 in 0097920

	useEffect(() => {
	if (isOffline) {
	return;
	}
	if (hasFreshData) {
	return;
	}
	if (userWallet?.isLoading) {
	return;
	}
	openEnablePaymentsPage();
	// userWallet.isLoading is intentionally omitted from the dependencies,
	// as reacting to it would endlessly retry a failed fetch
	// eslint-disable-next-line react-hooks/exhaustive-deps
	}, [isOffline, hasFreshData]);
	const isUserWalletEmpty = isEmptyObject(userWallet);
	const shouldWaitForWalletData = isUserWalletEmpty || !!userWallet?.isLoading || (!hasFreshData && !isOffline);
	const hasActivatedWallet = ([CONST.WALLET.TIER_NAME.GOLD, CONST.WALLET.TIER_NAME.PLATINUM] as string[]).includes(userWallet?.tierName ?? '');
	const userWalletCurrentStep = userWallet?.currentStep ? userWallet.currentStep : CONST.WALLET.STEP.ADDITIONAL_DETAILS;
	let canonicalPage: EnablePaymentsPageType | undefined;
	if (!shouldWaitForWalletData) {
	const enablePaymentsStep = !hasExpensifyPaymentMethod(paymentCardList, bankAccountList ?? {}, hasActivatedWallet) ? CONST.WALLET.STEP.ADD_BANK_ACCOUNT : userWalletCurrentStep;
	canonicalPage = pages.find((p) => p.serverSteps.includes(enablePaymentsStep))?.pageName;
	}
	// Keep the URL in sync with the user's real wallet progress:
	// - While the wallet data isn't fresh yet (shouldWaitForWalletData), skip the redirect since the canonical page can't be reliably derived.
	// - Once the data is fresh, canonicalPage reflects the step the user actually needs to be on.
	// - If the page in the URL doesn't match canonicalPage, redirect to the correct page.
	useEffect(() => {
	if (shouldWaitForWalletData) {
	return;
	}
	if (!canonicalPage || currentPage === canonicalPage) {
	return;
	}
	// This is a URL correction, so replace the current route instead of pushing a duplicate instance of this screen.
	Navigation.navigate(ROUTES.SETTINGS_ENABLE_PAYMENTS.getRoute({page: canonicalPage}), {forceReplace: true});
	}, [canonicalPage, shouldWaitForWalletData, currentPage]);
	if (shouldWaitForWalletData) {
	const reasonAttributes: SkeletonSpanReasonAttributes = {
	context: 'EnablePaymentsPage',
	isUserWalletEmpty,
	};
	return <FullScreenLoadingIndicator reasonAttributes={reasonAttributes} />;
	}
	if (userWallet?.errorCode === CONST.WALLET.ERROR.KYC) {
	return (

The regression was introduced by the fresh-data/loading flow in commits b6e52820ab3 and 94c4865f057; the existing failure view and kycFailed constant are otherwise present and correctly wired. The Pay Enable Payments screen is a separate call site and already has its own failure branch, so this proposal scopes the change to the Wallet screen.

App/src/pages/EnablePayments/Pay/EnablePaymentsPage.tsx

Lines 54 to 91 in 0097920

	// Only redirect after the fresh data loading cycle (isLoading: true → false) completes,
	// to avoid acting on stale cached values from a previous session.
	useEffect(() => {
	if (isOffline || !hasFreshData) {
	return;
	}
	if (isPendingOnfidoResult || hasFailedOnfido) {
	Navigation.navigate(ROUTES.SETTINGS_WALLET, {forceReplace: true});
	}
	}, [isOffline, isPendingOnfidoResult, hasFailedOnfido, hasFreshData]);
	const isUserWalletEmpty = isEmptyObject(userWallet);
	if (isUserWalletEmpty || userWallet?.isLoading || (!hasFreshData && !isOffline)) {
	const reasonAttributes: SkeletonSpanReasonAttributes = {
	context: 'EnablePaymentsPage',
	isUserWalletEmpty,
	};
	return <FullScreenLoadingIndicator reasonAttributes={reasonAttributes} />;
	}
	return (
	<ScreenWrapper
	shouldShowOfflineIndicator={userWallet?.currentStep !== CONST.WALLET.STEP.ONFIDO}
	includeSafeAreaPaddingBottom
	testID="EnablePaymentsPage"
	>
	{() => {
	if (userWallet?.errorCode === CONST.WALLET.ERROR.KYC) {
	return (
	<>
	<HeaderWithBackButton
	title={translate('additionalDetailsStep.headerTitle')}
	onBackButtonPress={() => Navigation.goBack(ROUTES.SETTINGS_WALLET)}
	/>
	<FailedKYC />
	</>
	);

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

In src/pages/EnablePayments/Wallet/EnablePayments.tsx, derive the KYC-failure condition from userWallet.errorCode and render the existing FailedKYC screen before the generic wallet-data loading/URL-correction path. Keep the existing header/back behavior and Concierge email rendering unchanged. The loading gate should continue to protect normal wallet-step selection, but it must not suppress an explicit terminal KYC error already present in Onyx.

App/src/pages/EnablePayments/Wallet/EnablePayments.tsx

Lines 136 to 169 in 0097920

	if (shouldWaitForWalletData) {
	const reasonAttributes: SkeletonSpanReasonAttributes = {
	context: 'EnablePaymentsPage',
	isUserWalletEmpty,
	};
	return <FullScreenLoadingIndicator reasonAttributes={reasonAttributes} />;
	}
	if (userWallet?.errorCode === CONST.WALLET.ERROR.KYC) {
	return (
	<ScreenWrapper
	testID="EnablePaymentsPage"
	includeSafeAreaPaddingBottom={false}
	shouldEnablePickerAvoiding={false}
	>
	<HeaderWithBackButton
	title={translate('personalInfoStep.personalInfo')}
	onBackButtonPress={() => Navigation.goBack(ROUTES.SETTINGS_WALLET)}
	/>
	<FailedKYC />
	</ScreenWrapper>
	);
	}
	const currentEntry = pages.find((p) => p.pageName === currentPage) ?? pages.find((p) => p.pageName === canonicalPage);
	const CurrentPage = currentEntry?.component;
	if (!CurrentPage) {
	return null;
	}
	return (
	<View style={styles.flex1}>
	<CurrentPage />
	</View>
	);

The shared FailedKYC component has two call sites: the Wallet screen and the Pay screen. Do not change the shared component or the Pay call site; the Pay flow already renders its error state after its own loading gate. The Wallet screen's only CONST.WALLET.ERROR.KYC check is the branch being moved/guarded.

App/src/pages/EnablePayments/shared/FailedKYC.tsx

Lines 11 to 27 in 0097920

	function FailedKYC() {
	const {translate} = useLocalize();
	const styles = useThemeStyles();
	return (
	<View style={styles.flex1}>
	<View style={[styles.ph5, styles.flexRow, styles.renderHTML]}>
	<RenderHTML
	html={translate('additionalDetailsStep.failedKYCMessage', {
	conciergeEmail: CONST.EMAIL.CONCIERGE,
	})}
	/>
	</View>
	</View>
	);
	}
	export default FailedKYC;

Test coverage:

• Add a Wallet Enable Payments render test with userWallet.errorCode = 'kycFailed' while wallet data is loading/not fresh; assert that the failure message and Concierge mail link render instead of the full-screen loader.
• Add the normal fresh-wallet cases to confirm regular step routing is unchanged.

What alternative solutions did you explore? (Optional)

An alternative is to change openEnablePaymentsPage so its API refresh preserves the cached errorCode or marks wallet data fresh in the failure callback. That changes data-fetch semantics and could display stale KYC failures after a later successful server response; it also does not guarantee that the UI handles an already-present terminal error. Rendering the explicit error before the generic loading gate is the narrower fix at the confirmed client decision point.

[melvin-bot]

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