Merge pull request #1105 from ensdomains/fix/primary-name-address-mismatch

fix: verify ETH address record matches in usePrimaryName mismatch case

Author: laurgk

e2e/specs/stateless/setPrimary.spec.ts

@@ -2,11 +2,12 @@ import { expect } from '@playwright/test'
 import { labelhash } from 'viem'
 
 import { getResolver } from '@ensdomains/ensjs/public'
-import { setPrimaryName } from '@ensdomains/ensjs/wallet'
+import { setPrimaryName, setRecords } from '@ensdomains/ensjs/wallet'
 
 import { test } from '../../../playwright'
 import { createAccounts } from '../../../playwright/fixtures/accounts'
 import {
+  testClient,
   waitForTransaction,
   walletClient,
 } from '../../../playwright/fixtures/contracts/utils/addTestContracts'
@@ -487,4 +488,130 @@ test.describe('profile', () => {
       accounts.getAddress('user2', 5),
     )
   })
+
+  test('should not show primary name when ETH address record points to different address', async ({
+    page,
+    login,
+    makeName,
+    accounts,
+    time,
+  }) => {
+    test.slow()
+
+    // Step 1: Create a name owned by user with ETH record pointing to user's own address
+    const name = await makeName({
+      label: 'primary-mismatch',
+      type: 'legacy',
+      owner: 'user',
+      manager: 'user',
+      addr: 'user', // Initially points to user's own address
+    })
+
+    const userAddress = accounts.getAddress('user')
+    const user2Address = accounts.getAddress('user2')
+
+    // Step 2: Set this name as primary name for user
+    const tx = await setPrimaryName(walletClient, {
+      name,
+      account: createAccounts().getAddress('user') as `0x${string}`,
+    })
+    await waitForTransaction(tx)
+
+    await page.goto('/')
+    await login.connect()
+
+    // Step 3: Verify primary name shows on user's address page
+    await page.getByPlaceholder('Search for a name').fill(userAddress)
+    await page.getByPlaceholder('Search for a name').press('Enter')
+    await expect(page.getByTestId('profile-snippet')).toBeVisible({ timeout: 25000 })
+    await expect(page.getByTestId('profile-title')).toHaveText(name)
+
+    // Step 4: Change the ETH address record to point to user2's address
+    const tx2 = await setRecords(walletClient, {
+      name,
+      coins: [
+        {
+          coin: 'eth',
+          value: user2Address,
+        },
+      ],
+      resolverAddress: walletClient.chain.contracts.legacyPublicResolver.address,
+      account: accounts.getAddress('user') as `0x${string}`,
+    })
+    await waitForTransaction(tx2)
+
+    await testClient.mine({ blocks: 1 })
+    await time.sync()
+
+    await page.reload()
+
+    // Step 5: Verify primary name NO LONGER shows on user's address page
+    await page.getByPlaceholder('Search for a name').fill(userAddress)
+    await page.getByPlaceholder('Search for a name').press('Enter')
+    await expect(page.getByTestId('no-profile-snippet')).toBeVisible({ timeout: 25000 })
+    await expect(page.getByText('No primary name set')).toBeVisible()
+  })
+
+  test('name-wrapper - should not show primary name when ETH address record points to different address', async ({
+    page,
+    login,
+    makeName,
+    accounts,
+    time,
+    makePageObject,
+  }) => {
+    test.slow()
+
+    // Step 1: Create a name owned by user with ETH record pointing to user's own address
+    const name = await makeName({
+      label: 'primary-mismatch',
+      type: 'wrapped',
+      owner: 'user',
+      addr: accounts.getAddress('user') as `0x${string}`,
+    })
+
+    const userAddress = accounts.getAddress('user')
+    const user2Address = accounts.getAddress('user2')
+
+    await page.goto('/')
+    await login.connect()
+
+    const profilePage = makePageObject('ProfilePage')
+
+    await profilePage.goto(name)
+    await page.getByText('Set as primary name').click()
+    const transactionModal = makePageObject('TransactionModal')
+    await transactionModal.autoComplete()
+
+    // Step 3: Verify primary name shows on user's address page
+    await page.getByPlaceholder('Search for a name').fill(userAddress)
+    await page.getByPlaceholder('Search for a name').press('Enter')
+    await expect(page.getByTestId('profile-snippet')).toBeVisible({ timeout: 25000 })
+    await expect(page.getByTestId('profile-title')).toHaveText(name)
+
+    // Step 4: Change the ETH address record to point to user2's address
+    const tx2 = await setRecords(walletClient, {
+      name,
+      coins: [
+        {
+          coin: 'eth',
+          value: user2Address,
+        },
+      ],
+      resolverAddress: walletClient.chain.contracts.ensPublicResolver.address as `0x${string}`,
+      account: accounts.getAddress('user') as `0x${string}`,
+    })
+    await waitForTransaction(tx2)
+
+    await testClient.mine({ blocks: 1 })
+    await time.sync()
+
+    await page.reload()
+
+    // Step 5: Verify primary name NO LONGER shows on user's address page
+    await page.getByPlaceholder('Search for a name').fill(userAddress)
+    await page.getByPlaceholder('Search for a name').press('Enter')
+    await expect(page.getByTestId('no-profile-snippet')).toBeVisible({ timeout: 25000 })
+    await expect(page.getByText('No primary name set')).toBeVisible()
+  })
 })

