wallet-stack 1.0.0-alpha.121

package/src/app/saga.ts

@@ -0,0 +1,367 @@
+import * as Keychain from '@divvi/react-native-keychain'
+import locales from 'locales'
+import { AppState, Platform } from 'react-native'
+import DeviceInfo from 'react-native-device-info'
+import InAppReview from 'react-native-in-app-review'
+import { findBestLanguageTag } from 'react-native-localize'
+import { eventChannel } from 'redux-saga'
+import AppAnalytics from 'src/analytics/AppAnalytics'
+import { AppEvents } from 'src/analytics/Events'
+import { HooksEnablePreviewOrigin } from 'src/analytics/types'
+import {
+  Actions,
+  androidMobileServicesAvailabilityChecked,
+  appLock,
+  inAppReviewRequested,
+  OpenDeepLink,
+  openDeepLink,
+  OpenUrlAction,
+  SetAppState,
+  setAppState,
+  setSupportedBiometryType,
+} from 'src/app/actions'
+import {
+  getLastTimeBackgrounded,
+  getRequirePinOnAppOpen,
+  googleMobileServicesAvailableSelector,
+  huaweiMobileServicesAvailableSelector,
+  inAppReviewLastInteractionTimestampSelector,
+} from 'src/app/selectors'
+import { getAppConfig } from 'src/appConfig'
+import { DEFAULT_APP_LANGUAGE, DEFAULT_SENTRY_NETWORK_ERRORS, isE2EEnv } from 'src/config'
+import { FiatExchangeFlow } from 'src/fiatExchanges/types'
+import { initI18n } from 'src/i18n'
+import { currentLanguageSelector, otaTranslationsAppVersionSelector } from 'src/i18n/selectors'
+import { navigate, navigateInitialTab } from 'src/navigator/NavigationService'
+import { Screens } from 'src/navigator/Screens'
+import { StackParamList } from 'src/navigator/types'
+import { handleEnableHooksPreviewDeepLink } from 'src/positions/saga'
+import { allowHooksPreviewSelector } from 'src/positions/selectors'
+import { Actions as SendActions } from 'src/send/actions'
+import { handlePaymentDeeplink } from 'src/send/utils'
+import { initializeSentry } from 'src/sentry/Sentry'
+import { SentrySpanHub } from 'src/sentry/SentrySpanHub'
+import { SentrySpan } from 'src/sentry/SentrySpans'
+import { getFeatureGate, patchUpdateStatsigUser, setupOverridesFromLaunchArgs } from 'src/statsig'
+import { StatsigFeatureGates } from 'src/statsig/types'
+import { swapSuccess } from 'src/swap/slice'
+import Logger from 'src/utils/Logger'
+import { ensureError } from 'src/utils/ensureError'
+import { isDeepLink, navigateToURI } from 'src/utils/linking'
+import { safely } from 'src/utils/safely'
+import { ONE_DAY_IN_MILLIS } from 'src/utils/time'
+import { isWalletConnectEnabled } from 'src/walletConnect/saga'
+import {
+  handleWalletConnectDeepLink,
+  isWalletConnectDeepLink,
+} from 'src/walletConnect/walletConnect'
+import { walletAddressSelector } from 'src/web3/selectors'
+import {
+  all,
+  call,
+  cancelled,
+  put,
+  select,
+  spawn,
+  take,
+  takeEvery,
+  takeLatest,
+} from 'typed-redux-saga'
+import { parse } from 'url'
+
+const TAG = 'app/saga'
+
+// There are cases, when user will put the app into `background` state,
+// but we do not want to lock it immeditely. Here are some examples:
+// case 1: User switches to SMS app to copy verification text
+// case 2: User gets a permission request dialog
+//    (which will put an app into `background` state until dialog disappears).
+const DO_NOT_LOCK_PERIOD = 30000 // 30 sec
+
+// REVIEW_INTERVAL is the time between app review prompts
+const REVIEW_INTERVAL = ONE_DAY_IN_MILLIS * 120 // 120 days
+
+// Work that's done before other sagas are initalized
+// Be mindful to not put long blocking tasks here
+export function* appInit() {
+  yield* call(initializeSentry)
+
+  SentrySpanHub.startSpan(SentrySpan.app_init_saga)
+
+  const otaTranslationsAppVersion = yield* select(otaTranslationsAppVersionSelector)
+  const language = yield* select(currentLanguageSelector)
+  const bestLanguage = findBestLanguageTag(Object.keys(locales))?.languageTag
+  const appConfig = yield* call(getAppConfig)
+  const allowOtaTranslations = appConfig.experimental?.otaTranslations !== undefined
+
+  yield* all([
+    call([AppAnalytics, 'init']),
+    call(
+      initI18n,
+      language || bestLanguage || DEFAULT_APP_LANGUAGE,
+      allowOtaTranslations,
+      otaTranslationsAppVersion
+    ),
+  ])
+
+  Logger.setNetworkErrors(DEFAULT_SENTRY_NETWORK_ERRORS)
+
+  const supportedBiometryType = yield* call(Keychain.getSupportedBiometryType)
+  yield* put(setSupportedBiometryType(supportedBiometryType))
+
+  // setup statsig overrides for E2E tests
+  if (isE2EEnv) {
+    setupOverridesFromLaunchArgs()
+  }
+
+  SentrySpanHub.finishSpan(SentrySpan.app_init_saga)
+}
+
+// Check the availability of Google Mobile Services and Huawei Mobile Services, an alternative to
+// that ships with Huawei phones which do not have GMS. Log and report the result to analytics.
+// Note: On iOS, this will be a no-op.
+export function* checkAndroidMobileServicesSaga() {
+  if (Platform.OS !== 'android') {
+    return
+  }
+
+  // Check to see if Google Mobile Services (i.e. Google Play Services) are available on this device.
+  let googleIsAvailable: boolean | undefined
+  try {
+    googleIsAvailable = yield* call([DeviceInfo, DeviceInfo.hasGms])
+    Logger.info(TAG, 'Result of check for Google Mobile Services', googleIsAvailable)
+  } catch (e) {
+    Logger.error(TAG, 'Error in check for Google Mobile Services', e)
+  }
+
+  // Check to see if Huawei Mobile Services are available on this device.
+  let huaweiIsAvailable: boolean | undefined
+  try {
+    huaweiIsAvailable = yield* call([DeviceInfo, DeviceInfo.hasHms])
+    Logger.info(TAG, `Result of check for Huawei Mobile Services`, huaweiIsAvailable)
+  } catch (e) {
+    Logger.error(TAG, `Error in check for Huawei Mobile Services`, e)
+  }
+
+  // Check if the availability status has changed. If so, log an analytics events.
+  // When this is first run, the status in the state tree will be undefined, ensuring this event is
+  // fired at least once for each client.
+  const updated =
+    googleIsAvailable !== (yield* select(googleMobileServicesAvailableSelector)) ||
+    huaweiIsAvailable !== (yield* select(huaweiMobileServicesAvailableSelector))
+
+  if (updated) {
+    AppAnalytics.track(AppEvents.android_mobile_services_checked, {
+      googleIsAvailable,
+      huaweiIsAvailable,
+    })
+  }
+
+  yield* put(androidMobileServicesAvailabilityChecked(googleIsAvailable, huaweiIsAvailable))
+}
+
+function parseValue(value: string) {
+  if (['true', 'false'].indexOf(value) >= 0) {
+    return value === 'true'
+  }
+  const number = parseFloat(value)
+  if (!isNaN(number)) {
+    return number
+  }
+  return value
+}
+
+// Parses the query string into an object. Only works with built-in strings, booleans and numbers.
+function convertQueryToScreenParams(query: string) {
+  const decodedParams = new URLSearchParams(decodeURIComponent(query))
+  const params: { [key: string]: any } = {}
+  decodedParams.forEach((value, key) => {
+    params[key] = parseValue(value)
+  })
+  return params
+}
+
+export function* handleDeepLink(action: OpenDeepLink) {
+  const { deepLink } = action
+  const { isSecureOrigin } = action
+  Logger.debug(TAG, `Handling deep link: ${deepLink}, isSecureOrigin: ${isSecureOrigin}`)
+
+  const walletAddress = yield* select(walletAddressSelector)
+  if (!walletAddress) {
+    Logger.error(TAG, 'No wallet address found in store. This should never happen.')
+    return
+  }
+
+  if (isWalletConnectDeepLink(deepLink)) {
+    yield* call(handleWalletConnectDeepLink, deepLink)
+    return
+  }
+
+  const rawParams = parse(deepLink)
+  if (rawParams.path) {
+    const pathParts = rawParams.path.split('/')
+    const pathStartsWith = pathParts[1].split('?')[0]
+    // Only log detailed paramters (fullPath and query) for allowed paths. This is a security precaution so we
+    // don't accidentally log sensitive information on new deeplinks.
+    const pathStartsWithAllowList = [
+      'pay',
+      'cashIn',
+      'bidali',
+      'cash-in-success',
+      'cash-in-failure',
+      'openScreen',
+      'share',
+      'hooks',
+    ]
+    AppAnalytics.track(AppEvents.handle_deeplink, {
+      pathStartsWith: pathParts[1].split('?')[0],
+      fullPath: pathStartsWithAllowList.includes(pathStartsWith) ? rawParams.pathname : null,
+      query: pathStartsWithAllowList.includes(pathStartsWith) ? rawParams.query : null,
+    })
+    if (rawParams.path.startsWith('/pay')) {
+      yield* call(handlePaymentDeeplink, deepLink)
+    } else if (rawParams.path === '/cashIn') {
+      navigate(Screens.FiatExchangeCurrencyBottomSheet, { flow: FiatExchangeFlow.CashIn })
+    } else if (rawParams.pathname === '/bidali') {
+      const appConfig = yield* call(getAppConfig)
+      if (appConfig.experimental?.bidali?.url) {
+        navigate(Screens.BidaliScreen, { currency: undefined })
+      } else {
+        Logger.warn(TAG, 'Unable to open Bidali deep link as bidali url is not found in app config')
+      }
+    } else if (rawParams.path.startsWith('/cash-in-success')) {
+      // Some providers append transaction information to the redirect links so can't check for strict equality
+      const cicoSuccessParam = (rawParams.pathname?.match(/cash-in-success\/(.+)/) || [])[1]
+      navigate(Screens.CashInSuccess, { provider: cicoSuccessParam.split('/')[0] })
+      // Some providers append transaction information to the redirect links so can't check for strict equality
+    } else if (rawParams.path.startsWith('/cash-in-failure')) {
+      navigateInitialTab()
+    } else if (isSecureOrigin && rawParams.pathname === '/openScreen' && rawParams.query) {
+      // The isSecureOrigin is important. We don't want it to be possible to fire this deep link from outside
+      // of our own notifications for security reasons.
+      const params = convertQueryToScreenParams(rawParams.query)
+      navigate(params.screen as keyof StackParamList, params)
+    } else if (
+      (yield* select(allowHooksPreviewSelector)) &&
+      rawParams.pathname === '/hooks/enablePreview'
+    ) {
+      yield* call(handleEnableHooksPreviewDeepLink, deepLink, HooksEnablePreviewOrigin.Deeplink)
+    }
+  }
+}
+
+function* watchDeepLinks() {
+  // using takeEvery over takeLatest because openScreen deep links could be
+  // fired by multiple handlers (one with isSecureOrigin and one without), and
+  // if takeLatest kills the call to the handler with isSecureOrigin, the deep
+  // link won't work.
+  yield* takeEvery(Actions.OPEN_DEEP_LINK, safely(handleDeepLink))
+}
+
+export function* handleOpenUrl(action: OpenUrlAction) {
+  const { url, openExternal, isSecureOrigin } = action
+  const walletConnectEnabled: boolean = yield* call(isWalletConnectEnabled, url)
+  Logger.debug(TAG, 'Handling url', url)
+  if (isDeepLink(url) || (walletConnectEnabled && isWalletConnectDeepLink(url))) {
+    // Handle celo links directly, this avoids showing the "Open with App" sheet on Android
+    yield* call(handleDeepLink, openDeepLink(url, isSecureOrigin))
+  } else if (/^https?:\/\//i.test(url) === true && !openExternal) {
+    // We display http or https links using our in app browser, unless openExternal is forced
+    navigate(Screens.WebViewScreen, { uri: url })
+  } else {
+    // Fallback
+    yield* call(navigateToURI, url)
+  }
+}
+
+function* watchOpenUrl() {
+  yield* takeEvery(Actions.OPEN_URL, safely(handleOpenUrl))
+}
+
+function createAppStateChannel() {
+  return eventChannel((emit: any) => {
+    const appStateListener = AppState.addEventListener('change', emit)
+
+    return () => {
+      appStateListener.remove()
+    }
+  })
+}
+
+function* watchAppState() {
+  Logger.debug(`${TAG}@monitorAppState`, 'Starting monitor app state saga')
+  const appStateChannel = yield* call(createAppStateChannel)
+  while (true) {
+    try {
+      const newState = (yield* take(appStateChannel)) as string
+      Logger.debug(`${TAG}@monitorAppState`, `App changed state: ${newState}`)
+      yield* put(setAppState(newState))
+    } catch (err) {
+      const error = ensureError(err)
+      AppAnalytics.track(AppEvents.app_state_error, { error: error.message })
+      Logger.error(`${TAG}@monitorAppState`, `App state Error`, error)
+    } finally {
+      if (yield* cancelled()) {
+        appStateChannel.close()
+      }
+    }
+  }
+}
+
+export function* handleSetAppState(action: SetAppState) {
+  const requirePinOnAppOpen = yield* select(getRequirePinOnAppOpen)
+  const lastTimeBackgrounded = yield* select(getLastTimeBackgrounded)
+  const isPassedDoNotLockPeriod = Date.now() - lastTimeBackgrounded > DO_NOT_LOCK_PERIOD
+  const isAppActive = action.state === 'active'
+
+  if (requirePinOnAppOpen && isPassedDoNotLockPeriod && isAppActive) {
+    yield* put(appLock())
+  }
+
+  if (isAppActive) {
+    // Force a statsig refresh by updating the user object
+    yield* call(patchUpdateStatsigUser)
+  }
+}
+
+export function* requestInAppReview() {
+  const walletAddress = yield* select(walletAddressSelector)
+  // Quick return if no wallet address or the device does not support in app review
+  if (
+    !walletAddress ||
+    !InAppReview.isAvailable() ||
+    !getFeatureGate(StatsigFeatureGates.APP_REVIEW)
+  )
+    return
+
+  const lastInteractionTimestamp = yield* select(inAppReviewLastInteractionTimestampSelector)
+  const now = Date.now()
+
+  // If the last interaction was less than a quarter year ago or null
+  if (!lastInteractionTimestamp || now - lastInteractionTimestamp >= REVIEW_INTERVAL) {
+    try {
+      // If we call InAppReview.RequestInAppReview and there wasn't an error
+      // Update the last interaction timestamp and send analytics
+      yield* call(InAppReview.RequestInAppReview)
+      yield* put(inAppReviewRequested(now))
+      AppAnalytics.track(AppEvents.in_app_review_impression)
+    } catch (err) {
+      const error = ensureError(err)
+      Logger.error(TAG, `Error while calling InAppReview.RequestInAppReview`, error)
+      AppAnalytics.track(AppEvents.in_app_review_error, { error: error.message })
+    }
+  }
+}
+
+function* watchAppReview() {
+  // Triggers on successful payment, swap, or rewards claim
+  yield* takeLatest([SendActions.SEND_PAYMENT_SUCCESS, swapSuccess], safely(requestInAppReview))
+}
+
+export function* appSaga() {
+  yield* spawn(watchDeepLinks)
+  yield* spawn(watchOpenUrl)
+  yield* spawn(watchAppState)
+  yield* takeLatest(Actions.SET_APP_STATE, safely(handleSetAppState))
+  yield* spawn(watchAppReview)
+}

