@ensdomains/ensjs 3.0.0-alpha.6 → 3.0.0-alpha.61

package/src/functions/getProfile.ts

@@ -1,9 +1,11 @@
 import { formatsByName } from '@ensdomains/address-encoder'
-import { ethers } from 'ethers'
+import { defaultAbiCoder } from '@ethersproject/abi'
+import { isAddress } from '@ethersproject/address'
+import { hexStripZeros, isBytesLike } from '@ethersproject/bytes'
 import { ENSArgs } from '..'
 import { decodeContenthash, DecodedContentHash } from '../utils/contentHash'
 import { hexEncodeName } from '../utils/hexEncodedName'
-import { parseInputType } from '../utils/validation'
+import { namehash } from '../utils/normalise'
 
 type InternalProfileOptions = {
   contentHash?: boolean | string | DecodedContentHash
@@ -17,6 +19,12 @@ type ProfileResponse = {
   coinTypes?: string[]
 }
 
+type FallbackRecords = {
+  contentHash?: boolean
+  texts?: string[]
+  coinTypes?: string[]
+}
+
 type DataItem = {
   key: string | number
   type: 'addr' | 'text' | 'contentHash'
@@ -29,6 +37,7 @@ type ResolvedProfile = {
   createdAt: string | null
   address?: string
   name?: string | null
+  decryptedName?: string | null
   match?: boolean
   message?: string
   records?: {
@@ -37,63 +46,70 @@ type ResolvedProfile = {
     coinTypes?: DataItem[]
   }
   resolverAddress?: string
+  isInvalidResolverAddress?: boolean
   reverseResolverAddress?: string
 }
 
+type CallObj = {
+  key: string
+  data: {
+    to: string
+    data: string
+  }
+  type: 'addr' | 'text' | 'contentHash'
+}
+
 const makeMulticallData = async (
   {
     _getAddr,
     _getContentHash,
     _getText,
-    resolverMulticallWrapper,
-  }: ENSArgs<
-    '_getText' | '_getAddr' | '_getContentHash' | 'resolverMulticallWrapper'
-  >,
+  }: ENSArgs<'_getText' | '_getAddr' | '_getContentHash'>,
   name: string,
   options: InternalProfileOptions,
 ) => {
-  let calls: any[] = []
-  options.texts &&
-    (calls = [
+  let calls: (CallObj | null)[] = []
+  if (options.texts)
+    calls = [
       ...calls,
       ...(await Promise.all(
         options.texts.map(async (x) => ({
           key: x,
           data: await _getText.raw(name, x),
-          type: 'text',
+          type: 'text' as const,
         })),
       )),
-    ])
-  options.coinTypes &&
-    (calls = [
+    ]
+
+  if (options.coinTypes)
+    calls = [
       ...calls,
       ...(await Promise.all(
         options.coinTypes.map(async (x) => ({
           key: x,
           data: await _getAddr.raw(name, x, true),
-          type: 'addr',
+          type: 'addr' as const,
         })),
       )),
-    ])
+    ]
+
   if (typeof options.contentHash === 'boolean' && options.contentHash) {
     calls.push({
       key: 'contentHash',
       data: await _getContentHash.raw(name),
-      type: 'contenthash',
+      type: 'contentHash' as const,
     })
   }
 
-  if (!calls.find((x) => x.key === '60')) {
+  if (!calls.find((x) => x!.key === '60')) {
     calls.push({
       key: '60',
       data: await _getAddr.raw(name, '60', true),
-      type: 'addr',
+      type: 'addr' as const,
     })
   }
 
-  const prRawData = await resolverMulticallWrapper.raw(calls.map((x) => x.data))
-
-  return { data: prRawData.data, calls }
+  return { data: calls.map((x) => x!.data.data), calls }
 }
 
 const fetchWithoutResolverMulticall = async (
@@ -113,74 +129,11 @@ const fetchWithoutResolverMulticall = async (
     data: call.data.data,
   }))
 
-  return (await multicallWrapper(callsWithResolver)).map(
-    (x: [boolean, string]) => x[1],
-  )
-}
-
-const getDataForName = async (
-  {
-    contracts,
-    _getAddr,
-    _getContentHash,
-    _getText,
-    resolverMulticallWrapper,
-    multicallWrapper,
-  }: ENSArgs<
-    | 'contracts'
-    | '_getText'
-    | '_getAddr'
-    | '_getContentHash'
-    | 'resolverMulticallWrapper'
-    | 'multicallWrapper'
-  >,
-  name: string,
-  options: InternalProfileOptions,
-  fallbackResolver: string,
-) => {
-  const universalResolver = await contracts?.getUniversalResolver()
-
-  const { data, calls } = await makeMulticallData(
-    { _getAddr, _getContentHash, _getText, resolverMulticallWrapper },
-    name,
-    options,
-  )
-
-  let resolvedData: any
-  let useFallbackResolver = false
-  try {
-    resolvedData = await universalResolver?.resolve(hexEncodeName(name), data)
-  } catch {
-    useFallbackResolver = true
-  }
-
-  let resolverAddress: string
-  let recordData: any
+  const results = await multicallWrapper(callsWithResolver)
 
-  if (useFallbackResolver) {
-    resolverAddress = fallbackResolver
-    recordData = await fetchWithoutResolverMulticall(
-      { multicallWrapper },
-      calls,
-      resolverAddress,
-    )
-  } else {
-    resolverAddress = resolvedData['1']
-    ;[recordData] = await resolverMulticallWrapper.decode(resolvedData['0'])
-  }
+  if (!results || !results.length) return []
 
-  const matchAddress = recordData[calls.findIndex((x) => x.key === '60')]
-
-  return {
-    address: matchAddress && (await _getAddr.decode(matchAddress)),
-    records: await formatRecords(
-      { _getAddr, _getContentHash, _getText },
-      recordData,
-      calls,
-      options,
-    ),
-    resolverAddress,
-  }
+  return results.map((x: [boolean, string]) => x[1])
 }
 
 const formatRecords = async (
@@ -193,7 +146,7 @@ const formatRecords = async (
   calls: any[],
   options: InternalProfileOptions,
 ) => {
-  let returnedRecords: DataItem[] = (
+  const returnedRecords: DataItem[] = (
     await Promise.all(
       data.map(async (item: string, i: number) => {
         let decodedFromAbi: any
@@ -201,12 +154,9 @@ const formatRecords = async (
           key: calls[i].key,
           type: calls[i].type,
         }
-        if (itemRet.type === 'contenthash') {
-          decodedFromAbi = ethers.utils.defaultAbiCoder.decode(
-            ['bytes'],
-            item,
-          )[0]
-          if (ethers.utils.hexStripZeros(decodedFromAbi) === '0x') {
+        if (itemRet.type === 'contentHash') {
+          ;[decodedFromAbi] = defaultAbiCoder.decode(['bytes'], item)
+          if (hexStripZeros(decodedFromAbi) === '0x') {
             return
           }
         }
@@ -233,15 +183,17 @@ const formatRecords = async (
             } catch {
               return
             }
-          case 'contenthash':
+          case 'contentHash':
             try {
               itemRet = {
                 ...itemRet,
                 value: await _getContentHash.decode(item),
               }
+              break
             } catch {
               return
             }
+          // no default
         }
         return itemRet
       }),
@@ -252,7 +204,7 @@ const formatRecords = async (
     })
     .filter((x) => x)
 
-  let returnedResponse: {
+  const returnedResponse: {
     contentHash?: string | null | DecodedContentHash
     coinTypes?: DataItem[]
     texts?: DataItem[]
@@ -264,12 +216,12 @@ const formatRecords = async (
   ) {
     if (
       typeof options.contentHash === 'string' &&
-      ethers.utils.hexStripZeros(options.contentHash) === '0x'
+      hexStripZeros(options.contentHash) === '0x'
     ) {
       returnedResponse.contentHash = null
     } else if (
-      ethers.utils.isBytesLike((options.contentHash as any).decoded) &&
-      ethers.utils.hexStripZeros((options.contentHash as any).decoded) === '0x'
+      isBytesLike((options.contentHash as any).decoded) &&
+      hexStripZeros((options.contentHash as any).decoded) === '0x'
     ) {
       returnedResponse.contentHash = null
     } else {
@@ -277,7 +229,7 @@ const formatRecords = async (
     }
   } else if (options.contentHash) {
     const foundRecord = returnedRecords.find(
-      (item: any) => item.type === 'contenthash',
+      (item: any) => item.type === 'contentHash',
     )
     returnedResponse.contentHash = foundRecord ? foundRecord.value : null
   }
@@ -294,14 +246,124 @@ const formatRecords = async (
   return returnedResponse
 }
 
+const getDataForName = async (
+  {
+    contracts,
+    _getAddr,
+    _getContentHash,
+    _getText,
+    multicallWrapper,
+  }: ENSArgs<
+    | 'contracts'
+    | '_getText'
+    | '_getAddr'
+    | '_getContentHash'
+    | 'resolverMulticallWrapper'
+    | 'multicallWrapper'
+  >,
+  name: string,
+  options: InternalProfileOptions,
+  specificResolver?: string,
+) => {
+  const universalResolver = await contracts?.getUniversalResolver()!
+
+  const { data, calls } = await makeMulticallData(
+    { _getAddr, _getContentHash, _getText },
+    name,
+    options,
+  )
+
+  let recordData: (string | null)[] | undefined
+  let resolverAddress: string | undefined = specificResolver
+
+  if (specificResolver) {
+    try {
+      const publicResolver = await contracts?.getPublicResolver(
+        undefined,
+        specificResolver,
+      )
+      recordData = await publicResolver?.callStatic.multicall(data)
+    } catch (e: any) {
+      console.error('getProfile error:', e)
+      recordData = await fetchWithoutResolverMulticall(
+        { multicallWrapper },
+        calls as CallObj[],
+        resolverAddress!,
+      )
+    }
+  } else {
+    try {
+      const resolvedData = await universalResolver['resolve(bytes,bytes[])'](
+        hexEncodeName(name),
+        data,
+        {
+          ccipReadEnabled: true,
+        },
+      )
+      recordData = [...resolvedData['0']]
+      resolverAddress = resolvedData['1']
+      for (let i = 0; i < recordData.length; i += 1) {
+        // error code for reverted call in batch
+        // this is expected when using offchain resolvers, so should be ignored
+        // Error((uint16, string)[])
+        // or if data is 0x, clear the call so there is no decoding errors
+        if (recordData[i]!.startsWith('0x0d1947a9') || recordData[i] === '0x') {
+          calls[i] = null
+          recordData[i] = null
+        }
+      }
+    } catch {
+      const registryContract = await contracts?.getRegistry()
+      resolverAddress = await registryContract?.resolver(namehash(name))
+      return {
+        address: undefined,
+        records: {},
+        resolverAddress,
+        isInvalidResolverAddress: true,
+      }
+    }
+  }
+  if (
+    !resolverAddress ||
+    !recordData ||
+    hexStripZeros(resolverAddress) === '0x'
+  ) {
+    return {
+      address: undefined,
+      records: {},
+      resolverAddress: undefined,
+    }
+  }
+
+  const filteredCalls = calls.filter((x) => x) as CallObj[]
+  const filteredRecordData = recordData.filter((x) => x)
+
+  const matchAddress =
+    filteredRecordData[filteredCalls.findIndex((x) => x.key === '60')]
+
+  return {
+    address:
+      matchAddress && (await _getAddr.decode(matchAddress).catch(() => false)),
+    records: await formatRecords(
+      { _getAddr, _getContentHash, _getText },
+      filteredRecordData,
+      filteredCalls,
+      options,
+    ),
+    resolverAddress,
+  }
+}
+
 const graphFetch = async (
   { gqlInstance }: ENSArgs<'gqlInstance'>,
   name: string,
   wantedRecords?: ProfileOptions,
+  resolverAddress?: string,
 ) => {
   const query = gqlInstance.gql`
-    query getRecords($name: String!) {
-      domains(where: { name: $name }) {
+    query getRecords($id: String!) {
+      domain(id: $id) {
+        name
         isMigrated
         createdAt
         resolver {
@@ -311,30 +373,58 @@ const graphFetch = async (
           addr {
             id
           }
-          address
         }
       }
     }
   `
 
-  const client = gqlInstance.client
+  const customResolverQuery = gqlInstance.gql`
+    query getRecordsWithCustomResolver($id: String!, $resolverId: String!) {
+      domain(id: $id) {
+        name
+        isMigrated
+        createdAt
+      }
+      resolver(id: $resolverId) {
+        texts
+        coinTypes
+        contentHash
+        addr {
+          id
+        }
+      }
+    }
+  `
+
+  const { client } = gqlInstance
 
-  const { domains } = await client.request(query, { name })
+  const id = namehash(name)
 
-  if (!domains || domains.length === 0) return
+  let domain: any
+  let resolverResponse: any
 
-  const [{ resolver: resolverResponse, isMigrated, createdAt }] = domains
+  if (!resolverAddress) {
+    const response = await client.request(query, { id })
+    domain = response?.domain
+    resolverResponse = domain?.resolver
+  } else {
+    const resolverId = `${resolverAddress.toLowerCase()}-${id}`
+    const response = await client.request(customResolverQuery, {
+      id,
+      resolverId,
+    })
+    resolverResponse = response?.resolver
+    domain = response?.domain
+  }
 
-  let returnedRecords: ProfileResponse = {}
+  if (!domain) return
 
-  if (!resolverResponse) return { isMigrated, createdAt }
+  const { isMigrated, createdAt, name: decryptedName } = domain
 
-  if (!wantedRecords)
-    return {
-      isMigrated,
-      createdAt,
-      graphResolverAddress: resolverResponse.address,
-    }
+  const returnedRecords: ProfileResponse = {}
+
+  if (!resolverResponse || !wantedRecords)
+    return { isMigrated, createdAt, decryptedName }
 
   Object.keys(wantedRecords).forEach((key: string) => {
     const data = wantedRecords[key as keyof ProfileOptions]
@@ -349,9 +439,9 @@ const graphFetch = async (
 
   return {
     ...returnedRecords,
+    decryptedName,
     isMigrated,
     createdAt,
-    graphResolverAddress: resolverResponse.address,
   }
 }
 
@@ -361,6 +451,11 @@ type ProfileOptions = {
   coinTypes?: boolean | string[]
 }
 
+type InputProfileOptions = ProfileOptions & {
+  resolverAddress?: string
+  fallback?: FallbackRecords
+}
+
 const getProfileFromName = async (
   {
     contracts,
@@ -380,42 +475,90 @@ const getProfileFromName = async (
     | 'multicallWrapper'
   >,
   name: string,
-  options?: ProfileOptions,
-) => {
-  const usingOptions =
-    !options || options?.texts === true || options?.coinTypes === true
-      ? options || { contentHash: true, texts: true, coinTypes: true }
-      : undefined
-  const graphResult = await graphFetch({ gqlInstance }, name, usingOptions)
-  if (!graphResult) return
-  const {
-    isMigrated,
-    createdAt,
-    graphResolverAddress,
-    ...wantedRecords
-  }: {
-    isMigrated: boolean
-    createdAt: string
-    graphResolverAddress?: string
-  } & InternalProfileOptions = graphResult
-  if (!graphResolverAddress)
-    return { isMigrated, createdAt, message: "Name doesn't have a resolver" }
-  const result = await getDataForName(
-    {
-      contracts,
-      _getAddr,
-      _getContentHash,
-      _getText,
-      resolverMulticallWrapper,
-      multicallWrapper,
-    },
+  options?: InputProfileOptions,
+): Promise<ResolvedProfile | undefined> => {
+  const { resolverAddress, fallback, ..._options } = options || {}
+  const optsLength = Object.keys(_options).length
+  let usingOptions: InputProfileOptions | undefined
+  if (!optsLength || _options?.texts === true || _options?.coinTypes === true) {
+    if (optsLength) usingOptions = _options
+    else usingOptions = { contentHash: true, texts: true, coinTypes: true }
+  }
+
+  const graphResult = await graphFetch(
+    { gqlInstance },
     name,
-    usingOptions ? wantedRecords : (options as InternalProfileOptions),
-    graphResolverAddress,
+    usingOptions,
+    resolverAddress,
   )
-  if (!result)
-    return { isMigrated, createdAt, message: "Records fetch didn't complete" }
-  return { ...result, isMigrated, createdAt, message: undefined }
+  let isMigrated: boolean | null = null
+  let createdAt: string | null = null
+  let decryptedName: string | null = null
+  let result: Awaited<ReturnType<typeof getDataForName>> | null = null
+  if (!graphResult) {
+    if (!fallback) return
+    result = await getDataForName(
+      {
+        contracts,
+        _getAddr,
+        _getContentHash,
+        _getText,
+        resolverMulticallWrapper,
+        multicallWrapper,
+      },
+      name,
+      fallback,
+      undefined,
+    )
+  } else {
+    const {
+      isMigrated: _isMigrated,
+      createdAt: _createdAt,
+      decryptedName: _decryptedName,
+      ...wantedRecords
+    }: {
+      isMigrated: boolean
+      createdAt: string
+      decryptedName: string
+    } & InternalProfileOptions = graphResult
+    isMigrated = _isMigrated
+    createdAt = _createdAt
+    decryptedName = _decryptedName
+    let recordsWithFallback = usingOptions
+      ? wantedRecords
+      : (_options as InternalProfileOptions)
+    if (
+      (Object.keys(recordsWithFallback).length === 0 ||
+        (!recordsWithFallback.coinTypes &&
+          !recordsWithFallback.texts &&
+          Object.keys(recordsWithFallback.contentHash || {}).length === 0)) &&
+      fallback
+    ) {
+      recordsWithFallback = fallback
+    }
+    result = await getDataForName(
+      {
+        contracts,
+        _getAddr,
+        _getContentHash,
+        _getText,
+        resolverMulticallWrapper,
+        multicallWrapper,
+      },
+      name,
+      recordsWithFallback,
+      options?.resolverAddress!,
+    )
+  }
+  if (!result?.resolverAddress)
+    return {
+      isMigrated,
+      createdAt,
+      message: !result
+        ? "Records fetch didn't complete"
+        : "Name doesn't have a resolver",
+    }
+  return { ...result, isMigrated, createdAt, decryptedName, message: undefined }
 }
 
 const getProfileFromAddress = async (
@@ -439,7 +582,7 @@ const getProfileFromAddress = async (
     | 'multicallWrapper'
   >,
   address: string,
-  options?: ProfileOptions,
+  options?: InputProfileOptions,
 ) => {
   let name
   try {
@@ -471,6 +614,13 @@ const getProfileFromAddress = async (
   }
 }
 
+const mapCoinTypes = (coin: string) => {
+  if (!Number.isNaN(parseInt(coin))) {
+    return coin
+  }
+  return `${formatsByName[coin.toUpperCase()].coinType}`
+}
+
 export default async function (
   {
     contracts,
@@ -492,25 +642,20 @@ export default async function (
     | 'multicallWrapper'
   >,
   nameOrAddress: string,
-  options?: ProfileOptions,
+  options?: InputProfileOptions,
 ): Promise<ResolvedProfile | undefined> {
-  if (options && options.coinTypes && typeof options.coinTypes !== 'boolean') {
-    options.coinTypes = options.coinTypes.map((coin: string) => {
-      if (!isNaN(parseInt(coin))) {
-        return coin
-      } else {
-        return `${formatsByName[coin.toUpperCase()].coinType}`
-      }
-    })
+  if (options) {
+    if (options.coinTypes && typeof options.coinTypes !== 'boolean') {
+      options.coinTypes = options.coinTypes.map(mapCoinTypes)
+    }
+    if (options.fallback && options.fallback.coinTypes) {
+      options.fallback.coinTypes = options.fallback.coinTypes.map(mapCoinTypes)
+    }
   }
 
-  const inputType = parseInputType(nameOrAddress)
-
-  if (inputType.type === 'unknown' || inputType.info === 'unsupported') {
-    throw new Error('Invalid input type')
-  }
+  const inputIsAddress = isAddress(nameOrAddress)
 
-  if (inputType.type === 'address') {
+  if (inputIsAddress) {
     return getProfileFromAddress(
       {
         contracts,

package/src/functions/getResolver.test.ts

@@ -1,19 +1,15 @@
 import { ENS } from '..'
-import setup from '../tests/setup'
+import setup, { deploymentAddresses } from '../tests/setup'
 
-let ENSInstance: ENS
+let ensInstance: ENS
 
 beforeAll(async () => {
-  ;({ ENSInstance } = await setup())
+  ;({ ensInstance } = await setup())
 })
 
 describe('getResolver', () => {
   it('should find the resolver for a name with a resolver', async () => {
-    const result = await ENSInstance.getResolver('jefflau.eth')
-    expect(result).toBe('0x42D63ae25990889E35F215bC95884039Ba354115')
-  })
-  it('should return .eth resolver for an unregistered name', async () => {
-    const result = await ENSInstance.getResolver('test123123cool.eth')
-    expect(result).toBe('0x3E8Dc215A6E404A7Ba811DE5Da3ff2A809AE94E2')
+    const result = await ensInstance.getResolver('with-profile.eth')
+    expect(result).toBe(deploymentAddresses.LegacyPublicResolver)
   })
 })