wallet-stack 1.0.0-alpha.121

package/src/analytics/types.ts

@@ -0,0 +1,46 @@
+export enum ScrollDirection {
+  next = 'next',
+  previous = 'previous',
+}
+
+export enum BackQuizProgress {
+  word_chosen = 'word_chosen',
+  backspace = 'backspace',
+}
+
+// Origin of Send actions
+export enum SendOrigin {
+  AppSendFlow = 'app_send_flow', // Sending as part of the app send flow
+  Bidali = 'bidali', // Sending from Bidali
+}
+
+// Origin of WalletConnect pairing
+export enum WalletConnectPairingOrigin {
+  Scan = 'scan',
+  Deeplink = 'deeplink',
+}
+
+// Origin of WalletConnect request
+export enum DappRequestOrigin {
+  InAppWebView = 'in_app_web_view',
+  External = 'external',
+}
+
+// Origin of Hooks enable preview
+export enum HooksEnablePreviewOrigin {
+  Scan = 'scan',
+  Deeplink = 'deeplink',
+}
+
+export type TransactionOrigin =
+  | 'send'
+  | 'swap'
+  | 'earn-deposit'
+  | 'earn-swap-deposit'
+  | 'earn-withdraw'
+  | 'earn-claim-rewards'
+  | 'jumpstart-send'
+  | 'jumpstart-claim'
+  | 'wallet-connect'
+  | 'shortcut'
+  | 'framework'

package/src/app/App.test.tsx

@@ -0,0 +1,25 @@
+import * as Sentry from '@sentry/react-native'
+import BigNumber from 'bignumber.js'
+import App from 'src/app/App'
+
+jest.mock('src/redux/store')
+jest.mock('react-native-screens')
+jest.mock('react-native-auth0', () => ({
+  Auth0Provider: ({ children }: { children: React.ReactNode }) => children,
+}))
+jest.mock('react-native-localize', () => ({
+  getNumberFormatSettings: jest
+    .fn()
+    .mockReturnValue({ decimalSeparator: ',', groupingSeparator: '.' }),
+}))
+
+describe('App', () => {
+  it('wraps sentry', () => {
+    expect(App).toBeDefined()
+    expect(Sentry.wrap).toHaveBeenCalledWith(App)
+  })
+
+  it('big number formats large numbers with separators from RN localize', () => {
+    expect(new BigNumber(1000000).toFormat(2)).toEqual('1.000.000,00')
+  })
+})

package/src/app/App.tsx