src/hooks/ensjs/public/usePrimaryName.test.ts

@@ -2,7 +2,7 @@ import { mockFunction } from '@app/test-utils'
 
 import { describe, expect, it, vi } from 'vitest'
 
-import { getName } from '@ensdomains/ensjs/public'
+import { getAddressRecord, getName } from '@ensdomains/ensjs/public'
 
 import { ClientWithEns, ConfigWithEns } from '@app/types'
 
@@ -11,6 +11,7 @@ import { getPrimaryNameQueryFn } from './usePrimaryName'
 vi.mock('@ensdomains/ensjs/public')
 
 const mockGetName = mockFunction(getName)
+const mockGetAddressRecord = mockFunction(getAddressRecord)
 
 const address = '0xaddress'
 const chainId = 1
@@ -96,6 +97,14 @@ describe('getPrimaryNameQueryFn', () => {
         reverseResolverAddress: '0xreverseResolver',
       }),
     )
+    // Mock getAddressRecord to return the same address so the check passes
+    mockGetAddressRecord.mockImplementationOnce(() =>
+      Promise.resolve({
+        id: 60,
+        name: 'eth',
+        value: address,
+      }),
+    )
     const result = await getPrimaryNameQueryFn(mockConfig)({
       queryKey: [{ address, allowMismatch: true }, chainId, address, undefined, 'getName'],
       meta: {} as any,
@@ -122,6 +131,14 @@ describe('getPrimaryNameQueryFn', () => {
         reverseResolverAddress: '0xreverseResolver',
       }),
     )
+    // Mock getAddressRecord to return the same address so the check passes
+    mockGetAddressRecord.mockImplementationOnce(() =>
+      Promise.resolve({
+        id: 60,
+        name: 'eth',
+        value: address,
+      }),
+    )
     const result = await getPrimaryNameQueryFn(mockConfig)({
       queryKey: [{ address, allowMismatch: true }, chainId, address, undefined, 'getName'],
       meta: {} as any,
@@ -164,4 +181,31 @@ describe('getPrimaryNameQueryFn', () => {
       }
     `)
   })
+
+  it('should return null when allowMismatch is true but ETH address record points to different address', async () => {
+    const differentAddress = '0x1234567890123456789012345678901234567890'
+
+    mockGetName.mockImplementationOnce(() =>
+      Promise.resolve({
+        name: 'test.eth',
+        match: false,
+        resolverAddress: '0xresolver',
+        reverseResolverAddress: '0xreverseResolver',
+      }),
+    )
+    // Mock getAddressRecord to return a DIFFERENT address
+    mockGetAddressRecord.mockImplementationOnce(() =>
+      Promise.resolve({
+        id: 60,
+        name: 'eth',
+        value: differentAddress, // ← Points to different address!
+      }),
+    )
+    const result = await getPrimaryNameQueryFn(mockConfig)({
+      queryKey: [{ address, allowMismatch: true }, chainId, address, undefined, 'getName'],
+      meta: {} as any,
+      signal: undefined as any,
+    })
+    expect(result).toBeNull() // Should return null because address doesn't match
+  })
 })

src/hooks/ensjs/public/usePrimaryName.ts

@@ -3,7 +3,12 @@ import { ContractFunctionExecutionError } from 'viem'
 import { readContract } from 'viem/actions'
 
 import { universalResolverReverseSnippet } from '@ensdomains/ensjs/contracts'
-import { getName, GetNameParameters, GetNameReturnType } from '@ensdomains/ensjs/public'
+import {
+  getAddressRecord,
+  getName,
+  GetNameParameters,
+  GetNameReturnType,
+} from '@ensdomains/ensjs/public'
 import { normalise } from '@ensdomains/ensjs/utils'
 
 import { useQueryOptions } from '@app/hooks/useQueryOptions'
@@ -83,14 +88,13 @@ export const getPrimaryNameQueryFn =
             try {
               const normalizedVersion = normalise(originalName)
               isNormalized = originalName === normalizedVersion
-            } catch (error) {
+            } catch {
               // If normalisation fails, treat as non-normalized
               isNormalized = false
             }
           }
         }
-      } catch (error) {
-        console.error('Failed to get raw reverse name:', error)
+      } catch {
         // Fall back to checking if res.name is normalized
         try {
           const normalizedVersion = normalise(res.name)
@@ -101,6 +105,18 @@ export const getPrimaryNameQueryFn =
       }
     } else {
       // For mismatch case, res.name is already the raw name
+      // Check if the ETH address record for the name matches the input address
+      try {
+        const ethAddressRecord = await getAddressRecord(client, { name: res.name })
+        const resolvedAddress = ethAddressRecord?.value
+
+        if (!resolvedAddress || resolvedAddress.toLowerCase() !== address.toLowerCase()) {
+          return null
+        }
+      } catch {
+        return null
+      }
+
       originalName = res.name
       isNormalized = false // Mismatches are treated as non-normalized
     }