wallet-stack 1.0.0-alpha.121

package/src/web3/saga.test.ts

@@ -0,0 +1,200 @@
+import { expectSaga } from 'redux-saga-test-plan'
+import * as matchers from 'redux-saga-test-plan/matchers'
+import { call, select } from 'redux-saga/effects'
+import { generateSignedMessage } from 'src/account/saga'
+import { ErrorMessages } from 'src/app/ErrorMessages'
+import { storeMnemonic } from 'src/backup/utils'
+import { currentLanguageSelector } from 'src/i18n/selectors'
+import { getPasswordSaga, retrieveSignedMessage } from 'src/pincode/authentication'
+import { MnemonicLanguages, MnemonicStrength, generateMnemonic } from 'src/utils/account'
+import { setAccount } from 'src/web3/actions'
+import {
+  UnlockResult,
+  getConnectedAccount,
+  getConnectedUnlockedAccount,
+  getOrCreateAccount,
+  getWalletAddress,
+  unlockAccount,
+  assignAccountFromPrivateKey,
+} from 'src/web3/saga'
+import { currentAccountSelector, walletAddressSelector } from 'src/web3/selectors'
+import { createMockStore } from 'test/utils'
+import { mockAccount, mockAccount3, mockPrivateKey, mockMnemonic } from 'test/values'
+import { isAddress } from 'viem'
+import Logger from 'src/utils/Logger'
+import { getKeychainAccounts } from 'src/web3/contracts'
+
+jest.mock('src/utils/Logger')
+jest.unmock('src/pincode/authentication')
+
+jest.mock('src/account/actions', () => ({
+  ...(jest.requireActual('src/account/actions') as any),
+  getPincode: async () => 'pin',
+}))
+
+jest.mock('src/navigator/NavigationService', () => ({
+  navigateToError: jest.fn().mockReturnValueOnce(undefined),
+}))
+
+const state = createMockStore({
+  web3: { account: mockAccount },
+}).getState()
+
+describe(getOrCreateAccount, () => {
+  it('returns an existing account', async () => {
+    await expectSaga(getOrCreateAccount)
+      .withState(state)
+      .not.call.fn(generateMnemonic)
+      .returns('0x0000000000000000000000000000000000007e57')
+      .run()
+  })
+
+  it.each`
+    expectedAddress                                 | expectedPrivateDek                                                      | mnemonic
+    ${'0xE025583d25Eff2C254999b5904C97bAe9B3F8D83'} | ${'0xb6812219f7003c27cc1ef17c2033c033a38cfc52d83f176a0667086787d59d39'} | ${'avellana novio zona pinza ducha íntimo amante diluir toldo peón ocio encía gen balcón carro lingote millón amasar mármol bondad toser soledad croqueta agosto'}
+    ${'0x49A4728b4F94E5ccC4dDFe2fE2269ccD431dc052'} | ${'0x596371d7f1dc3a1dfb9e00b51cb5ca46b73993b962c0fb0e04302004581bf45d'} | ${'sufrir maniquí índice viral boina reino choza denso gafas aviso nadar glaciar'}
+    ${'0xfD13B93085Fbf8eb7464Ad08C53E01F7637EEe1B'} | ${'0x67ad8db612e5ea510b2359b2e8c32a55a76dfbe5fd1b40a35ecbca948e8690e7'} | ${'diez ronco nueve muerte apuesta previo definir dureza vagar casco aseo tanque'}
+  `(
+    'creates a new account $expectedAddress',
+    async ({ expectedAddress, expectedPrivateDek, mnemonic }) => {
+      await expectSaga(getOrCreateAccount)
+        .withState(state)
+        .provide([
+          [select(currentAccountSelector), null],
+          [matchers.call.fn(generateMnemonic), mnemonic],
+          [
+            call(storeMnemonic, mnemonic, expectedAddress),
+            {
+              service: 'mnemonic',
+              storage: 'storage',
+            },
+          ],
+          [call(getPasswordSaga, expectedAddress, false, true), 'somePassword'],
+        ])
+        .put(setAccount(expectedAddress))
+        .returns(expectedAddress)
+        .run()
+    }
+  )
+
+  it.each`
+    appLang             | expectedMnemonicLang
+    ${'en-US'}          | ${MnemonicLanguages[MnemonicLanguages.english]}
+    ${'es-419'}         | ${MnemonicLanguages[MnemonicLanguages.english]}
+    ${'pt-BR'}          | ${MnemonicLanguages[MnemonicLanguages.english]}
+    ${'incorrect-lang'} | ${MnemonicLanguages[MnemonicLanguages.english]}
+  `(
+    'creates an account with a mnemonic in $expectedMnemonicLang when app language is $appLang',
+    async ({ appLang, expectedMnemonicLang }) => {
+      const { returnValue } = await expectSaga(getOrCreateAccount)
+        .withState(state)
+        .provide([
+          [select(currentAccountSelector), null],
+          [select(currentLanguageSelector), appLang],
+          [
+            matchers.call.fn(storeMnemonic),
+            {
+              service: 'mnemonic',
+              storage: 'storage',
+            },
+          ],
+          [matchers.call.fn(getPasswordSaga), 'somePassword'],
+        ])
+        .call(
+          generateMnemonic,
+          MnemonicStrength.s128_12words,
+          MnemonicLanguages[expectedMnemonicLang] as unknown as MnemonicLanguages
+        )
+        .run()
+
+      expect(isAddress(returnValue)).toBe(true)
+    }
+  )
+})
+
+describe('Address getters', () => {
+  it('getWalletAddress: unit test', async () => {
+    const EXPECTED_WALLET_ADDRESS = '0xabc'
+    await expectSaga(getWalletAddress)
+      .withState(state)
+      .provide([[select(walletAddressSelector), EXPECTED_WALLET_ADDRESS]])
+      .returns(EXPECTED_WALLET_ADDRESS)
+      .run()
+  })
+
+  it('getWalletAddress + walletAddressSelector: integration test, case where wallet address already set', async () => {
+    await expectSaga(getWalletAddress).withState(state).returns(mockAccount.toLowerCase()).run()
+  })
+
+  it('getWalletAddress + walletAddressSelector: integration test, case where wallet address is set with dispatched action', async () => {
+    const state = createMockStore({
+      web3: { account: null },
+    }).getState()
+    await expectSaga(getWalletAddress)
+      .withState(state)
+      .dispatch(setAccount(mockAccount3))
+      .returns(mockAccount3.toLowerCase())
+      .run()
+  })
+})
+
+describe('getConnectedUnlockedAccount', () => {
+  it("should generate the signed message if it doesn't exist", async () => {
+    await expectSaga(getConnectedUnlockedAccount)
+      .provide([
+        [call(getConnectedAccount), mockAccount],
+        [matchers.call.fn(unlockAccount), UnlockResult.SUCCESS],
+        [call(retrieveSignedMessage), null],
+        [call(generateSignedMessage), null],
+      ])
+      .call(generateSignedMessage)
+      .run()
+  })
+
+  it('should not generate the signed message if it exists', async () => {
+    await expectSaga(getConnectedUnlockedAccount)
+      .provide([
+        [call(getConnectedAccount), mockAccount],
+        [matchers.call.fn(unlockAccount), UnlockResult.SUCCESS],
+        [call(retrieveSignedMessage), 'some signed message'],
+        [call(generateSignedMessage), null],
+      ])
+      .not.call(generateSignedMessage)
+      .run()
+  })
+
+  it('should throw an error if the account could not be unlocked', async () => {
+    await expect(
+      expectSaga(getConnectedUnlockedAccount)
+        .provide([
+          [call(getConnectedAccount), mockAccount],
+          [matchers.call.fn(unlockAccount), UnlockResult.FAILURE],
+          [call(retrieveSignedMessage), null],
+        ])
+        .not.call(generateSignedMessage)
+        .run()
+    ).rejects.toThrowError(ErrorMessages.INCORRECT_PIN)
+  })
+})
+
+describe('assignAccountFromPrivateKey', () => {
+  it('warns when importing same account', async () => {
+    jest.mocked(getKeychainAccounts).mockResolvedValueOnce({
+      addAccount: jest
+        .fn()
+        .mockRejectedValue(new Error(ErrorMessages.KEYCHAIN_ACCOUNT_ALREADY_EXISTS)),
+      unlock: jest.fn(),
+    } as any)
+    await expectSaga(assignAccountFromPrivateKey, mockPrivateKey, mockMnemonic)
+      .withState(state)
+      .provide([
+        [select(currentAccountSelector), null],
+        [matchers.call.fn(getPasswordSaga), 'somePassword'],
+      ])
+      .run()
+    expect(Logger.warn).toHaveBeenCalledWith(
+      'web3/saga@assignAccountFromPrivateKey',
+      'Attempted to import same account'
+    )
+  })
+})