@@ -0,0 +1,124 @@
+import { BottomSheetModalProvider } from '@gorhom/bottom-sheet'
+import * as Sentry from '@sentry/react-native'
+import BigNumber from 'bignumber.js'
+import 'intl-pluralrules'
+import * as React from 'react'
+import { LogBox, Platform, StatusBar } from 'react-native'
+import { Auth0Provider } from 'react-native-auth0'
+import { GestureHandlerRootView } from 'react-native-gesture-handler'
+import { getNumberFormatSettings } from 'react-native-localize'
+import { initialWindowMetrics, SafeAreaProvider } from 'react-native-safe-area-context'
+import { enableFreeze, enableScreens } from 'react-native-screens'
+import { Provider } from 'react-redux'
+import { PersistGate } from 'redux-persist/integration/react'
+import AppInitGate from 'src/app/AppInitGate'
+import ErrorBoundary from 'src/app/ErrorBoundary'
+import { getAppConfig } from 'src/appConfig'
+import { AUTH0_CLIENT_ID, AUTH0_DOMAIN, isE2EEnv, SENTRY_ENABLED } from 'src/config'
+import i18n from 'src/i18n'
+import NavigatorWrapper from 'src/navigator/NavigatorWrapper'
+import { persistor, store } from 'src/redux/store'
+import Logger from 'src/utils/Logger'
+
+Logger.overrideConsoleLogs()
+// No need to await this, errors are handled internally
+void Logger.cleanupOldLogs()
+
+const defaultErrorHandler = ErrorUtils.getGlobalHandler()
+ErrorUtils.setGlobalHandler((e, isFatal) => {
+  if (SENTRY_ENABLED) {
+    Sentry.captureException(e)
+  }
+  Logger.error('RootErrorHandler', `Unhandled error. isFatal: ${isFatal}`, e)
+  defaultErrorHandler(e, isFatal)
+})
+
+Logger.debug('App/init', 'Current Language: ' + i18n.language)
+
+// Explicitly enable screens for react-native-screens
+enableScreens(true)
+// Prevent inactive screens from rerendering https://reactnavigation.org/docs/native-stack-navigator#freezeonblur
+enableFreeze(true)
+
+const ignoreWarnings = [
+  'componentWillReceiveProps',
+  'Remote debugger', // To avoid "Remote debugger in background tab" warning
+  'cancelTouches', // rn-screens warning on iOS
+  'Setting a timer', // warns about long setTimeouts which are actually saga timeouts
+  'Require cycle', // TODO: fix require cycles and remove this ;)
+]
+if (isE2EEnv) {
+  ignoreWarnings.push('Overriding previous layout')
+}
+LogBox.ignoreLogs(ignoreWarnings)
+
+const { decimalSeparator, groupingSeparator } = getNumberFormatSettings()
+
+BigNumber.config({
+  EXPONENTIAL_AT: 1e9, // toString almost never return exponential notation
+  FORMAT: {
+    decimalSeparator,
+    groupSeparator: groupingSeparator,
+    groupSize: 3,
+  },
+})
+
+interface Props extends Record<string, unknown> {
+  appStartedMillis: number
+}
+
+// Enables LayoutAnimation on Android. It makes transitions between states smoother.
+// https://reactnative.dev/docs/layoutanimation
+// Disabling it for now as it seems to cause blank white screens on certain android devices
+// if (Platform.OS === 'android' && UIManager.setLayoutAnimationEnabledExperimental) {
+//   UIManager.setLayoutAnimationEnabledExperimental(true)
+// }
+
+export class App extends React.Component<Props> {
+  reactLoadTime: number = Date.now()
+  isConsumingInitialLink = false
+  // TODO: add support for changing themes dynamically, here we are getting only the default theme colors.
+  isDarkTheme = getAppConfig().themes?.default?.isDark
+  backgroundColor = getAppConfig().themes?.default?.colors?.backgroundPrimary
+  isAndroid = Platform.OS === 'android'
+
+  async componentDidMount() {
+    if (isE2EEnv) {
+      LogBox.ignoreAllLogs(true)
+    }
+  }
+
+  render() {
+    return (
+      <SafeAreaProvider
+        style={this.isAndroid && { marginBottom: initialWindowMetrics?.insets.bottom ?? 0 }}
+      >
+        <Provider store={store}>
+          <PersistGate persistor={persistor}>
+            <Auth0Provider domain={AUTH0_DOMAIN} clientId={AUTH0_CLIENT_ID}>
+              <AppInitGate
+                appStartedMillis={this.props.appStartedMillis}
+                reactLoadTime={this.reactLoadTime}
+              >
+                <StatusBar
+                  backgroundColor="transparent"
+                  barStyle={this.isDarkTheme ? 'light-content' : 'dark-content'}
+                  translucent
+                />
+                <ErrorBoundary>
+                  <GestureHandlerRootView style={{ flex: 1 }}>
+                    <BottomSheetModalProvider>
+                      <NavigatorWrapper />
+                    </BottomSheetModalProvider>
+                  </GestureHandlerRootView>
+                </ErrorBoundary>
+              </AppInitGate>
+            </Auth0Provider>
+          </PersistGate>
+        </Provider>
+      </SafeAreaProvider>
+    )
+  }
+}
+
+export default Sentry.wrap(App)

package/src/app/AppInitGate.test.tsx

