@ensdomains/ensjs 3.0.0-alpha.2 → 3.0.0-alpha.20

package/src/functions/getProfile.ts

@@ -3,6 +3,7 @@ import { ethers } from 'ethers'
 import { ENSArgs } from '..'
 import { decodeContenthash, DecodedContentHash } from '../utils/contentHash'
 import { hexEncodeName } from '../utils/hexEncodedName'
+import { namehash } from '../utils/normalise'
 import { parseInputType } from '../utils/validation'
 
 type InternalProfileOptions = {
@@ -53,8 +54,8 @@ const makeMulticallData = async (
   options: InternalProfileOptions,
 ) => {
   let calls: any[] = []
-  options.texts &&
-    (calls = [
+  if (options.texts)
+    calls = [
       ...calls,
       ...(await Promise.all(
         options.texts.map(async (x) => ({
@@ -63,9 +64,10 @@ const makeMulticallData = async (
           type: 'text',
         })),
       )),
-    ])
-  options.coinTypes &&
-    (calls = [
+    ]
+
+  if (options.coinTypes)
+    calls = [
       ...calls,
       ...(await Promise.all(
         options.coinTypes.map(async (x) => ({
@@ -74,7 +76,8 @@ const makeMulticallData = async (
           type: 'addr',
         })),
       )),
-    ])
+    ]
+
   if (typeof options.contentHash === 'boolean' && options.contentHash) {
     calls.push({
       key: 'contentHash',
@@ -118,71 +121,6 @@ const fetchWithoutResolverMulticall = async (
   )
 }
 
-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
-
-  if (useFallbackResolver) {
-    resolverAddress = fallbackResolver
-    recordData = await fetchWithoutResolverMulticall(
-      { multicallWrapper },
-      calls,
-      resolverAddress,
-    )
-  } else {
-    resolverAddress = resolvedData['1']
-    ;[recordData] = await resolverMulticallWrapper.decode(resolvedData['0'])
-  }
-
-  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,
-  }
-}
-
 const formatRecords = async (
   {
     _getText,
@@ -193,7 +131,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
@@ -202,10 +140,10 @@ const formatRecords = async (
           type: calls[i].type,
         }
         if (itemRet.type === 'contenthash') {
-          decodedFromAbi = ethers.utils.defaultAbiCoder.decode(
+          ;[decodedFromAbi] = ethers.utils.defaultAbiCoder.decode(
             ['bytes'],
             item,
-          )[0]
+          )
           if (ethers.utils.hexStripZeros(decodedFromAbi) === '0x') {
             return
           }
@@ -239,9 +177,11 @@ const formatRecords = async (
                 ...itemRet,
                 value: await _getContentHash.decode(item),
               }
+              break
             } catch {
               return
             }
+          // no default
         }
         return itemRet
       }),
@@ -252,7 +192,7 @@ const formatRecords = async (
     })
     .filter((x) => x)
 
-  let returnedResponse: {
+  const returnedResponse: {
     contentHash?: string | null | DecodedContentHash
     coinTypes?: DataItem[]
     texts?: DataItem[]
@@ -294,14 +234,95 @@ const formatRecords = async (
   return returnedResponse
 }
 
+const getDataForName = async (
+  {
+    contracts,
+    _getAddr,
+    _getContentHash,
+    _getText,
+    resolverMulticallWrapper,
+    multicallWrapper,
+  }: ENSArgs<
+    | 'contracts'
+    | '_getText'
+    | '_getAddr'
+    | '_getContentHash'
+    | 'resolverMulticallWrapper'
+    | 'multicallWrapper'
+  >,
+  name: string,
+  options: InternalProfileOptions,
+  fallbackResolver?: string,
+  specificResolver?: string,
+) => {
+  const universalResolver = await contracts?.getUniversalResolver()
+
+  const { data, calls } = await makeMulticallData(
+    { _getAddr, _getContentHash, _getText, resolverMulticallWrapper },
+    name,
+    options,
+  )
+
+  let resolvedData: any
+  let useFallbackResolver = false
+  try {
+    if (specificResolver) {
+      const publicResolver = await contracts?.getPublicResolver(
+        undefined,
+        specificResolver,
+      )
+      resolvedData = await publicResolver?.callStatic.multicall(
+        calls.map((x) => x.data),
+      )
+    } else {
+      resolvedData = await universalResolver?.resolve(hexEncodeName(name), data)
+    }
+  } catch {
+    useFallbackResolver = true
+  }
+
+  let resolverAddress: string
+  let recordData: any
+
+  if (useFallbackResolver) {
+    resolverAddress = specificResolver || fallbackResolver!
+    recordData = await fetchWithoutResolverMulticall(
+      { multicallWrapper },
+      calls,
+      resolverAddress,
+    )
+  } else {
+    resolverAddress = specificResolver || resolvedData['1']
+    if (specificResolver) {
+      recordData = resolvedData
+    } else {
+      ;[recordData] = await resolverMulticallWrapper.decode(resolvedData['0'])
+    }
+  }
+
+  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,
+  }
+}
+
 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) {
         isMigrated
         createdAt
         resolver {
@@ -317,15 +338,46 @@ const graphFetch = async (
     }
   `
 
-  const client = gqlInstance.client
+  const customResolverQuery = gqlInstance.gql`
+    query getRecordsWithCustomResolver($id: String!, $resolverId: String!) {
+      domain(id: $id) {
+        isMigrated
+        createdAt
+      }
+      resolver(id: $resolverId) {
+        texts
+        coinTypes
+        contentHash
+        addr {
+          id
+        }
+      }
+    }
+  `
+
+  const { client } = gqlInstance
 
-  const { domains } = await client.request(query, { name })
+  const id = namehash(name)
+
+  let domain: any
+  let resolverResponse: any
+
+  if (!resolverAddress) {
+    ;({ domain } = await client.request(query, { id }))
+    resolverResponse = domain?.resolver
+  } else {
+    const resolverId = `${resolverAddress.toLowerCase()}-${id}`
+    ;({ resolver: resolverResponse, domain } = await client.request(
+      customResolverQuery,
+      { id, resolverId },
+    ))
+  }
 
-  if (!domains || domains.length === 0) return
+  if (!domain) return
 
-  const [{ resolver: resolverResponse, isMigrated, createdAt }] = domains
+  const { isMigrated, createdAt } = domain
 
-  let returnedRecords: ProfileResponse = {}
+  const returnedRecords: ProfileResponse = {}
 
   if (!resolverResponse) return { isMigrated, createdAt }
 
@@ -333,7 +385,7 @@ const graphFetch = async (
     return {
       isMigrated,
       createdAt,
-      graphResolverAddress: resolverResponse.address,
+      graphResolverAddress: resolverResponse.address || resolverAddress,
     }
 
   Object.keys(wantedRecords).forEach((key: string) => {
@@ -351,7 +403,7 @@ const graphFetch = async (
     ...returnedRecords,
     isMigrated,
     createdAt,
-    graphResolverAddress: resolverResponse.address,
+    graphResolverAddress: resolverResponse.address || resolverAddress,
   }
 }
 
@@ -361,6 +413,10 @@ type ProfileOptions = {
   coinTypes?: boolean | string[]
 }
 
+type InputProfileOptions = ProfileOptions & {
+  resolverAddress?: string
+}
+
 const getProfileFromName = async (
   {
     contracts,
@@ -380,13 +436,22 @@ const getProfileFromName = async (
     | 'multicallWrapper'
   >,
   name: string,
-  options?: ProfileOptions,
+  options?: InputProfileOptions,
 ) => {
-  const usingOptions =
-    !options || options?.texts === true || options?.coinTypes === true
-      ? options || { contentHash: true, texts: true, coinTypes: true }
-      : undefined
-  const graphResult = await graphFetch({ gqlInstance }, name, usingOptions)
+  const { resolverAddress, ..._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,
+    resolverAddress,
+  )
   if (!graphResult) return
   const {
     isMigrated,
@@ -398,7 +463,7 @@ const getProfileFromName = async (
     createdAt: string
     graphResolverAddress?: string
   } & InternalProfileOptions = graphResult
-  if (!graphResolverAddress)
+  if (!graphResolverAddress && !options?.resolverAddress)
     return { isMigrated, createdAt, message: "Name doesn't have a resolver" }
   const result = await getDataForName(
     {
@@ -412,6 +477,7 @@ const getProfileFromName = async (
     name,
     usingOptions ? wantedRecords : (options as InternalProfileOptions),
     graphResolverAddress,
+    options?.resolverAddress!,
   )
   if (!result)
     return { isMigrated, createdAt, message: "Records fetch didn't complete" }
@@ -439,7 +505,7 @@ const getProfileFromAddress = async (
     | 'multicallWrapper'
   >,
   address: string,
-  options?: ProfileOptions,
+  options?: InputProfileOptions,
 ) => {
   let name
   try {
@@ -492,15 +558,14 @@ 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))) {
+      if (!Number.isNaN(parseInt(coin))) {
         return coin
-      } else {
-        return `${formatsByName[coin.toUpperCase()].coinType}`
       }
+      return `${formatsByName[coin.toUpperCase()].coinType}`
     })
   }
 

package/src/functions/getRecords.ts

@@ -5,6 +5,7 @@ type ProfileOptions = {
   contentHash?: boolean
   texts?: boolean | string[]
   coinTypes?: boolean | string[]
+  resolverAddress?: string
 }
 
 export default async function (
@@ -18,5 +19,5 @@ export default async function (
     throw new Error('Input must be an ENS name')
   }
 
-  return await getProfile(name, options)
+  return getProfile(name, options)
 }

package/src/functions/getResolver.test.ts

@@ -0,0 +1,15 @@
+import { ENS } from '..'
+import setup from '../tests/setup'
+
+let ensInstance: ENS
+
+beforeAll(async () => {
+  ;({ ensInstance } = await setup())
+})
+
+describe('getResolver', () => {
+  it('should find the resolver for a name with a resolver', async () => {
+    const result = await ensInstance.getResolver('with-profile.eth')
+    expect(result).toBe('0x1613beB3B2C4f22Ee086B2b38C1476A3cE7f78E8')
+  })
+})

package/src/{tests → functions}/getSpecificRecord.test.ts

@@ -1,24 +1,24 @@
 import { ENS } from '..'
-import setup from './setup'
+import setup from '../tests/setup'
 
-let ENSInstance: ENS
+let ensInstance: ENS
 
 beforeAll(async () => {
-  ;({ ENSInstance } = await setup())
+  ;({ ensInstance } = await setup())
 })
 
 describe('getSpecificRecord', () => {
   describe('getContentHash', () => {
     it('should return null for a non-existent name', async () => {
-      const result = await ENSInstance.getContentHash('test123123cool.eth')
+      const result = await ensInstance.getContentHash('test123123cool.eth')
       expect(result).toBeUndefined()
     })
     it('should return null for a name with no contenthash record', async () => {
-      const result = await ENSInstance.getContentHash('jefflau.eth')
+      const result = await ensInstance.getContentHash('with-profile.eth')
       expect(result).toBeUndefined()
     })
     it('should return the contenthash for a name with the record set', async () => {
-      const result = await ENSInstance.getContentHash('matoken.eth')
+      const result = await ensInstance.getContentHash('with-contenthash.eth')
       expect(result).toMatchObject({
         protocolType: 'ipfs',
         decoded: 'bafybeico3uuyj3vphxpvbowchdwjlrlrh62awxscrnii7w7flu5z6fk77y',
@@ -29,13 +29,16 @@ describe('getSpecificRecord', () => {
 
   describe('getText', () => {
     it('should return a record from a key', async () => {
-      const result = await ENSInstance.getText('jefflau.eth', 'description')
+      const result = await ensInstance.getText(
+        'with-profile.eth',
+        'description',
+      )
       expect(result).toBe('Hello2')
     })
 
     it('should return null for a non-existent key', async () => {
-      const result = await ENSInstance.getText(
-        'jefflau.eth',
+      const result = await ensInstance.getText(
+        'with-profile.eth',
         'thiskeydoesntexist',
       )
       expect(result).toBeUndefined()
@@ -44,32 +47,32 @@ describe('getSpecificRecord', () => {
 
   describe('getAddr', () => {
     it('should return the ETH addr record if no coinType is provided', async () => {
-      const result = await ENSInstance.getAddr('jefflau.eth')
-      expect(result).toBe('0x866B3c4994e1416B7C738B9818b31dC246b95eEE')
+      const result = await ensInstance.getAddr('with-profile.eth')
+      expect(result).toBe('0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC')
     })
     it('should return the correct address based on a coin ID input as a number', async () => {
-      const result = await ENSInstance.getAddr('jefflau.eth', 61)
+      const result = await ensInstance.getAddr('with-profile.eth', 61)
       expect((result as any).addr).toBe(
-        '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+        '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       )
       expect((result as any).coin).toBe('ETC')
     })
     it('should return the correct address based on a coin ID input as a string', async () => {
-      const result = await ENSInstance.getAddr('jefflau.eth', '61')
+      const result = await ensInstance.getAddr('with-profile.eth', '61')
       expect((result as any).addr).toBe(
-        '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+        '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       )
       expect((result as any).coin).toBe('ETC')
     })
     it('should return the correct address based on a coin name', async () => {
-      const result = await ENSInstance.getAddr('jefflau.eth', 'ETC')
+      const result = await ensInstance.getAddr('with-profile.eth', 'ETC')
       expect((result as any).addr).toBe(
-        '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+        '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       )
       expect((result as any).coin).toBe('ETC')
     })
     it('should return null for a non-existent coin', async () => {
-      const result = await ENSInstance.getAddr('jefflau.eth', 'BNB')
+      const result = await ensInstance.getAddr('with-profile.eth', 'BNB')
       expect(result).toBeUndefined()
     })
   })