package/src/web3/saga.ts

@@ -0,0 +1,229 @@
+import { setAccountCreationTime } from 'src/account/actions'
+import { generateSignedMessage } from 'src/account/saga'
+import { ErrorMessages } from 'src/app/ErrorMessages'
+import { generateKeysFromMnemonic, storeMnemonic } from 'src/backup/utils'
+import { clearPasswordCaches } from 'src/pincode/PasswordCache'
+import {
+  CANCELLED_PIN_INPUT,
+  getPasswordSaga,
+  retrieveSignedMessage,
+} from 'src/pincode/authentication'
+import Logger from 'src/utils/Logger'
+import { MnemonicLanguages, MnemonicStrength, generateMnemonic } from 'src/utils/account'
+import { privateKeyToAddress } from 'src/utils/address'
+import { ensureError } from 'src/utils/ensureError'
+import { Actions, SetAccountAction, setAccount } from 'src/web3/actions'
+import { UNLOCK_DURATION } from 'src/web3/consts'
+import { getKeychainAccounts } from 'src/web3/contracts'
+import { currentAccountSelector, walletAddressSelector } from 'src/web3/selectors'
+import { call, put, select, take } from 'typed-redux-saga'
+import { RootState } from '../redux/reducers'
+
+const TAG = 'web3/saga'
+
+export function* getOrCreateAccount() {
+  const account = yield* select(currentAccountSelector)
+  if (account) {
+    Logger.debug(
+      TAG + '@getOrCreateAccount',
+      'Tried to create account twice, returning the existing one'
+    )
+    return account
+  }
+
+  let privateKey: string | undefined
+  try {
+    Logger.debug(TAG + '@getOrCreateAccount', 'Creating a new account')
+
+    const mnemonicBitLength = MnemonicStrength.s128_12words
+    const mnemonicLanguage = MnemonicLanguages.english
+    let mnemonic: string = yield* call(generateMnemonic, mnemonicBitLength, mnemonicLanguage)
+
+    // Ensure no duplicates in mnemonic
+    const checkDuplicate = (someString: string) => {
+      return new Set(someString.split(' ')).size !== someString.split(' ').length
+    }
+    let duplicateInMnemonic = checkDuplicate(mnemonic)
+    while (duplicateInMnemonic) {
+      Logger.debug(TAG + '@getOrCreateAccount', 'Regenerating mnemonic to avoid duplicates')
+      mnemonic = yield* call(generateMnemonic, mnemonicBitLength, mnemonicLanguage)
+      duplicateInMnemonic = checkDuplicate(mnemonic)
+    }
+
+    if (!mnemonic) {
+      throw new Error('Failed to generate mnemonic')
+    }
+
+    const keys = yield* call(generateKeysFromMnemonic, mnemonic)
+    privateKey = keys.privateKey
+    if (!privateKey) {
+      throw new Error('Failed to convert mnemonic to hex')
+    }
+
+    const accountAddress = yield* call(assignAccountFromPrivateKey, privateKey, mnemonic)
+    if (!accountAddress) {
+      throw new Error('Failed to assign account from private key')
+    }
+
+    yield* call(storeMnemonic, mnemonic, accountAddress)
+
+    return accountAddress
+  } catch (err) {
+    const error = ensureError(err)
+    const sanitizedError = Logger.sanitizeError(error, privateKey)
+    Logger.error(TAG + '@getOrCreateAccount', 'Error creating account', sanitizedError)
+    throw new Error(ErrorMessages.ACCOUNT_SETUP_FAILED)
+  }
+}
+
+export function* assignAccountFromPrivateKey(privateKey: string, mnemonic: string) {
+  try {
+    const account = privateKeyToAddress(privateKey)
+    const keychainAccounts = yield* call(getKeychainAccounts)
+    const password: string = yield* call(getPasswordSaga, account, false, true)
+
+    try {
+      yield* call([keychainAccounts, keychainAccounts.addAccount], privateKey, password)
+    } catch (err) {
+      const e = ensureError(err)
+      if (e.message === ErrorMessages.KEYCHAIN_ACCOUNT_ALREADY_EXISTS) {
+        Logger.warn(TAG + '@assignAccountFromPrivateKey', 'Attempted to import same account')
+      } else {
+        Logger.error(TAG + '@assignAccountFromPrivateKey', 'Error importing raw key')
+        throw e
+      }
+
+      yield* call([keychainAccounts, keychainAccounts.unlock], account, password, UNLOCK_DURATION)
+    }
+
+    Logger.debug(TAG + '@assignAccountFromPrivateKey', `Added to wallet: ${account}`)
+    yield* put(setAccount(account))
+    yield* put(setAccountCreationTime(Date.now()))
+    return account
+  } catch (e) {
+    Logger.error(TAG + '@assignAccountFromPrivateKey', 'Error assigning account', e)
+    throw e
+  }
+}
+
+/**
+ * Get an address associated with the user account.
+ *
+ * Waits for the address to exist, then returns it.
+ *
+ * Used to help make getWalletAddress and getMTWAddress more DRY (since they are almost exactly the same).
+ *
+ * @param addressSelector
+ * @param action
+ */
+function* getAddress<T extends { address: string | null }>({
+  addressSelector,
+  action,
+}: {
+  addressSelector: (state: RootState) => string | null
+  action: Actions
+}) {
+  while (true) {
+    const account = yield* select(addressSelector)
+    if (account) {
+      return account
+    }
+
+    const actionEffect = (yield* take(action)) as unknown as T
+    if (actionEffect.address) {
+      // account exists
+      return actionEffect.address
+    }
+  }
+}
+
+// Wait for account to exist and then return it
+export function* getWalletAddress() {
+  const address = yield* getAddress<SetAccountAction>({
+    addressSelector: walletAddressSelector,
+    action: Actions.SET_ACCOUNT,
+  })
+  return address as string
+}
+
+// deprecated, please use |getWalletAddress| instead.
+// This needs to be refactored and removed since the name is misleading.
+export const getAccount = getWalletAddress
+
+export type UnlockResultType = typeof UnlockResult
+export enum UnlockResult {
+  SUCCESS,
+  FAILURE,
+  CANCELED,
+}
+
+export type UnlockAccount = typeof unlockAccount
+export function* unlockAccount(account: string, force: boolean = false) {
+  Logger.debug(TAG + '@unlockAccount', `Unlocking account: ${account}`)
+
+  const keychainAccounts = yield* call(getKeychainAccounts)
+  if (!force && keychainAccounts.isUnlocked(account)) {
+    return UnlockResult.SUCCESS
+  }
+
+  try {
+    const password: string = yield* call(getPasswordSaga, account)
+
+    const result = yield* call(
+      [keychainAccounts, keychainAccounts.unlock],
+      account,
+      password,
+      UNLOCK_DURATION
+    )
+    if (!result) {
+      throw new Error('Unlock account result false')
+    }
+
+    Logger.debug(TAG + '@unlockAccount', `Account unlocked: ${account}`)
+    return UnlockResult.SUCCESS
+  } catch (error) {
+    if (error === CANCELLED_PIN_INPUT) {
+      return UnlockResult.CANCELED
+    }
+    Logger.error(TAG + '@unlockAccount', 'Account unlock failed, clearing password caches', error)
+    clearPasswordCaches()
+    return UnlockResult.FAILURE
+  }
+}
+
+// Wait for account ready
+export function* getConnectedAccount() {
+  const account: string = yield* call(getAccount)
+  return account
+}
+
+// Wait for geth to be connected, geth ready, and get unlocked account
+export function* getConnectedUnlockedAccount() {
+  const account: string = yield* call(getConnectedAccount)
+  const result: UnlockResult = yield* call(unlockAccount, account)
+  if (result === UnlockResult.SUCCESS) {
+    const signedMessage = yield* call(retrieveSignedMessage)
+    if (!signedMessage) {
+      try {
+        yield* call(generateSignedMessage)
+      } catch (error) {
+        Logger.error(
+          `${TAG}@getConnectedUnlockedAccount`,
+          'Unable to generate signed message and update account registration',
+          error
+        )
+      }
+    }
+    return account
+  } else {
+    throw new Error(
+      result === UnlockResult.FAILURE
+        ? ErrorMessages.INCORRECT_PIN
+        : ErrorMessages.PIN_INPUT_CANCELED
+    )
+  }
+}
+
+export function* getAccountAddress() {
+  return yield* call(getAccount)
+}

