wallet-stack 1.0.0-alpha.131 → 1.0.0-alpha.133

package/src/identity/saga.test.ts

@@ -1,103 +0,0 @@
-import { expectSaga } from 'redux-saga-test-plan'
-import { select } from 'redux-saga/effects'
-import { showErrorInline } from 'src/alert/actions'
-import { ErrorMessages } from 'src/app/ErrorMessages'
-import {
-  Actions,
-  ValidateRecipientAddressAction,
-  validateRecipientAddressSuccess,
-} from 'src/identity/actions'
-import { AddressValidationType } from 'src/identity/reducer'
-import { watchValidateRecipientAddress } from 'src/identity/saga'
-import { e164NumberToAddressSelector } from 'src/identity/selectors'
-import { currentAccountSelector } from 'src/web3/selectors'
-import {
-  mockAccount,
-  mockAccount2,
-  mockAccountInvite,
-  mockE164NumberInvite,
-  mockE164NumberToAddress,
-  mockInvitableRecipient2,
-} from 'test/values'
-
-describe(watchValidateRecipientAddress, () => {
-  beforeAll(() => {
-    jest.useRealTimers()
-  })
-
-  afterEach(() => {
-    jest.clearAllMocks()
-  })
-
-  it('full validation fails if the inputted address does not belong to the recipient', async () => {
-    const validateAction: ValidateRecipientAddressAction = {
-      type: Actions.VALIDATE_RECIPIENT_ADDRESS,
-      userInputOfFullAddressOrLastFourDigits: mockAccount2,
-      addressValidationType: AddressValidationType.FULL,
-      recipient: mockInvitableRecipient2,
-    }
-
-    await expectSaga(watchValidateRecipientAddress)
-      .provide([
-        [select(currentAccountSelector), mockAccount],
-        [select(e164NumberToAddressSelector), mockE164NumberToAddress],
-      ])
-      .dispatch(validateAction)
-      .put(showErrorInline(ErrorMessages.ADDRESS_VALIDATION_NO_MATCH))
-      .run()
-  })
-
-  it('full validation succeeds if the inputted address belongs to the recipient', async () => {
-    const validateAction: ValidateRecipientAddressAction = {
-      type: Actions.VALIDATE_RECIPIENT_ADDRESS,
-      userInputOfFullAddressOrLastFourDigits: mockAccountInvite,
-      addressValidationType: AddressValidationType.FULL,
-      recipient: mockInvitableRecipient2,
-    }
-
-    await expectSaga(watchValidateRecipientAddress)
-      .provide([
-        [select(currentAccountSelector), mockAccount],
-        [select(e164NumberToAddressSelector), mockE164NumberToAddress],
-      ])
-      .dispatch(validateAction)
-      .put(validateRecipientAddressSuccess(mockE164NumberInvite, mockAccountInvite.toLowerCase()))
-      .run()
-  })
-
-  it('partial validation fails if the inputted address does not belong to the recipient', async () => {
-    const validateAction: ValidateRecipientAddressAction = {
-      type: Actions.VALIDATE_RECIPIENT_ADDRESS,
-      userInputOfFullAddressOrLastFourDigits: mockAccount2.slice(-4),
-      addressValidationType: AddressValidationType.PARTIAL,
-      recipient: mockInvitableRecipient2,
-    }
-
-    await expectSaga(watchValidateRecipientAddress)
-      .provide([
-        [select(currentAccountSelector), mockAccount],
-        [select(e164NumberToAddressSelector), mockE164NumberToAddress],
-      ])
-      .dispatch(validateAction)
-      .put(showErrorInline(ErrorMessages.ADDRESS_VALIDATION_NO_MATCH))
-      .run()
-  })
-
-  it('partial validation succeeds if the inputted address belongs to the recipient', async () => {
-    const validateAction: ValidateRecipientAddressAction = {
-      type: Actions.VALIDATE_RECIPIENT_ADDRESS,
-      userInputOfFullAddressOrLastFourDigits: mockAccountInvite.slice(-4),
-      addressValidationType: AddressValidationType.PARTIAL,
-      recipient: mockInvitableRecipient2,
-    }
-
-    await expectSaga(watchValidateRecipientAddress)
-      .provide([
-        [select(currentAccountSelector), mockAccount],
-        [select(e164NumberToAddressSelector), mockE164NumberToAddress],
-      ])
-      .dispatch(validateAction)
-      .put(validateRecipientAddressSuccess(mockE164NumberInvite, mockAccountInvite.toLowerCase()))
-      .run()
-  })
-})

