wallet-stack 1.0.0-alpha.121

package/src/recipients/RecipientPickerV2.test.tsx

@@ -0,0 +1,110 @@
+import { render } from '@testing-library/react-native'
+import * as React from 'react'
+import { Provider } from 'react-redux'
+import { ReactTestInstance } from 'react-test-renderer'
+import RecipientPicker from 'src/recipients/RecipientPickerV2'
+import { createMockStore } from 'test/utils'
+import { mockRecipient, mockRecipient2, mockRecipient3 } from 'test/values'
+
+const mockRecipients = [
+  {
+    ...mockRecipient,
+    contactId: 'contactId1',
+  },
+  {
+    ...mockRecipient2,
+    contactId: 'contactId2',
+  },
+  {
+    ...mockRecipient3,
+    contactId: 'contactId3',
+  },
+]
+const store = createMockStore()
+
+describe('RecipientPickerV2', () => {
+  it('renders all recipients', () => {
+    const { getAllByTestId } = render(
+      <Provider store={store}>
+        <RecipientPicker
+          recipients={mockRecipients}
+          onSelectRecipient={jest.fn()}
+          selectedRecipient={null}
+          isSelectedRecipientLoading={false}
+        />
+      </Provider>
+    )
+
+    expect(getAllByTestId('RecipientItem')).toHaveLength(3)
+  })
+
+  it('renders all recipients with title', () => {
+    const { getAllByTestId, getByText } = render(
+      <Provider store={store}>
+        <RecipientPicker
+          title="mockRecipientTitle"
+          recipients={mockRecipients}
+          onSelectRecipient={jest.fn()}
+          selectedRecipient={null}
+          isSelectedRecipientLoading={false}
+        />
+      </Provider>
+    )
+
+    expect(getByText('mockRecipientTitle')).toBeTruthy()
+    expect(getAllByTestId('RecipientItem')).toHaveLength(3)
+  })
+
+  it('renders all recipients with one recipient selected', () => {
+    const { getAllByTestId, queryByTestId } = render(
+      <Provider store={store}>
+        <RecipientPicker
+          recipients={mockRecipients}
+          onSelectRecipient={jest.fn()}
+          selectedRecipient={mockRecipients[1]}
+          isSelectedRecipientLoading={false}
+        />
+      </Provider>
+    )
+
+    expect(getAllByTestId('RecipientItem')).toHaveLength(3)
+    expect(queryByTestId('RecipientItem/ActivityIndicator')).toBeFalsy()
+    expect(
+      (getAllByTestId('RecipientItem')[0].children[0] as ReactTestInstance).props.style[1]
+    ).toBeFalsy()
+    expect(
+      (getAllByTestId('RecipientItem')[1].children[0] as ReactTestInstance).props.style[1]
+    ).toHaveProperty('backgroundColor')
+    expect(
+      (getAllByTestId('RecipientItem')[2].children[0] as ReactTestInstance).props.style[1]
+    ).toBeFalsy()
+  })
+
+  it('renders all recipients with one recipient selected and loading', () => {
+    const { getAllByTestId, getByTestId } = render(
+      <Provider store={store}>
+        <RecipientPicker
+          recipients={mockRecipients}
+          onSelectRecipient={jest.fn()}
+          selectedRecipient={mockRecipients[0]}
+          isSelectedRecipientLoading={true}
+        />
+      </Provider>
+    )
+
+    expect(getAllByTestId('RecipientItem')).toHaveLength(3)
+    expect(getAllByTestId('RecipientItem/ActivityIndicator')).toHaveLength(1)
+    expect(
+      (getAllByTestId('RecipientItem')[0].children[0] as ReactTestInstance).props.style[1]
+    ).toHaveProperty('backgroundColor')
+    expect(getAllByTestId('RecipientItem')[0]).toContainElement(
+      getByTestId('RecipientItem/ActivityIndicator')
+    )
+    expect(
+      (getAllByTestId('RecipientItem')[1].children[0] as ReactTestInstance).props.style[1]
+    ).toBeFalsy()
+    expect(
+      (getAllByTestId('RecipientItem')[2].children[0] as ReactTestInstance).props.style[1]
+    ).toBeFalsy()
+  })
+})

package/src/recipients/RecipientPickerV2.tsx

