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

package/src/identity/contactMapping.test.ts

@@ -6,17 +6,15 @@ import { call, select } from 'redux-saga/effects'
 import { setUserContactDetails } from 'src/account/actions'
 import { defaultCountryCodeSelector, e164NumberSelector } from 'src/account/selectors'
 import { showError, showErrorOrFallback } from 'src/alert/actions'
-import { IdentityEvents } from 'src/analytics/Events'
 import AppAnalytics from 'src/analytics/AppAnalytics'
+import { IdentityEvents } from 'src/analytics/Events'
 import { ErrorMessages } from 'src/app/ErrorMessages'
 import { phoneNumberVerifiedSelector } from 'src/app/selectors'
 import {
   Actions,
-  addressVerificationStatusReceived,
   contactsSaved,
   fetchAddressVerification,
   fetchAddressesAndValidate,
-  requireSecureSend,
   updateE164PhoneNumberAddresses,
 } from 'src/identity/actions'
 import {
@@ -25,12 +23,11 @@ import {
   fetchAddressesAndValidateSaga,
   saveContacts,
 } from 'src/identity/contactMapping'
-import { AddressValidationType } from 'src/identity/reducer'
 import {
-  addressToVerificationStatusSelector,
+  addressToE164NumberSelector,
+  addressToVerifiedBySelector,
   e164NumberToAddressSelector,
   lastSavedContactsHashSelector,
-  secureSendPhoneNumberMappingSelector,
 } from 'src/identity/selectors'
 import { retrieveSignedMessage } from 'src/pincode/authentication'
 import { contactsToRecipients } from 'src/recipients/recipient'
@@ -97,19 +94,21 @@ describe('Fetch Addresses Saga', () => {
       mockFetch.resetMocks()
     })
 
+    const emptyMappingProviders: [any, any][] = [
+      [select(e164NumberToAddressSelector), {}],
+      [select(addressToE164NumberSelector), {}],
+      [select(addressToVerifiedBySelector), {}],
+    ]
+
     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],
+          ...emptyMappingProviders,
           [select(walletAddressSelector), '0xxyz'],
           [call(retrieveSignedMessage), 'some signed message'],
-          [select(secureSendPhoneNumberMappingSelector), {}],
         ])
         .put(updateE164PhoneNumberAddresses({ [mockE164Number]: undefined }, {}))
         .put(
@@ -135,18 +134,14 @@ 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],
+          ...emptyMappingProviders,
+          [select(walletAddressSelector), '0xxyz'],
           [call(retrieveSignedMessage), 'some signed message'],