package/src/identity/secureSend.ts

@@ -1,171 +0,0 @@
-import { ErrorMessages } from 'src/app/ErrorMessages'
-import { AddressValidationType, SecureSendPhoneNumberMapping } from 'src/identity/reducer'
-import { Recipient, recipientHasNumber } from 'src/recipients/recipient'
-import Logger from 'src/utils/Logger'
-
-const TAG = 'identity/secureSend'
-
-// Given addresses can be added and deleted we can't rely on changes in length to signal address changes
-// Not sure if address order in array is consistent so not assuming it
-function newAddressesAdded(oldAddresses: string[], newAddresses: string[]) {
-  const oldAddressesSorted = oldAddresses.sort()
-  const newAddressesSorted = newAddresses.sort()
-
-  for (let i = 0; i < newAddressesSorted.length; i += 1) {
-    if (oldAddressesSorted[i] !== newAddressesSorted[i]) {
-      return true
-    }
-  }
-
-  return false
-}
-
-function last4DigitsAreUnique(addressArr: string[]) {
-  const last4DigitArr = addressArr.map((address) => address.slice(-4).toLowerCase())
-  const last4DigitSet = new Set()
-  last4DigitArr.forEach((endDigits) => last4DigitSet.add(endDigits))
-  return last4DigitArr.length === last4DigitSet.size
-}
-
-// Check if there are multiple addresses but somehow a preferred address hasn't been set yet
-// Should never happen in production but makes the change backwards compatible for testing env
-function accidentallyBypassedValidation(
-  newAddresses: string[] | null,
-  e164Number: string,
-  secureSendPhoneNumberMapping: SecureSendPhoneNumberMapping
-) {
-  const validatedAddress =
-    secureSendPhoneNumberMapping[e164Number] && secureSendPhoneNumberMapping[e164Number].address
-  return newAddresses && newAddresses.length > 1 && !validatedAddress
-}
-
-export function checkIfValidationRequired(
-  oldAddresses: string[],
-  possibleAddresses: string[],
-  userAddress: string,
-  secureSendPhoneNumberMapping: SecureSendPhoneNumberMapping,
-  e164Number: string
-) {
-  // No validation needed if there is only 1 possible address
-  if (possibleAddresses.length < 2) {
-    return AddressValidationType.NONE
-  }
-
-  if (
-    newAddressesAdded(oldAddresses, possibleAddresses) ||
-    accidentallyBypassedValidation(possibleAddresses, e164Number, secureSendPhoneNumberMapping)
-  ) {
-    Logger.debug(TAG, 'Address needs to be validated by user')
-    // Adding user's address so they don't mistakenly verify with last 4 digits of their own address
-    if (last4DigitsAreUnique([userAddress, ...possibleAddresses])) {
-      return AddressValidationType.PARTIAL
-    }
-    return AddressValidationType.FULL
-  }
-
-  return AddressValidationType.NONE
-}
-
-function hasSpecialChars(address: string, addressValidationType: AddressValidationType) {
-  const regex = new RegExp('[^0-9A-Za-z]', 'g')
-  const cleanedAddress = address.replace(regex, '')
-
-  if (cleanedAddress !== address) {
-    const errorMessage =
-      addressValidationType === AddressValidationType.FULL
-        ? ErrorMessages.ADDRESS_VALIDATION_FULL_POORLY_FORMATTED
-        : ErrorMessages.ADDRESS_VALIDATION_PARTIAL_POORLY_FORMATTED
-    throw Error(errorMessage)
-  }
-}
-
-function validateFullAddressAndReturnMatch(
-  userInputtedAddress: string,
-  possibleRecievingAddresses: string[],
-  userAddress: string
-) {
-  if (userInputtedAddress.length !== 42 || userInputtedAddress.slice(0, 2) !== '0x') {
-    throw Error(ErrorMessages.ADDRESS_VALIDATION_FULL_POORLY_FORMATTED)
-  }
-
-  if (userInputtedAddress === userAddress) {
-    throw Error(ErrorMessages.ADDRESS_VALIDATION_FULL_OWN_ADDRESS)
-  }
-
-  if (!possibleRecievingAddresses.includes(userInputtedAddress)) {
-    throw Error(ErrorMessages.ADDRESS_VALIDATION_NO_MATCH)
-  }
-
-  return userInputtedAddress
-}
-
-function validatePartialAddressAndReturnMatch(
-  lastFourDigitsOfUserInputtedAddress: string,
-  possibleRecievingAddresses: string[],
-  userAddress: string
-) {
-  if (lastFourDigitsOfUserInputtedAddress.length !== 4) {
-    throw Error(ErrorMessages.ADDRESS_VALIDATION_PARTIAL_POORLY_FORMATTED)
-  }
-
-  if (lastFourDigitsOfUserInputtedAddress === userAddress.slice(-4)) {
-    throw Error(ErrorMessages.ADDRESS_VALIDATION_PARTIAL_OWN_ADDRESS)
-  }
-
-  const targetAddress = possibleRecievingAddresses.find(
-    (address) => address.slice(-4) === lastFourDigitsOfUserInputtedAddress
-  )
-
-  if (!targetAddress) {
-    throw Error(ErrorMessages.ADDRESS_VALIDATION_NO_MATCH)
-  }
-
-  return targetAddress
-}
-
-export function validateAndReturnMatch(
-  userInputOfFullAddressOrLastFourDigits: string,
-  possibleRecievingAddresses: string[],
-  userAddress: string,
-  addressValidationType: AddressValidationType
-) {
-  const userInput = userInputOfFullAddressOrLastFourDigits.toLowerCase()
-  const possibleAddresses = possibleRecievingAddresses.map((address) => address.toLowerCase())
-  const userOwnAddress = userAddress.toLowerCase()
-
-  hasSpecialChars(userInputOfFullAddressOrLastFourDigits, addressValidationType)
-
-  if (addressValidationType === AddressValidationType.FULL) {
-    return validateFullAddressAndReturnMatch(userInput, possibleAddresses, userOwnAddress)
-  }
-  return validatePartialAddressAndReturnMatch(userInput, possibleAddresses, userOwnAddress)
-}
-
-export function getAddressValidationType(
-  recipient: Recipient,
-  secureSendPhoneNumberMapping: SecureSendPhoneNumberMapping
-) {
-  const e164PhoneNumber = recipient.e164PhoneNumber
-
-  if (
-    !e164PhoneNumber ||
-    !secureSendPhoneNumberMapping[e164PhoneNumber] ||
-    !secureSendPhoneNumberMapping[e164PhoneNumber].addressValidationType
-  ) {
-    return AddressValidationType.NONE
-  }
-
-  return secureSendPhoneNumberMapping[e164PhoneNumber].addressValidationType
-}
-
-export function getSecureSendAddress(
-  recipient: Recipient,
-  secureSendPhoneNumberMapping: SecureSendPhoneNumberMapping
-) {
-  const e164PhoneNumber = recipientHasNumber(recipient) ? recipient.e164PhoneNumber : undefined
-  if (!e164PhoneNumber || !secureSendPhoneNumberMapping[e164PhoneNumber]) {
-    return undefined
-  }
-
-  return secureSendPhoneNumberMapping[e164PhoneNumber].address
-}