package/src/app/selectors.ts

@@ -0,0 +1,53 @@
+import { RootState } from 'src/redux/reducers'
+
+export const getRequirePinOnAppOpen = (state: RootState) => {
+  return state.app.requirePinOnAppOpen
+}
+
+export const appStateSelector = (state: RootState) => {
+  return state.app.appState
+}
+
+export const getAppLocked = (state: RootState) => {
+  return state.app.locked
+}
+
+export const analyticsEnabledSelector = (state: RootState) => {
+  return state.app.analyticsEnabled
+}
+
+export const getLastTimeBackgrounded = (state: RootState) => {
+  return state.app.lastTimeBackgrounded
+}
+
+export const sessionIdSelector = (state: RootState) => {
+  return state.app.sessionId
+}
+
+export const googleMobileServicesAvailableSelector = (state: RootState) =>
+  state.app.googleMobileServicesAvailable
+
+export const huaweiMobileServicesAvailableSelector = (state: RootState) =>
+  state.app.huaweiMobileServicesAvailable
+
+export const supportedBiometryTypeSelector = (state: RootState) => state.app.supportedBiometryType
+
+export const phoneNumberVerifiedSelector = (state: RootState) => state.app.phoneNumberVerified
+
+export const hapticFeedbackEnabledSelector = (state: RootState) => state.app.hapticFeedbackEnabled
+
+export const pushNotificationsEnabledSelector = (state: RootState) =>
+  state.app.pushNotificationsEnabled
+
+export const pushNotificationRequestedUnixTimeSelector = (state: RootState) =>
+  state.app.pushNotificationRequestedUnixTime
+
+export const inAppReviewLastInteractionTimestampSelector = (state: RootState) =>
+  state.app.inAppReviewLastInteractionTimestamp
+
+export const showNotificationSpotlightSelector = (state: RootState) =>
+  state.app.showNotificationSpotlight
+
+export const hideWalletBalancesSelector = (state: RootState) => state.app.hideBalances
+
+export const pendingDeepLinkSelector = (state: RootState) => state.app.pendingDeepLinks[0] ?? null