@@ -0,0 +1,100 @@
+import { act, render, waitFor } from '@testing-library/react-native'
+import * as React from 'react'
+import { Text } from 'react-native'
+import * as RNLocalize from 'react-native-localize'
+import { Provider } from 'react-redux'
+import AppAnalytics from 'src/analytics/AppAnalytics'
+import { appMounted } from 'src/app/actions'
+import AppInitGate from 'src/app/AppInitGate'
+import { setLanguage } from 'src/i18n/slice'
+import { navigateToError } from 'src/navigator/NavigationService'
+import { waitUntilSagasFinishLoading } from 'src/redux/sagas'
+import { createMockStore } from 'test/utils'
+
+jest.mock('src/redux/store')
+jest.mock('src/analytics/AppAnalytics')
+jest.mock('src/redux/sagas', () => ({
+  ...(jest.requireActual('src/redux/sagas') as any),
+  waitUntilSagasFinishLoading: jest.fn(),
+}))
+
+jest.mock('src/i18n', () => ({
+  changeLanguage: jest.fn().mockResolvedValue(jest.fn()),
+  t: jest.fn(),
+}))
+
+jest.mock('src/navigator/NavigationService', () => ({
+  navigateToError: jest.fn(),
+}))
+
+const renderAppInitGate = (language: string | null = 'en-US') => {
+  const store = createMockStore({ i18n: { language } })
+  const tree = render(
+    <Provider store={store}>
+      <AppInitGate appStartedMillis={1682415628} reactLoadTime={1682418628}>
+        <Text>App</Text>
+      </AppInitGate>
+    </Provider>
+  )
+
+  return { ...tree, store }
+}
+
+beforeAll(() => {
+  jest.useFakeTimers({ now: new Date(1682420628) })
+})
+
+describe('AppInitGate', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('should render the fallback before initialised', async () => {
+    jest
+      .mocked(waitUntilSagasFinishLoading)
+      .mockImplementationOnce(() => new Promise((resolve) => setTimeout(resolve, 5000)))
+    const { getByText, queryByText, store } = renderAppInitGate()
+    await act(() => {
+      jest.advanceTimersByTime(2000)
+    })
+
+    expect(queryByText('App')).toBeFalsy()
+
+    await act(() => {
+      jest.advanceTimersByTime(5000)
+    })
+
+    await waitFor(() => expect(getByText('App')).toBeTruthy())
+    expect(store.getActions()).toEqual([appMounted()])
+    expect(AppAnalytics.startSession).toHaveBeenCalledWith(
+      'app_launched',
+      expect.objectContaining({
+        appLoadDuration: 12,
+        deviceHeight: 1334,
+        deviceWidth: 750,
+        reactLoadDuration: 3,
+      })
+    )
+    expect(navigateToError).not.toHaveBeenCalled()
+  })
+
+  it('should update the language if none was set', async () => {
+    jest
+      .spyOn(RNLocalize, 'findBestLanguageTag')
+      .mockReturnValue({ languageTag: 'de-DE', isRTL: true })
+
+    const { getByText, store } = renderAppInitGate(null)
+
+    await waitFor(() => expect(getByText('App')).toBeTruthy())
+    expect(store.getActions()).toEqual([setLanguage('de-DE'), appMounted()])
+    expect(navigateToError).not.toHaveBeenCalled()
+  })
+
+  it('should show error screen in case of failed i18n init', async () => {
+    jest.mocked(waitUntilSagasFinishLoading).mockRejectedValueOnce('some error')
+    renderAppInitGate()
+
+    await waitFor(() => expect(waitUntilSagasFinishLoading).toHaveBeenCalledTimes(1))
+    expect(navigateToError).toHaveBeenCalledWith('appInitFailed', 'some error')
+  })
+})

package/src/app/AppInitGate.tsx

@@ -0,0 +1,77 @@
+import locales from 'locales'
+import React, { useEffect, type JSX } from 'react'
+import { useAsync } from 'react-async-hook'
+import { Dimensions } from 'react-native'
+import { findBestLanguageTag } from 'react-native-localize'
+import { AppEvents } from 'src/analytics/Events'
+import AppAnalytics from 'src/analytics/AppAnalytics'
+import { appMounted, appUnmounted } from 'src/app/actions'
+import { isE2EEnv } from 'src/config'
+import i18n from 'src/i18n'
+import { currentLanguageSelector } from 'src/i18n/selectors'
+import useChangeLanguage from 'src/i18n/useChangeLanguage'
+import { navigateToError } from 'src/navigator/NavigationService'
+import { useDispatch, useSelector } from 'src/redux/hooks'
+import { waitUntilSagasFinishLoading } from 'src/redux/sagas'
+import Logger from 'src/utils/Logger'
+
+const TAG = 'AppInitGate'
+
+interface Props {
+  reactLoadTime: number
+  appStartedMillis: number
+  children: React.ReactNode
+}
+
+const AppInitGate = ({ appStartedMillis, reactLoadTime, children }: Props) => {
+  const changelanguage = useChangeLanguage()
+  const dispatch = useDispatch()
+
+  const language = useSelector(currentLanguageSelector)
+  const bestLanguage = !isE2EEnv ? findBestLanguageTag(Object.keys(locales))?.languageTag : 'en-US'
+
+  useEffect(() => {
+    return () => {
+      dispatch(appUnmounted())
+    }
+  }, [])
+
+  const initResult = useAsync(
+    async () => {
+      Logger.debug(TAG, 'Starting AppInitGate init')
+      await waitUntilSagasFinishLoading()
+
+      if (!language && bestLanguage) {
+        await changelanguage(bestLanguage)
+      }
+
+      const reactLoadDuration = (reactLoadTime - appStartedMillis) / 1000
+      const appLoadDuration = (Date.now() - appStartedMillis) / 1000
+      Logger.debug('TAG', `reactLoad: ${reactLoadDuration} appLoad: ${appLoadDuration}`)
+
+      const { width, height } = Dimensions.get('window')
+      AppAnalytics.startSession(AppEvents.app_launched, {
+        deviceHeight: height,
+        deviceWidth: width,
+        reactLoadDuration,
+        appLoadDuration,
+        language: i18n.language || language,
+      })
+
+      Logger.debug(TAG, 'AppInitGate init completed')
+      dispatch(appMounted())
+    },
+    [],
+    {
+      onError: (error) => {
+        Logger.error(TAG, 'Failed init', error)
+        navigateToError('appInitFailed', error)
+      },
+    }
+  )
+
+  // type assertion here because https://github.com/DefinitelyTyped/DefinitelyTyped/issues/44572
+  return initResult.loading ? null : (children as JSX.Element)
+}
+
+export default AppInitGate