package/src/web3/selectors.ts

@@ -0,0 +1,47 @@
+import { createSelector } from 'reselect'
+import type { RootState } from 'src/redux/reducers'
+import { getDynamicConfigParams } from 'src/statsig'
+import { DynamicConfigs } from 'src/statsig/constants'
+import { StatsigDynamicConfigs } from 'src/statsig/types'
+
+/**
+ * Get the "raw" (non-lower-cased) version of the wallet address in redux state.
+ *
+ * Intended for the niche data analytics use case of preserving backwards-compatibility with
+ *  when we took the wallet address from redux state a different way (not using walletAddressSelector)
+ *  for the "accountAddress" user property, which falls back to EOA if no MTW exists.
+ *
+ * NOTE: modern users (2020 onwards) will *already* have a lower-cased address saved in redux state, so this will
+ *  give the same output as walletAddressSelector most of the time.
+ */
+export const rawWalletAddressSelector = (state: RootState) => state.web3.account ?? null
+
+export const demoModeEnabledSelector = createSelector(
+  [
+    () =>
+      getDynamicConfigParams(DynamicConfigs[StatsigDynamicConfigs.DEMO_MODE_CONFIG])
+        ?.enabledInOnboarding,
+    (state: RootState) => state.web3.demoModeEnabled,
+  ],
+  (dynamicConfigEnabled, demoModeToggledOn) => {
+    return dynamicConfigEnabled && demoModeToggledOn
+  }
+)
+
+export const walletAddressSelector = createSelector(
+  [
+    rawWalletAddressSelector,
+    demoModeEnabledSelector,
+    () =>
+      getDynamicConfigParams(DynamicConfigs[StatsigDynamicConfigs.DEMO_MODE_CONFIG])
+        ?.demoWalletAddress,
+  ],
+  (rawAddress, demoModeEnabled, demoModeAddress) => {
+    return (demoModeEnabled ? demoModeAddress : rawAddress)?.toLowerCase() ?? null
+  }
+)
+
+// @deprecated please use walletAddressSelector instead.
+export const currentAccountSelector = walletAddressSelector
+
+export type WalletAddressSelector = typeof walletAddressSelector