package/src/app/useDeepLinks.test.tsx

@@ -0,0 +1,43 @@
+import { act, renderHook } from '@testing-library/react-native'
+import React from 'react'
+import { Linking } from 'react-native'
+import { Provider } from 'react-redux'
+import { useDeepLinks } from 'src/app/useDeepLinks'
+import { createMockStore } from 'test/utils'
+
+describe('useDeepLinks', () => {
+  let linkingListenerCallback: Function
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    jest.mocked(Linking.addEventListener).mockImplementation((event, callback) => {
+      if (event === 'url') {
+        linkingListenerCallback = callback
+      }
+      return {
+        remove: jest.fn(),
+      } as any
+    })
+  })
+
+  it('should handle linking events with deep links', async () => {
+    const store = createMockStore()
+    renderHook(() => useDeepLinks(), {
+      wrapper: (component) => (
+        <Provider store={store}>{component?.children ? component.children : component}</Provider>
+      ),
+    })
+
+    await act(() => {
+      linkingListenerCallback({ url: 'some-link' })
+    })
+
+    expect(store.getActions()).toEqual([
+      {
+        deepLink: 'some-link',
+        isSecureOrigin: false,
+        type: 'APP/OPEN_DEEP_LINK',
+      },
+    ])
+  })
+})

package/src/app/useDeepLinks.ts

