fix(spark): address settings + onboarding UI/UX issues from

__tests__/components/mnemonic-word-input.spec.tsx

@@ -1,7 +1,11 @@
-import React from "react"
+import React, { createRef } from "react"
+import { TextInput } from "react-native"
 import { render, fireEvent } from "@testing-library/react-native"
 
-import { MnemonicWordInput } from "@app/components/mnemonic-word-input"
+import {
+  MnemonicWordInput,
+  MnemonicWordInputHandle,
+} from "@app/components/mnemonic-word-input"
 
 jest.mock("@rn-vui/themed", () => {
   const colors = {
@@ -81,4 +85,16 @@ describe("MnemonicWordInput", () => {
 
     expect(onFocus).toHaveBeenCalled()
   })
+
+  it("forwards focus through ref to underlying TextInput", () => {
+    const ref = createRef<MnemonicWordInputHandle>()
+    const focusSpy = jest.spyOn(TextInput.prototype, "focus")
+
+    render(<MnemonicWordInput ref={ref} {...defaultProps} />)
+
+    ref.current?.focus()
+
+    expect(focusSpy).toHaveBeenCalled()
+    focusSpy.mockRestore()
+  })
 })

__tests__/components/password-input.spec.tsx

@@ -58,4 +58,16 @@ describe("PasswordInput", () => {
 
     expect(queryByText("Too short")).toBeNull()
   })
+
+  it("calls onBlur when the input loses focus", () => {
+    const onBlur = jest.fn()
+    const { getByPlaceholderText } = render(
+      <ContextForScreen>
+        <PasswordInput {...defaultProps} onBlur={onBlur} />
+      </ContextForScreen>,
+    )
+
+    fireEvent(getByPlaceholderText("Enter password"), "blur")
+    expect(onBlur).toHaveBeenCalledTimes(1)
+  })
 })

__tests__/hooks/use-backup-nudge-state.spec.ts

@@ -21,6 +21,18 @@ jest.mock("@app/config/feature-flags-context", () => ({
   useRemoteConfig: () => mockRemoteConfig(),
 }))
 