package/src/app/AppLoading.test.tsx

@@ -0,0 +1,11 @@
+import { render } from '@testing-library/react-native'
+import * as React from 'react'
+import 'react-native'
+import AppLoading from 'src/app/AppLoading'
+
+describe('AppLoading', () => {
+  it('renders correctly', () => {
+    const tree = render(<AppLoading />)
+    expect(tree).toMatchSnapshot()
+  })
+})

package/src/app/AppLoading.tsx

@@ -0,0 +1,79 @@
+import * as React from 'react'
+import { WithTranslation } from 'react-i18next'
+import { StyleSheet, View } from 'react-native'
+import { SafeAreaView } from 'react-native-safe-area-context'
+import Button, { BtnTypes } from 'src/components/Button'
+import { withTranslation } from 'src/i18n'
+import colors from 'src/styles/colors'
+import { RESTART_APP_I18N_KEY, restartApp } from 'src/utils/AppRestart'
+
+const SHOW_RESTART_BUTTON_TIMEOUT = 10000
+
+interface State {
+  showRestartButton: boolean
+}
+
+type Props = {} & WithTranslation
+export class AppLoading extends React.Component<Props, State> {
+  showRestartButtonTimer: number | null = null
+
+  state = {
+    showRestartButton: false,
+  }
+
+  componentDidMount() {
+    this.showRestartButtonTimer = window.setTimeout(
+      this.showRestartButton,
+      SHOW_RESTART_BUTTON_TIMEOUT
+    )
+  }
+
+  componentWillUnmount() {
+    if (this.showRestartButtonTimer) {
+      clearTimeout(this.showRestartButtonTimer)
+    }
+  }
+
+  showRestartButton = () => {
+    this.setState({ showRestartButton: true })
+  }
+
+  render() {
+    const { t } = this.props
+
+    return (
+      <SafeAreaView style={styles.content}>
+        <View style={styles.button}>
+          {this.state.showRestartButton && (
+            <Button
+              onPress={restartApp}
+              text={t(RESTART_APP_I18N_KEY)}
+              type={BtnTypes.PRIMARY}
+              testID="RestartButton"
+            />
+          )}
+        </View>
+      </SafeAreaView>
+    )
+  }
+}
+
+const styles = StyleSheet.create({
+  content: {
+    alignItems: 'center',
+    justifyContent: 'center',
+    flex: 1,
+    width: '100%',
+    backgroundColor: colors.accent,
+  },
+
+  button: {
+    alignItems: 'center',
+    justifyContent: 'flex-end',
+    paddingLeft: 20,
+    paddingRight: 20,
+    flex: 1,
+  },
+})
+
+export default withTranslation<Props>()(AppLoading)

package/src/app/DebugImages.tsx