package/src/web3/utils.test.ts

@@ -0,0 +1,12 @@
+import { Network, NetworkId } from 'src/transactions/types'
+import { getNetworkFromNetworkId } from 'src/web3/utils'
+
+describe('web3 utils', () => {
+  describe('getNetworkFromNetworkId', () => {
+    it('spot checks for celo and ethereum', () => {
+      // testing every case would be circular
+      expect(getNetworkFromNetworkId(NetworkId['celo-mainnet'])).toEqual(Network.Celo)
+      expect(getNetworkFromNetworkId(NetworkId['ethereum-mainnet'])).toEqual(Network.Ethereum)
+    })
+  })
+})

package/src/web3/utils.ts

@@ -0,0 +1,11 @@
+import { ENABLED_NETWORK_IDS } from 'src/config'
+import { Network, NetworkId } from 'src/transactions/types'
+import { networkIdToNetwork } from 'src/web3/networkConfig'
+
+export function getNetworkFromNetworkId(networkId?: NetworkId): Network | undefined {
+  return networkId ? networkIdToNetwork[networkId] : undefined
+}
+
+export function getSupportedNetworkIds(): NetworkId[] {
+  return ENABLED_NETWORK_IDS as NetworkId[]
+}

package/src/webview/WebViewAndroidBottomSheet.test.tsx