+const SATS_PER_USD_CENT = 10
+
+jest.mock("@app/components/balance-header/use-total-balance", () => ({
+  useTotalBalance: (wallets: Array<{ walletCurrency: string; balance: number }>) => ({
+    satsBalance: wallets.reduce((sum, w) => {
+      if (w.walletCurrency === "BTC") return sum + w.balance
+      if (w.walletCurrency === "USD") return sum + w.balance * 10
+      return sum
+    }, 0),
+  }),
+}))
+
 jest.mock("@react-native-async-storage/async-storage", () => ({
   getItem: (...args: string[]) => mockGetItem(...args),
   setItem: (...args: string[]) => mockSetItem(...args),
@@ -30,11 +42,11 @@ const defaultBackupState = { backupState: { status: "none", method: null } }
 const completedBackupState = { backupState: { status: "completed", method: "manual" } }
 const selfCustodialWallet = {
   accountType: "self-custodial",
-  wallets: [{ walletCurrency: "BTC", balance: { amount: 3000 } }],
+  wallets: [{ id: "btc-1", walletCurrency: "BTC", balance: { amount: 3000 } }],
 }
 const custodialWallet = {
   accountType: "custodial",
-  wallets: [{ walletCurrency: "BTC", balance: { amount: 50000 } }],
+  wallets: [{ id: "btc-1", walletCurrency: "BTC", balance: { amount: 50000 } }],
 }
 const defaultConfig = {
   backupNudgeBannerThreshold: 2100,
@@ -51,14 +63,21 @@ describe("useBackupNudgeState", () => {
     mockSetItem.mockResolvedValue(undefined)
   })
 
-  it("returns false for all flags before loaded resolves", () => {
+  it("hides banner and modal while dismissal-load is pending", () => {
     mockGetItem.mockReturnValue(new Promise(() => {}))
 
     const { result } = renderHook(() => useBackupNudgeState())
 
     expect(result.current.shouldShowBanner).toBe(false)
     expect(result.current.shouldShowModal).toBe(false)
-    expect(result.current.shouldShowSettingsBanner).toBe(false)
+  })
+
+  it("shows settings banner without waiting for dismissal-load", () => {
+    mockGetItem.mockReturnValue(new Promise(() => {}))
+
+    const { result } = renderHook(() => useBackupNudgeState())
+
+    expect(result.current.shouldShowSettingsBanner).toBe(true)
   })
 
   it("shows banner when balance >= banner threshold and not backed up", async () => {
@@ -73,7 +92,7 @@ describe("useBackupNudgeState", () => {
   it("shows modal when balance >= modal threshold", async () => {
     mockActiveWallet.mockReturnValue({
       accountType: "self-custodial",
-      wallets: [{ walletCurrency: "BTC", balance: { amount: 22000 } }],
+      wallets: [{ id: "btc-1", walletCurrency: "BTC", balance: { amount: 22000 } }],
     })
 
     const { result } = renderHook(() => useBackupNudgeState())
@@ -147,4 +166,48 @@ describe("useBackupNudgeState", () => {
 
     expect(result.current.shouldShowBanner).toBe(true)
   })
+
+  it("triggers banner when USD weight pushes combined balance over the threshold", async () => {
+    const btcAmount = 1_000
+    const usdCentsAmount = 200
+    const combinedSats = btcAmount + usdCentsAmount * SATS_PER_USD_CENT
+    expect(btcAmount).toBeLessThan(defaultConfig.backupNudgeBannerThreshold)
+    expect(combinedSats).toBeGreaterThanOrEqual(defaultConfig.backupNudgeBannerThreshold)
+
+    mockActiveWallet.mockReturnValue({
+      accountType: "self-custodial",
+      wallets: [
+        { id: "btc-1", walletCurrency: "BTC", balance: { amount: btcAmount } },
+        { id: "usd-1", walletCurrency: "USD", balance: { amount: usdCentsAmount } },
+      ],
+    })
+
+    const { result } = renderHook(() => useBackupNudgeState())
+
+    await act(async () => {})
+
+    expect(result.current.shouldShowBanner).toBe(true)
+  })
+
+  it("triggers modal when USD weight pushes combined balance over the modal threshold", async () => {
+    const btcAmount = 1_000
+    const usdCentsAmount = 2_200
+    const combinedSats = btcAmount + usdCentsAmount * SATS_PER_USD_CENT
+    expect(btcAmount).toBeLessThan(defaultConfig.backupNudgeModalThreshold)
+    expect(combinedSats).toBeGreaterThanOrEqual(defaultConfig.backupNudgeModalThreshold)
+
+    mockActiveWallet.mockReturnValue({
+      accountType: "self-custodial",
+      wallets: [
+        { id: "btc-1", walletCurrency: "BTC", balance: { amount: btcAmount } },
+        { id: "usd-1", walletCurrency: "USD", balance: { amount: usdCentsAmount } },
+      ],
+    })
+
+    const { result } = renderHook(() => useBackupNudgeState())
+
+    await act(async () => {})
+
+    expect(result.current.shouldShowModal).toBe(true)
+  })
 })

__tests__/hooks/use-bip39-input.spec.ts

@@ -3,11 +3,29 @@ import { renderHook, act } from "@testing-library/react-native"
 import { useBip39Input } from "@app/hooks/use-bip39-input"
 
 jest.mock("@app/utils/bip39-wordlist", () => ({
-  BIP39_WORDLIST_EN: ["abandon", "ability", "able", "about", "above", "absent"],
-  getBip39Suggestions: (prefix: string) =>
-    ["abandon", "ability", "able", "about", "above", "absent"].filter((w) =>
-      w.startsWith(prefix),
-    ),
+  BIP39_WORDLIST_EN: [
+    "abandon",
+    "ability",
+    "able",
+    "about",
+    "above",
+    "absent",
+    "run",
+    "runway",
+  ],
+  getBip39Suggestions: (prefix: string, options?: { maxResults?: number }) => {
+    const all = [
+      "abandon",
+      "ability",
+      "able",
+      "about",
+      "above",
+      "absent",
+      "run",
+      "runway",
+    ].filter((w) => w.startsWith(prefix))
+    return options?.maxResults ? all.slice(0, options.maxResults) : all
+  },
   splitWords: (text: string) => text.trim().toLowerCase().split(/\s+/),
 }))
 
@@ -177,4 +195,62 @@ describe("useBip39Input", () => {
     expect(result.current.words[5]).toBe("absent")
     expect(result.current.activeIndex).toBe(5)
   })
+
+  it("requests focus on next index when input is a prefix-unique BIP39 word", () => {
+    const { result } = renderHook(() => useBip39Input({ wordCount: 12 }))
+
+    act(() => {
+      result.current.updateWord(0, "abandon")
+    })
+
+    expect(result.current.focusRequest).toBe(1)
+  })
+
+  it("does not advance when input is BIP39 word but prefix has multiple matches", () => {
+    const { result } = renderHook(() => useBip39Input({ wordCount: 12 }))
+
+    act(() => {
+      result.current.updateWord(0, "run")
+    })
+
+    expect(result.current.focusRequest).toBeNull()
+  })
+
+  it("does not advance when input is not a BIP39 word", () => {
+    const { result } = renderHook(() => useBip39Input({ wordCount: 12 }))
+
+    act(() => {
+      result.current.updateWord(0, "ru")
+    })
+
+    expect(result.current.focusRequest).toBeNull()
+  })
+
+  it("does not advance past last index in step", () => {
+    const { result } = renderHook(() =>
+      useBip39Input({ wordCount: 12, wordsPerStep: 6, step: 1 }),
+    )
+
+    act(() => {
+      result.current.updateWord(5, "abandon")
+    })
+
+    expect(result.current.focusRequest).toBeNull()
+  })
+
+  it("clearFocusRequest resets focusRequest", () => {
+    const { result } = renderHook(() => useBip39Input({ wordCount: 12 }))
+
+    act(() => {
+      result.current.updateWord(0, "abandon")
+    })
+
+    expect(result.current.focusRequest).toBe(1)
+
+    act(() => {
+      result.current.clearFocusRequest()
+    })
+
+    expect(result.current.focusRequest).toBeNull()
+  })
 })

__tests__/i18n/locale-parity.test.ts

@@ -0,0 +1,64 @@
+import { loadLocale } from "@app/i18n/i18n-util.sync"
+import { i18nObject } from "@app/i18n/i18n-util"
+import type { Locales } from "@app/i18n/i18n-types"
+
+const LOCALES: ReadonlyArray<Locales> = [
+  "af",
+  "ar",
+  "ca",
+  "cs",
+  "da",
+  "de",
+  "el",
+  "en",
+  "es",
+  "fr",
+  "hr",
+  "hu",
+  "hy",
+  "it",
+  "ja",
+  "lg",
+  "ms",
+  "nl",
+  "pt",
+  "qu",
+  "ro",
+  "sk",
+  "sr",
+  "sw",
+  "th",
+  "tr",
+  "vi",
+]
+
+describe("locale parity for backup/restore i18n keys", () => {
+  LOCALES.forEach((locale) => {
+    describe(`locale: ${locale}`, () => {
+      beforeAll(() => {
+        loadLocale(locale)
+      })
+
+      it("exposes a non-empty SettingsScreen.recoveryMethod string", () => {
+        const LL = i18nObject(locale)
+        const value = LL.SettingsScreen.recoveryMethod()
+        expect(typeof value).toBe("string")
+        expect(value.length).toBeGreaterThan(0)
+      })
+
+      it("exposes a non-empty RestoreScreen.invalidMnemonic string", () => {
+        const LL = i18nObject(locale)
+        const value = LL.RestoreScreen.invalidMnemonic()
+        expect(typeof value).toBe("string")
+        expect(value.length).toBeGreaterThan(0)
+      })
+
+      it("exposes a non-empty BackupScreen.ManualBackup.Phrase.headerTitle string", () => {
+        const LL = i18nObject(locale)
+        const value = LL.BackupScreen.ManualBackup.Phrase.headerTitle()
+        expect(typeof value).toBe("string")
+        expect(value.length).toBeGreaterThan(0)
+      })
+    })
+  })
+})

__tests__/screens/account-type-selection/account-type-selection.spec.tsx

@@ -36,21 +36,28 @@ jest.mock("@app/i18n/i18n-react", () => ({
   }),
 }))
 
+const mockCardDefaultBg = "#1d1d1d"
+const mockCardSelectedBg = "#2B2B2B"
+const mockPrimary = "#fc5805"
+
 jest.mock("@rn-vui/themed", () => ({
   makeStyles:
     (fn: (args: { colors: Record<string, string> }) => Record<string, object>) => () =>
       fn({
         colors: {
-          primary: "#000",
+          primary: "#fc5805",
           grey2: "#949494",
           grey3: "#999",
-          grey5: "#eee",
+          grey5: "#1d1d1d",
+          grey6: "#2B2B2B",
           black: "#000",
         },
       }),
   Text: ({ children, ...props }: { children: React.ReactNode }) =>
     React.createElement("Text", props, children),
-  useTheme: () => ({ theme: { colors: { primary: "#000", grey5: "#eee" } } }),
+  useTheme: () => ({
+    theme: { colors: { primary: "#fc5805", grey5: "#1d1d1d", grey6: "#2B2B2B" } },
+  }),
 }))
 
 jest.mock("@app/components/atomic/galoy-icon", () => ({
@@ -166,4 +173,33 @@ describe("AccountTypeSelectionScreen", () => {
 
     expect(mockNavigate).not.toHaveBeenCalled()
   })
+
+  it("uses grey5 as default card background and grey6 when selected", () => {
+    const { getByTestId } = render(<AccountTypeSelectionScreen />)
+
+    const custodialCard = getByTestId("custodial-option")
+    const selfCustodialCard = getByTestId("self-custodial-option")
+
+    expect(custodialCard.props.style).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ backgroundColor: mockCardDefaultBg }),
+      ]),
+    )
+    expect(selfCustodialCard.props.style).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ backgroundColor: mockCardDefaultBg }),
+      ]),
+    )
+
+    fireEvent.press(custodialCard)
+
+    expect(custodialCard.props.style).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          backgroundColor: mockCardSelectedBg,
+          borderColor: mockPrimary,
+        }),
+      ]),
+    )
+  })
 })