wallet-stack 1.0.0-alpha.136 → 1.0.0-alpha.138

package/src/send/useRecipientLookup.test.tsx

@@ -0,0 +1,139 @@
+import { act, renderHook } from '@testing-library/react-native'
+import * as React from 'react'
+import { Provider } from 'react-redux'
+import {
+  fetchAddressVerification,
+  fetchAddressesAndValidate,
+  recipientLookupResolved,
+  updateE164PhoneNumberAddresses,
+} from 'src/identity/actions'
+import { Recipient, RecipientType } from 'src/recipients/recipient'
+import { setupStore } from 'src/redux/store'
+import { useRecipientLookup } from 'src/send/useRecipientLookup'
+import { getMockStoreData } from 'test/utils'
+import { mockAccount, mockAccount2, mockE164Number, mockName } from 'test/values'
+
+jest.mock('src/redux/sagas', () => ({
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  rootSaga: jest.fn(function* () {}),
+}))
+
+const phoneRecipient: Recipient & { address: string } = {
+  name: mockName,
+  contactId: 'contactId',
+  e164PhoneNumber: mockE164Number,
+  recipientType: RecipientType.PhoneNumber,
+  address: mockAccount,
+}
+
+const addressRecipient: Recipient & { address: string } = {
+  address: mockAccount,
+  recipientType: RecipientType.Address,
+}
+
+function setupHook(
+  recipient: Recipient & { address: string },
+  options?: { skipFetch?: boolean },
+  storeOverrides: Parameters<typeof getMockStoreData>[0] = {}
+) {
+  const { store } = setupStore(getMockStoreData(storeOverrides))
+  const dispatchSpy = jest.spyOn(store, 'dispatch')
+  const { result, rerender } = renderHook(() => useRecipientLookup(recipient, options), {
+    wrapper: ({ children }: { children: React.ReactNode }) => (
+      <Provider store={store}>{children}</Provider>
+    ),
+  })
+  return { result, rerender, store, dispatchSpy }
+}
+
+describe('useRecipientLookup', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('dispatches fetchAddressesAndValidate for phone recipients', () => {
+    const { dispatchSpy } = setupHook(phoneRecipient)
+    expect(dispatchSpy).toHaveBeenCalledWith(fetchAddressesAndValidate(mockE164Number))
+  })
+
+  it('dispatches fetchAddressVerification for address-only recipients', () => {
+    const { dispatchSpy } = setupHook(addressRecipient)
+    expect(dispatchSpy).toHaveBeenCalledWith(fetchAddressVerification(mockAccount.toLowerCase()))
+  })
+
+  it('does not dispatch when skipFetch is set (caller already triggered the lookup)', () => {
+    const { dispatchSpy } = setupHook(phoneRecipient, { skipFetch: true })
+    expect(dispatchSpy).not.toHaveBeenCalledWith(fetchAddressesAndValidate(mockE164Number))
+  })
+
+  it('reports loading while the lookup is in flight and resolves to unknown when no verifier is recorded', () => {
+    const { result, store } = setupHook(addressRecipient)
+    expect(result.current.status).toBe('loading')
+
+    act(() => {
+      store.dispatch(recipientLookupResolved())
+    })
+    expect(result.current.status).toBe('unknown')
+  })
+
+  it('returns "unverified" for a phone recipient when the lookup resolved with no verified addresses', () => {
+    const { result, store } = setupHook(phoneRecipient, { skipFetch: true })
+    act(() => {
+      store.dispatch(updateE164PhoneNumberAddresses({ [mockE164Number]: null }, {}))
+    })
+    expect(result.current.status).toBe('unverified')
+  })
+
+  it('returns "verified" when the address has a known verifier', () => {
+    const { result } = setupHook(
+      addressRecipient,
+      { skipFetch: true },
+      {
+        identity: {
+          addressToVerifiedBy: { [mockAccount.toLowerCase()]: 'valora' },
+        },
+      }
+    )
+    expect(result.current.status).toBe('verified')
+  })
+
+  it('returns "unverified" when the address is known to be unverified (verifier=null)', () => {
+    const { result } = setupHook(
+      addressRecipient,
+      { skipFetch: true },
+      {
+        identity: {
+          addressToVerifiedBy: { [mockAccount.toLowerCase()]: null },
+        },
+      }
+    )
+    expect(result.current.status).toBe('unverified')
+  })
+
+  it('returns the verified addresses linked to a phone recipient, filtering out unverified ones', () => {
+    const { result, store } = setupHook(
+      phoneRecipient,
+      { skipFetch: true },
+      {
+        identity: {
+          addressToVerifiedBy: {
+            [mockAccount.toLowerCase()]: 'valora',
+            [mockAccount2.toLowerCase()]: null,
+          },
+        },
+      }
+    )
+    act(() => {
+      store.dispatch(
+        updateE164PhoneNumberAddresses(
+          { [mockE164Number]: [mockAccount.toLowerCase(), mockAccount2.toLowerCase()] },
+          {}
+        )
+      )
+    })
+
+    expect(result.current.verifiedAddresses).toEqual([
+      { address: mockAccount.toLowerCase(), verifier: 'valora' },
+    ])
+  })
+})