@@ -0,0 +1,58 @@
+import { fireEvent, render } from '@testing-library/react-native'
+import * as React from 'react'
+import { Platform } from 'react-native'
+import { Provider } from 'react-redux'
+import { navigateToURI } from 'src/utils/linking'
+import { WebViewAndroidBottomSheet } from 'src/webview/WebViewAndroidBottomSheet'
+import { createMockStore } from 'test/utils'
+
+describe('WebViewAndroidBottomSheet', () => {
+  beforeEach(() => {
+    Platform.OS = 'android'
+  })
+
+  it('renders correctly when visible', () => {
+    const tree = render(
+      <Provider store={createMockStore({})}>
+        <WebViewAndroidBottomSheet
+          currentUrl="https://example.com"
+          isVisible={true}
+          onClose={jest.fn()}
+          toggleBottomSheet={jest.fn()}
+        />
+      </Provider>
+    )
+    expect(tree).toMatchSnapshot()
+  })
+
+  it('renders correctly when not visible', () => {
+    const tree = render(
+      <Provider store={createMockStore({})}>
+        <WebViewAndroidBottomSheet
+          currentUrl="https://example.com"
+          isVisible={false}
+          onClose={jest.fn()}
+          toggleBottomSheet={jest.fn()}
+        />
+      </Provider>
+    )
+
+    expect(tree).toMatchSnapshot()
+  })
+
+  it('navigates to the correct url', () => {
+    const { getByTestId } = render(
+      <Provider store={createMockStore({})}>
+        <WebViewAndroidBottomSheet
+          currentUrl="https://example.com"
+          isVisible={true}
+          onClose={jest.fn()}
+          toggleBottomSheet={jest.fn()}
+        />
+      </Provider>
+    )
+
+    fireEvent.press(getByTestId('OpenInExternalBrowser'))
+    expect(navigateToURI).toHaveBeenCalledWith('https://example.com')
+  })
+})