package/src/send/ValidateRecipientAccount.test.tsx

@@ -1,182 +0,0 @@
-import { fireEvent, render } from '@testing-library/react-native'
-import * as React from 'react'
-import { Provider } from 'react-redux'
-import { SendOrigin } from 'src/analytics/types'
-import { AddressValidationType } from 'src/identity/reducer'
-import { navigate } from 'src/navigator/NavigationService'
-import { Screens } from 'src/navigator/Screens'
-import ValidateRecipientAccount from 'src/send/ValidateRecipientAccount'
-import { createMockStore, getMockStackScreenProps } from 'test/utils'
-import {
-  mockAccountInvite,
-  mockCusdAddress,
-  mockE164NumberInvite,
-  mockInvitableRecipient2,
-} from 'test/values'
-
-describe('ValidateRecipientAccount', () => {
-  beforeEach(() => {
-    jest.clearAllMocks()
-  })
-
-  it('renders correctly when full validation required', () => {
-    const store = createMockStore({
-      identity: {
-        secureSendPhoneNumberMapping: {
-          [mockE164NumberInvite]: {
-            addressValidationType: AddressValidationType.FULL,
-            validationSuccessful: false,
-          },
-        },
-      },
-    })
-    const tree = render(
-      <Provider store={store}>
-        <ValidateRecipientAccount
-          {...getMockStackScreenProps(Screens.ValidateRecipientAccount, {
-            recipient: mockInvitableRecipient2,
-            origin: SendOrigin.AppSendFlow,
-          })}
-        />
-      </Provider>
-    )
-    expect(tree).toMatchSnapshot()
-  })
-
-  it('renders correctly when partial validation required', () => {
-    const store = createMockStore({
-      identity: {
-        secureSendPhoneNumberMapping: {
-          [mockE164NumberInvite]: {
-            addressValidationType: AddressValidationType.PARTIAL,
-            validationSuccessful: false,
-          },
-        },
-      },
-    })
-    const tree = render(
-      <Provider store={store}>
-        <ValidateRecipientAccount
-          {...getMockStackScreenProps(Screens.ValidateRecipientAccount, {
-            recipient: mockInvitableRecipient2,
-            origin: SendOrigin.AppSendFlow,
-          })}
-        />
-      </Provider>
-    )
-    expect(tree).toMatchSnapshot()
-  })
-
-  it('typing correct last four of account enables submit button', () => {
-    const store = createMockStore({
-      identity: {
-        secureSendPhoneNumberMapping: {
-          [mockE164NumberInvite]: {
-            addressValidationType: AddressValidationType.PARTIAL,
-            validationSuccessful: false,
-          },
-        },
-      },
-    })
-    const tree = render(
-      <Provider store={store}>
-        <ValidateRecipientAccount
-          {...getMockStackScreenProps(Screens.ValidateRecipientAccount, {
-            recipient: mockInvitableRecipient2,
-            origin: SendOrigin.AppSendFlow,
-          })}
-        />
-      </Provider>
-    )
-    expect(tree.getByTestId('ConfirmAccountButton')).toBeDisabled()
-    fireEvent.changeText(tree.getByTestId('SingleDigitInput/digit0'), mockCusdAddress[38])
-    fireEvent.changeText(tree.getByTestId('SingleDigitInput/digit1'), mockCusdAddress[39])
-    fireEvent.changeText(tree.getByTestId('SingleDigitInput/digit2'), mockCusdAddress[40])
-    fireEvent.changeText(tree.getByTestId('SingleDigitInput/digit3'), mockCusdAddress[41])
-    expect(tree.getByTestId('ConfirmAccountButton')).not.toBeDisabled()
-  })
-
-  it('enables submit button for full validation', () => {
-    const store = createMockStore({
-      identity: {
-        secureSendPhoneNumberMapping: {
-          [mockE164NumberInvite]: {
-            addressValidationType: AddressValidationType.FULL,
-            validationSuccessful: false,
-          },
-        },
-      },
-    })
-    const tree = render(
-      <Provider store={store}>
-        <ValidateRecipientAccount
-          {...getMockStackScreenProps(Screens.ValidateRecipientAccount, {
-            recipient: mockInvitableRecipient2,
-            origin: SendOrigin.AppSendFlow,
-          })}
-        />
-      </Provider>
-    )
-
-    expect(tree.getByTestId('ConfirmAccountButton')).toBeDisabled()
-    fireEvent.changeText(
-      tree.getByTestId('ValidateRecipientAccount/TextInput'),
-      mockCusdAddress[38]
-    )
-    expect(tree.getByTestId('ConfirmAccountButton')).not.toBeDisabled()
-  })
-
-  it('navigates to send enter amount with validated address when validation is successful', () => {
-    const store = createMockStore({
-      identity: {
-        secureSendPhoneNumberMapping: {
-          [mockE164NumberInvite]: {
-            addressValidationType: AddressValidationType.NONE,
-            validationSuccessful: false,
-          },
-        },
-      },
-    })
-
-    const props = getMockStackScreenProps(Screens.ValidateRecipientAccount, {
-      recipient: mockInvitableRecipient2,
-      origin: SendOrigin.AppSendFlow,
-    })
-
-    const tree = render(
-      <Provider store={store}>
-        <ValidateRecipientAccount {...props} />
-      </Provider>
-    )
-
-    const updatedStore = createMockStore({
-      identity: {
-        secureSendPhoneNumberMapping: {
-          [mockE164NumberInvite]: {
-            addressValidationType: AddressValidationType.NONE,
-            address: mockAccountInvite,
-            validationSuccessful: true,
-          },
-        },
-      },
-    })
-
-    tree.rerender(
-      <Provider store={updatedStore}>
-        <ValidateRecipientAccount {...props} />
-      </Provider>
-    )
-
-    expect(navigate).toHaveBeenCalledWith(Screens.SendEnterAmount, {
-      origin: SendOrigin.AppSendFlow,
-      isFromScan: false,
-      defaultTokenIdOverride: undefined,
-      forceTokenId: undefined,
-      recipient: {
-        ...mockInvitableRecipient2,
-        address: mockAccountInvite,
-      },
-      isMiniPayRecipient: false,
-    })
-  })
-})