package/src/send/useRecipientLookup.ts

@@ -0,0 +1,74 @@
+import { useEffect } from 'react'
+import { fetchAddressVerification, fetchAddressesAndValidate } from 'src/identity/actions'
+import type { AddressToVerifiedByType } from 'src/identity/reducer'
+import {
+  addressToVerifiedBySelector,
+  e164NumberToAddressSelector,
+  recipientLookupLoadingSelector,
+} from 'src/identity/selectors'
+import { Recipient } from 'src/recipients/recipient'
+import { type Verifier, isKnownVerifier } from 'src/recipients/verifier'
+import { useDispatch, useSelector } from 'src/redux/hooks'
+
+export type RecipientLookupStatus = 'unknown' | 'loading' | 'verified' | 'unverified'
+
+export interface VerifiedAddressEntry {
+  address: string
+  verifier: Verifier
+}
+
+function getVerifiedAddresses(
+  addresses: readonly string[],
+  addressToVerifiedBy: AddressToVerifiedByType
+): VerifiedAddressEntry[] {
+  return addresses
+    .map((address) => ({ address, verifier: addressToVerifiedBy[address] }))
+    .filter((entry): entry is VerifiedAddressEntry => isKnownVerifier(entry.verifier))
+}
+
+/**
+ * Dispatches a verification lookup for `recipient` and returns the status plus any verified
+ * addresses linked to the phone number. Pass `skipFetch` when the caller has already triggered
+ * a fresh lookup and re-fetching would be wasteful.
+ */
+export function useRecipientLookup(
+  recipient: Recipient & { address: string },
+  options: { skipFetch?: boolean } = {}
+): { status: RecipientLookupStatus; verifiedAddresses: VerifiedAddressEntry[] } {
+  const dispatch = useDispatch()
+  const e164PhoneNumber = recipient.e164PhoneNumber
+  const recipientAddress = recipient.address.toLowerCase()
+  const skipFetch = !!options.skipFetch
+
+  const e164NumberToAddress = useSelector(e164NumberToAddressSelector)
+  const addressToVerifiedBy = useSelector(addressToVerifiedBySelector)
+  const recipientLookupLoading = useSelector(recipientLookupLoadingSelector)
+
+  useEffect(() => {
+    if (skipFetch || !e164PhoneNumber) return
+    dispatch(fetchAddressesAndValidate(e164PhoneNumber))
+  }, [dispatch, e164PhoneNumber, skipFetch])
+
+  useEffect(() => {
+    if (skipFetch || e164PhoneNumber) return
+    dispatch(fetchAddressVerification(recipientAddress))
+  }, [dispatch, e164PhoneNumber, recipientAddress, skipFetch])
+
+  const cachedAddresses = e164PhoneNumber ? e164NumberToAddress[e164PhoneNumber] : undefined
+  const verifiedAddresses = getVerifiedAddresses(cachedAddresses ?? [], addressToVerifiedBy)
+
+  const verifier = addressToVerifiedBy[recipientAddress]
+
+  let status: RecipientLookupStatus
+  if (recipientLookupLoading) {
+    status = 'loading'
+  } else if (isKnownVerifier(verifier)) {
+    status = 'verified'
+  } else if (verifier === null || cachedAddresses === null) {
+    status = 'unverified'
+  } else {
+    status = 'unknown'
+  }
+
+  return { status, verifiedAddresses }
+}