package/src/webview/WebViewAndroidBottomSheet.tsx

@@ -0,0 +1,83 @@
+import React from 'react'
+import { useTranslation } from 'react-i18next'
+import { Pressable, StyleSheet, Text, View } from 'react-native'
+import Modal from 'react-native-modal'
+import AppAnalytics from 'src/analytics/AppAnalytics'
+import { WebViewEvents } from 'src/analytics/Events'
+import Colors from 'src/styles/colors'
+import { typeScale } from 'src/styles/fonts'
+import variables from 'src/styles/variables'
+import { navigateToURI } from 'src/utils/linking'
+
+interface Props {
+  currentUrl: string
+  isVisible: boolean
+  onClose(): void
+  toggleBottomSheet(): void
+}
+
+export function WebViewAndroidBottomSheet({
+  currentUrl,
+  isVisible,
+  onClose,
+  toggleBottomSheet,
+}: Props) {
+  const { t } = useTranslation()
+  const openExternalLink = () => {
+    navigateToURI(currentUrl)
+    toggleBottomSheet()
+    AppAnalytics.track(WebViewEvents.webview_open_in_browser, { currentUrl })
+  }
+
+  return (
+    <Modal
+      isVisible={isVisible}
+      animationIn="slideInUp"
+      animationInTiming={400}
+      swipeDirection="down"
+      style={styles.overlay}
+      onBackdropPress={onClose}
+      onSwipeComplete={onClose}
+      useNativeDriverForBackdrop={true}
+    >
+      <View style={styles.centerContainer} testID="WebViewAndroidBottomSheet">
+        <Pressable
+          style={styles.pressable}
+          onPress={openExternalLink}
+          android_ripple={{ color: Colors.lightShadow, borderless: false }}
+          testID="OpenInExternalBrowser"
+        >
+          <Text style={styles.bottomSheetText}>{t('webView.openExternal')}</Text>
+        </Pressable>
+        <Pressable
+          onPress={onClose}
+          android_ripple={{ color: Colors.lightShadow, borderless: false }}
+        >
+          <Text style={styles.bottomSheetText}>{t('dismiss')}</Text>
+        </Pressable>
+      </View>
+    </Modal>
+  )
+}
+
+const styles = StyleSheet.create({
+  overlay: {
+    justifyContent: 'flex-end',
+    margin: 0,
+  },
+  centerContainer: {
+    backgroundColor: Colors.backgroundPrimary,
+  },
+  // Needed to add icons in the pressable buttons
+  pressable: {
+    flexDirection: 'row',
+    alignItems: 'center',
+  },
+  bottomSheetText: {
+    ...typeScale.bodyMedium,
+    textAlign: 'left',
+    padding: variables.contentPadding,
+  },
+})
+
+export default WebViewAndroidBottomSheet