@@ -0,0 +1,61 @@
+import { isEqual } from 'lodash'
+import React from 'react'
+import { FlatList, StyleProp, StyleSheet, Text, View, ViewStyle } from 'react-native'
+import RecipientItem from 'src/recipients/RecipientItemV2'
+import { Recipient } from 'src/recipients/recipient'
+import Colors from 'src/styles/colors'
+import { typeScale } from 'src/styles/fonts'
+import { Spacing } from 'src/styles/styles'
+
+interface Props {
+  testID?: string
+  recipients: Recipient[]
+  title?: string | null
+  onSelectRecipient(recipient: Recipient): void
+  selectedRecipient: Recipient | null
+  isSelectedRecipientLoading: boolean
+  style?: StyleProp<ViewStyle>
+}
+
+function RecipientPicker({
+  testID,
+  recipients,
+  title,
+  onSelectRecipient,
+  selectedRecipient,
+  isSelectedRecipientLoading,
+  style,
+}: Props) {
+  return (
+    <View style={[styles.body, style]} testID={testID}>
+      {!!title && <Text style={styles.title}>{title}</Text>}
+      <FlatList
+        keyboardShouldPersistTaps={'always'}
+        scrollEnabled={false}
+        data={recipients}
+        renderItem={({ item }) => (
+          <RecipientItem
+            recipient={item}
+            onSelectRecipient={onSelectRecipient}
+            selected={isEqual(item, selectedRecipient)}
+            loading={isEqual(item, selectedRecipient) && isSelectedRecipientLoading}
+          />
+        )}
+      />
+    </View>
+  )
+}
+
+const styles = StyleSheet.create({
+  body: {
+    flex: 1,
+  },
+  title: {
+    ...typeScale.labelSmall,
+    marginBottom: Spacing.Smallest8,
+    marginHorizontal: Spacing.Regular16,
+    color: Colors.contentSecondary,
+  },
+})
+
+export default RecipientPicker

package/src/recipients/recipient.test.ts

@@ -0,0 +1,113 @@
+import { MinimalContact } from 'react-native-contacts'
+import { RecipientVerificationStatus } from 'src/identity/types'
+import {
+  contactsToRecipients,
+  getRecipientVerificationStatus,
+  sortRecipients,
+} from 'src/recipients/recipient'
+import {
+  mockAccount,
+  mockAddressRecipient,
+  mockInvitableRecipient,
+  mockRecipient,
+  mockRecipient2,
+  mockRecipient3,
+} from 'test/values'
+
+describe('contactsToRecipients', () => {
+  it('returns a recipient per phone number', () => {
+    const countryCode = '+1'
+    const mockContacts: MinimalContact[] = [
+      {
+        recordID: '1',
+        displayName: 'Alice The Person',
+        thumbnailPath: 'does-not-matter',
+        phoneNumbers: [
+          {
+            label: 'mobile',
+            number: '(209) 555-9790',
+          },
+        ],
+      },
+      {
+        recordID: '2',
+        thumbnailPath: 'does-not-matter',
+        displayName: 'Bob Bobson',
+        phoneNumbers: [
+          { label: 'home', number: '+14155550000' },
+          { label: 'mobile', number: '100200' },
+        ],
+      },
+    ]
+
+    const recipients = contactsToRecipients(mockContacts, countryCode)
+
+    expect(recipients).toMatchObject({
+      '+14155550000': {
+        name: 'Bob Bobson',
+        displayNumber: '+14155550000',
+        e164PhoneNumber: '+14155550000',
+        contactId: '2',
+      },
+      '+12095559790': {
+        name: 'Alice The Person',
+        displayNumber: '(209) 555-9790',
+        e164PhoneNumber: '+12095559790',
+        contactId: '1',
+      },
+    })
+  })
+})
+
+describe('Recipient sorting', () => {
+  const recipients = [mockRecipient2, mockRecipient, mockRecipient3]
+  it('Sorts recipients without any prioritized', () => {
+    expect(sortRecipients(recipients)).toStrictEqual([
+      mockRecipient3,
+      mockRecipient2,
+      mockRecipient,
+    ])
+  })
+})
+
+describe('getRecipientVerificationStatus', () => {
+  describe.each([
+    { recipient: mockAddressRecipient, type: 'without phone number' },
+    { recipient: mockRecipient, type: 'with phone number' },
+  ])('address recipient $type', ({ recipient }) => {
+    it('returns appropriate status', () => {
+      expect(getRecipientVerificationStatus(recipient, {}, { [recipient.address]: true })).toEqual(
+        RecipientVerificationStatus.VERIFIED
+      )
+      expect(getRecipientVerificationStatus(recipient, {}, { [recipient.address]: false })).toEqual(
+        RecipientVerificationStatus.UNVERIFIED
+      )
+      expect(
+        getRecipientVerificationStatus(recipient, {}, { [recipient.address]: undefined })
+      ).toEqual(RecipientVerificationStatus.UNKNOWN)
+      expect(getRecipientVerificationStatus(recipient, {}, {})).toEqual(
+        RecipientVerificationStatus.UNKNOWN
+      )
+    })
+  })
+
+  it('returns appropriate status for phone recipient', () => {
+    expect(
+      getRecipientVerificationStatus(
+        mockInvitableRecipient,
+        { [mockInvitableRecipient.e164PhoneNumber]: [mockAccount] },
+        {}
+      )
+    ).toEqual(RecipientVerificationStatus.VERIFIED)
+    expect(
+      getRecipientVerificationStatus(
+        mockInvitableRecipient,
+        { [mockInvitableRecipient.e164PhoneNumber]: null },
+        {}
+      )
+    ).toEqual(RecipientVerificationStatus.UNVERIFIED)
+    expect(getRecipientVerificationStatus(mockInvitableRecipient, {}, {})).toEqual(
+      RecipientVerificationStatus.UNKNOWN
+    )
+  })
+})