@@ -0,0 +1,110 @@
+import * as React from 'react'
+import { Image, StyleSheet, Text, View } from 'react-native'
+import { ScrollView } from 'react-native-gesture-handler'
+import LinearGradient from 'react-native-linear-gradient'
+import { SafeAreaView } from 'react-native-safe-area-context'
+import * as Images from 'src/images/Images'
+import Colors from 'src/styles/colors'
+import { typeScale } from 'src/styles/fonts'
+import { Spacing } from 'src/styles/styles'
+
+// @ts-expect-error property "context" does not exist in the NodeRequire type,
+// but it is available in the metro runtime
+const icons = require.context('../icons', true, /\.tsx$/)
+// @ts-expect-error
+const images = require.context('../images', true, /\.tsx$/)
+
+const ICON_SIZE = 32
+const IMAGE_SIZE = 96
+
+const IconItem = ({ Component, fileName }: { Component: React.ElementType; fileName: string }) => {
+  return (
+    <View style={styles.itemContainer}>
+      {/* Not all icons have the same props, we do our best here to set consistent size and color */}
+      <Component
+        height={ICON_SIZE}
+        width={ICON_SIZE}
+        size={ICON_SIZE}
+        color={Colors.contentPrimary}
+      />
+      <Text>{fileName.split('.tsx')[0].slice(2)}</Text>
+    </View>
+  )
+}
+
+function DebugImages() {
+  return (
+    <LinearGradient
+      colors={[Colors.backgroundPrimary, Colors.inactive]}
+      start={{ x: 0, y: 0 }}
+      end={{ x: 0, y: 1 }}
+    >
+      <ScrollView>
+        <SafeAreaView edges={['bottom']}>
+          <Text style={styles.title}>ICONS</Text>
+          <View style={styles.container}>
+            {icons.keys().map((iconFileName: string) => {
+              return (
+                <IconItem
+                  key={iconFileName}
+                  Component={icons(iconFileName).default}
+                  fileName={iconFileName}
+                />
+              )
+            })}
+          </View>
+
+          <Text style={styles.title}>IMAGES</Text>
+          <View style={styles.container}>
+            {images.keys().map((imageFileName: string) => {
+              return (
+                <IconItem
+                  key={imageFileName}
+                  Component={images(imageFileName).default}
+                  fileName={imageFileName}
+                />
+              )
+            })}
+            {Object.keys(Images).map((key) => (
+              <View style={styles.itemContainer} key={key}>
+                <Image
+                  // @ts-ignore
+                  source={Images[key]}
+                  style={styles.image}
+                  resizeMode="contain"
+                />
+                <Text>{key}</Text>
+              </View>
+            ))}
+          </View>
+        </SafeAreaView>
+      </ScrollView>
+    </LinearGradient>
+  )
+}
+
+const styles = StyleSheet.create({
+  container: {
+    flexDirection: 'row',
+    flexWrap: 'wrap',
+    justifyContent: 'center',
+  },
+  itemContainer: {
+    alignItems: 'center',
+    justifyContent: 'flex-end',
+    gap: Spacing.Regular16,
+    marginBottom: Spacing.XLarge48,
+    marginHorizontal: Spacing.Regular16,
+  },
+  image: {
+    height: IMAGE_SIZE,
+  },
+  title: {
+    ...typeScale.titleMedium,
+    marginHorizontal: Spacing.Regular16,
+    marginBottom: Spacing.Large32,
+    textAlign: 'center',
+  },
+})
+
+export default DebugImages

package/src/app/ErrorBoundary.test.tsx

@@ -0,0 +1,19 @@
+import { render } from '@testing-library/react-native'
+import * as React from 'react'
+import ErrorBoundary from 'src/app/ErrorBoundary'
+
+const ErrorComponent = () => {
+  throw new Error('Snap!')
+}
+
+describe('ErrorBoundary', () => {
+  it('catches the errors', () => {
+    const wrapper = render(
+      <ErrorBoundary>
+        <ErrorComponent />
+      </ErrorBoundary>
+    )
+
+    expect(wrapper.getAllByText('oops')).toHaveLength(1)
+  })
+})

package/src/app/ErrorBoundary.tsx

@@ -0,0 +1,41 @@
+import * as Sentry from '@sentry/react-native'
+import * as React from 'react'
+import { WithTranslation } from 'react-i18next'
+import AppAnalytics from 'src/analytics/AppAnalytics'
+import { AppEvents } from 'src/analytics/Events'
+import ErrorScreen from 'src/app/ErrorScreen'
+import { withTranslation } from 'src/i18n'
+import { getErrorMessage } from 'src/utils/displayFormatting'
+
+interface State {
+  childError: Error | null
+}
+
+interface OwnProps {
+  children: React.ReactElement<any> | number | string
+}
+
+type Props = OwnProps & WithTranslation
+
+class ErrorBoundary extends React.Component<Props, State> {
+  state: State = {
+    childError: null,
+  }
+
+  componentDidCatch(error: Error, info: any) {
+    this.setState({ childError: error })
+    AppAnalytics.track(AppEvents.error_displayed, { error: error.message })
+    Sentry.captureException(error)
+  }
+
+  render() {
+    const { childError } = this.state
+    if (childError) {
+      return <ErrorScreen errorMessage={getErrorMessage(childError)} />
+    }
+
+    return this.props.children
+  }
+}
+
+export default withTranslation<Props>()(ErrorBoundary)