@@ -0,0 +1,72 @@
+import { useEffect, useState } from 'react'
+import { useAsync } from 'react-async-hook'
+import { Linking } from 'react-native'
+import { deepLinkDeferred, openDeepLink } from 'src/app/actions'
+import { pendingDeepLinkSelector } from 'src/app/selectors'
+import { hasVisitedHomeSelector } from 'src/home/selectors'
+import { useDispatch, useSelector } from 'src/redux/hooks'
+import Logger from 'src/utils/Logger'
+import { walletAddressSelector } from 'src/web3/selectors'
+
+export const useDeepLinks = () => {
+  const [isConsumingInitialLink, setIsConsumingInitialLink] = useState(false)
+  const dispatch = useDispatch()
+
+  const pendingDeepLink = useSelector(pendingDeepLinkSelector)
+  const address = useSelector(walletAddressSelector)
+  // having seen the home screen is a proxy for having finished onboarding. we
+  // want to prevent consuming deep links during the onboarding flow in case the
+  // deep link includes navigation.
+  const hasVisitedHome = useSelector(hasVisitedHomeSelector)
+
+  const shouldConsumeDeepLinks = address && hasVisitedHome
+
+  const handleOpenURL = (event: { url: string }) => {
+    Logger.debug(
+      'useDeepLinks/handleOpenURL',
+      `Handling url: ${event.url}, shouldConsumeDeepLinks: ${shouldConsumeDeepLinks}`
+    )
+    // defer consuming deep links until the user has completed onboarding
+    if (shouldConsumeDeepLinks) {
+      dispatch(openDeepLink(event.url, false))
+    } else {
+      dispatch(deepLinkDeferred(event.url, false))
+    }
+  }
+
+  useEffect(() => {
+    if (pendingDeepLink && shouldConsumeDeepLinks) {
+      Logger.debug('useDeepLinks/useEffect', 'Consuming pending deep link', pendingDeepLink.url)
+      dispatch(openDeepLink(pendingDeepLink.url, pendingDeepLink.isSecureOrigin))
+    }
+  }, [pendingDeepLink, address, hasVisitedHome])
+
+  const handleOpenInitialURL = (event: { url: string }) => {
+    if (!isConsumingInitialLink) {
+      setIsConsumingInitialLink(true)
+      handleOpenURL(event)
+    }
+  }
+
+  useAsync(async () => {
+    const initialUrl = await Linking.getInitialURL()
+    if (initialUrl) {
+      Logger.debug('useDeepLinks/useAsync', 'Linking InitialUrl', initialUrl)
+      handleOpenInitialURL({ url: initialUrl })
+    }
+  }, [])
+
+  useEffect(() => {
+    // Handles opening any deep links. This listener is also triggered when the
+    // app is closed, so the openDeepLink action could be dispatched multiple
+    // times in this case.
+    const linkingEventListener = Linking.addEventListener('url', (event) => {
+      Logger.debug('useDeepLinks/useEffect', 'Linking url event', event)
+      handleOpenURL(event)
+    })
+
+    return () => {
+      linkingEventListener.remove()
+    }
+  }, [])
+}

