wallet-stack 1.0.0-alpha.121

package/src/account/saga.test.ts

@@ -0,0 +1,209 @@
+import * as Keychain from '@divvi/react-native-keychain'
+import { FetchMock } from 'jest-fetch-mock/types'
+import { expectSaga } from 'redux-saga-test-plan'
+import * as matchers from 'redux-saga-test-plan/matchers'
+import { throwError } from 'redux-saga-test-plan/providers'
+import { call, select } from 'redux-saga/effects'
+import {
+  generateSignedMessage,
+  handleUpdateAccountRegistration,
+  initializeAccountSaga,
+} from 'src/account/saga'
+import { choseToRestoreAccountSelector } from 'src/account/selectors'
+import { updateAccountRegistration } from 'src/account/updateAccountRegistration'
+import AppAnalytics from 'src/analytics/AppAnalytics'
+import { OnboardingEvents } from 'src/analytics/Events'
+import { Actions as AccountActions, phoneNumberVerificationCompleted } from 'src/app/actions'
+import { currentLanguageSelector } from 'src/i18n/selectors'
+import { userLocationDataSelector } from 'src/networkInfo/selectors'
+import { retrieveSignedMessage, storeSignedMessage } from 'src/pincode/authentication'
+import Logger from 'src/utils/Logger'
+import { ViemKeychainAccount } from 'src/viem/keychainAccountToAccount'
+import { getKeychainAccounts } from 'src/web3/contracts'
+import networkConfig from 'src/web3/networkConfig'
+import { UnlockResult, getOrCreateAccount, unlockAccount } from 'src/web3/saga'
+import { walletAddressSelector } from 'src/web3/selectors'
+import { initializeAccountSuccess, saveSignedMessage } from './actions'
+
+const loggerErrorSpy = jest.spyOn(Logger, 'error')
+const mockedKeychain = jest.mocked(Keychain)
+
+const mockFetch = fetch as FetchMock
+jest.unmock('src/pincode/authentication')
+jest.mock('src/analytics/AppAnalytics')
+
+jest.mock('@react-native-firebase/app', () => ({
+  app: jest.fn(() => ({
+    messaging: () => ({
+      getToken: jest.fn().mockResolvedValue('someToken'),
+    }),
+  })),
+}))
+
+describe('handleUpdateAccountRegistration', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('calls the account registration service with correct params', async () => {
+    await expectSaga(handleUpdateAccountRegistration)
+      .provide([
+        [select(walletAddressSelector), '0xabc'],
+        [call(retrieveSignedMessage), 'someSignedMessage'],
+        [call(generateSignedMessage), 'someSignedMessage'],
+        [select(currentLanguageSelector), 'en-US'],
+        [select(userLocationDataSelector), { countryCodeAlpha2: 'US' }],
+      ])
+      .call(updateAccountRegistration, '0xabc', 'someSignedMessage', {
+        appVersion: '0.0.1',
+        language: 'en-US',
+        country: 'US',
+        fcmToken: 'someToken',
+      })
+      .run()
+  })
+
+  it('logs an error if the account registration service fails', async () => {
+    await expectSaga(handleUpdateAccountRegistration)
+      .provide([
+        [select(walletAddressSelector), '0xabc'],
+        [call(retrieveSignedMessage), 'someSignedMessage'],
+        [select(currentLanguageSelector), null],
+        [select(userLocationDataSelector), { countryCodeAlpha2: null }],
+        [matchers.call.fn(updateAccountRegistration), throwError(new Error('some error'))],
+      ])
+      .call(updateAccountRegistration, '0xabc', 'someSignedMessage', {
+        appVersion: '0.0.1',
+        fcmToken: 'someToken',
+      })
+      .run()
+
+    expect(loggerErrorSpy).toHaveBeenCalled()
+  })
+})
+
+describe('generateSignedMessage', () => {
+  const address = '0x3460806908173E6291960662c17592D423Fb22e5'
+  let mockViemAccount: ViemKeychainAccount
+
+  beforeEach(async () => {
+    jest.clearAllMocks()
+
+    const keychainAccounts = await getKeychainAccounts()
+    const viemAccount = await keychainAccounts.getViemAccount(address)
+    if (!viemAccount) {
+      throw new Error('No viem account found')
+    }
+    mockViemAccount = viemAccount
+  })
+
+  it('generates and saves the signed message', async () => {
+    mockedKeychain.getGenericPassword.mockResolvedValue({
+      username: 'some username',
+      password: 'someSignedMessage',
+      service: 'some service',
+      storage: Keychain.STORAGE_TYPE.RSA,
+    })
+
+    await expectSaga(generateSignedMessage)
+      .provide([
+        [select(walletAddressSelector), address],
+        [call(unlockAccount, address), UnlockResult.SUCCESS],
+        [matchers.call.fn(mockViemAccount.signTypedData), 'someSignedMessage'],
+        [call(storeSignedMessage, 'someSignedMessage'), undefined],
+      ])
+      .put(saveSignedMessage())
+      .call(storeSignedMessage, 'someSignedMessage')
+      .run()
+  })
+
+  it('logs an error if signed message could not be generated', async () => {
+    await expect(
+      expectSaga(generateSignedMessage)
+        .provide([
+          [select(walletAddressSelector), address],
+          [call(unlockAccount, address), UnlockResult.FAILURE],
+          [
+            matchers.call.fn(mockViemAccount.signTypedData),
+            throwError(new Error('could not generate signature')),
+          ],
+        ])
+        .not.put(saveSignedMessage())
+        .not.call(storeSignedMessage)
+        .run()
+    ).rejects.toThrowError('could not generate signature')
+  })
+})
+
+describe('initializeAccount', () => {
+  beforeEach(() => {
+    mockFetch.resetMocks()
+  })
+
+  it('should handle the last previously verified phone number', async () => {
+    mockFetch.mockResponse(
+      JSON.stringify({ data: { phoneNumbers: ['+1302123456', '+31619123456'] } })
+    )
+
+    await expectSaga(initializeAccountSaga)
+      .provide([
+        [call(getOrCreateAccount), undefined],
+        [call(generateSignedMessage), undefined],
+        [select(choseToRestoreAccountSelector), true],
+        [call(retrieveSignedMessage), 'some signed message'],
+        [select(walletAddressSelector), '0xabc'],
+      ])
+      .put(initializeAccountSuccess())
+      .put(phoneNumberVerificationCompleted('+31619123456', '+31'))
+      .run()
+
+    expect(mockFetch).toHaveBeenCalledTimes(1)
+    expect(mockFetch).toHaveBeenCalledWith(
+      `${networkConfig.lookupAddressUrl}?clientPlatform=android&clientVersion=0.0.1`,
+      {
+        method: 'GET',
+        headers: {
+          'Content-Type': 'application/json',
+          authorization: `${networkConfig.authHeaderIssuer} 0xabc:some signed message`,
+        },
+      }
+    )
+    expect(AppAnalytics.track).toHaveBeenCalledWith(OnboardingEvents.initialize_account_complete)
+  })
+
+  it('should handle if there is no previously verified phone number', async () => {
+    mockFetch.mockResponse(JSON.stringify({ data: { phoneNumbers: [] } }))
+
+    await expectSaga(initializeAccountSaga)
+      .provide([
+        [call(getOrCreateAccount), undefined],
+        [call(generateSignedMessage), undefined],
+        [select(choseToRestoreAccountSelector), true],
+        [call(retrieveSignedMessage), 'some signed message'],
+        [select(walletAddressSelector), '0xabc'],
+      ])
+      .put(initializeAccountSuccess())
+      .not.put.actionType(AccountActions.PHONE_NUMBER_VERIFICATION_COMPLETED)
+      .run()
+
+    expect(mockFetch).toHaveBeenCalledTimes(1)
+  })
+
+  it('should still initialize account if lookup address fails', async () => {
+    mockFetch.mockResponse(JSON.stringify({ message: 'something went wrong' }), { status: 500 })
+
+    await expectSaga(initializeAccountSaga)
+      .provide([
+        [call(getOrCreateAccount), undefined],
+        [call(generateSignedMessage), undefined],
+        [select(choseToRestoreAccountSelector), true],
+        [call(retrieveSignedMessage), 'some signed message'],
+        [select(walletAddressSelector), '0xabc'],
+      ])
+      .put(initializeAccountSuccess())
+      .not.put.actionType(AccountActions.PHONE_NUMBER_VERIFICATION_COMPLETED)
+      .run()
+
+    expect(mockFetch).toHaveBeenCalledTimes(1)
+  })
+})

