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

package/locales/base/translation.json

@@ -2169,6 +2169,11 @@
     "importSuccess": "Successfully imported {{tokenSymbol}} token",
     "importButton": "Import"
   },
+  "selectRecipientAddress": {
+    "header": "Select wallet",
+    "recipient": "Recipient",
+    "explanation": "<0>{{name}}</0> has more than one wallet linked to the phone number. Choose which one to send to."
+  },
   "sendSelectRecipient": {
     "searchText": "Search by name, phone, wallet...",
     "searchInputLabel": "To",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wallet-stack",
-  "version": "1.0.0-alpha.132",
+  "version": "1.0.0-alpha.133",
   "author": "Valora Inc",
   "license": "Apache-2.0",
   "repository": {
@@ -148,7 +148,6 @@
     "bignumber.js": "^9.1.2",
     "country-data": "^0.0.31",
     "date-fns": "^4.1.0",
-    "dot-prop-immutable": "^2.1.1",
     "expo": "^53.0.22",
     "expo-image": "~2.4.0",
     "fast-levenshtein": "^3.0.0",

package/src/analytics/Events.tsx

@@ -269,16 +269,6 @@ export enum SendEvents {
   send_confirm_back = 'send_confirm_back',
   send_confirm_send = 'send_confirm_send',
 
-  send_secure_start = 'send_secure_start',
-  send_secure_back = 'send_secure_back',
-  send_secure_cancel = 'send_secure_cancel',
-
-  send_secure_info = 'send_secure_info',
-  send_secure_info_dismissed = 'send_secure_info_dismissed',
-  send_secure_submit = 'send_secure_submit',
-  send_secure_incorrect = 'send_secure_incorrect',
-  send_secure_complete = 'send_secure_complete',
-
   send_tx_start = 'send_tx_start',
   send_tx_complete = 'send_tx_complete',
   send_tx_error = 'send_tx_error',
@@ -305,6 +295,9 @@ export enum SendEvents {
   send_select_recipient_invite_press = 'send_select_recipient_invite_press',
   send_select_recipient_send_press = 'send_select_recipient_send_press',
   send_select_recipient_recent_press = 'send_select_recipient_recent_press',
+  send_select_recipient_address_open = 'send_select_recipient_address_open',
+  send_select_recipient_address_select = 'send_select_recipient_address_select',
+  send_select_recipient_address_back = 'send_select_recipient_address_back',
 }
 
 export enum QrScreenEvents {

package/src/analytics/Properties.tsx

@@ -71,6 +71,7 @@ import { NftOrigin } from 'src/nfts/types'
 import { NotificationReceiveState } from 'src/notifications/types'
 import { PointsActivityId } from 'src/points/types'
 import { RecipientType } from 'src/recipients/recipient'
+import { Verifier } from 'src/send/SelectRecipientAddress'
 import { AmountEnteredIn, QrCode } from 'src/send/types'
 import { Field, SwapType } from 'src/swap/types'
 import { TokenActionName } from 'src/tokens/types'
@@ -521,31 +522,6 @@ interface SendEventsProperties {
         isTokenManuallyImported: boolean
       }
 
-  [SendEvents.send_secure_start]: {
-    confirmByScan: boolean
-  }
-  [SendEvents.send_secure_back]: undefined
-  [SendEvents.send_secure_cancel]: undefined
-  [SendEvents.send_secure_submit]: {
-    partialAddressValidation: boolean
-    address: string
-  }
-  [SendEvents.send_secure_complete]: {
-    confirmByScan: boolean
-    partialAddressValidation?: boolean
-  }
-  [SendEvents.send_secure_incorrect]: {
-    confirmByScan: boolean
-    partialAddressValidation?: boolean
-    error: string
-  }
-  [SendEvents.send_secure_info]: {
-    partialAddressValidation: boolean
-  }
-  [SendEvents.send_secure_info_dismissed]: {
-    partialAddressValidation: boolean
-  }
-
   [SendEvents.send_tx_start]: undefined
   [SendEvents.send_tx_complete]: {
     txId: string
@@ -605,6 +581,14 @@ interface SendEventsProperties {
   [SendEvents.send_select_recipient_recent_press]: {
     recipientType: RecipientType
   }
+
+  [SendEvents.send_select_recipient_address_open]: {
+    addressCount: number
+  }
+  [SendEvents.send_select_recipient_address_select]: {
+    verifier: Verifier
+  }
+  [SendEvents.send_select_recipient_address_back]: undefined
 }
 
 interface FeeEventsProperties {

package/src/analytics/docs.ts

@@ -259,14 +259,6 @@ export const eventDocs: Record<AnalyticsEventType, string> = {
   [SendEvents.send_amount_continue]: `when next button pressed on amount enter page`,
   [SendEvents.send_confirm_back]: `when back button pressed on send confirmation screen`,
   [SendEvents.send_confirm_send]: `when send button pressed on send confirmation screen`,
-  [SendEvents.send_secure_start]: `when either secure send scan or manual confirm button pressed`,
-  [SendEvents.send_secure_back]: `when back button is pressed during secure send`,
-  [SendEvents.send_secure_cancel]: `when secure send flow is canceled`,
-  [SendEvents.send_secure_info]: `when "help" button is pressed`,
-  [SendEvents.send_secure_info_dismissed]: `when "help" button is dismissed`,
-  [SendEvents.send_secure_submit]: `when an account is submitted for validation`,
-  [SendEvents.send_secure_incorrect]: `when there's been an error validating the account`,
-  [SendEvents.send_secure_complete]: `when an account has been validated`,
   [SendEvents.send_tx_start]: `issued from the sendPayment saga, after a user confirms their intent to send and right before we build and send the transaction to the network`,
   [SendEvents.send_tx_complete]: `when a send transaction has successfully completed`,
   [SendEvents.send_tx_error]: `when there is an error sending a transaction`,
@@ -292,6 +284,9 @@ export const eventDocs: Record<AnalyticsEventType, string> = {
   [SendEvents.send_select_recipient_send_press]: `When the send button is pressed after selecting a recipient`,
   [SendEvents.send_select_recipient_invite_press]: `When the invite button is pressed after selecting a recipient`,
   [SendEvents.send_select_recipient_recent_press]: `When a recent recipient is pressed`,
+  [SendEvents.send_select_recipient_address_open]: `When the address picker screen is shown (a phone recipient has multiple verified addresses)`,
+  [SendEvents.send_select_recipient_address_select]: `When a verified address is picked from the address picker screen`,
+  [SendEvents.send_select_recipient_address_back]: `When the back button is pressed on the address picker screen`,
   [JumpstartEvents.jumpstart_reclaim_press]:
     'When user taps on "Reclaim" button on the Jumpstart screen',
   [JumpstartEvents.jumpstart_reclaim_start]:
@@ -578,6 +573,14 @@ export const eventDocs: Record<AnalyticsEventType, string> = {
 
   // Legacy event docs
   //  The below events had docs, but are no longer produced by the latest app version.
+  // [SendEvents.send_secure_start]: `when either secure send scan or manual confirm button pressed`,
+  // [SendEvents.send_secure_back]: `when back button is pressed during secure send`,
+  // [SendEvents.send_secure_cancel]: `when secure send flow is canceled`,
+  // [SendEvents.send_secure_info]: `when "help" button is pressed`,
+  // [SendEvents.send_secure_info_dismissed]: `when "help" button is dismissed`,
+  // [SendEvents.send_secure_submit]: `when an account is submitted for validation`,
+  // [SendEvents.send_secure_incorrect]: `when there's been an error validating the account`,
+  // [SendEvents.send_secure_complete]: `when an account has been validated`,
   // [HomeEvents.home_send]: `when "send" button is pressed from home screen send or request bar (NOT from home screen actions)`,
   // [HomeEvents.view_nft_home_assets]: `When "NFTs" is clicked in Home Assets Pages`,
   // [DappExplorerEvents.dapp_open_info]: `when a user taps on the help icon`,

package/src/app/ErrorMessages.ts

@@ -16,13 +16,6 @@ export enum ErrorMessages {
   FIREBASE_FAILED = 'firebaseFailed',
   IMPORT_CONTACTS_FAILED = 'importContactsFailed',
   QR_FAILED_INVALID_ADDRESS = 'qrFailedInvalidAddress',
-  QR_FAILED_INVALID_RECIPIENT = 'qrFailedInvalidRecipient',
-  ADDRESS_VALIDATION_ERROR = 'addressValidationError',
-  ADDRESS_VALIDATION_NO_MATCH = 'addressValidationNoMatch',
-  ADDRESS_VALIDATION_FULL_POORLY_FORMATTED = 'addressValidationFullPoorlyFormatted',
-  ADDRESS_VALIDATION_PARTIAL_POORLY_FORMATTED = 'addressValidationPartialPoorlyFormatted',
-  ADDRESS_VALIDATION_FULL_OWN_ADDRESS = 'addressValidationFullOwnAddress',
-  ADDRESS_VALIDATION_PARTIAL_OWN_ADDRESS = 'addressValidationPartialOwnAddress',
   ACCOUNT_CLEAR_FAILED = 'accountClearFailed',
   KEYCHAIN_FETCH_ACCOUNTS = 'keychainFetchAccounts',
   KEYCHAIN_ACCOUNT_ALREADY_EXISTS = 'keychainAccountAlreadyExists',

package/src/identity/actions.ts

@@ -2,26 +2,18 @@ import {
   AddressToDisplayNameType,
   AddressToE164NumberType,
   AddressToVerifiedByType,
-  AddressValidationType,
   E164NumberToAddressType,
 } from 'src/identity/reducer'
 import { ImportContactsStatus } from 'src/identity/types'
-import { Recipient } from 'src/recipients/recipient'
-import { type E164Number } from 'src/utils/io'
 
 export enum Actions {
   UPDATE_E164_PHONE_NUMBER_ADDRESSES = 'IDENTITY/UPDATE_E164_PHONE_NUMBER_ADDRESSES',
   UPDATE_KNOWN_ADDRESSES = 'IDENTITY/UPDATE_KNOWN_ADDRESSES',
   FETCH_ADDRESSES_AND_VALIDATION_STATUS = 'IDENTITY/FETCH_ADDRESSES_AND_VALIDATION_STATUS',
-  END_FETCHING_ADDRESSES = 'IDENTITY/END_FETCHING_ADDRESSES',
   IMPORT_CONTACTS = 'IDENTITY/IMPORT_CONTACTS',
   UPDATE_IMPORT_CONTACT_PROGRESS = 'IDENTITY/UPDATE_IMPORT_CONTACT_PROGRESS',
   CANCEL_IMPORT_CONTACTS = 'IDENTITY/CANCEL_IMPORT_CONTACTS',
   END_IMPORT_CONTACTS = 'IDENTITY/END_IMPORT_CONTACTS',
-  VALIDATE_RECIPIENT_ADDRESS = 'IDENTITY/VALIDATE_RECIPIENT_ADDRESS',
-  VALIDATE_RECIPIENT_ADDRESS_SUCCESS = 'IDENTITY/VALIDATE_RECIPIENT_ADDRESS_SUCCESS',
-  VALIDATE_RECIPIENT_ADDRESS_RESET = 'IDENTITY/VALIDATE_RECIPIENT_ADDRESS_RESET',
-  REQUIRE_SECURE_SEND = 'IDENTITY/REQUIRE_SECURE_SEND',
   FETCH_ADDRESS_VERIFICATION_STATUS = 'IDENTITY/FETCH_ADDRESS_VERIFICATION_STATUS',
   ADDRESS_VERIFICATION_STATUS_RECEIVED = 'IDENTITY/ADDRESS_VERIFICATION_STATUS_RECEIVED',
   CONTACTS_SAVED = 'IDENTITY/CONTACTS_SAVED',
@@ -43,13 +35,6 @@ export interface UpdateKnownAddressesAction {
 export interface FetchAddressesAndValidateAction {
   type: Actions.FETCH_ADDRESSES_AND_VALIDATION_STATUS
   e164Number: string
-  requesterAddress?: string
-}
-
-export interface EndFetchingAddressesAction {
-  type: Actions.END_FETCHING_ADDRESSES
-  e164Number: string
-  lastFetchSuccessful: boolean
 }
 
 export interface ImportContactsAction {
@@ -68,31 +53,6 @@ export interface EndImportContactsAction {
   success: boolean
 }
 
-export interface ValidateRecipientAddressAction {
-  type: Actions.VALIDATE_RECIPIENT_ADDRESS
-  userInputOfFullAddressOrLastFourDigits: string
-  addressValidationType: AddressValidationType
-  recipient: Recipient
-  requesterAddress?: string
-}
-
-export interface ValidateRecipientAddressSuccessAction {
-  type: Actions.VALIDATE_RECIPIENT_ADDRESS_SUCCESS
-  e164Number: string
-  validatedAddress: string
-}
-
-export interface ValidateRecipientAddressResetAction {
-  type: Actions.VALIDATE_RECIPIENT_ADDRESS_RESET
-  e164Number: string
-}
-
-export interface RequireSecureSendAction {
-  type: Actions.REQUIRE_SECURE_SEND
-  e164Number: E164Number
-  addressValidationType: AddressValidationType
-}
-
 export interface FetchAddressVerificationAction {
   type: Actions.FETCH_ADDRESS_VERIFICATION_STATUS
   address: string
@@ -119,24 +79,15 @@ export type ActionTypes =
   | ImportContactsAction
   | UpdateImportContactProgress
   | EndImportContactsAction
-  | ValidateRecipientAddressAction
-  | ValidateRecipientAddressSuccessAction
-  | ValidateRecipientAddressResetAction
-  | RequireSecureSendAction
   | FetchAddressesAndValidateAction
-  | EndFetchingAddressesAction
   | FetchAddressVerificationAction
   | AddressVerificationStatusReceivedAction
   | ContactsSavedAction
   | StoredPasswordRefreshedAction
 
-export const fetchAddressesAndValidate = (
-  e164Number: string,
-  requesterAddress?: string
-): FetchAddressesAndValidateAction => ({
+export const fetchAddressesAndValidate = (e164Number: string): FetchAddressesAndValidateAction => ({
   type: Actions.FETCH_ADDRESSES_AND_VALIDATION_STATUS,
   e164Number,
-  requesterAddress,
 })
 
 export const addressVerificationStatusReceived = (
@@ -153,15 +104,6 @@ export const fetchAddressVerification = (address: string): FetchAddressVerificat
   address,
 })
 
-export const endFetchingAddresses = (
-  e164Number: string,
-  lastFetchSuccessful: boolean
-): EndFetchingAddressesAction => ({
-  type: Actions.END_FETCHING_ADDRESSES,
-  e164Number,
-  lastFetchSuccessful,
-})
-
 export const updateE164PhoneNumberAddresses = (
   e164NumberToAddress: E164NumberToAddressType,
   addressToE164Number: AddressToE164NumberType,
@@ -200,44 +142,6 @@ export const endImportContacts = (success: boolean): EndImportContactsAction =>
   success,
 })
 
-export const validateRecipientAddress = (
-  userInputOfFullAddressOrLastFourDigits: string,
-  addressValidationType: AddressValidationType,
-  recipient: Recipient,
-  requesterAddress?: string
-): ValidateRecipientAddressAction => ({
-  type: Actions.VALIDATE_RECIPIENT_ADDRESS,
-  userInputOfFullAddressOrLastFourDigits,
-  addressValidationType,
-  recipient,
-  requesterAddress,
-})
-
-export const validateRecipientAddressSuccess = (
-  e164Number: E164Number,
-  validatedAddress: string
-): ValidateRecipientAddressSuccessAction => ({
-  type: Actions.VALIDATE_RECIPIENT_ADDRESS_SUCCESS,
-  e164Number,
-  validatedAddress,
-})
-
-export const validateRecipientAddressReset = (
-  e164Number: E164Number
-): ValidateRecipientAddressResetAction => ({
-  type: Actions.VALIDATE_RECIPIENT_ADDRESS_RESET,
-  e164Number,
-})
-
-export const requireSecureSend = (
-  e164Number: E164Number,
-  addressValidationType: AddressValidationType
-): RequireSecureSendAction => ({
-  type: Actions.REQUIRE_SECURE_SEND,
-  e164Number,
-  addressValidationType,
-})
-
 export const contactsSaved = (hash: string): ContactsSavedAction => ({
   type: Actions.CONTACTS_SAVED,
   hash,

package/src/identity/contactMapping.test.ts

@@ -16,7 +16,6 @@ import {
   contactsSaved,
   fetchAddressVerification,
   fetchAddressesAndValidate,
-  requireSecureSend,
   updateE164PhoneNumberAddresses,
 } from 'src/identity/actions'
 import {
@@ -25,12 +24,9 @@ import {
   fetchAddressesAndValidateSaga,
   saveContacts,
 } from 'src/identity/contactMapping'
-import { AddressValidationType } from 'src/identity/reducer'
 import {
   addressToVerificationStatusSelector,
-  e164NumberToAddressSelector,
   lastSavedContactsHashSelector,
-  secureSendPhoneNumberMappingSelector,
 } from 'src/identity/selectors'
 import { retrieveSignedMessage } from 'src/pincode/authentication'
 import { contactsToRecipients } from 'src/recipients/recipient'
@@ -98,18 +94,13 @@ describe('Fetch Addresses Saga', () => {
     })
 
     it('fetches and caches addresses correctly', async () => {
-      const mockE164NumberToAddress = {
-        [mockE164Number]: [mockAccount.toLowerCase()],
-      }
       const updatedAccount = '0xAbC'
       mockFetch.mockResponseOnce(JSON.stringify({ data: { addresses: [updatedAccount] } }))
 
       await expectSaga(fetchAddressesAndValidateSaga, fetchAddressesAndValidate(mockE164Number))
         .provide([
-          [select(e164NumberToAddressSelector), mockE164NumberToAddress],
           [select(walletAddressSelector), '0xxyz'],
           [call(retrieveSignedMessage), 'some signed message'],
-          [select(secureSendPhoneNumberMappingSelector), {}],
         ])
         .put(updateE164PhoneNumberAddresses({ [mockE164Number]: undefined }, {}))
         .put(
@@ -135,18 +126,13 @@ describe('Fetch Addresses Saga', () => {
     })
 
     it('fetches and caches multiple addresses correctly', async () => {
-      const mockE164NumberToAddress = {
-        [mockE164Number]: [mockAccount.toLowerCase()],
-      }
       const updatedAccounts = ['0xAbC', '0xdef']
       mockFetch.mockResponseOnce(JSON.stringify({ data: { addresses: updatedAccounts } }))
 
       await expectSaga(fetchAddressesAndValidateSaga, fetchAddressesAndValidate(mockE164Number))
         .provide([
-          [select(e164NumberToAddressSelector), mockE164NumberToAddress],
-          [select(walletAddressSelector), mockAccount],
+          [select(walletAddressSelector), '0xxyz'],
           [call(retrieveSignedMessage), 'some signed message'],
-          [select(secureSendPhoneNumberMappingSelector), {}],
         ])
         .put(updateE164PhoneNumberAddresses({ [mockE164Number]: undefined }, {}))
         .put(
@@ -156,14 +142,10 @@ describe('Fetch Addresses Saga', () => {
             {}
           )
         )
-        .put(requireSecureSend(mockE164Number, AddressValidationType.PARTIAL))
         .run()
     })
 
     it('uses verifiedAddresses as source of truth when present', async () => {
-      const mockE164NumberToAddress = {
-        [mockE164Number]: [mockAccount.toLowerCase()],
-      }
       // addresses only contains DB-verified addresses (backward compat),
       // verifiedAddresses contains all (DB + SC) and is the source of truth
       mockFetch.mockResponseOnce(
@@ -180,10 +162,8 @@ describe('Fetch Addresses Saga', () => {
 
       await expectSaga(fetchAddressesAndValidateSaga, fetchAddressesAndValidate(mockE164Number))
         .provide([
-          [select(e164NumberToAddressSelector), mockE164NumberToAddress],
-          [select(walletAddressSelector), mockAccount],
+          [select(walletAddressSelector), '0xxyz'],
           [call(retrieveSignedMessage), 'some signed message'],
-          [select(secureSendPhoneNumberMappingSelector), {}],
         ])
         .put(updateE164PhoneNumberAddresses({ [mockE164Number]: undefined }, {}))
         .put(
@@ -193,20 +173,15 @@ describe('Fetch Addresses Saga', () => {
             { '0xabc': 'valora', '0xdef': 'minipay' }
           )
         )
-        .put(requireSecureSend(mockE164Number, AddressValidationType.PARTIAL))
         .run()
     })
 
     it('handles lookup errors correctly', async () => {
-      const mockE164NumberToAddress = {
-        [mockE164Number]: [mockAccount.toLowerCase()],
-      }
       mockFetch.mockReject()
 
       await expectSaga(fetchAddressesAndValidateSaga, fetchAddressesAndValidate(mockE164Number))
         .provide([
-          [select(e164NumberToAddressSelector), mockE164NumberToAddress],
-          [select(walletAddressSelector), mockAccount],
+          [select(walletAddressSelector), '0xxyz'],
           [call(retrieveSignedMessage), 'some signed message'],
         ])
         .put(showErrorOrFallback(expect.anything(), ErrorMessages.ADDRESS_LOOKUP_FAILURE))

package/src/identity/contactMapping.ts

@@ -13,24 +13,14 @@ import {
   FetchAddressesAndValidateAction,
   addressVerificationStatusReceived,
   contactsSaved,
-  endFetchingAddresses,
   endImportContacts,
-  requireSecureSend,
   updateE164PhoneNumberAddresses,
   updateImportContactsProgress,
 } from 'src/identity/actions'
-import {
-  AddressToE164NumberType,
-  AddressValidationType,
-  E164NumberToAddressType,
-  SecureSendPhoneNumberMapping,
-} from 'src/identity/reducer'
-import { checkIfValidationRequired } from 'src/identity/secureSend'
+import { AddressToE164NumberType, E164NumberToAddressType } from 'src/identity/reducer'
 import {
   addressToVerificationStatusSelector,
-  e164NumberToAddressSelector,
   lastSavedContactsHashSelector,
-  secureSendPhoneNumberMappingSelector,
 } from 'src/identity/selectors'
 import { ImportContactsStatus } from 'src/identity/types'
 import { retrieveSignedMessage } from 'src/pincode/authentication'
@@ -144,17 +134,10 @@ function* updateUserContact(e164NumberToRecipients: NumberToRecipient) {
   yield* put(setUserContactDetails(userRecipient.contactId, userRecipient.thumbnailPath || null))
 }
 
-export function* fetchAddressesAndValidateSaga({
-  e164Number,
-  requesterAddress,
-}: FetchAddressesAndValidateAction) {
+export function* fetchAddressesAndValidateSaga({ e164Number }: FetchAddressesAndValidateAction) {
   AppAnalytics.track(IdentityEvents.phone_number_lookup_start)
   try {
     Logger.debug(TAG + '@fetchAddressesAndValidate', `Fetching addresses for number`)
-    const oldE164NumberToAddress: E164NumberToAddressType = yield* select(
-      e164NumberToAddressSelector
-    )
-    const oldAddresses = oldE164NumberToAddress[e164Number] || []
 
     // Clear existing entries for those numbers so our mapping consumers know new status is pending.
     yield* put(updateE164PhoneNumberAddresses({ [e164Number]: undefined }, {}))
@@ -186,28 +169,6 @@ export function* fetchAddressesAndValidateSaga({
       walletAddresses.map((a) => (addressToE164NumberUpdates[a] = e164Number))
     }
 
-    const userAddress = yield* select(walletAddressSelector)
-    if (!userAddress) {
-      throw new Error('Wallet address not set')
-    }
-    const secureSendPossibleAddresses = [...walletAddresses]
-    const secureSendPhoneNumberMapping = yield* select(secureSendPhoneNumberMappingSelector)
-    // If fetch is being done as part of a payment request from an unverified address,
-    // the unverified address should be considered in the Secure Send check
-    if (requesterAddress && !secureSendPossibleAddresses.includes(requesterAddress)) {
-      secureSendPossibleAddresses.push(requesterAddress)
-    }
-
-    const addressValidationType = checkIfValidationRequired(
-      oldAddresses,
-      secureSendPossibleAddresses,
-      userAddress,
-      secureSendPhoneNumberMapping,
-      e164Number
-    )
-    if (addressValidationType !== AddressValidationType.NONE) {
-      yield* put(requireSecureSend(e164Number, addressValidationType))
-    }
     yield* put(
       updateE164PhoneNumberAddresses(
         e164NumberToAddressUpdates,
@@ -215,13 +176,11 @@ export function* fetchAddressesAndValidateSaga({
         addressToVerifiedByUpdates
       )
     )
-    yield* put(endFetchingAddresses(e164Number, true))
     AppAnalytics.track(IdentityEvents.phone_number_lookup_complete)
   } catch (err) {
     const error = ensureError(err)
     Logger.debug(TAG + '@fetchAddressesAndValidate', `Error fetching addresses`, error)
     yield* put(showErrorOrFallback(error, ErrorMessages.ADDRESS_LOOKUP_FAILURE))
-    yield* put(endFetchingAddresses(e164Number, false))
     AppAnalytics.track(IdentityEvents.phone_number_lookup_error, {
       error: error.message,
     })
@@ -340,51 +299,6 @@ function* fetchAddressVerification(address: string) {
   }
 }
 
-// Only use with multiple addresses if user has
-// gone through SecureSend
-export function getAddressFromPhoneNumber(
-  e164Number: string,
-  e164NumberToAddress: E164NumberToAddressType,
-  secureSendPhoneNumberMapping: SecureSendPhoneNumberMapping,
-  requesterAddress?: string
-): string | null | undefined {
-  const addresses = e164NumberToAddress[e164Number]
-
-  // If there are no verified addresses for the number,
-  // use the requester's given address
-  if (!addresses && requesterAddress) {
-    return requesterAddress
-  }
-
-  // If address is null (unverified) or undefined (in the process
-  // of being updated) then just return that falsy value
-  if (!addresses) {
-    return addresses
-  }
-
-  // If there are multiple addresses, need to determine which to use
-  if (addresses.length > 1) {
-    // Check if the user has gone through Secure Send and validated a
-    // recipient address
-    const validatedAddress = secureSendPhoneNumberMapping[e164Number]
-      ? secureSendPhoneNumberMapping[e164Number].address
-      : undefined
-
-    // If they have not, they shouldn't have been able to
-    // get to this point
-    if (!validatedAddress) {
-      throw new Error(
-        'Multiple addresses but none were validated. Should have routed through Secure Send.'
-      )
-    }
-
-    return validatedAddress
-  }
-
-  // Normal case when there is only one address in the mapping
-  return addresses[0]
-}
-
 export function* saveContacts() {
   try {
     const saveContactsGate = getFeatureGate(StatsigFeatureGates.SAVE_CONTACTS)

package/src/identity/reducer.ts

@@ -1,4 +1,3 @@
-import dotProp from 'dot-prop-immutable'
 import { RehydrateAction } from 'redux-persist'
 import { Actions as AccountActions, ClearStoredAccountAction } from 'src/account/actions'
 import { ActionTypes, Actions } from 'src/identity/actions'
@@ -32,24 +31,6 @@ export interface ImportContactProgress {
   total: number
 }
 
-export enum AddressValidationType {
-  FULL = 'full',
-  PARTIAL = 'partial',
-  NONE = 'none',
-}
-
-export interface SecureSendPhoneNumberMapping {
-  [e164Number: string]: SecureSendDetails
-}
-
-export interface SecureSendDetails {
-  address?: string
-  addressValidationType: AddressValidationType
-  isFetchingAddresses?: boolean
-  lastFetchSuccessful?: boolean
-  validationSuccessful?: boolean
-}
-
 export interface AddressToVerificationStatus {
   [address: string]: boolean | undefined
 }
@@ -67,8 +48,6 @@ interface State {
   // Has the user already been asked for contacts permission
   askedContactsPermission: boolean
   importContactsProgress: ImportContactProgress
-  // Contacts found during the matchmaking process
-  secureSendPhoneNumberMapping: SecureSendPhoneNumberMapping
   // Mapping of address to verification status; undefined entries represent a loading state
   addressToVerificationStatus: AddressToVerificationStatus
   // Mapping of address to the entity that verified it (e.g. "valora", "minipay")
@@ -87,7 +66,6 @@ const initialState: State = {
     current: 0,
     total: 0,
   },
-  secureSendPhoneNumberMapping: {},
   addressToVerificationStatus: {},
   addressToVerifiedBy: {},
   lastSavedContactsHash: null,
@@ -159,66 +137,11 @@ export const reducer = (
           status: success ? ImportContactsStatus.Done : ImportContactsStatus.Failed,
         },
       }
-    case Actions.VALIDATE_RECIPIENT_ADDRESS_SUCCESS:
-      return {
-        ...state,
-        // Overwrite the previous mapping when a new address is validated
-        secureSendPhoneNumberMapping: dotProp.set(
-          state.secureSendPhoneNumberMapping,
-          `${action.e164Number}`,
-          {
-            address: action.validatedAddress,
-            addressValidationType: AddressValidationType.NONE,
-            validationSuccessful: true,
-          }
-        ),
-      }
-    case Actions.VALIDATE_RECIPIENT_ADDRESS_RESET:
-      return {
-        ...state,
-        secureSendPhoneNumberMapping: dotProp.set(
-          state.secureSendPhoneNumberMapping,
-          `${action.e164Number}.validationSuccessful`,
-          false
-        ),
-      }
-    case Actions.REQUIRE_SECURE_SEND:
-      return {
-        ...state,
-        // Erase the previous mapping when new validation is required
-        secureSendPhoneNumberMapping: dotProp.set(
-          state.secureSendPhoneNumberMapping,
-          `${action.e164Number}`,
-          {
-            address: undefined,
-            addressValidationType: action.addressValidationType,
-          }
-        ),
-      }
-    case Actions.FETCH_ADDRESSES_AND_VALIDATION_STATUS:
-      return {
-        ...state,
-        secureSendPhoneNumberMapping: dotProp.set(
-          state.secureSendPhoneNumberMapping,
-          `${action.e164Number}.isFetchingAddresses`,
-          true
-        ),
-      }
-    case Actions.END_FETCHING_ADDRESSES:
-      return {
-        ...state,
-        secureSendPhoneNumberMapping: dotProp.merge(
-          state.secureSendPhoneNumberMapping,
-          `${action.e164Number}`,
-          { isFetchingAddresses: false, lastFetchSuccessful: action.lastFetchSuccessful }
-        ),
-      }
     case AccountActions.CLEAR_STORED_ACCOUNT:
       return {
         ...initialState,
         addressToE164Number: state.addressToE164Number,
         e164NumberToAddress: state.e164NumberToAddress,
-        secureSendPhoneNumberMapping: state.secureSendPhoneNumberMapping,
       }
     case Actions.FETCH_ADDRESS_VERIFICATION_STATUS:
       // If the current status is false or does not exist, we set it to undefined