package/src/app/ErrorMessages.ts

@@ -0,0 +1,40 @@
+export enum ErrorMessages {
+  TRANSACTION_TIMEOUT = 'transactionTimeout',
+  INCORRECT_PIN = 'incorrectPin',
+  PIN_INPUT_CANCELED = 'pinInputCanceled',
+  INVALID_BACKUP_PHRASE = 'invalidBackupPhrase',
+  INVALID_WORDS_IN_BACKUP_PHRASE = 'invalidWordsInBackupPhrase',
+  IMPORT_BACKUP_FAILED = 'importBackupFailed',
+  FAILED_FETCH_MNEMONIC = 'failedFetchMnemonic',
+  MISSING_FULL_NAME = 'missingFullName',
+  PHONE_NUMBER_VERIFICATION_FAILURE = 'phoneVerificationInput.verificationFailure',
+  PHONE_NUMBER_REVOKE_FAILED = 'revokePhoneNumber.revokeError',
+  ADDRESS_LOOKUP_FAILURE = 'addressLookupFailure',
+  ACCOUNT_UNLOCK_FAILED = 'accountUnlockFailed',
+  SEND_PAYMENT_FAILED = 'sendPaymentFailed',
+  ACCOUNT_SETUP_FAILED = 'accountSetupFailed',
+  FIREBASE_FAILED = 'firebaseFailed',
+  IMPORT_CONTACTS_FAILED = 'importContactsFailed',
+  QR_FAILED_INVALID_ADDRESS = 'qrFailedInvalidAddress',
+  QR_FAILED_INVALID_RECIPIENT = 'qrFailedInvalidRecipient',
+  ADDRESS_VALIDATION_ERROR = 'addressValidationError',
+  ADDRESS_VALIDATION_NO_MATCH = 'addressValidationNoMatch',
+  ADDRESS_VALIDATION_FULL_POORLY_FORMATTED = 'addressValidationFullPoorlyFormatted',
+  ADDRESS_VALIDATION_PARTIAL_POORLY_FORMATTED = 'addressValidationPartialPoorlyFormatted',
+  ADDRESS_VALIDATION_FULL_OWN_ADDRESS = 'addressValidationFullOwnAddress',
+  ADDRESS_VALIDATION_PARTIAL_OWN_ADDRESS = 'addressValidationPartialOwnAddress',
+  ACCOUNT_CLEAR_FAILED = 'accountClearFailed',
+  KEYCHAIN_FETCH_ACCOUNTS = 'keychainFetchAccounts',
+  KEYCHAIN_ACCOUNT_ALREADY_EXISTS = 'keychainAccountAlreadyExists',
+  FETCH_FAILED = 'fetchFailed',
+  SIMPLEX_PURCHASE_FETCH_FAILED = 'simplexPurchaseFetchFailed',
+  PROVIDER_FETCH_FAILED = 'providerFetchFailed',
+  CASH_OUT_LIMIT_EXCEEDED = 'cashOutLimitExceeded',
+  PERSONA_ACCOUNT_ENDPOINT_FAIL = 'personaAccountEndpointFail',
+  FETCH_SWAP_QUOTE_FAILED = 'swapScreen.fetchSwapQuoteFailed',
+  FIATCONNECT_ADD_ACCOUNT_EXISTS = 'fiatDetailsScreen.addFiatAccountResourceExist',
+  FIATCONNECT_ADD_ACCOUNT_FAILED = 'fiatDetailsScreen.addFiatAccountFailed',
+  KYC_TRY_AGAIN_FAILED = 'fiatConnectKycStatusScreen.tryAgainFailed',
+  HOOKS_INVALID_PREVIEW_API_URL = 'hooksPreview.invalidApiUrl',
+  SHORTCUT_CLAIM_REWARD_FAILED = 'dappShortcuts.claimRewardFailure',
+}