package/src/app/utils.ts

@@ -0,0 +1,14 @@
+import { DappRequestOrigin } from 'src/analytics/types'
+import { ActiveDapp } from 'src/dapps/types'
+
+// Assume that if we have an active dapp, any WC request comes from the in-app webview.
+// Note that this may be incorrect if the user interacts with another dapp while the dapp webview is open.
+// I thought about comparing the request url to the active dapp url, but that could fail too if the dapp url we have is different.
+// For instance the dapp-list could contain a "example.com", while the request is "dapp.something.com".
+export function getDappRequestOrigin(activeDapp: ActiveDapp | null) {
+  if (activeDapp) {
+    return DappRequestOrigin.InAppWebView
+  }
+
+  return DappRequestOrigin.External
+}

package/src/appConfig.test.ts

@@ -0,0 +1,37 @@
+import * as AppConfigModule from './appConfig'
+import { PublicAppConfig } from './public/types'
+
+describe('appConfig', () => {
+  let getAppConfig: typeof AppConfigModule.getAppConfig
+  let setAppConfig: typeof AppConfigModule.setAppConfig
+
+  beforeEach(() => {
+    // Reset the module between tests to clear the appConfig
+    jest.resetModules()
+    // Re-import the functions after reset
+    const newAppConfigModule = require('./appConfig')
+    setAppConfig = newAppConfigModule.setAppConfig
+    getAppConfig = newAppConfigModule.getAppConfig
+  })
+
+  const mockConfig: PublicAppConfig = {
+    registryName: 'MyApp',
+    displayName: 'MyApp',
+    deepLinkUrlScheme: 'myapp',
+  }
+
+  it('should set and get app config correctly', () => {
+    setAppConfig(mockConfig)
+    const retrievedConfig = getAppConfig()
+    expect(retrievedConfig).toEqual(mockConfig)
+  })
+
+  it('should throw when setting config multiple times', () => {
+    setAppConfig(mockConfig)
+    expect(() => setAppConfig(mockConfig)).toThrow('App config already set')
+  })
+
+  it('should throw when getting config before setting it', () => {
+    expect(() => getAppConfig()).toThrow('App config not set')
+  })
+})