package/src/recipients/recipient.ts

@@ -0,0 +1,313 @@
+import * as fuzzysort from 'fuzzysort'
+import { TFunction } from 'i18next'
+import { MinimalContact } from 'react-native-contacts'
+import { formatShortenedAddress } from 'src/account/utils'
+import {
+  AddressToDisplayNameType,
+  AddressToE164NumberType,
+  AddressToVerificationStatus,
+  E164NumberToAddressType,
+} from 'src/identity/reducer'
+import { RecipientVerificationStatus } from 'src/identity/types'
+import Logger from 'src/utils/Logger'
+import { parsePhoneNumber } from 'src/utils/phoneNumbers'
+
+const TAG = 'recipients/recipient'
+
+export type Recipient = {
+  name?: string | null
+  contactId?: string // unique ID given by phone OS
+  thumbnailPath?: string
+  displayNumber?: string
+  e164PhoneNumber?: string
+  address?: string
+  recipientType: RecipientType
+} & ({ e164PhoneNumber: string } | { address: string })
+
+export type MobileRecipient = Recipient & {
+  e164PhoneNumber: string
+}
+
+// contacts pulled from the phone
+export type ContactRecipient = MobileRecipient & {
+  name: string
+  contactId: string
+}
+
+export type AddressRecipient = Recipient & {
+  address: string
+  recipientType: RecipientType.Address
+}
+
+export enum RecipientType {
+  Address = 'Address',
+  PhoneNumber = 'PhoneNumber',
+  Merchant = 'Merchant',
+  Ens = 'ENS',
+}
+
+export function recipientHasNumber(recipient: Recipient): recipient is MobileRecipient {
+  return recipient && 'e164PhoneNumber' in recipient && !!recipient.e164PhoneNumber
+}
+
+function recipientHasAddress(recipient: Recipient): recipient is AddressRecipient {
+  return recipient && 'address' in recipient && !!recipient.address
+}
+
+export function getDisplayName(recipient: Recipient, t: TFunction) {
+  if (recipient.name) {
+    return recipient.name
+  } else if (recipient.displayNumber) {
+    return recipient.displayNumber
+  } else if (recipient.e164PhoneNumber) {
+    return recipient.e164PhoneNumber
+  } else if (recipient.address) {
+    return t('feedItemAddress', { address: formatShortenedAddress(recipient.address) })
+  } else {
+    return t('unknown')
+  }
+}
+
+export function getDisplayDetail(recipient: Recipient) {
+  if (recipientHasNumber(recipient)) {
+    return recipient.displayNumber || recipient.e164PhoneNumber
+  } else {
+    return recipient.address.substring(0, 15) + '...'
+  }
+}
+
+export interface NumberToRecipient {
+  [number: string]: ContactRecipient
+}
+
+export interface AddressToRecipient {
+  [address: string]: AddressRecipient
+}
+
+/**
+ * Transforms contacts into a map of e164Number to recipients based on phone numbers from contacts.
+ * If a contact has no phone numbers it won't result in any recipients.
+ */
+export function contactsToRecipients(contacts: MinimalContact[], defaultCountryCode: string) {
+  try {
+    //  We need a map of e164Number to recipients so we can efficiently
+    //    update them later as the latest contact mappings arrive from the contact calls.
+
+    const e164NumberToRecipients: NumberToRecipient = {}
+    for (const contact of contacts) {
+      if (!contact.phoneNumbers || !contact.phoneNumbers.length) {
+        // Skip contacts without phone numbers
+        continue
+      }
+
+      for (const phoneNumber of contact.phoneNumbers) {
+        const parsedNumber = parsePhoneNumber(phoneNumber.number, defaultCountryCode)
+
+        if (parsedNumber) {
+          if (e164NumberToRecipients[parsedNumber.e164Number]) {
+            // Skip duplicate phone numbers
+            continue
+          }
+          e164NumberToRecipients[parsedNumber.e164Number] = {
+            name: contact.displayName,
+            // We intentionally use phoneNumber.number rather than parsedNumber.displayNumber.
+            displayNumber: phoneNumber.number,
+            e164PhoneNumber: parsedNumber.e164Number,
+            // @ts-ignore TODO Minimal contact type is incorrect, on android it returns id
+            contactId: contact.recordID || contact.id,
+            // we are no longer using local contact pictures
+            recipientType: RecipientType.PhoneNumber,
+          }
+        } else {
+          // don't do anything for contacts without e164PhoneNumber, as we can't interact with them anyways
+        }
+      }
+    }
+    return e164NumberToRecipients
+  } catch (error) {
+    Logger.error(TAG, 'Failed to build recipients cache', error)
+    throw error
+  }
+}
+
+export interface RecipientInfo {
+  addressToE164Number: AddressToE164NumberType
+  phoneRecipientCache: NumberToRecipient
+  appRecipientCache: AddressToRecipient
+  // this info comes from Firebase for known addresses (ex. Simplex, cUSD incentive programs)
+  // differentiated from appRecipients because they are not displayed in the RecipientPicker
+  addressToDisplayName: AddressToDisplayNameType
+}
+
+export function getRecipientFromAddress(
+  address: string,
+  info: RecipientInfo,
+  defaultName?: string | null,
+  defaultImage?: string | null
+): Recipient {
+  const e164PhoneNumber = info.addressToE164Number[address]
+  const numberRecipient = e164PhoneNumber ? info.phoneRecipientCache[e164PhoneNumber] : undefined
+  const appRecipient = info.appRecipientCache[address]
+  const displayInfo = info.addressToDisplayName[address]
+
+  const recipient: Recipient = {
+    address,
+    name:
+      appRecipient?.name || numberRecipient?.name || displayInfo?.name || defaultName || undefined,
+    thumbnailPath:
+      appRecipient?.thumbnailPath || displayInfo?.imageUrl || defaultImage || undefined,
+    contactId: appRecipient?.contactId || numberRecipient?.contactId,
+    e164PhoneNumber: e164PhoneNumber || undefined,
+    displayNumber: numberRecipient?.displayNumber,
+    recipientType: RecipientType.Address,
+  }
+
+  return recipient
+}
+
+export function getRecipientVerificationStatus(
+  recipient: Recipient,
+  e164NumberToAddress: E164NumberToAddressType,
+  addressToVerificationStatus: AddressToVerificationStatus
+): RecipientVerificationStatus {
+  // phone recipients should always have a number, the extra check is to ensure typing
+  if (recipient.recipientType === RecipientType.PhoneNumber && recipientHasNumber(recipient)) {
+    const addresses = e164NumberToAddress[recipient.e164PhoneNumber]
+    if (addresses === undefined) {
+      return RecipientVerificationStatus.UNKNOWN
+    }
+
+    if (addresses === null) {
+      return RecipientVerificationStatus.UNVERIFIED
+    }
+
+    return RecipientVerificationStatus.VERIFIED
+  }
+  if (recipientHasAddress(recipient) && recipient.address in addressToVerificationStatus) {
+    switch (addressToVerificationStatus[recipient.address]) {
+      case true:
+        return RecipientVerificationStatus.VERIFIED
+      case false:
+        return RecipientVerificationStatus.UNVERIFIED
+      case undefined:
+        return RecipientVerificationStatus.UNKNOWN
+    }
+  } else {
+    return RecipientVerificationStatus.UNKNOWN
+  }
+}
+
+type PreparedRecipient = Recipient & {
+  displayPrepared: Fuzzysort.Prepared | undefined
+  phonePrepared: Fuzzysort.Prepared | undefined
+}
+
+type FuzzyRecipient = Recipient | PreparedRecipient
+
+const SCORE_THRESHOLD = -6000
+
+const fuzzysortOptions = {
+  keys: ['displayName', 'e164PhoneNumber', 'address'],
+  threshold: SCORE_THRESHOLD,
+  allowTypo: false,
+}
+
+const fuzzysortPreparedOptions = {
+  keys: ['displayPrepared', 'phonePrepared', 'addressPrepared'],
+  threshold: SCORE_THRESHOLD,
+  allowTypo: false,
+}
+
+function fuzzysortToRecipients(
+  fuzzyResults: Fuzzysort.KeysResults<FuzzyRecipient>
+): FuzzyRecipient[] {
+  // This is the fastest way to map the 'obj' into a results array
+  // https://jsperf.com/set-iterator-vs-foreach/16
+  const result = []
+  for (let _len = fuzzyResults.length, _key = 0; _key < _len; _key++) {
+    result[_key] = fuzzyResults[_key].obj
+  }
+  return result
+}
+
+function nameCompare(a: FuzzyRecipient, b: FuzzyRecipient) {
+  const nameA = a.name?.toUpperCase() ?? ''
+  const nameB = b.name?.toUpperCase() ?? ''
+
+  if (nameA > nameB) {
+    return 1
+  } else if (nameA < nameB) {
+    return -1
+  }
+  return 0
+}
+
+export function sortRecipients(recipients: Recipient[]) {
+  return recipients.sort(nameCompare)
+}
+
+function executeFuzzySearch(
+  recipients: FuzzyRecipient[],
+  query: string,
+  options: Fuzzysort.KeysOptions<FuzzyRecipient>,
+  shouldSort?: boolean
+): FuzzyRecipient[] {
+  const parsedQuery = query.replace(/[()-\s/\\]/g, '')
+  if (parsedQuery === '') {
+    // fuzzysort does not handle empty string query
+    if (shouldSort) {
+      return sortRecipients(recipients)
+    } else {
+      return recipients
+    }
+  }
+
+  return fuzzysortToRecipients(fuzzysort.go(parsedQuery, recipients, options))
+}
+
+export function filterRecipients(recipients: Recipient[], query: string, shouldSort?: boolean) {
+  return executeFuzzySearch(recipients, query, fuzzysortOptions, shouldSort)
+}
+
+export function filterRecipientFactory(recipients: Recipient[], shouldSort: boolean) {
+  const preparedRecipients = recipients.map((r) => ({
+    ...r,
+    displayPrepared: fuzzysort.prepare(r.name!),
+    phonePrepared: recipientHasNumber(r) ? fuzzysort.prepare(r.e164PhoneNumber) : undefined,
+    addressPrepared: recipientHasAddress(r) ? fuzzysort.prepare(r.address) : undefined,
+  }))
+
+  return (query: string) => {
+    return executeFuzzySearch(preparedRecipients, query, fuzzysortPreparedOptions, shouldSort)
+  }
+}
+
+// Returns true if two recipients are equivalent
+// This isn't trivial because two recipients of diff types (Qr code vs contact)
+// could potentially refer to the same recipient
+export function areRecipientsEquivalent(recipient1: Recipient, recipient2: Recipient) {
+  if (recipient1 === recipient2) {
+    return true
+  }
+
+  if (
+    recipientHasNumber(recipient1) &&
+    recipientHasNumber(recipient2) &&
+    recipient1.e164PhoneNumber === recipient2.e164PhoneNumber
+  ) {
+    return true
+  }
+
+  if (
+    recipientHasAddress(recipient1) &&
+    recipientHasAddress(recipient2) &&
+    recipient1.address === recipient2.address
+  ) {
+    return true
+  }
+
+  // Todo(Rossy) there's still the case where one recip's e164Number gets resolved to another's address
+  // but to detect that we'll need to wire in the mappings and check there too
+
+  return false
+}