package/src/account/saga.ts

@@ -0,0 +1,249 @@
+import firebase from '@react-native-firebase/app'
+import { Platform } from 'react-native'
+import DeviceInfo from 'react-native-device-info'
+import {
+  Actions,
+  ClearStoredAccountAction,
+  initializeAccountSuccess,
+  saveSignedMessage,
+} from 'src/account/actions'
+import { choseToRestoreAccountSelector } from 'src/account/selectors'
+import { updateAccountRegistration } from 'src/account/updateAccountRegistration'
+import { showError } from 'src/alert/actions'
+import AppAnalytics from 'src/analytics/AppAnalytics'
+import { OnboardingEvents } from 'src/analytics/Events'
+import { ErrorMessages } from 'src/app/ErrorMessages'
+import { phoneNumberVerificationCompleted } from 'src/app/actions'
+import { clearStoredMnemonic } from 'src/backup/utils'
+import { FIREBASE_ENABLED } from 'src/config'
+import { firebaseSignOut } from 'src/firebase/firebase'
+import { currentLanguageSelector } from 'src/i18n/selectors'
+import { navigate, navigateClearingStack } from 'src/navigator/NavigationService'
+import { Screens } from 'src/navigator/Screens'
+import { userLocationDataSelector } from 'src/networkInfo/selectors'
+import {
+  Actions as OnboardingActions,
+  UpdateStatsigAndNavigateAction,
+} from 'src/onboarding/actions'
+import {
+  removeAccountLocally,
+  retrieveSignedMessage,
+  storeSignedMessage,
+} from 'src/pincode/authentication'
+import { persistor } from 'src/redux/store'
+import { patchUpdateStatsigUser } from 'src/statsig'
+import { restartApp } from 'src/utils/AppRestart'
+import Logger from 'src/utils/Logger'
+import { ensureError } from 'src/utils/ensureError'
+import { parsePhoneNumber } from 'src/utils/phoneNumbers'
+import { safely } from 'src/utils/safely'
+import { clearStoredAccounts } from 'src/web3/KeychainAccounts'
+import { getKeychainAccounts } from 'src/web3/contracts'
+import networkConfig from 'src/web3/networkConfig'
+import { getOrCreateAccount, getWalletAddress, unlockAccount } from 'src/web3/saga'
+import { walletAddressSelector } from 'src/web3/selectors'
+import { call, put, select, spawn, take, takeLeading } from 'typed-redux-saga'
+const TAG = 'account/saga'
+
+export const SENTINEL_MIGRATE_COMMENT = '__CELO_MIGRATE_TX__'
+
+function* clearStoredAccountSaga({ account }: ClearStoredAccountAction) {
+  try {
+    yield* call(removeAccountLocally, account)
+    yield* call(clearStoredMnemonic)
+    yield* call(AppAnalytics.reset)
+    yield* call(clearStoredAccounts)
+
+    // Ignore error if it was caused by Firebase.
+    try {
+      yield* call(firebaseSignOut, firebase.app())
+    } catch (error) {
+      if (FIREBASE_ENABLED) {
+        Logger.error(TAG + '@clearStoredAccount', 'Failed to sign out from Firebase', error)
+      }
+    }
+
+    yield* call(persistor.flush)
+    yield* call(restartApp)
+  } catch (error) {
+    Logger.error(TAG + '@clearStoredAccount', 'Error while removing account', error)
+    yield* put(showError(ErrorMessages.ACCOUNT_CLEAR_FAILED))
+  }
+}
+
+export function* initializeAccountSaga() {
+  Logger.debug(TAG + '@initializeAccountSaga', 'Creating account')
+  try {
+    AppAnalytics.track(OnboardingEvents.initialize_account_start)
+    yield* call(getOrCreateAccount)
+    yield* call(generateSignedMessage)
+
+    const choseToRestoreAccount = yield* select(choseToRestoreAccountSelector)
+    if (choseToRestoreAccount) {
+      yield* call(handlePreviouslyVerifiedPhoneNumber)
+    }
+
+    Logger.debug(TAG + '@initializeAccountSaga', 'Account creation success')
+    yield* put(initializeAccountSuccess())
+    AppAnalytics.track(OnboardingEvents.initialize_account_complete)
+  } catch (err) {
+    const error = ensureError(err)
+    Logger.error(TAG, 'Failed to initialize account', error)
+    AppAnalytics.track(OnboardingEvents.initialize_account_error, { error: error.message })
+    navigateClearingStack(Screens.AccounSetupFailureScreen)
+  }
+}
+
+function* handlePreviouslyVerifiedPhoneNumber() {
+  const address = yield* select(walletAddressSelector)
+
+  try {
+    const signedMessage = yield* call(retrieveSignedMessage)
+    const queryParams = new URLSearchParams({
+      clientPlatform: Platform.OS,
+      clientVersion: DeviceInfo.getVersion(),
+    }).toString()
+
+    const response = yield* call(fetch, `${networkConfig.lookupAddressUrl}?${queryParams}`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        authorization: `${networkConfig.authHeaderIssuer} ${address}:${signedMessage}`,
+      },
+    })
+
+    const result = yield* call([response, 'json'])
+    if (response.ok && result.data?.phoneNumbers) {
+      // if phoneNumbers length is 0, there are no verified numbers so do nothing
+      if (result.data.phoneNumbers.length > 0) {
+        const lastVerifiedNumber = result.data.phoneNumbers[result.data.phoneNumbers.length - 1]
+        const phoneDetails = yield* call(parsePhoneNumber, lastVerifiedNumber)
+        if (phoneDetails) {
+          yield* put(
+            phoneNumberVerificationCompleted(
+              phoneDetails.e164Number,
+              phoneDetails.countryCode ? `+${phoneDetails.countryCode}` : null
+            )
+          )
+        } else {
+          throw new Error('Could not parse verified phone number')
+        }
+      }
+    } else {
+      throw new Error(yield* call([response, 'text']))
+    }
+  } catch (error) {
+    Logger.warn(
+      `${TAG}@importBackupPhraseSaga`,
+      `Failed to lookup and store verified phone numbers for this wallet address`,
+      error
+    )
+  }
+}
+
+export function* generateSignedMessage() {
+  try {
+    const keychainAccounts = yield* call(getKeychainAccounts)
+    const address = yield* select(walletAddressSelector)
+    if (!address) {
+      throw new Error('No address found')
+    }
+
+    yield* call(unlockAccount, address)
+    const viemAccount = yield* call([keychainAccounts, 'getViemAccount'], address)
+    if (!viemAccount) {
+      // This should never happen
+      throw new Error('Viem account not found')
+    }
+
+    const signedTypedMessage = yield* call(
+      [viemAccount, 'signTypedData'],
+      networkConfig.setRegistrationPropertiesAuth
+    )
+
+    yield* call(storeSignedMessage, signedTypedMessage)
+    yield* put(saveSignedMessage())
+  } catch (error) {
+    throw error
+  }
+}
+
+export function* handleUpdateAccountRegistration() {
+  const signedMessage = yield* call(retrieveSignedMessage)
+  if (!signedMessage) {
+    // ensures backwards compatibility - this should happen only for updating the
+    // fcm token when an existing user updates the app and the signed message is
+    // not yet generated
+    Logger.warn(
+      `${TAG}@handleUpdateAccountRegistration`,
+      'Tried to update account registration without signed message'
+    )
+    return
+  }
+
+  const address = yield* select(walletAddressSelector)
+  const appVersion = DeviceInfo.getVersion()
+  const language = yield* select(currentLanguageSelector)
+  const country = yield* select(userLocationDataSelector)
+
+  let fcmToken
+  try {
+    const isEmulator = yield* call([DeviceInfo, 'isEmulator'])
+    // Emulators can't handle fcm tokens and calling getToken on them will throw an error
+    if (!isEmulator) {
+      fcmToken = yield* call([firebase.app().messaging(), 'getToken'])
+    }
+  } catch (error) {
+    Logger.error(`${TAG}@handleUpdateAccountRegistration`, 'Could not get fcm token', error)
+  }
+
+  try {
+    yield* call(updateAccountRegistration, address, signedMessage, {
+      appVersion,
+      ...(language && { language }),
+      ...(country?.countryCodeAlpha2 && { country: country?.countryCodeAlpha2 }),
+      ...(fcmToken && { fcmToken }),
+    })
+  } catch (error) {
+    Logger.error(
+      `${TAG}@handleUpdateAccountRegistration`,
+      'Unable to update account registration',
+      error
+    )
+  }
+}
+
+export function* updateStatsigAndNavigate(action: UpdateStatsigAndNavigateAction) {
+  // Wait for wallet address to exist before updating statsig user
+  yield* call(getWalletAddress)
+  yield* call(patchUpdateStatsigUser)
+  navigate(action.screen)
+}
+
+export function* watchUpdateStatsigAndNavigate() {
+  yield* takeLeading(
+    OnboardingActions.UPDATE_STATSIG_AND_NAVIGATE,
+    safely(updateStatsigAndNavigate)
+  )
+}
+
+export function* watchClearStoredAccount() {
+  const action = (yield* take(Actions.CLEAR_STORED_ACCOUNT)) as ClearStoredAccountAction
+  yield* call(clearStoredAccountSaga, action)
+}
+
+export function* watchInitializeAccount() {
+  yield* takeLeading(Actions.INITIALIZE_ACCOUNT, safely(initializeAccountSaga))
+}
+
+export function* watchSignedMessage() {
+  yield* take(Actions.SAVE_SIGNED_MESSAGE)
+  yield* call(handleUpdateAccountRegistration)
+}
+
+export function* accountSaga() {
+  yield* spawn(watchUpdateStatsigAndNavigate)
+  yield* spawn(watchClearStoredAccount)
+  yield* spawn(watchInitializeAccount)
+  yield* spawn(watchSignedMessage)
+}