-          [select(secureSendPhoneNumberMappingSelector), {}],
         ])
         .put(updateE164PhoneNumberAddresses({ [mockE164Number]: undefined }, {}))
         .put(
@@ -156,14 +151,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 +171,9 @@ describe('Fetch Addresses Saga', () => {
 
       await expectSaga(fetchAddressesAndValidateSaga, fetchAddressesAndValidate(mockE164Number))
         .provide([
-          [select(e164NumberToAddressSelector), mockE164NumberToAddress],
-          [select(walletAddressSelector), mockAccount],
+          ...emptyMappingProviders,
+          [select(walletAddressSelector), '0xxyz'],
           [call(retrieveSignedMessage), 'some signed message'],
-          [select(secureSendPhoneNumberMappingSelector), {}],
         ])
         .put(updateE164PhoneNumberAddresses({ [mockE164Number]: undefined }, {}))
         .put(
@@ -193,20 +183,48 @@ describe('Fetch Addresses Saga', () => {
             { '0xabc': 'valora', '0xdef': 'minipay' }
           )
         )
-        .put(requireSecureSend(mockE164Number, AddressValidationType.PARTIAL))
+        .run()
+    })
+
+    it('prunes stale address mappings no longer returned by the fresh lookup', async () => {
+      mockFetch.mockResponseOnce(
+        JSON.stringify({
+          data: {
+            addresses: ['0xkept'],
+            verifiedAddresses: [{ address: '0xkept', verifiedBy: 'valora' }],
+          },
+        })
+      )
+
+      await expectSaga(fetchAddressesAndValidateSaga, fetchAddressesAndValidate(mockE164Number))
+        .provide([
+          [select(e164NumberToAddressSelector), { [mockE164Number]: ['0xstale', '0xkept'] }],
+          [
+            select(addressToE164NumberSelector),
+            { '0xstale': mockE164Number, '0xkept': mockE164Number },
+          ],
+          [select(addressToVerifiedBySelector), { '0xstale': 'valora', '0xkept': 'valora' }],
+          [select(walletAddressSelector), '0xxyz'],
+          [call(retrieveSignedMessage), 'some signed message'],
+        ])
+        .put(updateE164PhoneNumberAddresses({ [mockE164Number]: undefined }, {}))
+        .put(
+          updateE164PhoneNumberAddresses(
+            { [mockE164Number]: ['0xkept'] },
+            { '0xstale': null, '0xkept': mockE164Number },
+            { '0xstale': null, '0xkept': 'valora' }
+          )
+        )
         .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],
+          ...emptyMappingProviders,
+          [select(walletAddressSelector), '0xxyz'],
           [call(retrieveSignedMessage), 'some signed message'],
         ])
         .put(showErrorOrFallback(expect.anything(), ErrorMessages.ADDRESS_LOOKUP_FAILURE))
@@ -220,48 +238,64 @@ describe('Fetch Address Verification Saga', () => {
     mockFetch.resetMocks()
   })
 
-  it('fetches and stores verified address', async () => {
-    mockFetch.mockResponseOnce(JSON.stringify({ data: { addressVerified: true } }))
+  it('records the `verifiedBy` value returned by the backend', async () => {
+    mockFetch.mockResponseOnce(
+      JSON.stringify({ data: { addressVerified: true, verifiedBy: 'minipay' } })
+    )
 
     await expectSaga(fetchAddressVerificationSaga, fetchAddressVerification(mockAccount))
       .provide([
-        [select(addressToVerificationStatusSelector), {}],
         [select(walletAddressSelector), '0xxyz'],
         [call(retrieveSignedMessage), 'some signed message'],
       ])
-      .put(addressVerificationStatusReceived(mockAccount, true))
+      .put(updateE164PhoneNumberAddresses({}, {}, { [mockAccount.toLowerCase()]: 'minipay' }))
       .run()
 
     expect(mockFetch).toHaveBeenCalledTimes(1)
     expect(mockFetch).toHaveBeenCalledWith(
-      `${networkConfig.checkAddressVerifiedUrl}?address=${mockAccount}&clientPlatform=android&clientVersion=0.0.1`,
-      {
+      `${networkConfig.checkAddressVerifiedUrl}?address=${mockAccount.toLowerCase()}&clientPlatform=android&clientVersion=0.0.1`,
+      expect.objectContaining({
         method: 'GET',
-        headers: {
-          'Content-Type': 'application/json',
+        headers: expect.objectContaining({
           authorization: `${networkConfig.authHeaderIssuer} 0xxyz:some signed message`,
-        },
-        signal: expect.any(AbortSignal),
-      }
+        }),
+      })
     )
   })
 
-  it('skips fetching if address already known', async () => {
+  it('falls back to `valora` when the backend confirms the address without a `verifiedBy` field', async () => {
+    mockFetch.mockResponseOnce(JSON.stringify({ data: { addressVerified: true } }))
+
     await expectSaga(fetchAddressVerificationSaga, fetchAddressVerification(mockAccount))
-      .provide([[select(addressToVerificationStatusSelector), { [mockAccount]: true }]])
+      .provide([
+        [select(walletAddressSelector), '0xxyz'],
+        [call(retrieveSignedMessage), 'some signed message'],
+      ])
+      .put(updateE164PhoneNumberAddresses({}, {}, { [mockAccount.toLowerCase()]: 'valora' }))
       .run()
+  })
 
-    expect(mockFetch).toHaveBeenCalledTimes(0)
+  it('records `null` (checked, not verified) when the backend returns false', async () => {
+    mockFetch.mockResponseOnce(JSON.stringify({ data: { addressVerified: false } }))
+
+    await expectSaga(fetchAddressVerificationSaga, fetchAddressVerification(mockAccount))
+      .provide([
+        [select(walletAddressSelector), '0xxyz'],
+        [call(retrieveSignedMessage), 'some signed message'],
+      ])
+      .put(updateE164PhoneNumberAddresses({}, {}, { [mockAccount.toLowerCase()]: null }))
+      .run()
   })
 
-  it('handles errors gracefully', async () => {
+  it('does not touch `addressToVerifiedBy` on network errors — the check is inconclusive, not negative', async () => {
     mockFetch.mockReject()
     await expectSaga(fetchAddressVerificationSaga, fetchAddressVerification(mockAccount))
       .provide([
-        [select(addressToVerificationStatusSelector), {}],
         [select(walletAddressSelector), '0xxyz'],
         [call(retrieveSignedMessage), 'some signed message'],
       ])
+      .not.put.actionType(Actions.UPDATE_E164_PHONE_NUMBER_ADDRESSES)
+      .put(showErrorOrFallback(expect.anything(), ErrorMessages.ADDRESS_LOOKUP_FAILURE))
       .run()
     expect(AppAnalytics.track).toHaveBeenCalledWith(IdentityEvents.address_lookup_error, {
       error: 'Unable to fetch verification status for this address',

package/src/identity/contactMapping.ts

@@ -11,26 +11,21 @@ import {
   Actions,
   FetchAddressVerificationAction,
   FetchAddressesAndValidateAction,
-  addressVerificationStatusReceived,
   contactsSaved,
-  endFetchingAddresses,
   endImportContacts,
-  requireSecureSend,
   updateE164PhoneNumberAddresses,
   updateImportContactsProgress,
 } from 'src/identity/actions'
 import {
   AddressToE164NumberType,
-  AddressValidationType,
+  AddressToVerifiedByType,
   E164NumberToAddressType,
-  SecureSendPhoneNumberMapping,
 } from 'src/identity/reducer'
-import { checkIfValidationRequired } from 'src/identity/secureSend'
 import {
-  addressToVerificationStatusSelector,
+  addressToE164NumberSelector,
+  addressToVerifiedBySelector,
   e164NumberToAddressSelector,
   lastSavedContactsHashSelector,
-  secureSendPhoneNumberMappingSelector,
 } from 'src/identity/selectors'
 import { ImportContactsStatus } from 'src/identity/types'
 import { retrieveSignedMessage } from 'src/pincode/authentication'
@@ -144,17 +139,17 @@ 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] || []
+
+    // Snapshot the previous mappings before we clear them so we can prune stale entries
+    // after the fresh response arrives (see the pruning block below).
+    const prevE164NumberToAddress = yield* select(e164NumberToAddressSelector)
+    const prevAddressToE164Number = yield* select(addressToE164NumberSelector)
+    const prevAddressToVerifiedBy = yield* select(addressToVerifiedBySelector)
+    const prevAddresses = prevE164NumberToAddress[e164Number] ?? []
 
     // Clear existing entries for those numbers so our mapping consumers know new status is pending.
     yield* put(updateE164PhoneNumberAddresses({ [e164Number]: undefined }, {}))
@@ -165,10 +160,26 @@ export function* fetchAddressesAndValidateSaga({
     // it includes addresses verified by both CPV and SocialConnect.
     // The `addresses` field is used for backward compatibility.
     const walletAddresses = verifiedAddresses ? verifiedAddresses.map((v) => v.address) : addresses
+    const walletAddressSet = new Set(walletAddresses)
 
     const e164NumberToAddressUpdates: E164NumberToAddressType = {}
     const addressToE164NumberUpdates: AddressToE164NumberType = {}
-    const addressToVerifiedByUpdates: Record<string, string> = {}
+    const addressToVerifiedByUpdates: AddressToVerifiedByType = {}
+
+    // Prune addresses previously associated with this phone number but no longer present
+    // in the fresh response.
+    for (const prevAddress of prevAddresses) {
+      if (!walletAddressSet.has(prevAddress)) {
+        // Clear the reverse mapping for this number.
+        if (prevAddressToE164Number[prevAddress] === e164Number) {
+          addressToE164NumberUpdates[prevAddress] = null
+        }
+        // Clear verifier info.
+        if (prevAddress in prevAddressToVerifiedBy) {
+          addressToVerifiedByUpdates[prevAddress] = null
+        }
+      }
+    }
 
     if (verifiedAddresses) {
       for (const { address, verifiedBy } of verifiedAddresses) {
@@ -186,28 +197,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 +204,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,
     })
@@ -229,14 +216,20 @@ export function* fetchAddressesAndValidateSaga({
 }
 
 export function* fetchAddressVerificationSaga({ address }: FetchAddressVerificationAction) {
+  const normalizedAddress = address.toLowerCase()
   try {
-    const addressToVerificationStatus = yield* select(addressToVerificationStatusSelector)
-    if (!(address in addressToVerificationStatus && addressToVerificationStatus[address])) {
-      AppAnalytics.track(IdentityEvents.address_lookup_start)
-      const addressVerified = yield* call(fetchAddressVerification, address)
-      yield* put(addressVerificationStatusReceived(address, addressVerified))
-      AppAnalytics.track(IdentityEvents.address_lookup_complete)
-    }
+    AppAnalytics.track(IdentityEvents.address_lookup_start)
+    const { addressVerified, verifiedBy } = yield* call(fetchAddressVerification, normalizedAddress)
+    // Older backend responses omit `verifiedBy` and only signal Valora-verified addresses,
+    // so fall back to 'valora' when verification is confirmed without a verifier.
+    yield* put(
+      updateE164PhoneNumberAddresses(
+        {},
+        {},
+        { [normalizedAddress]: addressVerified ? (verifiedBy ?? 'valora') : null }
+      )
+    )
+    AppAnalytics.track(IdentityEvents.address_lookup_complete)
   } catch (err) {
     const error = ensureError(err)
     Logger.debug(
@@ -244,13 +237,8 @@ export function* fetchAddressVerificationSaga({ address }: FetchAddressVerificat
       `Error fetching address verification`,
       error
     )
-    AppAnalytics.track(IdentityEvents.address_lookup_error, {
-      error: error.message,
-    })
-    // Setting this address to "false" does not mean that the address
-    // if definitely unverified; we set it to false to indicate that
-    // the request is finished, and possibly unverified.
-    yield* put(addressVerificationStatusReceived(address, false))
+    yield* put(showErrorOrFallback(error, ErrorMessages.ADDRESS_LOOKUP_FAILURE))
+    AppAnalytics.track(IdentityEvents.address_lookup_error, { error: error.message })
   }
 }
 
@@ -332,59 +320,15 @@ function* fetchAddressVerification(address: string) {
       )
     }
 
-    const { data }: { data: { addressVerified: boolean } } = yield* call([response, 'json'])
-    return data.addressVerified
+    const { data }: { data: { addressVerified: boolean; verifiedBy?: string | null } } =
+      yield* call([response, 'json'])
+    return { addressVerified: data.addressVerified, verifiedBy: data.verifiedBy }
   } catch (error) {
     Logger.warn(`${TAG}/fetchAddressVerification`, 'Unable to look up address', error)
     throw new Error('Unable to fetch verification status for this address')
   }
 }
 
-// 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,30 +31,11 @@ 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
-}
-
 export interface AddressToVerifiedByType {
-  [address: string]: string | undefined
+  // undefined = never checked / unknown
+  // null      = checked, no known verifier
+  // string    = checked, verified by that verifier (e.g. "valora", "minipay")
+  [address: string]: string | null | undefined
 }
 
 interface State {
@@ -67,10 +47,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")
   addressToVerifiedBy: AddressToVerifiedByType
   lastSavedContactsHash: string | null
@@ -87,8 +63,6 @@ const initialState: State = {
     current: 0,
     total: 0,
   },
-  secureSendPhoneNumberMapping: {},
-  addressToVerificationStatus: {},
   addressToVerifiedBy: {},
   lastSavedContactsHash: null,
   shouldRefreshStoredPasswordHash: false,
@@ -159,83 +133,18 @@ 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
-      // to mark it as being in a loading state.
       return {
         ...state,
-        addressToVerificationStatus: {
-          ...state.addressToVerificationStatus,
-          [action.address]: state.addressToVerificationStatus[action.address] || undefined,
-        },
-      }
-    case Actions.ADDRESS_VERIFICATION_STATUS_RECEIVED:
-      return {
-        ...state,
-        addressToVerificationStatus: {
-          ...state.addressToVerificationStatus,
-          [action.address]: action.addressVerified,
+        addressToVerifiedBy: {
+          ...state.addressToVerifiedBy,
+          [action.address]: undefined,
         },
       }
     case Actions.CONTACTS_SAVED: