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

package/src/components/ErrorMessageInline.tsx

@@ -1,78 +0,0 @@
-import React from 'react'
-import { WithTranslation } from 'react-i18next'
-import { StyleSheet, Text, View } from 'react-native'
-import { connect } from 'react-redux'
-import { hideAlert } from 'src/alert/actions'
-import { ErrorDisplayType } from 'src/alert/reducer'
-import { ErrorMessages } from 'src/app/ErrorMessages'
-import { withTranslation } from 'src/i18n'
-import { RootState } from 'src/redux/reducers'
-import colors from 'src/styles/colors'
-import { typeScale } from 'src/styles/fonts'
-
-const DISMISS_DEFAULT = 5
-
-interface StateProps {
-  displayMethod: ErrorDisplayType | null
-}
-
-interface OwnProps {
-  error?: ErrorMessages | null
-  dismissAfter?: number
-}
-
-interface DispatchProps {
-  hideAlert: typeof hideAlert
-}
-
-const mapStateToProps = (state: RootState): StateProps => {
-  const displayMethod = state.alert ? state.alert.displayMethod : null
-  return {
-    displayMethod,
-  }
-}
-
-const mapDispatchToProps = {
-  hideAlert,
-}
-
-type Props = DispatchProps & OwnProps & WithTranslation & StateProps
-
-function ErrorMessageInline(props: Props) {
-  const { error, displayMethod, dismissAfter, t } = props
-
-  // Want to initiate/cleanup a timer for each new error
-  React.useEffect(() => {
-    const timer = window.setTimeout(props.hideAlert, (dismissAfter || DISMISS_DEFAULT) * 1000)
-    return () => window.clearTimeout(timer)
-  }, [error])
-
-  // Keep the space empty when there isn't an inline error
-  // displayMethod lives in redux store and we want to be able to use this component
-  // without populating it so much check if other types are already displayed
-  // rather than if INLINE is
-  if (!error || displayMethod === ErrorDisplayType.BANNER) {
-    return <View style={dismissAfter !== null && styles.errorContainer} />
-  }
-
-  return (
-    <View style={dismissAfter !== null && styles.errorContainer}>
-      <Text style={styles.errorMessage}>{t(error)} </Text>
-    </View>
-  )
-}
-
-const styles = StyleSheet.create({
-  errorContainer: {
-    height: 64,
-  },
-  errorMessage: {
-    ...typeScale.bodySmall,
-    color: colors.errorPrimary,
-  },
-})
-
-export default connect<StateProps, DispatchProps, OwnProps, RootState>(
-  (state: RootState) => mapStateToProps,
-  mapDispatchToProps
-)(withTranslation<Props>()(ErrorMessageInline))

package/src/components/SingleDigitInput.tsx

@@ -1,53 +0,0 @@
-import * as React from 'react'
-import { StyleSheet } from 'react-native'
-import TextInput from 'src/components/TextInput'
-import colors from 'src/styles/colors'
-
-export interface SingleDigitInputProps {
-  inputValue: string
-  inputPlaceholder: string
-  onInputChange: (value: string) => void
-  testID?: string
-  forwardedRef: any
-}
-
-type Props = SingleDigitInputProps
-
-// Multiline enabled as to handle unexpected cursor behavior
-// https://github.com/facebook/react-native/issues/28794#issuecomment-877769852
-
-export function SingleDigitInput({
-  inputValue,
-  inputPlaceholder,
-  onInputChange,
-  testID,
-  forwardedRef,
-}: Props) {
-  return (
-    <TextInput
-      multiline={true}
-      textAlign={'center'}
-      value={inputValue}
-      placeholder={inputPlaceholder}
-      onChangeText={onInputChange}
-      maxLength={1}
-      showClearButton={false}
-      style={styles.codeInput}
-      testID={testID}
-      ref={forwardedRef}
-    />
-  )
-}
-
-const styles = StyleSheet.create({
-  codeInput: {
-    borderColor: colors.borderPrimary,
-    borderRadius: 3,
-    borderWidth: 1,
-    flex: 0,
-    backgroundColor: colors.backgroundPrimary,
-    height: 50,
-    width: 50,
-    marginVertical: 5,
-  },
-})

package/src/icons/HamburgerCard.tsx

@@ -1,55 +0,0 @@
-import * as React from 'react'
-import { StyleSheet, View } from 'react-native'
-import { Line, Svg } from 'react-native-svg'
-import { default as Colors, default as colors } from 'src/styles/colors'
-import globalStyles from 'src/styles/styles'
-
-function HamburgerCard() {
-  return (
-    <View style={styles.container}>
-      <Svg testID="Hamburger" width="32" height="32" viewBox="0 0 32 32" fill="none">
-        <Line
-          x1="7.25"
-          y1="9.75"
-          x2="24.75"
-          y2="9.75"
-          stroke={Colors.contentPrimary}
-          strokeWidth="2.5"
-          strokeLinecap="round"
-        />
-        <Line
-          x1="7.25"
-          y1="15.75"
-          x2="24.75"
-          y2="15.75"
-          stroke={Colors.contentPrimary}
-          strokeWidth="2.5"
-          strokeLinecap="round"
-        />
-        <Line
-          x1="7.25"
-          y1="21.75"
-          x2="24.75"
-          y2="21.75"
-          stroke={Colors.contentPrimary}
-          strokeWidth="2.5"
-          strokeLinecap="round"
-        />
-      </Svg>
-    </View>
-  )
-}
-
-const styles = StyleSheet.create({
-  container: {
-    backgroundColor: colors.backgroundPrimary,
-    ...globalStyles.softShadowLight,
-    alignItems: 'center',
-    justifyContent: 'center',
-    borderRadius: 4,
-    height: 32,
-    width: 32,
-  },
-})
-
-export default React.memo(HamburgerCard)

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,
-    })
-  })
-})