package/src/account/selectors.test.ts

@@ -0,0 +1,18 @@
+import { defaultCountryCodeSelector } from 'src/account/selectors'
+import { getMockStoreData } from 'test/utils'
+
+jest.mock('react-native-localize', () => ({
+  getCountry: () => 'IR',
+}))
+
+describe(defaultCountryCodeSelector, () => {
+  it('does not return a sanctioned country', () => {
+    expect(
+      defaultCountryCodeSelector(
+        getMockStoreData({
+          account: { defaultCountryCode: null },
+        })
+      )
+    ).toBe(null)
+  })
+})

package/src/account/selectors.ts

@@ -0,0 +1,60 @@
+import * as RNLocalize from 'react-native-localize'
+import { createSelector } from 'reselect'
+import i18n from 'src/i18n'
+import { RecipientType } from 'src/recipients/recipient'
+import { RootState } from 'src/redux/reducers'
+import { Countries } from 'src/utils/Countries'
+import { getCountryFeatures } from 'src/utils/countryFeatures'
+import { currentAccountSelector } from 'src/web3/selectors'
+
+const inferCountryCode = () => {
+  const localizedCountry = new Countries(i18n.language).getCountryByCodeAlpha2(
+    RNLocalize.getCountry()
+  )
+  if (localizedCountry && !getCountryFeatures(localizedCountry.alpha2).SANCTIONED_COUNTRY) {
+    return localizedCountry.countryCallingCode
+  }
+  return null
+}
+
+export const devModeSelector = (state: RootState) => state.account.devModeActive
+export const nameSelector = (state: RootState) => state.account.name
+export const e164NumberSelector = (state: RootState) => state.account.e164PhoneNumber
+export const defaultCountryCodeSelector = createSelector(
+  (state: RootState) => state.account.defaultCountryCode,
+  (defaultCountryCode) => {
+    return defaultCountryCode || inferCountryCode()
+  }
+)
+export const pincodeTypeSelector = (state: RootState) => state.account.pincodeType
+
+export const currentUserRecipientSelector = createSelector(
+  [currentAccountSelector, nameSelector],
+  (account, name) => {
+    return {
+      address: account!,
+      name: name ?? undefined,
+      recipientType: RecipientType.Address,
+    }
+  }
+)
+export const recoveringFromStoreWipeSelector = (state: RootState) =>
+  state.account.recoveringFromStoreWipe ?? false
+export const accountToRecoverSelector = (state: RootState) =>
+  state.account.accountToRecoverFromStoreWipe
+
+export const backupCompletedSelector = (state: RootState) => state.account.backupCompleted
+
+export const choseToRestoreAccountSelector = (state: RootState) =>
+  state.account.choseToRestoreAccount
+
+export const accountCreationTimeSelector = (state: RootState) => state.account.accountCreationTime
+
+export const celoEducationCompletedSelector = (state: RootState) =>
+  state.account.celoEducationCompleted
+
+export const startOnboardingTimeSelector = (state: RootState) => state.account.startOnboardingTime
+export const recoveryPhraseInOnboardingStatusSelector = (state: RootState) =>
+  state.account.recoveryPhraseInOnboardingStatus
+
+export const cloudBackupCompletedSelector = (state: RootState) => state.account.cloudBackupCompleted