package/src/appConfig.ts

@@ -0,0 +1,20 @@
+// IMPORTANT: This file should not import any other runtime files, to avoid circular dependencies
+import { PublicAppConfig } from './public/types'
+
+let appConfig: PublicAppConfig | undefined
+
+export function setAppConfig(config: PublicAppConfig) {
+  if (appConfig) {
+    throw new Error('App config already set')
+  }
+  appConfig = config
+}
+
+export function getAppConfig(): PublicAppConfig {
+  if (!appConfig) {
+    // If this happens, something is wrong in the initialization of the runtime
+    // Either some code tried to access the config before it was set, or the config was not set at all
+    throw new Error('App config not set')
+  }
+  return appConfig
+}

package/src/backup/BackupComplete.test.tsx

@@ -0,0 +1,61 @@
+import { render } from '@testing-library/react-native'
+import * as React from 'react'
+import 'react-native'
+import { Provider } from 'react-redux'
+import AppAnalytics from 'src/analytics/AppAnalytics'
+import BackupComplete from 'src/backup/BackupComplete'
+import { navigate, navigateInitialTab } from 'src/navigator/NavigationService'
+import { Screens } from 'src/navigator/Screens'
+import { createMockStore, getMockStackScreenProps } from 'test/utils'
+
+describe('BackupComplete', () => {
+  beforeEach(() => {
+    jest.useFakeTimers()
+    jest.clearAllMocks()
+  })
+  it('renders correctly', () => {
+    const tree = render(
+      <Provider
+        store={createMockStore({
+          account: { backupCompleted: true },
+        })}
+      >
+        <BackupComplete {...getMockStackScreenProps(Screens.BackupComplete)} />
+      </Provider>
+    )
+    expect(tree).toMatchSnapshot()
+  })
+
+  it('navigates to settings on account removal', () => {
+    render(
+      <Provider
+        store={createMockStore({
+          account: { backupCompleted: true },
+        })}
+      >
+        <BackupComplete
+          {...getMockStackScreenProps(Screens.BackupComplete, { isAccountRemoval: true })}
+        />
+      </Provider>
+    )
+    jest.advanceTimersByTime(2000)
+    expect(navigate).toHaveBeenCalledWith(Screens.SecuritySubmenu, {
+      promptConfirmRemovalModal: true,
+    })
+  })
+
+  it('navigates home and fires analytics event when not on account removal', () => {
+    render(
+      <Provider
+        store={createMockStore({
+          account: { backupCompleted: true },
+        })}
+      >
+        <BackupComplete {...getMockStackScreenProps(Screens.BackupComplete)} />
+      </Provider>
+    )
+    jest.advanceTimersByTime(2000)
+    expect(navigateInitialTab).toHaveBeenCalledWith()
+    expect(AppAnalytics.track).toHaveBeenCalledWith('backup_complete')
+  })
+})