diff --git a/deploy/00_register_legacy.ts b/deploy/00_register_legacy.ts
index 0e996a477..b5e8874bf 100644
--- a/deploy/00_register_legacy.ts
+++ b/deploy/00_register_legacy.ts
@@ -353,6 +353,7 @@ const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
     subnames,
     ...rest
   }: Name) => {
+    // eslint-disable-next-line no-restricted-syntax
     const secret = '0x0000000000000000000000000000000000000000000000000000000000000000'
     const registrant = allNamedAccts[namedOwner]
     const owner = namedController ? allNamedAccts[namedController] : undefined
diff --git a/playwright/pageObjects/ownershipPage.ts b/playwright/pageObjects/ownershipPage.ts
index 868e4b9e9..faa0b61fb 100644
--- a/playwright/pageObjects/ownershipPage.ts
+++ b/playwright/pageObjects/ownershipPage.ts
@@ -44,7 +44,6 @@ export class OwnershipPage {
     const timestamp = await this.page
       .getByTestId('expiry-panel-expiry')
       .getAttribute('data-timestamp')
-    console.log('>>>>', timestamp)
     const parsed = parseInt(timestamp || '')
     return parsed
   }
diff --git a/src/components/@molecules/AvatarWithIdentifier/AvatarWithIdentifier.test.tsx b/src/components/@molecules/AvatarWithIdentifier/AvatarWithIdentifier.test.tsx
index 753d7ab84..8854b4a7e 100644
--- a/src/components/@molecules/AvatarWithIdentifier/AvatarWithIdentifier.test.tsx
+++ b/src/components/@molecules/AvatarWithIdentifier/AvatarWithIdentifier.test.tsx
@@ -3,7 +3,6 @@ import { render, screen} from '@app/test-utils'
 import { AvatarWithIdentifier } from './AvatarWithIdentifier'
 
 const mockUsePrimary = jest.fn().mockImplementation((address) => {
-  console.log('mockUsePrimary', address)
   return ({
   data: address === '0xaddressWithoutAPrimaryName' ? undefined : { beautifiedName: 'test.eth', name: 'test.eth' },
   isLoading: false
diff --git a/src/components/pages/profile/[name]/tabs/MoreTab/MoreTab.tsx b/src/components/pages/profile/[name]/tabs/MoreTab/MoreTab.tsx
index eff1bc18d..5cdf312f6 100644
--- a/src/components/pages/profile/[name]/tabs/MoreTab/MoreTab.tsx
+++ b/src/components/pages/profile/[name]/tabs/MoreTab/MoreTab.tsx
@@ -3,11 +3,7 @@ import styled, { css } from 'styled-components'
 import { CacheableComponent } from '@app/components/@atoms/CacheableComponent'
 import type { useAbilities } from '@app/hooks/abilities/useAbilities'
 import { useNameDetails } from '@app/hooks/useNameDetails'
-import useOwners from '@app/hooks/useOwners'
-import { validateExpiry } from '@app/utils/utils'
 
-import Miscellaneous from './Miscellaneous/Miscellaneous'
-import Ownership from './Ownership'
 import Resolver from './Resolver'
 import Token from './Token/Token'
 
@@ -30,48 +26,11 @@ type Props = {
 }
 
 const MoreTab = ({ name, nameDetails, abilities }: Props) => {
-  const {
-    canBeWrapped,
-    ownerData,
-    wrapperData,
-    dnsOwner,
-    isWrapped,
-    basicIsCachedData,
-    profileIsCachedData,
-    profile,
-    expiryDate,
-    pccExpired,
-  } = nameDetails
-
-  const owners = useOwners({
-    ownerData: ownerData!,
-    wrapperData: wrapperData!,
-    dnsOwner,
-    abilities,
-  })
+  const { canBeWrapped, ownerData, wrapperData, isWrapped, profileIsCachedData, profile } =
+    nameDetails
 
   return (
     <MoreContainer>
-      <Miscellaneous
-        expiryDate={validateExpiry(
-          name,
-          wrapperData,
-          expiryDate || wrapperData?.expiryDate,
-          pccExpired,
-        )}
-        name={name}
-        isCachedData={basicIsCachedData}
-      />
-      {owners && owners.length > 0 && (
-        <Ownership
-          name={name}
-          owners={owners}
-          canSend={abilities.canSend}
-          canSendError={abilities.canSendError}
-          isCachedData={basicIsCachedData}
-          isWrapped={isWrapped}
-        />
-      )}
       {ownerData && (
         <Token
           isWrapped={isWrapped}
diff --git a/src/components/pages/profile/[name]/tabs/OwnershipTab/OwnershipTab.tsx b/src/components/pages/profile/[name]/tabs/OwnershipTab/OwnershipTab.tsx
index 771dcdc66..3d35084d9 100644
--- a/src/components/pages/profile/[name]/tabs/OwnershipTab/OwnershipTab.tsx
+++ b/src/components/pages/profile/[name]/tabs/OwnershipTab/OwnershipTab.tsx
@@ -29,7 +29,6 @@ export const OwnershipTab = ({ name, details }: Props) => {
   const nameType = useNameType(name)
   const warning = useOwnershipWarning({ name, details, nameType })
   const isLoading = roles.isLoading || details.isLoading
-
   if (isLoading) return null
   return (
     <Container>
diff --git a/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/ExpirySection/ExpirySection.test.tsx b/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/ExpirySection/ExpirySection.test.tsx
new file mode 100644
index 000000000..ac44f8935
--- /dev/null
+++ b/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/ExpirySection/ExpirySection.test.tsx
@@ -0,0 +1,58 @@
+import { render, screen, userEvent, waitFor } from '@app/test-utils'
+import { GRACE_PERIOD } from '@app/utils/constants'
+import { ExpirySection } from './ExpirySection';
+
+
+jest.mock('./hooks/useExpiryDetails', () => ({
+  useExpiryDetails: ({name}: any) => {
+    if (name === 'test.eth') return  {
+    data: [{type: 'expiry', date: new Date(3255803954000)}, {type: 'grace-period', date: new Date(3255803954000 + GRACE_PERIOD)}, {type: 'registration', date: new Date(3255803954000)}],
+    isLoading: false
+  }}
+}))
+
+const mockShowInput = jest.fn()
+jest.mock('./hooks/useExpiryActions', () => ({
+  useExpiryActions: ({name}: any) => {
+   if (name === 'test.eth') return [ {
+    label: 'action.setReminder',
+    type: 'set-reminder',
+    icon: <div >ICON</div>,
+    primary: false,
+    expiryDate: new Date()
+  },
+  {
+    label: 'action.extend',
+    type: 'extend',
+    icon: <div>ICON</div>,
+    primary: true,
+    onClick: () => {
+      mockShowInput()
+    },
+  }]}})
+)
+
+describe('ExpirySection', () => {
+  it('should be able to open earnify button modal', async () => {
+    render(<ExpirySection name="test.eth" details={{} as any}/>)
+    expect(screen.getByText('action.setReminder')).toBeVisible()
+    expect(screen.getByText('action.extend')).toBeVisible()
+    await userEvent.click(screen.getByText('action.setReminder'))
+    await waitFor(async () => {
+      expect(screen.getByText('tabs.more.misc.reminderOptions.earnifi')).toBeVisible()
+      await userEvent.click(screen.getByText('tabs.more.misc.reminderOptions.earnifi'))
+    })
+    await waitFor(() => {
+      expect(screen.getByText('tabs.more.misc.earnfi.title')).toBeVisible()
+    })
+  })
+
+  it('should be able to call show extend modal', async () => {
+    render(<ExpirySection name="test.eth" details={{} as any}/>)
+    expect(screen.getByText('action.extend')).toBeVisible()
+    await userEvent.click(screen.getByText('action.extend'))
+    await waitFor(() => {
+      expect(mockShowInput).toHaveBeenCalled()
+    })
+  })
+})
\ No newline at end of file
diff --git a/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/ExpirySection/ExpirySection.tsx b/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/ExpirySection/ExpirySection.tsx
index 5982ca71b..77ae1571f 100644
--- a/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/ExpirySection/ExpirySection.tsx
+++ b/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/ExpirySection/ExpirySection.tsx
@@ -117,11 +117,10 @@ type Props = {
 export const ExpirySection = ({ name, details }: Props) => {
   const { t } = useTranslation('profile')
   const expiry = useExpiryDetails({ name, details })
+  const actions = useExpiryActions({ name, expiryDetails: expiry.data })
 
   const [showEarnifiDialog, setShowEarnifiDialog] = useState(false)
 
-  const actions = useExpiryActions({ name, expiryDetails: expiry.data })
-
   if (!expiry.data || expiry.data?.length === 0) return null
   return (
     <>
diff --git a/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/ExpirySection/components/ExpiryPanel.test.tsx b/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/ExpirySection/components/ExpiryPanel.test.tsx
index 85e6d4364..7a2b4f3be 100644
--- a/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/ExpirySection/components/ExpiryPanel.test.tsx
+++ b/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/ExpirySection/components/ExpiryPanel.test.tsx
@@ -1,6 +1,14 @@
-import { render, screen } from "@app/test-utils"
+import { render, screen, userEvent } from "@app/test-utils"
 import { ExpiryPanel } from "./ExpiryPanel"
 
+jest.mock('@ensdomains/thorin', () => {
+  const _thorin = jest.requireActual('@ensdomains/thorin')
+  return {
+  _esModule: true,
+  ..._thorin,
+  QuestionCircleSVG: () => <div>ICON</div>
+}})
+
 describe('ExpiryPanel', () => {
   it('should render', async () => {
     render(<ExpiryPanel type="expiry" date={new Date(3255803954000)}/>)
@@ -11,4 +19,22 @@ describe('ExpiryPanel', () => {
     render(<ExpiryPanel type="expiry" date={'3255803954000' as any}/>)
     expect(screen.getByTestId('expiry-panel-expiry')).toHaveTextContent(/Mar (2|3|4), 2073/)
   })
+
+  it('should not display link only if link is provided', async () => {
+    const {rerender} = render(<ExpiryPanel type="expiry" date={new Date(3255803954000)} link="https://app.ens.domains"/>)
+    expect(screen.getByText('action.view')).toBeVisible()
+    rerender(<ExpiryPanel type="expiry" date={new Date(3255803954000)}/>)
+    expect(screen.queryByText('action.view')).toEqual(null)
+  })
+
+  it('should not display tooltip only if tooltip is provided', async () => {
+    const {rerender} = render(<ExpiryPanel type="expiry" date={new Date(3255803954000)} tooltip={'TOOLTIP'}/>)
+    expect(screen.getByText('ICON')).toBeVisible()
+    expect(screen.queryByText('TOOLTIP')).toEqual(null)
+    await userEvent.hover(screen.getByText('ICON'))
+    expect(screen.getByText('TOOLTIP')).toBeVisible()
+    rerender(<ExpiryPanel type="expiry" date={new Date(3255803954000)}/>)
+    expect(screen.queryByText('ICON')).toEqual(null)
+    expect(screen.queryByText('TOOLTIP')).toEqual(null)
+  })
 })
\ No newline at end of file
diff --git a/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/ExpirySection/hooks/useExpiryActions.test.tsx b/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/ExpirySection/hooks/useExpiryActions.test.tsx
new file mode 100644
index 000000000..6d12df7f1
--- /dev/null
+++ b/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/ExpirySection/hooks/useExpiryActions.test.tsx
@@ -0,0 +1,24 @@
+import { renderHook } from "@app/test-utils"
+import { useExpiryActions } from "./useExpiryActions"
+
+describe('useExpiryActions', () => {
+  it('should render if expiryDetails contains a expiry type data with a valid expiry date', () => {
+    const { result} = renderHook(() => useExpiryActions({ name: 'test.eth', expiryDetails: [{ type: 'expiry', date: new Date('3255803954000') }]}))
+    expect(result.current).toEqual(expect.arrayContaining([expect.objectContaining({type: 'extend'})]))
+  })
+
+  it('should render null if name is subname and if expiryDetails contains a expiry type data with a valid expiry date', () => {
+    const { result} = renderHook(() => useExpiryActions({ name: 'sub.test.eth', expiryDetails: [{ type: 'expiry', date: new Date('3255803954000') }]}))
+    expect(result.current).toEqual(null)
+  })
+
+  it('should return null if expiryDetails contains a expiry type data but an invalid expiry date', () => {
+    const { result} = renderHook(() => useExpiryActions({ name: 'test.eth', expiryDetails: [{ type: 'expiry', date: undefined }]}))
+    expect(result.current).toEqual(null)
+  })
+
+  it('should return null if expiryDetails does not contain a expiry type data', () => {
+    const { result} = renderHook(() => useExpiryActions({ name: 'test.eth', expiryDetails: [{ type: 'expiry', date: undefined }]}))
+    expect(result.current).toEqual(null)
+  })
+})
\ No newline at end of file
diff --git a/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/ExpirySection/hooks/useExpiryDetails.test.ts b/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/ExpirySection/hooks/useExpiryDetails.test.ts
new file mode 100644
index 000000000..827ce85f9
--- /dev/null
+++ b/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/ExpirySection/hooks/useExpiryDetails.test.ts
@@ -0,0 +1,109 @@
+import { renderHook } from "@testing-library/react-hooks"
+import { useExpiryDetails } from "./useExpiryDetails"
+import { checkETH2LDFromName } from "@app/utils/utils"
+
+const mockUseNameType = jest.fn()
+jest.mock('@app/hooks/useNameType', () => ({
+  useNameType: () => mockUseNameType()
+}))
+
+const mockUseBasicName = jest.fn() 
+jest.mock('@app/hooks/useBasicName', () => ({
+  useBasicName: (_: string, {enabled}: any) => { 
+    return enabled ?  mockUseBasicName() : {isLoading: false} }
+}))
+
+const mockUseRegistrationData = jest.fn().mockReturnValue({
+  data: {
+    registrationDate: new Date(3255803954000),
+    transactionHash: '0xhash'
+  } ,
+  isLoading: false
+})
+jest.mock('@app/hooks/useRegistrationData', () =>  (name: string, {enabled}: any) => enabled && checkETH2LDFromName(name) ? mockUseRegistrationData() : { isLoading: false})
+
+jest.mock('@app/hooks/useChainName', () => ({
+  useChainName: () => 'goerli'
+}))
+
+beforeEach(() => {
+  jest.clearAllMocks()
+})
+
+describe('useExpiryDetails', () => {
+  describe('eth 2lds', () => {
+    ['eth-unwrapped-2ld', 'eth-emancipated-2ld', 'eth-locked-2ld'].forEach((nameType) => {
+      it(`should return expiry, grace-period and `, () => {
+        mockUseNameType.mockReturnValue({
+          data: nameType,
+          isLoading: false
+        })
+        const { result } = renderHook(() => useExpiryDetails({name: 'test.eth', details: {
+          expiryDate: new Date(3255803954000),
+          isLoading: false
+        } as any}))
+
+        expect(mockUseRegistrationData).toHaveBeenCalled()
+        expect(mockUseBasicName).not.toHaveBeenCalled()
+        expect(result.current.data).toEqual(expect.arrayContaining([expect.objectContaining({type: 'expiry'})]))
+        expect(result.current.data).toEqual(expect.arrayContaining([expect.objectContaining({type: 'grace-period'})]))
+        expect(result.current.data).toEqual(expect.arrayContaining([expect.objectContaining({type: 'registration'})]))
+
+      })
+    })
+  })
+
+  describe('pcc burned eth subnamess', () => {
+    ['eth-emancipated-subname', 'eth-locked-subname'].forEach((nameType) => {
+      it(`should return expiry, grace-period and `, () => {
+        mockUseNameType.mockReturnValue({
+          data: nameType,
+          isLoading: false
+        })
+        mockUseBasicName.mockReturnValue({
+          wrapperData: {
+            expiryDate: new Date(3255803954000)
+          },
+          isLoading: false
+        })
+
+        const { result } = renderHook(() => useExpiryDetails({name: 'sub.test.eth', details: {
+          wrapperData: {
+            expiryDate: new Date(3255803954000)
+          },
+          isLoading: false
+        } as any}))
+
+        expect(mockUseRegistrationData).not.toHaveBeenCalled()
+        expect(mockUseBasicName).toHaveBeenCalled()
+        expect(result.current.data).toEqual(expect.arrayContaining([expect.objectContaining({type: 'expiry'})]))
+        expect(result.current.data).toEqual(expect.arrayContaining([expect.objectContaining({type: 'parent-expiry'})]))
+      })
+    })
+  })
+
+  describe('pcc not burned eth subnamess', () => {
+    ['eth-unwrapped-subname', 'eth-wrapped-subname', 'eth-pcc-expired-subname'].forEach((nameType) => {
+      it(`should return expiry, grace-period and `, () => {
+        mockUseNameType.mockReturnValue({
+          data: nameType,
+          isLoading: false
+        })
+        mockUseBasicName.mockReturnValue({
+          expiryDate: new Date(3255803954000),
+          isLoading: false
+        })
+
+        const { result } = renderHook(() => useExpiryDetails({name: 'sub.test.eth', details: {
+          expiryDate: new Date(3255803954000),
+          isLoading: false
+        } as any}))
+
+        expect(mockUseRegistrationData).not.toHaveBeenCalled()
+        expect(mockUseBasicName).toHaveBeenCalled()
+        expect(result.current.data).toEqual(expect.arrayContaining([expect.objectContaining({type: 'parent-grace-period'})]))
+        expect(result.current.data).toEqual(expect.arrayContaining([expect.objectContaining({type: 'parent-expiry'})]))
+      })
+    })
+  })
+})
\ No newline at end of file
diff --git a/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/ExpirySection/hooks/useExpiryDetails.ts b/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/ExpirySection/hooks/useExpiryDetails.ts
index bd81dc961..d323f0633 100644
--- a/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/ExpirySection/hooks/useExpiryDetails.ts
+++ b/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/ExpirySection/hooks/useExpiryDetails.ts
@@ -2,13 +2,14 @@ import { useMemo } from 'react'
 import { useTranslation } from 'react-i18next'
 import { P, match } from 'ts-pattern'
 
+import { useBasicName } from '@app/hooks/useBasicName'
 import { useChainName } from '@app/hooks/useChainName'
 import type { useNameDetails } from '@app/hooks/useNameDetails'
 import { useNameType } from '@app/hooks/useNameType'
-import useParentBasicName from '@app/hooks/useParentBasicName'
 import useRegistrationData from '@app/hooks/useRegistrationData'
 import { GRACE_PERIOD } from '@app/utils/constants'
 import { safeDateObj } from '@app/utils/date'
+import { parentName } from '@app/utils/name'
 import { makeEtherscanLink } from '@app/utils/utils'
 
 type Input = {
@@ -26,9 +27,14 @@ export const useExpiryDetails = ({ name, details }: Input, options: Options = {}
   const { t } = useTranslation('profile')
 
   const nameType = useNameType(name, { enabled })
-  const parentData = useParentBasicName(name)
+  const parentData = useBasicName(parentName(name), {
+    skipGraph: false,
+    enabled: enabled && !!nameType.data && nameType.data!.includes('subname'),
+  })
   const chainName = useChainName()
-  const registrationData = useRegistrationData(name)
+  const registrationData = useRegistrationData(name, {
+    enabled,
+  })
 
   const isLoading =
     nameType.isLoading || details.isLoading || parentData.isLoading || registrationData.isLoading
diff --git a/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/RolesSection/RolesSection.tsx b/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/RolesSection/RolesSection.tsx
index 041f874da..f92ebda7a 100644
--- a/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/RolesSection/RolesSection.tsx
+++ b/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/RolesSection/RolesSection.tsx
@@ -39,7 +39,12 @@ export const RolesSection = ({ name, roles, details }: Props) => {
       <Header count={roles?.filter(({ address }) => !!address).length || 0} />
       <Card.Divider />
       {roles?.map((role) => (
-        <RoleRow key={role.address} {...role} actions={actions.data} details={details} />
+        <RoleRow
+          key={role.address || 'noaddress'}
+          {...role}
+          actions={actions.data}
+          isWrapped={details.isWrapped}
+        />
       ))}
       <Footer>
         {actions.data?.map(({ label, type, primary, icon, disabled = false, onClick }) => {
diff --git a/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/RolesSection/components/RoleRow.test.tsx b/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/RolesSection/components/RoleRow.test.tsx
new file mode 100644
index 000000000..473e37dad
--- /dev/null
+++ b/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/RolesSection/components/RoleRow.test.tsx
@@ -0,0 +1,121 @@
+import { render, userEvent, screen, waitFor } from "@app/test-utils";
+import { RoleRow } from "./RoleRow";
+
+const mockUsePrimary = jest.fn().mockReturnValue({})
+jest.mock('@app/hooks/usePrimary', () => ({
+  usePrimary: () => ({
+    ...mockUsePrimary(),
+    isLoading: false
+  })
+}))
+
+describe('RoleRow', () => {
+  it('should render', () => {
+    render(<RoleRow address="0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC" roles={[]} actions={[]} isWrapped/>)
+  })
+
+  it('should display role tags', () => {
+    render(<RoleRow address="0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC" roles={['manager', 'owner']} actions={[]} isWrapped/>)
+    expect(screen.getByText('roles.owner.title')).toBeVisible()
+    expect(screen.getByText('roles.manager.title')).toBeVisible()
+  })
+
+  it('should display tooltip when hovering role tags', async () => {
+    render(<RoleRow address="0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC" roles={['manager', 'owner']} actions={[]} isWrapped/>)
+    expect(screen.queryByText('roles.owner.description')).toEqual(null)
+    await userEvent.hover(screen.getByText('roles.owner.title'))
+    await waitFor(() => {
+      expect(screen.getByText('roles.owner.description')).toBeVisible()
+    })
+  })
+
+  it('should display dropdown with option to view and copy address', async () => {
+    render(<RoleRow address="0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC" roles={[]} actions={[]} isWrapped/>)
+    await userEvent.click(screen.getByTestId('role-row-button-0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC'))
+    await waitFor(() => {
+      expect(screen.getByText('address.viewAddress')).toBeVisible()
+    })
+    expect(screen.getByText('address.copyAddress')).toBeVisible()
+  })
+
+  it('should display view name and copy name if usePrimary returns a name', async () => {
+    mockUsePrimary.mockReturnValueOnce({data: {name: 'test.eth'}})
+    render(<RoleRow address="0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC" roles={[]} actions={[]} isWrapped/>)
+    await userEvent.click(screen.getByTestId('role-row-button-0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC'))
+    await waitFor(() => {
+      expect(screen.getByText('wallet.viewProfile')).toBeVisible()
+    })
+    expect(screen.getByText('name.copy')).toBeVisible()
+  })
+
+  it('should not display view name and copy name if usePrimary returns no name', async () => {
+    mockUsePrimary.mockReturnValueOnce({data: undefined})
+    render(<RoleRow address="0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC" roles={[]} actions={[]} isWrapped/>)
+    await userEvent.click(screen.getByTestId('role-row-button-0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC'))
+    await waitFor(() => {
+      expect(screen.getByText('address.viewAddress')).toBeVisible()
+    })
+    expect(screen.queryByText('wallet.viewProfile')).toEqual(null)
+    expect(screen.queryByText('name.copy')).toEqual(null)
+  })
+
+  it('should display etherscn  name and copy name if usePrimary returns a name', async () => {
+    mockUsePrimary.mockReturnValueOnce({data: {name: 'test.eth'}})
+    render(<RoleRow address="0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC" roles={[]} actions={[]} isWrapped/>)
+    await userEvent.click(screen.getByTestId('role-row-button-0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC'))
+    await waitFor(() => {
+      expect(screen.getByText('wallet.viewProfile')).toBeVisible()
+    })
+    expect(screen.getByText('name.copy')).toBeVisible()
+  })
+
+  it('should not display view name and copy name if usePrimary returns no name', async () => {
+    mockUsePrimary.mockReturnValueOnce({data: undefined})
+    render(<RoleRow address="0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC" roles={[]} actions={[]} isWrapped/>)
+    await userEvent.click(screen.getByTestId('role-row-button-0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC'))
+    await waitFor(() => {
+      expect(screen.getByText('address.viewAddress')).toBeVisible()
+    })
+    expect(screen.queryByText('wallet.viewProfile')).toEqual(null)
+    expect(screen.queryByText('name.copy')).toEqual(null)
+  })
+
+  it('should display view on etherscan if usePrimary returns name and name is 2LDEth', async () => {
+    mockUsePrimary.mockReturnValueOnce({data: {name: 'test.eth'}})
+    render(<RoleRow address="0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC" roles={[]} actions={[]} isWrapped={false}/>)
+    await userEvent.click(screen.getByTestId('role-row-button-0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC'))
+    await waitFor(() => {
+      expect(screen.getByText('address.viewAddress')).toBeVisible()
+    })
+    expect(screen.queryByText('transaction.viewOnEtherscan')).toBeVisible()
+  })
+
+  it('should display view on etherscan if usePrimary returns subaname and name is wrapped', async () => {
+    mockUsePrimary.mockReturnValueOnce({data: {name: 'sub.test.eth'}})
+    render(<RoleRow address="0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC" roles={[]} actions={[]} isWrapped/>)
+    await userEvent.click(screen.getByTestId('role-row-button-0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC'))
+    await waitFor(() => {
+      expect(screen.getByText('address.viewAddress')).toBeVisible()
+    })
+    expect(screen.queryByText('transaction.viewOnEtherscan')).toBeVisible()
+  })
+
+  it('should display edit roles option if action type `edit-roles`', async () => {
+    mockUsePrimary.mockReturnValueOnce({data: {name: 'sub.test.eth'}})
+    render(<RoleRow address="0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC" roles={[]} actions={[{ label: 'action.editRoles', type: 'edit-roles'} as any]} isWrapped/>)
+    await userEvent.click(screen.getByTestId('role-row-button-0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC'))
+    await waitFor(() => {
+      expect(screen.getByText('address.viewAddress')).toBeVisible()
+    })
+    expect(screen.getByText('action.editRoles')).toBeVisible()
+  })
+
+  it('should display sync manager option if roles includes `manager` and action includes type `sync-manager`', async () => {
+    render(<RoleRow address="0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC" roles={['manager']} actions={[{ label: 'action.syncManager', type: 'sync-manager'} as any]} isWrapped/>)
+    await userEvent.click(screen.getByTestId('role-row-button-0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC'))
+    await waitFor(() => {
+      expect(screen.getByText('address.viewAddress')).toBeVisible()
+    })
+    expect(screen.getByText('action.syncManager')).toBeVisible()
+  })
+})
\ No newline at end of file
diff --git a/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/RolesSection/components/RoleRow.tsx b/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/RolesSection/components/RoleRow.tsx
index 96dde9cad..6e83259fe 100644
--- a/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/RolesSection/components/RoleRow.tsx
+++ b/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/RolesSection/components/RoleRow.tsx
@@ -17,16 +17,15 @@ import {
 } from '@ensdomains/thorin'
 
 import { AvatarWithIdentifier } from '@app/components/@molecules/AvatarWithIdentifier/AvatarWithIdentifier'
+import type { Role } from '@app/hooks/ownership/useRoles/useRoles'
 import { useChainName } from '@app/hooks/useChainName'
 import { useContractAddress } from '@app/hooks/useContractAddress'
-import type { useNameDetails } from '@app/hooks/useNameDetails'
 import { usePrimary } from '@app/hooks/usePrimary'
 import { useRouterWithHistory } from '@app/hooks/useRouterWithHistory'
 import { getDestination } from '@app/routes'
 import { emptyAddress } from '@app/utils/constants'
 import { checkETH2LDFromName, makeEtherscanLink } from '@app/utils/utils'
 
-import type { Role } from '../../../../../../../../../hooks/ownership/useRoles/useRoles'
 import { useRoleActions } from '../hooks/useRoleActions'
 import { RoleTag } from './RoleTag'
 
@@ -63,21 +62,19 @@ type Props = {
   address?: string | null
   roles: Role[]
   actions: ReturnType<typeof useRoleActions>['data']
-  details: ReturnType<typeof useNameDetails>
+  isWrapped: boolean
 }
 
-export const RoleRow = ({ address, roles, actions, details }: Props) => {
+export const RoleRow = ({ address, roles, actions, isWrapped }: Props) => {
   const router = useRouterWithHistory()
   const { t } = useTranslation('common')
 
   const primary = usePrimary(address!, !address)
-
-  const [, copy] = useCopyToClipboard()
-
   const networkName = useChainName()
   const wrapperAddress = useContractAddress('NameWrapper')
   const registrarAddress = useContractAddress('BaseRegistrarImplementation')
-  const { isWrapped } = details
+  const [, copy] = useCopyToClipboard()
+
   const etherscanAction = useMemo(() => {
     const name = primary.data?.name
     if (!name) return null
@@ -88,7 +85,7 @@ export const RoleRow = ({ address, roles, actions, details }: Props) => {
     const tokenId = BigNumber.from(hex).toString()
     const contractAddress = isWrapped ? wrapperAddress : registrarAddress
     return {
-      label: t('transaction.viewOnEtherscan'),
+      label: t('transaction.viewEtherscan', { ns: 'common' }),
       onClick: () =>
         window.open(
           makeEtherscanLink(`${contractAddress}/${tokenId}`, networkName, 'nft'),
@@ -154,7 +151,11 @@ export const RoleRow = ({ address, roles, actions, details }: Props) => {
         </InnerContainer>
         <div>
           <Dropdown items={items} align="right" keepMenuOnTop width={200}>
-            <Button colorStyle="accentSecondary" size="small">
+            <Button
+              data-testid={`role-row-button-${address}`}
+              colorStyle="accentSecondary"
+              size="small"
+            >
               <VerticalDotsSVG />
             </Button>
           </Dropdown>
diff --git a/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/RolesSection/hooks/useRoleActions.test.tsx b/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/RolesSection/hooks/useRoleActions.test.tsx
new file mode 100644
index 000000000..87d772dfa
--- /dev/null
+++ b/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/RolesSection/hooks/useRoleActions.test.tsx
@@ -0,0 +1,169 @@
+import { renderHook } from "@app/test-utils";
+import { useRoleActions } from "./useRoleActions";
+
+const mockUseNameType = jest.fn()
+jest.mock('@app/hooks/useNameType', () => ({
+  useNameType: () => ({...mockUseNameType(), isLoading: false})
+}))
+
+const mockUseAbilites = jest.fn()
+jest.mock('@app/hooks/abilities/useAbilities', () => ({
+  useAbilities: () => ({
+    ...mockUseAbilites(),
+    isLoading: false
+  })
+}))
+
+jest.mock('@app/hooks/useAccountSafely', () => ({
+  useAccountSafely: () => ({address: '0xaccount'})
+}))
+
+const mockCheckCanSend = jest.fn()
+jest.mock('@app/transaction-flow/input/SendName/utils/checkCanSend', () => ({
+  checkCanSend: () => mockCheckCanSend()
+}))
+
+const mockCheckCanSyncManager = jest.fn()
+jest.mock('@app/transaction-flow/input/SyncManager/utils/checkCanSyncManager', () => ({
+  checkCanSyncManager: () => mockCheckCanSyncManager()
+}))
+
+const mockGetAvailableRoles = jest.fn().mockReturnValue([])
+jest.mock('@app/hooks/ownership/useRoles/utils/getAvailableRoles', () => ({
+  getAvailableRoles: () => mockGetAvailableRoles()
+}))
+
+describe('useRoleActions', () => {
+  it('should include the ability to send eth name if checkCanSend return true', async () => {
+    mockCheckCanSend.mockReturnValueOnce(true)
+    const {result} = renderHook(() => useRoleActions({
+      name: 'test.eth',
+      roles: [],
+      details: {
+        ownerData: {
+          owner: '0xowner',
+          ownershipLevel: 'registrar'
+        },
+        isLoading: false
+      } as any
+    }))
+    expect(result.current.data).toEqual(expect.arrayContaining([expect.objectContaining({type: 'send-name'})]))
+    expect(result.current.data).not.toEqual(expect.arrayContaining([expect.objectContaining({type: 'send-dns'})]))
+  })
+
+  it('should include the ability to send dns name if checkCanSend returns true', async () => {
+    mockCheckCanSend.mockReturnValueOnce(true)
+    const {result} = renderHook(() => useRoleActions({
+      name: 'test.com',
+      roles: [],
+      details: {
+        ownerData: {
+          owner: '0xowner',
+          ownershipLevel: 'registrar'
+        },
+        isLoading: false
+      } as any
+    }))
+    expect(result.current.data).toEqual(expect.arrayContaining([expect.objectContaining({type: 'send-dns'})]))
+    expect(result.current.data).not.toEqual(expect.arrayContaining([expect.objectContaining({type: 'send-name'})]))
+  })
+
+  it('should not include the ability to send dns or eth name if checkCanSend returns false', async () => {
+    mockCheckCanSend.mockReturnValueOnce(false)
+    const {result} = renderHook(() => useRoleActions({
+      name: 'test.com',
+      roles: [],
+      details: {
+        ownerData: {
+          owner: '0xowner',
+          ownershipLevel: 'registrar'
+        },
+        isLoading: false
+      } as any
+    }))
+    expect(result.current.data).not.toEqual(expect.arrayContaining([expect.objectContaining({type: 'send-dns'})]))
+    expect(result.current.data).not.toEqual(expect.arrayContaining([expect.objectContaining({type: 'send-name'})]))
+  })
+
+  it('should include the ability to refresh dns name if user is logged in and name is not .eth', async () => {
+    const {result} = renderHook(() => useRoleActions({
+      name: 'test.com',
+      roles: [],
+      details: {
+        ownerData: {
+          owner: '0xowner',
+          ownershipLevel: 'registrar'
+        },
+        isLoading: false
+      } as any
+    }))
+    expect(result.current.data).toEqual(expect.arrayContaining([expect.objectContaining({type: 'refresh-dns'})]))
+  })
+
+  it('should not include the ability to refresh dns name if user is logged in and name is .eth', async () => {
+    const {result} = renderHook(() => useRoleActions({
+      name: 'test.eth',
+      roles: [],
+      details: {
+        isLoading: false
+      } as any
+    }))
+    expect(result.current.data).not.toEqual(expect.arrayContaining([expect.objectContaining({type: 'refresh-dns'})]))
+  })
+
+  it('should include the ability to sync manager if checkCanSyncManager returns true', async () => {
+    mockCheckCanSyncManager.mockReturnValueOnce(true)
+    const {result} = renderHook(() => useRoleActions({
+      name: 'test.com',
+      roles: [],
+      details: {
+        ownerData: {
+          owner: '0xowner',
+          ownershipLevel: 'registrar'
+        },
+        isLoading: false
+      } as any
+    }))
+    expect(result.current.data).toEqual(expect.arrayContaining([expect.objectContaining({type: 'sync-manager'})]))
+  })
+
+  it('should not include the ability to sync manager checkCanSyncManager returns false', async () => {
+    mockCheckCanSyncManager.mockReturnValueOnce(false)
+    const {result} = renderHook(() => useRoleActions({
+      name: 'test.com',
+      roles: [],
+      details: {
+        ownerData: {
+          owner: '0xowner',
+          ownershipLevel: 'registrar'
+        },
+        isLoading: false
+      } as any
+    }))
+    expect(result.current.data).not.toEqual(expect.arrayContaining([expect.objectContaining({type: 'sync-manager'})]))
+  })
+
+  it('should include the ability to edit roles if getAvailableRoles returns at least one result', async () => {
+    mockGetAvailableRoles.mockReturnValueOnce([{ role: 'manager', address: '0xmanager'}])
+    const {result} = renderHook(() => useRoleActions({
+      name: 'test.com',
+      roles: [],
+      details: {
+        isLoading: false
+      } as any
+    }))
+    expect(result.current.data).toEqual(expect.arrayContaining([expect.objectContaining({type: 'edit-roles'})]))
+  })
+
+  it('should not include the ability to edit roles if getAvailableRoles returns at zero result', async () => {
+    mockGetAvailableRoles.mockReturnValueOnce([])
+    const {result} = renderHook(() => useRoleActions({
+      name: 'test.com',
+      roles: [],
+      details: {
+        isLoading: false
+      } as any
+    }))
+    expect(result.current.data).not.toEqual(expect.arrayContaining([expect.objectContaining({type: 'edit-roles'})]))
+  })
+})
\ No newline at end of file
diff --git a/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/RolesSection/hooks/useRoleActions.tsx b/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/RolesSection/hooks/useRoleActions.tsx
index 9761467ff..45f2c1ae4 100644
--- a/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/RolesSection/hooks/useRoleActions.tsx
+++ b/src/components/pages/profile/[name]/tabs/OwnershipTab/sections/RolesSection/hooks/useRoleActions.tsx
@@ -52,9 +52,9 @@ export const useRoleActions = ({ name, roles, details }: Props) => {
   const data = useMemo(() => {
     if (isLoading) return undefined
     const canSend = checkCanSend({ abilities: abilities.data, nameType: nameType.data })
-    const canSendDNS = canSend && nameType.data?.startsWith('dns')
-    const canSendEth = canSend && nameType.data?.startsWith('eth')
-    const canRefreshDNS = !!account.address && nameType.data?.startsWith('dns')
+    const canSendDNS = canSend && name && !name.endsWith('.eth')
+    const canSendEth = canSend && name && name.endsWith('.eth')
+    const canRefreshDNS = !!account.address && name && !name.endsWith('.eth')
     const showSyncManager = checkCanSyncManager({
       address: account.address,
       nameType: nameType.data,
@@ -70,7 +70,7 @@ export const useRoleActions = ({ name, roles, details }: Props) => {
             type: 'send-dns',
             icon: <AeroplaneSVG />,
             label: t('action.send'),
-            onClick: () => showSendNameInput(`send-name`, { name }),
+            onClick: () => showSendNameInput(`send-name-${name}`, { name }),
           }
         : null,
       canRefreshDNS
@@ -88,7 +88,7 @@ export const useRoleActions = ({ name, roles, details }: Props) => {
             icon: <HorizontalOutwardArrowsSVG />,
             label: t('transaction.description.syncManager'),
             onClick: () =>
-              showSyncManagerInput(`sync-manager`, {
+              showSyncManagerInput(`sync-manager-${name}`, {
                 name,
               }),
           }
@@ -98,7 +98,7 @@ export const useRoleActions = ({ name, roles, details }: Props) => {
             type: 'send-name',
             icon: <AeroplaneSVG />,
             label: t('action.send'),
-            onClick: () => showSendNameInput(`send-name`, { name }),
+            onClick: () => showSendNameInput(`send-name-${name}`, { name }),
           }
         : null,
       canEditRoles
@@ -107,7 +107,7 @@ export const useRoleActions = ({ name, roles, details }: Props) => {
             icon: <PersonSVG />,
             label: t('action.editRoles'),
             primary: true,
-            onClick: () => showEditRolesInput(`edit-roles`, { name }),
+            onClick: () => showEditRolesInput(`edit-roles-${name}`, { name }),
           }
         : null,
     ].filter((action) => !!action) as Action[]
diff --git a/src/hooks/abilities/utils/getSendAbilities.test.ts b/src/hooks/abilities/utils/getSendAbilities.test.ts
index 666e01ca3..7c510a571 100644
--- a/src/hooks/abilities/utils/getSendAbilities.test.ts
+++ b/src/hooks/abilities/utils/getSendAbilities.test.ts
@@ -75,6 +75,50 @@ const partialUserStates = {
       },
     },
   },
+  unwrappedDNSOwner: {
+    basicNameData: {
+      ownerData: {
+        ownershipLevel: 'registry',
+        owner: '0xnotOwner'
+      },
+      wrapperData: {
+        parent: {},
+        child: {}
+      }
+    },
+    parentBasicNameData: {
+      ownerData: {
+        ownershipLevel: 'registry',
+        owner: '0xdnsowner'
+      },
+      wrapperData: {
+        parent: {},
+        child: {}
+      }
+    }
+  },
+  unwrappedDNSManager: {
+    basicNameData: {
+      ownerData: {
+        ownershipLevel: 'registry',
+        owner: ownerAddress
+      },
+      wrapperData: {
+        parent: {},
+        child: {}
+      }
+    },
+    parentBasicNameData: {
+      ownerData: {
+        ownershipLevel: 'registry',
+        owner: '0xdnsowner'
+      },
+      wrapperData: {
+        parent: {},
+        child: {}
+      }
+    }
+  },
   unwrappedSubnameManagerHolderUnwrappedParentManager: {
     basicNameData: {
       ownerData: {
@@ -310,6 +354,7 @@ const partialUserStates = {
     parentBasicNameData: {
       ownerData: {
         ownershipLevel: 'registry',
+        owner: '0xnotowner'
       },
       wrapperData: {
         child: {},
@@ -937,6 +982,79 @@ describe('getSendAbilities', () => {
         })
       })
     })
+
+    describe('DNS name', () => {
+      it('for 2ld owner who wants to send owner', () => {
+        const { basicNameData, parentBasicNameData } =
+        userStates.unwrappedDNSOwner
+
+        const result = getSendAbilities({
+          basicNameData,
+          parentBasicNameData,
+          address: account,
+          name: 'nick.com',
+        })
+        expect(result.sendNameFunctionCallDetails?.sendOwner).toEqual(undefined)
+      })
+
+      it('for 2ld owner who wants to send manager', () => {
+        const { basicNameData, parentBasicNameData } =
+        userStates.unwrappedDNSOwner
+
+        const result = getSendAbilities({
+          basicNameData,
+          parentBasicNameData,
+          address: account,
+          name: 'nick.com',
+        })
+        expect(result.sendNameFunctionCallDetails?.sendManager).toEqual(undefined)
+      })
+
+      it('for 2ld manager who wants to send owner', () => {
+        const { basicNameData, parentBasicNameData } =
+        userStates.unwrappedDNSManager
+
+        const result = getSendAbilities({
+          basicNameData,
+          parentBasicNameData,
+          address: account,
+          name: 'nick.com',
+        })
+        expect(result.sendNameFunctionCallDetails?.sendOwner).toEqual(undefined)
+      })
+
+      it('for 2ld manager who wants to send manager', () => {
+        const { basicNameData, parentBasicNameData } =
+        userStates.unwrappedDNSManager
+
+        const result = getSendAbilities({
+          basicNameData,
+          parentBasicNameData,
+          address: account,
+          name: 'nick.com',
+        })
+        expect(result.sendNameFunctionCallDetails?.sendManager).toEqual({
+          contract: 'registry',
+          method: 'setOwner'
+        })
+      })
+
+      it('for 2ld wrapped name manager who wants to send manager', () => {
+        const { basicNameData, parentBasicNameData } =
+        userStates.wrappedNameManager
+
+        const result = getSendAbilities({
+          basicNameData,
+          parentBasicNameData,
+          address: account,
+          name: 'nick.com',
+        })
+        expect(result.sendNameFunctionCallDetails?.sendManager).toEqual({
+          contract: 'nameWrapper',
+          method: 'safeTransferFrom'
+        })
+      })
+    })
   })
   describe('correct permissions', () => {
     it('should return for wrapped name owner', () => {
@@ -1265,5 +1383,56 @@ describe('getSendAbilities', () => {
         })
       })
     })
+
+    describe('DNS names', () => {
+      it('should return for unwrapped DNS name owner', () => {
+        const { basicNameData, parentBasicNameData } =
+        userStates.unwrappedDNSOwner
+
+        const result = getSendAbilities({
+          basicNameData,
+          parentBasicNameData,
+          address: account,
+          name: 'nick.com',
+        })
+        expect(result).toMatchObject({
+          canSend: false,
+        })
+      })
+
+      it('should return for unwrapped DNS name manager', () => {
+        const { basicNameData, parentBasicNameData } =
+        userStates.unwrappedDNSManager
+
+        const result = getSendAbilities({
+          basicNameData,
+          parentBasicNameData,
+          address: account,
+          name: 'nick.com',
+        })
+        expect(result).toMatchObject({
+          canSend: true,
+          canSendManager: true,
+          canSendOwner: false
+        })
+      })
+
+      it('should return for wrapped DNS name manager', () => {
+        const { basicNameData, parentBasicNameData } =
+        userStates.wrappedNameManager
+
+        const result = getSendAbilities({
+          basicNameData,
+          parentBasicNameData,
+          address: account,
+          name: 'nick.com',
+        })
+        expect(result).toMatchObject({
+          canSend: true,
+          canSendManager: true,
+          canSendOwner: false
+        })
+      })
+    })
   })
 })
diff --git a/src/hooks/ownership/useRoles/useRoles.test.ts b/src/hooks/ownership/useRoles/useRoles.test.ts
index 3cb1a2dd9..3f5c4f2c7 100644
--- a/src/hooks/ownership/useRoles/useRoles.test.ts
+++ b/src/hooks/ownership/useRoles/useRoles.test.ts
@@ -1,4 +1,4 @@
-import { mockFunction, renderHook } from '@app/test-utils';
+import { renderHook } from '@app/test-utils';
 import useRoles from './useRoles';
 
 const mockGetRoles = jest.fn().mockReturnValue([
diff --git a/src/hooks/resolver/useResolverIsAuthorized.ts b/src/hooks/resolver/useResolverIsAuthorized.ts
index c94746d3d..13caa958b 100644
--- a/src/hooks/resolver/useResolverIsAuthorized.ts
+++ b/src/hooks/resolver/useResolverIsAuthorized.ts
@@ -77,8 +77,6 @@ const checkIsKnownAuthorizedResolver = (
   return true
 }
 
-// 0xa4b91a01
-
 export const checkInterface = async (contract: Contract) => {
   try {
     const supportsInterface = await contract.supportsInterface('0xf1cb7e06')
diff --git a/src/hooks/resolver/useResolverSupportsInterfaces.test.ts b/src/hooks/resolver/useResolverSupportsInterfaces.test.ts
new file mode 100644
index 000000000..54309aa84
--- /dev/null
+++ b/src/hooks/resolver/useResolverSupportsInterfaces.test.ts
@@ -0,0 +1,43 @@
+import { renderHook } from "@app/test-utils"
+import { useResolverSupportsInterfaces } from "./useResolverSupportsInterfaces"
+import { ResolverInterfaceName } from "@app/constants/resolverInterfaceIds"
+
+const mockSupportsInterface = jest.fn().mockReturnValue(true)
+jest.mock('@ethersproject/contracts', () => ({
+  Contract: class {
+    async supportsInterface() {
+      return mockSupportsInterface()
+    }
+  }
+}))
+
+describe('useResolverSupportsInterface', () => {
+  it('should return object with interface as key and value is true if supportsInterface returns true', async () => {
+    const { result, waitForNextUpdate } = renderHook(() => useResolverSupportsInterfaces({
+      resolverAddress: '0xresolver',
+      interfaces: ['AddressResolver'] as ResolverInterfaceName[]
+    }))
+    await waitForNextUpdate()
+    expect(result.current.data).toEqual({AddressResolver: true})
+  })
+
+  it('should return object with interface as key and value is false if supportsInterface returns false', async () => {
+    mockSupportsInterface.mockReturnValue(false)
+    const { result, waitForNextUpdate } = renderHook(() => useResolverSupportsInterfaces({
+      resolverAddress: '0xresolver',
+      interfaces: ['AddressResolver'] as ResolverInterfaceName[]
+    }))
+    await waitForNextUpdate()
+    expect(result.current.data).toEqual({AddressResolver: false})
+  })
+
+  it('should return object with interface as key and value is false if supportsInterface is rejected', async () => {
+    mockSupportsInterface.mockImplementation(() => Promise.reject())
+    const { result, waitForNextUpdate } = renderHook(() => useResolverSupportsInterfaces({
+      resolverAddress: '0xresolver',
+      interfaces: ['AddressResolver'] as ResolverInterfaceName[]
+    }))
+    await waitForNextUpdate()
+    expect(result.current.data).toEqual({AddressResolver: false})
+  })
+})
\ No newline at end of file
diff --git a/src/hooks/resolver/useResolverSupportsInterface.ts b/src/hooks/resolver/useResolverSupportsInterfaces.ts
similarity index 94%
rename from src/hooks/resolver/useResolverSupportsInterface.ts
rename to src/hooks/resolver/useResolverSupportsInterfaces.ts
index 7dcf4806f..68bc5e9a2 100644
--- a/src/hooks/resolver/useResolverSupportsInterface.ts
+++ b/src/hooks/resolver/useResolverSupportsInterfaces.ts
@@ -51,8 +51,8 @@ export const useResolverSupportsInterfaces = (
       const results = await Promise.allSettled(
         _interfaces.map(async ([i, id]) => {
           try {
-            const suppored = await contract.supportsInterface(id)
-            return [i, suppored]
+            const supported = await contract.supportsInterface(id)
+            return [i, supported]
           } catch {
             return [i, false]
           }
diff --git a/src/hooks/useNameType.test.ts b/src/hooks/useNameType.test.ts
new file mode 100644
index 000000000..7dd29b2a9
--- /dev/null
+++ b/src/hooks/useNameType.test.ts
@@ -0,0 +1,191 @@
+import { renderHook } from "@app/test-utils"
+import { useNameType } from "./useNameType"
+
+const mockBasicData = jest.fn()
+jest.mock('@app/hooks/useBasicName', () => ({
+  useBasicName: () => mockBasicData()
+}))
+
+describe('useNameType', () => {
+  describe('name level', () => {
+    it('should return root', async () => {
+      mockBasicData.mockReturnValue({
+        ownerData: {
+          ownershipLevel: 'namewrapper'
+        },
+        wrapperData: {
+          child: {
+            CANNOT_UNWRAP: true
+          },
+          parent: {
+            PARENT_CANNOT_CONTROL: true
+          }
+        },
+        pccExpired: true
+      })
+      const { result } = renderHook(() => useNameType('[root]'))
+      expect(result.current.data).toEqual('root')
+    })
+
+    it('should return tld', async () => {
+      mockBasicData.mockReturnValue({
+        ownerData: {
+          ownershipLevel: 'namewrapper'
+        },
+        wrapperData: {
+          child: {
+            CANNOT_UNWRAP: true
+          },
+          parent: {
+            PARENT_CANNOT_CONTROL: true
+          }
+        },
+        pccExpired: true
+      })
+      const { result } = renderHook(() => useNameType('eth'))
+      expect(result.current.data).toEqual('tld')
+    })
+
+    it('should return 2ld', async () => {
+      mockBasicData.mockReturnValue({
+        ownerData: {
+          ownershipLevel: 'namewrapper'
+        },
+        wrapperData: {
+          child: {
+            CANNOT_UNWRAP: true
+          },
+          parent: {
+            PARENT_CANNOT_CONTROL: true
+          }
+        },
+        pccExpired: true
+      })
+      const { result } = renderHook(() => useNameType('test.eth'))
+      expect(result.current.data).toEqual('eth-locked-2ld')
+    })
+
+    it('should return dns type', async () => {
+      mockBasicData.mockReturnValue({
+        ownerData: {
+          ownershipLevel: 'namewrapper'
+        },
+        wrapperData: {
+          child: {
+            CANNOT_UNWRAP: true
+          },
+          parent: {
+            PARENT_CANNOT_CONTROL: true
+          }
+        },
+        pccExpired: true
+      })
+      const { result } = renderHook(() => useNameType('sub.test.com'))
+      expect(result.current.data).toEqual('dns-pcc-expired-subname')
+    })
+  })
+
+  describe('wrap level', () => {
+    it('should return unwrapped', async () => {
+      mockBasicData.mockReturnValue({
+        ownerData: {},
+        wrapperData: {
+          child: {},
+          parent: {}
+        },
+        pccExpired: true
+      })
+      const { result } = renderHook(() => useNameType('test.eth'))
+      expect(result.current.data).toEqual('eth-unwrapped-2ld')
+    })
+
+    it('should return wrapped', async () => {
+      mockBasicData.mockReturnValue({
+        ownerData: {
+          ownershipLevel: 'nameWrapper'
+        },
+        wrapperData: {
+          child: {},
+          parent: {}
+        },
+        pccExpired: true
+      })
+      const { result } = renderHook(() => useNameType('test.eth'))
+      expect(result.current.data).toEqual('eth-wrapped-2ld')
+    })
+
+    it('should return emancipated', async () => {
+      mockBasicData.mockReturnValue({
+        ownerData: {
+          ownershipLevel: 'nameWrapper'
+        },
+        wrapperData: {
+          child: {},
+          parent: {
+            PARENT_CANNOT_CONTROL: true
+          }
+        },
+        pccExpired: true
+      })
+      const { result } = renderHook(() => useNameType('test.eth'))
+      expect(result.current.data).toEqual('eth-emancipated-2ld')
+    })
+
+    it('should return locked', async () => {
+      mockBasicData.mockReturnValue({
+        ownerData: {
+          ownershipLevel: 'nameWrapper'
+        },
+        wrapperData: {
+          child: {
+            CANNOT_UNWRAP: true
+          },
+          parent: {
+            PARENT_CANNOT_CONTROL: true
+          }
+        },
+        pccExpired: true
+      })
+      const { result } = renderHook(() => useNameType('test.eth'))
+      expect(result.current.data).toEqual('eth-locked-2ld')
+    })
+
+    it('should return unwrapped subname', async () => {
+      mockBasicData.mockReturnValue({
+        ownerData: {
+          ownershipLevel: 'registry'
+        },
+        wrapperData: {
+          child: {
+            CANNOT_UNWRAP: false
+          },
+          parent: {
+            PARENT_CANNOT_CONTROL: false
+          }
+        },
+        pccExpired: false
+      })
+      const { result } = renderHook(() => useNameType('sub.test.eth'))
+      expect(result.current.data).toEqual('eth-unwrapped-subname')
+    })
+
+    it('should return pcc expired subname', async () => {
+      mockBasicData.mockReturnValue({
+        ownerData: {
+          ownershipLevel: 'nameWrapper'
+        },
+        wrapperData: {
+          child: {
+            CANNOT_UNWRAP: false
+          },
+          parent: {
+            PARENT_CANNOT_CONTROL: false
+          }
+        },
+        pccExpired: true
+      })
+      const { result } = renderHook(() => useNameType('sub.test.eth'))
+      expect(result.current.data).toEqual('eth-pcc-expired-subname')
+    })
+  })
+})
\ No newline at end of file
diff --git a/src/transaction-flow/input/EditRoles/EditRoles-flow.tsx b/src/transaction-flow/input/EditRoles/EditRoles-flow.tsx
index 56d72125f..94103249e 100644
--- a/src/transaction-flow/input/EditRoles/EditRoles-flow.tsx
+++ b/src/transaction-flow/input/EditRoles/EditRoles-flow.tsx
@@ -6,12 +6,12 @@ import { P, match } from 'ts-pattern'
 import { InnerDialog } from '@app/components/@atoms/InnerDialog'
 import { useAbilities } from '@app/hooks/abilities/useAbilities'
 import useRoles, { Role, RoleRecord } from '@app/hooks/ownership/useRoles/useRoles'
+import { getAvailableRoles } from '@app/hooks/ownership/useRoles/utils/getAvailableRoles'
 import { useAccountSafely } from '@app/hooks/useAccountSafely'
 import { useBasicName } from '@app/hooks/useBasicName'
 import { makeTransactionItem } from '@app/transaction-flow/transaction'
 import { TransactionDialogPassthrough } from '@app/transaction-flow/types'
 
-import { getAvailableRoles } from '../../../hooks/ownership/useRoles/utils/getAvailableRoles'
 import { EditRoleView } from './views/EditRoleView/EditRoleView'
 import { MainView } from './views/MainView/MainView'
 
diff --git a/src/transaction-flow/input/EditRoles/EditRoles.test.tsx b/src/transaction-flow/input/EditRoles/EditRoles.test.tsx
new file mode 100644
index 000000000..32a93266e
--- /dev/null
+++ b/src/transaction-flow/input/EditRoles/EditRoles.test.tsx
@@ -0,0 +1,174 @@
+import { render, userEvent, screen, within, waitFor } from "@app/test-utils"
+import EditRoles from './EditRoles-flow'
+
+jest.mock('@app/hooks/useAccountSafely', () => ({
+  useAccountSafely: () => ({ address: '0xowner'})
+}))
+
+jest.mock('@app/hooks/useBasicName', () => ({
+  useBasicName: () => ({
+    ownerData: {
+      owner: '0xmanager',
+      registrant: '0xowner'
+    },
+    isLoading: false
+  })
+}))
+
+jest.mock('@app/hooks/ownership/useRoles/useRoles', () => () => ({
+  data: [
+  {
+    role: 'owner',
+    address: '0xowner'
+  },
+  {
+    role: 'manager',
+    address: '0xmanager'
+  },
+  {
+    role: 'eth-record',
+    address: '0xeth-record'
+  },
+  {
+    role: 'parent-owner',
+    address: '0xparent-address'
+  },
+  {
+    role: 'dns-owner',
+    address: '0xdns-owner'
+  }
+],
+isLoading: false}
+))
+
+jest.mock('@app/hooks/abilities/useAbilities', () => ({
+  useAbilities: () => ({
+    data: {
+      canSendOwner: true,
+      canSendManager: true,
+      canEditRecords: true,
+      sendNameFunctionCallDetails: {
+        sendManager: {
+          contract: 'contract',
+        },
+        sendOwner: {
+          contract: 'contract'
+        }
+      }
+    },
+    isLoading: false
+  })
+}))
+
+let searchData: any[] = []
+jest.mock('@app/transaction-flow/input/EditRoles/hooks/useSimpleSearch.ts', () => ({
+  useSimpleSearch: () => ({
+    mutate: (query: string) => {
+      searchData = [{ name: `${query}.eth`, address: `0x${query}`}]
+    },
+    data: searchData,
+    isLoading: false, 
+    isSuccess: true
+  })
+}))
+
+jest.mock('@app/components/@molecules/AvatarWithIdentifier/AvatarWithIdentifier', () => ({
+  AvatarWithIdentifier: ({name, address}: any) => <div><span>{name}</span><span>{address}</span></div>
+}))
+
+const mockIntersectionObserver = jest.fn().mockReturnValue({
+  observe: () => null,
+  unobserve: () => null,
+  disconnect: () => null,
+})
+window.IntersectionObserver = mockIntersectionObserver
+window.scroll = jest.fn()
+
+const mockDispatch = jest.fn()
+
+describe('EditRoles', () => {
+  it('should dispatch a transaction for each role changed', async () => {
+    render(<EditRoles data={{name: 'test.eth'}} dispatch={mockDispatch} onDismiss={() => {}} />)
+    await userEvent.click(within(screen.getByTestId('role-card-owner')).getByTestId('role-card-change-button'))
+    await userEvent.type(screen.getByTestId('edit-roles-search-input'), 'nick')
+    await waitFor(() => {
+      expect(screen.getByTestId('search-result-0xnick')).toBeVisible()
+    })
+    await userEvent.click(screen.getByTestId('search-result-0xnick'))
+
+    await userEvent.click(within(screen.getByTestId('role-card-manager')).getByTestId('role-card-change-button'))
+    await userEvent.type(screen.getByTestId('edit-roles-search-input'), 'nick')
+    await waitFor(() => {
+      expect(screen.getByTestId('search-result-0xnick')).toBeVisible()
+    })
+    await userEvent.click(screen.getByTestId('search-result-0xnick'))
+
+    await userEvent.click(within(screen.getByTestId('role-card-eth-record')).getByTestId('role-card-change-button'))
+    await userEvent.type(screen.getByTestId('edit-roles-search-input'), 'nick')
+    await waitFor(() => {
+      expect(screen.getByTestId('search-result-0xnick')).toBeVisible()
+    })
+    await userEvent.click(screen.getByTestId('search-result-0xnick'))
+    await waitFor(() => {
+      expect(screen.getByTestId('edit-roles-save-button')).toBeVisible()
+    })
+    await userEvent.click(screen.getByTestId('edit-roles-save-button'))
+    expect(mockDispatch).toHaveBeenCalledWith({"name": "setTransactions", "payload": [{"data": {"address": "0xnick", "name": "test.eth"}, "name": "updateEthAddress"}, {"data": {"contract": "contract", "name": "test.eth", "newOwner": "0xnick", "reclaim": false, "sendType": "sendManager"}, "name": "transferName"}, {"data": {"contract": "contract", "name": "test.eth", "newOwner": "0xnick", "sendType": "sendOwner"}, "name": "transferName"}]})
+  })
+
+  it('should not be able to set a role to the existing address', async () => {
+    render(<EditRoles data={{name: 'test.eth'}} dispatch={mockDispatch} onDismiss={() => {}} />)
+    await userEvent.click(within(screen.getByTestId('role-card-owner')).getByTestId('role-card-change-button'))
+    await userEvent.type(screen.getByTestId('edit-roles-search-input'), 'owner')
+    await waitFor(() => {
+      expect(screen.getByTestId('search-result-0xowner')).toBeDisabled()
+    })
+    await userEvent.click(screen.getByRole('button', {name: 'action.cancel'}))
+
+    await userEvent.click(within(screen.getByTestId('role-card-manager')).getByTestId('role-card-change-button'))
+    await userEvent.type(screen.getByTestId('edit-roles-search-input'), 'manager')
+    await waitFor(() => {
+      expect(screen.getByTestId('search-result-0xmanager')).toBeDisabled()
+    })
+    await userEvent.click(screen.getByRole('button', {name: 'action.cancel'}))
+
+    await userEvent.click(within(screen.getByTestId('role-card-eth-record')).getByTestId('role-card-change-button'))
+    await userEvent.type(screen.getByTestId('edit-roles-search-input'), 'eth-record')
+    await waitFor(() => {
+      expect(screen.getByTestId('search-result-0xeth-record')).toBeDisabled()
+    })
+    await userEvent.click(screen.getByRole('button', {name: 'action.cancel'}))
+  })
+
+  it('should show shortcuts for setting to self or setting to 0x0', async () => {
+    render(<EditRoles data={{name: 'test.eth'}} dispatch={mockDispatch} onDismiss={() => {}} />)
+    // Change owner first
+    await userEvent.click(within(screen.getByTestId('role-card-owner')).getByTestId('role-card-change-button'))
+    await userEvent.type(screen.getByTestId('edit-roles-search-input'), 'dave')
+    await waitFor(() => {
+      expect(screen.getByTestId('search-result-0xdave')).toBeVisible()
+    })
+    await userEvent.click(screen.getByTestId('search-result-0xdave'))
+
+    // Change owner should not have any shortcuts
+    await userEvent.click(within(screen.getByTestId('role-card-owner')).getByTestId('role-card-change-button'))
+    expect(screen.queryByTestId('edit-roles-set-to-self-button')).toEqual(null)
+    expect(screen.queryByRole('button', { name: 'action.remove'})).toEqual(null)
+    await userEvent.click(screen.getByRole('button', {name: 'action.cancel'}))
+
+    // Manager set to self
+    await userEvent.click(within(screen.getByTestId('role-card-manager')).getByTestId('role-card-change-button'))
+    await userEvent.click(screen.getByTestId('edit-roles-set-to-self-button'))
+    expect(within(screen.getByTestId('role-card-manager')).getByText('0xowner')).toBeVisible()
+
+    // Eth-record set to self
+    await userEvent.click(within(screen.getByTestId('role-card-eth-record')).getByTestId('role-card-change-button'))
+    await userEvent.click(screen.getByTestId('edit-roles-set-to-self-button'))
+    expect(within(screen.getByTestId('role-card-eth-record')).getByText('0xowner')).toBeVisible()
+
+    // Eth-record remove
+    await userEvent.click(within(screen.getByTestId('role-card-eth-record')).getByTestId('role-card-change-button'))
+    await userEvent.click(screen.getByRole('button', {name: 'action.remove'}))
+    expect(within(screen.getByTestId('role-card-eth-record')).getByText('None set')).toBeVisible()
+  })
+})
\ No newline at end of file
diff --git a/src/transaction-flow/input/EditRoles/views/EditRoleView/views/EditRoleIntroView.tsx b/src/transaction-flow/input/EditRoles/views/EditRoleView/views/EditRoleIntroView.tsx
index 81750b110..eb6d0880b 100644
--- a/src/transaction-flow/input/EditRoles/views/EditRoleView/views/EditRoleIntroView.tsx
+++ b/src/transaction-flow/input/EditRoles/views/EditRoleView/views/EditRoleIntroView.tsx
@@ -52,9 +52,9 @@ export const EditRoleIntroView = ({ role, address, onSelect }: Props) => {
   const { t } = useTranslation('transactionFlow')
   const account = useAccountSafely()
 
-  const showIntro = !!account.address && account.address !== address
   const showRemove = SHOW_REMOVE_ROLES.includes(role) && !!address && address !== emptyAddress
-  const showSetToSelf = SHOW_SET_TO_SELF_ROLES.includes(role)
+  const showSetToSelf = SHOW_SET_TO_SELF_ROLES.includes(role) && account.address !== address
+  const showIntro = showRemove || showSetToSelf
 
   if (!account.address) return null
   return (
diff --git a/src/transaction-flow/input/SendName-flow.tsx b/src/transaction-flow/input/SendName-flow.tsx
deleted file mode 100644
index 930856b5f..000000000
--- a/src/transaction-flow/input/SendName-flow.tsx
+++ /dev/null
@@ -1,271 +0,0 @@
-import { useForm } from 'react-hook-form'
-import { useTranslation } from 'react-i18next'
-import styled, { css } from 'styled-components'
-import { useAccount } from 'wagmi'
-
-import { Button, Dialog, Helper, Toggle, Typography, mq } from '@ensdomains/thorin'
-
-import { Spacer } from '@app/components/@atoms/Spacer'
-import { DogFood } from '@app/components/@molecules/DogFood'
-import { Outlink } from '@app/components/Outlink'
-import { useAbilities } from '@app/hooks/abilities/useAbilities'
-import { useBasicName } from '@app/hooks/useBasicName'
-import { TransactionDialogPassthrough } from '@app/transaction-flow/types'
-import { getSupportLink } from '@app/utils/supportLinks'
-
-import { makeTransactionItem } from '../transaction'
-
-type Data = {
-  name: string
-  type?: 'manager' | 'owner'
-}
-
-type FormData = {
-  managerChoice: string
-  ownerChoice: string
-  dogfoodRaw: string
-  address: string
-}
-
-export type Props = {
-  data: Data
-} & TransactionDialogPassthrough
-
-type BasicNameData = ReturnType<typeof useBasicName>
-
-const SwitchBox = styled.div(
-  ({ theme }) => css`
-    display: flex;
-    align-items: center;
-    justify-content: flex-end;
-    gap: ${theme.space['4']};
-    padding: 20px;
-    width: 100%;
-    border-radius: ${theme.radii.extraLarge};
-    border: ${theme.borderWidths.px} ${theme.borderStyles.solid} ${theme.colors.border};
-  `,
-)
-
-const TextContainer = styled.div`
-  display: flex;
-  flex-direction: column;
-  flex: 1;
-`
-
-const Form = styled.form(
-  () => css`
-    width: 100%;
-  `,
-)
-
-export const handleSubmitForm = ({
-  basicNameData,
-  dispatch,
-  newOwner,
-  managerChoice,
-  ownerChoice,
-  canSendOwner,
-  canSendManager,
-  name,
-  address,
-  sendNameFunctionCallDetails,
-}: {
-  basicNameData: BasicNameData
-  dispatch: TransactionDialogPassthrough['dispatch']
-  newOwner: string
-  managerChoice: string
-  ownerChoice: string
-  canSendOwner: boolean
-  canSendManager: boolean
-  name: string
-  address: string
-  sendNameFunctionCallDetails: NonNullable<
-    ReturnType<typeof useAbilities>['data']
-  >['sendNameFunctionCallDetails']
-}) => {
-  const { ownerData } = basicNameData
-  const isOwnerOrManager = ownerData?.owner === address || ownerData?.registrant === address
-  const transactions = []
-  if (canSendManager && managerChoice === 'manager' && sendNameFunctionCallDetails?.sendManager) {
-    transactions.push(
-      makeTransactionItem(isOwnerOrManager ? 'transferName' : 'transferSubname', {
-        name,
-        newOwner,
-        contract: sendNameFunctionCallDetails.sendManager.contract,
-        sendType: 'sendManager',
-        reclaim: sendNameFunctionCallDetails.sendManager.method === 'reclaim',
-      }),
-    )
-  }
-
-  if (canSendOwner && ownerChoice === 'owner' && sendNameFunctionCallDetails?.sendOwner) {
-    transactions.push(
-      makeTransactionItem(isOwnerOrManager ? 'transferName' : 'transferSubname', {
-        name,
-        newOwner,
-        contract: sendNameFunctionCallDetails.sendOwner!.contract,
-        sendType: 'sendOwner',
-      }),
-    )
-  }
-
-  if (transactions.length === 0) return true
-
-  dispatch({
-    name: 'setTransactions',
-    payload: transactions,
-  })
-  dispatch({ name: 'setFlowStage', payload: 'transaction' })
-}
-
-const InnerContainer = styled.div(({ theme }) => [
-  css`
-    width: 100%;
-  `,
-  mq.sm.min(css`
-    width: calc(80vw - 2 * ${theme.space['6']});
-    max-width: 510px;
-  `),
-])
-
-const FooterContainer = styled.div`
-  display: flex;
-  align-items: center;
-  justify-content: center;
-`
-
-export const SendName = ({ data, dispatch, onDismiss }: Props) => {
-  const { name } = data
-  const { t } = useTranslation('profile')
-  const basicNameData = useBasicName(name as string, { skipGraph: false })
-  const { address = '' } = useAccount()
-
-  const {
-    register,
-    watch,
-    getFieldState,
-    handleSubmit,
-    setValue,
-    getValues,
-    setError,
-    formState,
-    trigger,
-  } = useForm<FormData>({
-    mode: 'onChange',
-    defaultValues: {
-      managerChoice: 'manager',
-      ownerChoice: 'owner',
-      dogfoodRaw: '',
-      address: '',
-    },
-  })
-
-  const managerChoiceWatch = watch('managerChoice')
-  const ownerChoiceWatch = watch('ownerChoice')
-  const abilities = useAbilities(name)
-  const { canSendManager, canSendOwner, sendNameFunctionCallDetails } = abilities.data || {}
-  const loadingAbilities = abilities.isLoading
-  const hasChoice =
-    (canSendManager && managerChoiceWatch) || (canSendOwner && ownerChoiceWatch) || loadingAbilities
-
-  const hasErrors = Object.keys(formState.errors || {}).length > 0
-
-  const onSubmit = (formData: any) => {
-    handleSubmitForm({
-      basicNameData,
-      dispatch,
-      newOwner: formData.address,
-      managerChoice: formData.managerChoice,
-      ownerChoice: formData.ownerChoice,
-      canSendOwner: !!canSendOwner,
-      canSendManager: !!canSendManager,
-      name,
-      address,
-      sendNameFunctionCallDetails,
-    })
-  }
-
-  return (
-    <>
-      <Typography fontVariant="headingFour">{t('details.sendName.title')}</Typography>
-      <Typography style={{ textAlign: 'center' }}>{t('details.sendName.description')}</Typography>
-      <Outlink href={getSupportLink('managersAndOwners')}>
-        {t('details.sendName.learnMore')}
-      </Outlink>
-      {canSendOwner && (
-        <SwitchBox>
-          <TextContainer>
-            <Typography weight="bold">{t('details.sendName.makeOwner')}</Typography>
-            <Typography fontVariant="small">
-              {t('details.sendName.makeOwnerDescription')}
-            </Typography>
-          </TextContainer>
-          <Toggle
-            size="large"
-            value="owner"
-            defaultChecked
-            data-testid="owner-checkbox"
-            {...register('ownerChoice', { shouldUnregister: true })}
-          />
-        </SwitchBox>
-      )}
-      {canSendManager && (
-        <SwitchBox>
-          <TextContainer>
-            <Typography weight="bold">{t('details.sendName.makeManager')}</Typography>
-            <Typography fontVariant="small">
-              {t('details.sendName.makeManagerDescription')}
-            </Typography>
-          </TextContainer>
-          <Toggle
-            size="large"
-            value="manager"
-            defaultChecked
-            data-testid="manager-checkbox"
-            {...register('managerChoice', { shouldUnregister: true })}
-          />
-        </SwitchBox>
-      )}
-      <Form onSubmit={handleSubmit(onSubmit)}>
-        <InnerContainer>
-          <DogFood
-            {...{
-              register,
-              getFieldState,
-              watch,
-              setValue,
-              getValues,
-              setError,
-              label: 'Send to',
-              formState,
-              trigger,
-            }}
-          />
-        </InnerContainer>
-        {!hasChoice && (
-          <>
-            <Spacer $height="3" />
-            <Helper type="error">{t('errors.ownerManagerChoice')}</Helper>
-          </>
-        )}
-        <Spacer $height="3" />
-        <FooterContainer>
-          <Dialog.Footer
-            leading={
-              <Button colorStyle="accentSecondary" onClick={onDismiss}>
-                {t('action.cancel', { ns: 'common' })}
-              </Button>
-            }
-            trailing={
-              <Button type="submit" disabled={!hasChoice || !formState.isDirty || hasErrors}>
-                {t('action.next', { ns: 'common' })}
-              </Button>
-            }
-          />
-        </FooterContainer>
-      </Form>
-    </>
-  )
-}
-
-export default SendName
diff --git a/src/transaction-flow/input/SendName/SendName-flow.tsx b/src/transaction-flow/input/SendName/SendName-flow.tsx
index 81b210a5a..5e00bbf2e 100644
--- a/src/transaction-flow/input/SendName/SendName-flow.tsx
+++ b/src/transaction-flow/input/SendName/SendName-flow.tsx
@@ -5,7 +5,7 @@ import { P, match } from 'ts-pattern'
 import { InnerDialog } from '@app/components/@atoms/InnerDialog'
 import { useAbilities } from '@app/hooks/abilities/useAbilities'
 import useRoles from '@app/hooks/ownership/useRoles/useRoles'
-import { useResolverSupportsInterfaces } from '@app/hooks/resolver/useResolverSupportsInterface'
+import { useResolverSupportsInterfaces } from '@app/hooks/resolver/useResolverSupportsInterfaces'
 import { useAccountSafely } from '@app/hooks/useAccountSafely'
 import { useBasicName } from '@app/hooks/useBasicName'
 import { useNameType } from '@app/hooks/useNameType'
@@ -139,7 +139,6 @@ const SendName = ({ data: { name }, dispatch, onDismiss }: Props) => {
         : null,
     ].filter((transaction) => !!transaction)
 
-    console.log('_transactions', _transactions)
     if (_transactions.length === 0) return
 
     dispatch({
diff --git a/src/transaction-flow/input/SendName/SendName.test.tsx b/src/transaction-flow/input/SendName/SendName.test.tsx
new file mode 100644
index 000000000..fb002f7e4
--- /dev/null
+++ b/src/transaction-flow/input/SendName/SendName.test.tsx
@@ -0,0 +1,106 @@
+import { render, userEvent, screen } from '@app/test-utils'
+import SendName from './SendName-flow' 
+
+jest.mock('@app/hooks/useAccountSafely', () => ({
+  useAccountSafely: () => ({ address: '0xowner'})
+}))
+
+jest.mock('@app/hooks/useBasicName', () => ({
+  useBasicName: () => ({
+    ownerData: {
+      owner: '0xmanager',
+      registrant: '0xowner'
+    },
+    isLoading: false
+  })
+}))
+
+jest.mock('@app/hooks/ownership/useRoles/useRoles', () => () => ({
+  data: [
+  {
+    role: 'owner',
+    address: '0xowner'
+  },
+  {
+    role: 'manager',
+    address: '0xmanager'
+  },
+  {
+    role: 'eth-record',
+    address: '0xeth-record'
+  },
+  {
+    role: 'parent-owner',
+    address: '0xparent-address'
+  },
+  {
+    role: 'dns-owner',
+    address: '0xdns-owner'
+  }
+],
+isLoading: false}
+))
+
+jest.mock('@app/hooks/abilities/useAbilities', () => ({
+  useAbilities: () => ({
+    data: {
+      canSendOwner: true,
+      canSendManager: true,
+      canEditRecords: true,
+      sendNameFunctionCallDetails: {
+        sendManager: {
+          contract: 'contract',
+        },
+        sendOwner: {
+          contract: 'contract'
+        }
+      }
+    },
+    isLoading: false
+  })
+}))
+
+let searchData: any[] = []
+jest.mock('@app/transaction-flow/input/EditRoles/hooks/useSimpleSearch.ts', () => ({
+  useSimpleSearch: () => ({
+    mutate: (query: string) => {
+      searchData = [{ name: `${query}.eth`, address: `0x${query}`}]
+    },
+    data: searchData,
+    isLoading: false, 
+    isSuccess: true
+  })
+}))
+
+jest.mock('@app/components/@molecules/AvatarWithIdentifier/AvatarWithIdentifier', () => ({
+  AvatarWithIdentifier: ({name, address}: any) => <div><span>{name}</span><span>{address}</span></div>
+}))
+
+const mockIntersectionObserver = jest.fn().mockReturnValue({
+  observe: () => null,
+  unobserve: () => null,
+  disconnect: () => null,
+})
+window.IntersectionObserver = mockIntersectionObserver
+window.scroll = jest.fn()
+
+const mockDispatch = jest.fn()
+
+afterEach(() => {
+  jest.clearAllMocks()
+})
+
+describe('SendName', () => {
+  it('should', async () => {
+    render(<SendName data={{name: 'test.eth'}} dispatch={mockDispatch} onDismiss={() => {}}/>)
+    await userEvent.type(screen.getByTestId('send-name-search-input'), 'owner')
+    await userEvent.click(screen.getByTestId('search-result-0xnick'))
+    
+  })
+
+  it('should disable the row if it is the current send role ', async () => {
+    render(<SendName data={{name: 'test.eth'}} dispatch={mockDispatch} onDismiss={() => {}}/>)
+    await userEvent.type(screen.getByTestId('send-name-search-input'), 'owner')
+    expect(screen.getByTestId('search-result-0xowner')).toBeDisabled()
+  })
+})
\ No newline at end of file
diff --git a/src/transaction-flow/input/SendName/views/SearchView/components/SearchViewResult.tsx b/src/transaction-flow/input/SendName/views/SearchView/components/SearchViewResult.tsx
index 03c6e2d87..a79a22e84 100644
--- a/src/transaction-flow/input/SendName/views/SearchView/components/SearchViewResult.tsx
+++ b/src/transaction-flow/input/SendName/views/SearchView/components/SearchViewResult.tsx
@@ -63,8 +63,6 @@ type Props = {
 export const SearchViewResult = ({ address, name, excludeRole: role, roles, ...props }: Props) => {
   const { t } = useTranslation('transactionFlow')
   const markers = useMemo(() => {
-    console.log('markers', roles, address)
-    console.log('address', address)
     const userRoles = roles.filter((r) => r.address?.toLowerCase() === address.toLowerCase())
     const hasRole = userRoles.some((r) => r.role === role)
     const primaryRole = userRoles[0]
diff --git a/src/transaction-flow/input/SendName/views/SummaryView/SummaryView.tsx b/src/transaction-flow/input/SendName/views/SummaryView/SummaryView.tsx
index 3cb33af1f..d5647b781 100644
--- a/src/transaction-flow/input/SendName/views/SummaryView/SummaryView.tsx
+++ b/src/transaction-flow/input/SendName/views/SummaryView/SummaryView.tsx
@@ -49,7 +49,6 @@ export const SummaryView = ({ name, canResetProfile, onNext, onBack }: Props) =>
   const { control, register } = useFormContext<SendNameForm>()
   const recipient = useWatch({ control, name: 'recipient' })
   const expiry = useExpiry(name)
-  console.log('expiry', expiry)
 
   const isLoading = expiry.loading
   if (isLoading) return null
diff --git a/src/utils/date.test.ts b/src/utils/date.test.ts
index c122fc9c3..242fc027d 100644
--- a/src/utils/date.test.ts
+++ b/src/utils/date.test.ts
@@ -11,7 +11,6 @@ describe('safeDateObj', () => {
 
   it('should return a date object for a string timestamp', () => {
     const test = new Date('3255803954000')
-    console.log(!Number.isNaN(test))
     expect(safeDateObj('3255803954000')?.getTime()).toEqual(new Date(3255803954000).getTime())
   })