package/src/account/updateAccountRegistration.ts

@@ -0,0 +1,35 @@
+import networkConfig from 'src/web3/networkConfig'
+
+export interface RegistrationProperties {
+  language?: string | null
+  country?: string
+  appVersion?: string
+  fcmToken?: string
+}
+
+export async function updateAccountRegistration(
+  address: string | null,
+  signature: string | null,
+  properties: RegistrationProperties
+): Promise<void> {
+  if (!signature || !address) {
+    throw new Error('Missing address or signed message')
+  }
+
+  const response = await fetch(networkConfig.setRegistrationPropertiesUrl, {
+    method: 'POST',
+    headers: {
+      'content-Type': 'application/json',
+      authorization: `${networkConfig.authHeaderIssuer} ${address}:${signature}`,
+    },
+    body: JSON.stringify({ ...properties, address }),
+  })
+
+  if (!response.ok) {
+    throw new Error(
+      `Update registration properties failed with status ${
+        response.status
+      }, text: ${await response.text()}`
+    )
+  }
+}

package/src/account/utils.ts

@@ -0,0 +1,36 @@
+import { parsePhoneNumber } from 'src/utils/phoneNumbers'
+
+const ADDRESS_LENGTH = 42 // TODO(ACT-1173): see if this can be replaced with a viem helper
+
+export const isAddressFormat = (content: string): boolean => {
+  return content.startsWith('0x') && content.length === ADDRESS_LENGTH
+}
+
+export function getPhoneNumberDetails(
+  phoneNumber: string,
+  countryCallingCode: string,
+  countryCodeAlpha2: string
+) {
+  const phoneDetails = parsePhoneNumber(phoneNumber, countryCallingCode)
+
+  if (phoneDetails) {
+    return {
+      // Show international display number to avoid confusion
+      internationalPhoneNumber: phoneDetails.displayNumberInternational,
+      e164Number: phoneDetails.e164Number,
+      isValidNumber: true,
+      countryCodeAlpha2: phoneDetails.regionCode!,
+    }
+  } else {
+    return {
+      internationalPhoneNumber: phoneNumber,
+      e164Number: '',
+      isValidNumber: false,
+      countryCodeAlpha2,
+    }
+  }
+}
+
+export function formatShortenedAddress(address: string): string {
+  return `${address.slice(0, 6)}...${address.slice(-4)}`
+}