package/src/recipients/reducer.ts

@@ -0,0 +1,107 @@
+import { createAction, createReducer, createSelector } from '@reduxjs/toolkit'
+import { addressToDisplayNameSelector, addressToE164NumberSelector } from 'src/identity/selectors'
+import { AddressToRecipient, NumberToRecipient } from 'src/recipients/recipient'
+import { REHYDRATE, RehydrateAction, getRehydratePayload } from 'src/redux/persist-helper'
+import { RootState } from 'src/redux/reducers'
+
+interface State {
+  // phoneRecipientCache contains the processed contact data imported from the
+  // phone for a single app session.
+  // Think of contacts as raw data and recipients as filtered data
+  // No relation to recent recipients, which is in /send/reducer.ts
+  phoneRecipientCache: NumberToRecipient
+  // appRecipientCache contains accounts that the user has sent/recieved transactions from,
+  // and includes CIP8 profile data if available
+  appRecipientCache: AddressToRecipient
+  rewardsSenders: string[]
+  inviteRewardsSenders: string[]
+  coinbasePaySenders: string[]
+}
+
+const initialState: State = {
+  phoneRecipientCache: {},
+  appRecipientCache: {},
+  rewardsSenders: [],
+  inviteRewardsSenders: [],
+  coinbasePaySenders: [],
+}
+
+const rehydrate = createAction<any>(REHYDRATE)
+export const setPhoneRecipientCache = createAction<NumberToRecipient>(
+  'RECIPIENTS/SET_PHONE_RECIPIENT_CACHE'
+)
+export const updateAppRecipientCache = createAction<AddressToRecipient>(
+  'RECIPIENTS/SET_APP_RECIPIENT_CACHE'
+)
+export const rewardsSendersFetched = createAction<string[]>('RECIPIENTS/REWARDS_SENDERS_FETCHED')
+export const inviteRewardsSendersFetched = createAction<string[]>(
+  'RECIPIENTS/INVITE_REWARDS_SENDERS_FETCHED'
+)
+export const coinbasePaySendersFetched = createAction<string[]>(
+  'RECIPIENTS/COINBASE_PAY_SENDERS_FETCHED'
+)
+
+export const recipientsReducer = createReducer(initialState, (builder) => {
+  builder
+    .addCase(rehydrate, (state, action) => {
+      // hack to allow rehydrate actions here
+      const hydrated = getRehydratePayload(action as unknown as RehydrateAction, 'recipients')
+      return {
+        ...initialState,
+        ...state,
+        ...hydrated,
+      }
+    })
+    .addCase(setPhoneRecipientCache, (state, action) => ({
+      ...state,
+      phoneRecipientCache: action.payload,
+    }))
+    .addCase(updateAppRecipientCache, (state, action) => ({
+      ...state,
+      appRecipientCache: { ...state.appRecipientCache, ...action.payload },
+    }))
+    .addCase(rewardsSendersFetched, (state, action) => ({
+      ...state,
+      rewardsSenders: action.payload,
+    }))
+    .addCase(inviteRewardsSendersFetched, (state, action) => ({
+      ...state,
+      inviteRewardsSenders: action.payload,
+    }))
+    .addCase(coinbasePaySendersFetched, (state, action) => ({
+      ...state,
+      coinbasePaySenders: action.payload,
+    }))
+})
+
+export const phoneRecipientCacheSelector = (state: RootState) =>
+  state.recipients.phoneRecipientCache
+export const appRecipientCacheSelector = (state: RootState) => state.recipients.appRecipientCache
+export const rewardsSendersSelector = (state: RootState) => state.recipients.rewardsSenders
+export const inviteRewardsSendersSelector = (state: RootState) =>
+  state.recipients.inviteRewardsSenders
+
+export const allRewardsSendersSelector = createSelector(
+  [rewardsSendersSelector, inviteRewardsSendersSelector],
+  (rewardsSenders, inviteRewardsSenders) => {
+    return [...rewardsSenders, ...inviteRewardsSenders]
+  }
+)
+export const coinbasePaySendersSelector = (state: RootState) => state.recipients.coinbasePaySenders
+
+export const recipientInfoSelector = createSelector(
+  [
+    addressToE164NumberSelector,
+    phoneRecipientCacheSelector,
+    appRecipientCacheSelector,
+    addressToDisplayNameSelector,
+  ],
+  (addressToE164Number, phoneRecipientCache, appRecipientCache, addressToDisplayName) => {
+    return {
+      addressToE164Number,
+      phoneRecipientCache,
+      appRecipientCache,
+      addressToDisplayName,
+    }
+  }
+)