Feat: custom ENS lookup for Sepolia

src/services/ens/config.ts

@@ -0,0 +1,6 @@
+/**
+ * @see https://docs.ens.domains/ens-deployments
+ */
+export const CUSTOM_REGISTRIES: Record<string, string> = {
+  '11155111': '0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e', // ENS on Sepolia
+}

src/services/ens/custom.ts

@@ -0,0 +1,25 @@
+import { type JsonRpcProvider } from '@ethersproject/providers'
+import { Contract, utils, constants } from 'ethers'
+
+// ENS Registry ABI (simplified version)
+const ensRegistryAbi = ['function resolver(bytes32 node) external view returns (address)']
+const resolverAbi = ['function addr(bytes32 node) external view returns (address)']
+
+export const customResolveName = async (
+  registryAddress: string,
+  rpcProvider: JsonRpcProvider,
+  name: string,
+): Promise<string | undefined> => {
+  const ensRegistry = new Contract(registryAddress, ensRegistryAbi, rpcProvider)
+  const namehash = utils.namehash(name)
+  const resolverAddress = await ensRegistry.resolver(namehash)
+
+  if (resolverAddress === constants.AddressZero) {
+    return undefined
+  }
+
+  const resolver = new Contract(resolverAddress, resolverAbi, rpcProvider)
+  const address = await resolver.addr(namehash)
+
+  return address || undefined
+}

src/services/__tests__/ens.test.ts → src/services/ens/index.test.ts

@@ -1,23 +1,29 @@
 import { type JsonRpcProvider } from '@ethersproject/providers'
-import { resolveName, lookupAddress, isDomain } from '../ens'
+import { resolveName, lookupAddress, isDomain } from '.'
 import { logError } from '../exceptions'
 
 // mock rpcProvider
 const rpcProvider = {
   resolveName: jest.fn(() => Promise.resolve('0x0000000000000000000000000000000000000000')),
   lookupAddress: jest.fn(() => Promise.resolve('safe.eth')),
+  getNetwork: jest.fn(() => Promise.resolve({ chainId: 1 })),
 } as unknown as JsonRpcProvider
 
 const badRpcProvider = {
   resolveName: jest.fn(() => Promise.reject(new Error('bad resolveName'))),
   lookupAddress: jest.fn(() => Promise.reject(new Error('bad lookupAddress'))),
+  getNetwork: jest.fn(() => Promise.resolve({ chainId: 1 })),
 } as unknown as JsonRpcProvider
 
 // mock logError
 jest.mock('../exceptions', () => ({
   logError: jest.fn(),
 }))
 
+jest.mock('./custom', () => ({
+  customResolveName: jest.fn(() => Promise.resolve('0x0000001111111111111111111111111111111111')),
+}))
+
 describe('domains', () => {
   describe('isDomain', () => {
     it('should check the domain format', async () => {
@@ -39,6 +45,15 @@ describe('domains', () => {
       expect(address).toBe(undefined)
       expect(logError).toHaveBeenCalledWith('101: Failed to resolve the address', 'bad resolveName')
     })
+
+    it('should look up names on Sepolia', async () => {
+      // mock rpcProvider
+      const rpcProvider = {
+        getNetwork: jest.fn(() => Promise.resolve({ chainId: 11155111 })),
+      } as unknown as JsonRpcProvider
+
+      expect(await resolveName(rpcProvider, 'sepolia.eth')).toBe('0x0000001111111111111111111111111111111111')
+    })
   })
 
   describe('lookupAddress', () => {

src/services/ens.ts → src/services/ens/index.ts

@@ -1,6 +1,8 @@
 import { type JsonRpcProvider } from '@ethersproject/providers'
-import { logError } from './exceptions'
-import ErrorCodes from './exceptions/ErrorCodes'
+import { logError } from '../exceptions'
+import ErrorCodes from '../exceptions/ErrorCodes'
+import { CUSTOM_REGISTRIES } from './config'
+import { customResolveName } from './custom'
 
 type EthersError = Error & {
   reason?: string
@@ -14,7 +16,18 @@ export function isDomain(domain: string): boolean {
 }
 
 export const resolveName = async (rpcProvider: JsonRpcProvider, name: string): Promise<string | undefined> => {
+  let chainId = ''
   try {
+    chainId = (await rpcProvider.getNetwork()).chainId.toString()
+  } catch {}
+
+  try {
+    // Try custom resolvers first
+    if (chainId && CUSTOM_REGISTRIES[chainId]) {
+      return await customResolveName(CUSTOM_REGISTRIES[chainId], rpcProvider, name)
+    }
+
+    // The default ENS resolver
     return (await rpcProvider.resolveName(name)) || undefined
   } catch (e) {
     const err = e as EthersError