@ensdomains/ensjs 3.0.0-alpha.1 → 3.0.0-alpha.12

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 = {
@@ -96,10 +97,27 @@ const makeMulticallData = async (
   return { data: prRawData.data, calls }
 }
 
-const makeHashIndexes = (data: string, name: string) =>
-  [...data.matchAll(ethers.utils.namehash(name).substring(2) as any)].map(
-    (x: any) => x.index / 2 - 1,
+const fetchWithoutResolverMulticall = async (
+  { multicallWrapper }: ENSArgs<'multicallWrapper'>,
+  calls: {
+    key: string | number
+    data: {
+      to: string
+      data: string
+    }
+    type: 'addr' | 'text' | 'contentHash'
+  }[],
+  resolverAddress: string,
+) => {
+  const callsWithResolver = calls.map((call) => ({
+    to: resolverAddress,
+    data: call.data.data,
+  }))
+
+  return (await multicallWrapper(callsWithResolver)).map(
+    (x: [boolean, string]) => x[1],
   )
+}
 
 const getDataForName = async (
   {
@@ -108,15 +126,19 @@ const getDataForName = async (
     _getContentHash,
     _getText,
     resolverMulticallWrapper,
+    multicallWrapper,
   }: ENSArgs<
     | 'contracts'
     | '_getText'
     | '_getAddr'
     | '_getContentHash'
     | 'resolverMulticallWrapper'
+    | 'multicallWrapper'
   >,
   name: string,
   options: InternalProfileOptions,
+  fallbackResolver?: string,
+  specificResolver?: string,
 ) => {
   const universalResolver = await contracts?.getUniversalResolver()
 
@@ -126,14 +148,42 @@ const getDataForName = async (
     options,
   )
 
-  let resolver: any
+  let resolvedData: any
+  let useFallbackResolver = false
   try {
-    resolver = await universalResolver?.resolve(hexEncodeName(name), data)
+    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 {
-    return
+    useFallbackResolver = true
   }
 
-  const [recordData] = await resolverMulticallWrapper.decode(resolver['0'])
+  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')]
 
@@ -145,7 +195,7 @@ const getDataForName = async (
       calls,
       options,
     ),
-    resolverAddress: resolver['1'],
+    resolverAddress,
   }
 }
 
@@ -167,7 +217,7 @@ const formatRecords = async (
           key: calls[i].key,
           type: calls[i].type,
         }
-        if (itemRet.type === 'addr' || itemRet.type === 'contenthash') {
+        if (itemRet.type === 'contenthash') {
           decodedFromAbi = ethers.utils.defaultAbiCoder.decode(
             ['bytes'],
             item,
@@ -264,10 +314,11 @@ 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 {
@@ -277,6 +328,24 @@ const graphFetch = async (
           addr {
             id
           }
+          address
+        }
+      }
+    }
+  `
+
+  const customResolverQuery = gqlInstance.gql`
+    query getRecordsWithCustomResolver($id: String!, $resolverId: String!) {
+      domain(id: $id) {
+        isMigrated
+        createdAt
+      }
+      resolver(id: $resolverId) {
+        texts
+        coinTypes
+        contentHash
+        addr {
+          id
         }
       }
     }
@@ -284,15 +353,36 @@ const graphFetch = async (
 
   const client = gqlInstance.client
 
-  const { domains } = await client.request(query, { name })
+  const id = namehash(name)
 
-  if (!domains || domains.length === 0) return
+  let domain: any
+  let resolverResponse: any
+
+  if (!resolverAddress) {
+    ;({ domain } = await client.request(query, { id }))
+    resolverResponse = domain?.resolver
+  } else {
+    const resolverId = `${resolverAddress}-${id}`
+    ;({ resolver: resolverResponse, domain } = await client.request(
+      customResolverQuery,
+      { id, resolverId },
+    ))
+  }
 
-  const [{ resolver: resolverResponse, isMigrated, createdAt }] = domains
+  if (!domain) return
+
+  const { isMigrated, createdAt } = domain
 
   let returnedRecords: ProfileResponse = {}
 
-  if (!wantedRecords) return { isMigrated, createdAt }
+  if (!resolverResponse) return { isMigrated, createdAt }
+
+  if (!wantedRecords)
+    return {
+      isMigrated,
+      createdAt,
+      graphResolverAddress: resolverResponse.address || resolverAddress,
+    }
 
   Object.keys(wantedRecords).forEach((key: string) => {
     const data = wantedRecords[key as keyof ProfileOptions]
@@ -305,7 +395,12 @@ const graphFetch = async (
     }
   })
 
-  return { ...returnedRecords, isMigrated, createdAt }
+  return {
+    ...returnedRecords,
+    isMigrated,
+    createdAt,
+    graphResolverAddress: resolverResponse.address || resolverAddress,
+  }
 }
 
 type ProfileOptions = {
@@ -314,6 +409,10 @@ type ProfileOptions = {
   coinTypes?: boolean | string[]
 }
 
+type InputProfileOptions = ProfileOptions & {
+  resolverAddress?: string
+}
+
 const getProfileFromName = async (
   {
     contracts,
@@ -322,6 +421,7 @@ const getProfileFromName = async (
     _getContentHash,
     _getText,
     resolverMulticallWrapper,
+    multicallWrapper,
   }: ENSArgs<
     | 'contracts'
     | 'gqlInstance'
@@ -329,22 +429,39 @@ const getProfileFromName = async (
     | '_getAddr'
     | '_getContentHash'
     | 'resolverMulticallWrapper'
+    | 'multicallWrapper'
   >,
   name: string,
-  options?: ProfileOptions,
+  options?: InputProfileOptions,
 ) => {
+  const { resolverAddress, ..._options } = options || {}
+  const optsLength = Object.keys(_options).length
   const usingOptions =
-    !options || options?.texts === true || options?.coinTypes === true
-      ? options || { contentHash: true, texts: true, coinTypes: true }
+    !optsLength || _options?.texts === true || _options?.coinTypes === true
+      ? optsLength
+        ? _options
+        : { contentHash: true, texts: true, coinTypes: true }
       : undefined
-  const graphResult = await graphFetch({ gqlInstance }, name, usingOptions)
+
+  const graphResult = await graphFetch(
+    { gqlInstance },
+    name,
+    usingOptions,
+    resolverAddress,
+  )
   if (!graphResult) return
   const {
     isMigrated,
     createdAt,
+    graphResolverAddress,
     ...wantedRecords
-  }: { isMigrated: boolean; createdAt: string } & InternalProfileOptions =
-    graphResult
+  }: {
+    isMigrated: boolean
+    createdAt: string
+    graphResolverAddress?: string
+  } & InternalProfileOptions = graphResult
+  if (!graphResolverAddress && !options?.resolverAddress)
+    return { isMigrated, createdAt, message: "Name doesn't have a resolver" }
   const result = await getDataForName(
     {
       contracts,
@@ -352,9 +469,12 @@ const getProfileFromName = async (
       _getContentHash,
       _getText,
       resolverMulticallWrapper,
+      multicallWrapper,
     },
     name,
     usingOptions ? wantedRecords : (options as InternalProfileOptions),
+    graphResolverAddress,
+    options?.resolverAddress!,
   )
   if (!result)
     return { isMigrated, createdAt, message: "Records fetch didn't complete" }
@@ -370,6 +490,7 @@ const getProfileFromAddress = async (
     _getContentHash,
     _getText,
     resolverMulticallWrapper,
+    multicallWrapper,
   }: ENSArgs<
     | 'contracts'
     | 'gqlInstance'
@@ -378,9 +499,10 @@ const getProfileFromAddress = async (
     | '_getAddr'
     | '_getContentHash'
     | 'resolverMulticallWrapper'
+    | 'multicallWrapper'
   >,
   address: string,
-  options?: ProfileOptions,
+  options?: InputProfileOptions,
 ) => {
   let name
   try {
@@ -398,6 +520,7 @@ const getProfileFromAddress = async (
       _getContentHash,
       _getText,
       resolverMulticallWrapper,
+      multicallWrapper,
     },
     name.name,
     options,
@@ -420,6 +543,7 @@ export default async function (
     _getContentHash,
     _getText,
     resolverMulticallWrapper,
+    multicallWrapper,
   }: ENSArgs<
     | 'contracts'
     | 'gqlInstance'
@@ -428,9 +552,10 @@ export default async function (
     | '_getAddr'
     | '_getContentHash'
     | 'resolverMulticallWrapper'
+    | '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) => {
@@ -458,6 +583,7 @@ export default async function (
         _getContentHash,
         _getText,
         resolverMulticallWrapper,
+        multicallWrapper,
       },
       nameOrAddress,
       options,
@@ -472,6 +598,7 @@ export default async function (
       _getContentHash,
       _getText,
       resolverMulticallWrapper,
+      multicallWrapper,
     },
     nameOrAddress,
     options,

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 (

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,5 +1,5 @@
 import { ENS } from '..'
-import setup from './setup'
+import setup from '../tests/setup'
 
 let ENSInstance: ENS
 
@@ -14,11 +14,11 @@ describe('getSpecificRecord', () => {
       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',
+        '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()
     })
   })

package/src/functions/getSpecificRecord.ts

@@ -2,6 +2,7 @@ import { formatsByCoinType, formatsByName } from '@ensdomains/address-encoder'
 import { ethers } from 'ethers'
 import { ENSArgs } from '..'
 import { decodeContenthash } from '../utils/contentHash'
+import { namehash } from '../utils/normalise'
 
 export const _getContentHash = {
   raw: async ({ contracts }: ENSArgs<'contracts'>, name: string) => {
@@ -9,16 +10,22 @@ export const _getContentHash = {
     return {
       to: '0x0000000000000000000000000000000000000000',
       data: publicResolver.interface.encodeFunctionData('contenthash', [
-        ethers.utils.namehash(name),
+        namehash(name),
       ]),
     }
   },
   decode: async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
+    let response: any
     const publicResolver = await contracts?.getPublicResolver()!
-    const [response] = publicResolver.interface.decodeFunctionResult(
-      'contenthash',
-      data,
-    )
+    try {
+      ;[response] = publicResolver.interface.decodeFunctionResult(
+        'contenthash',
+        data,
+      )
+    } catch {
+      return
+    }
+
     if (!response) {
       return
     }
@@ -66,7 +73,7 @@ export const _getText = {
     return {
       to: '0x0000000000000000000000000000000000000000',
       data: publicResolver.interface.encodeFunctionData('text', [
-        ethers.utils.namehash(name),
+        namehash(name),
         key,
       ]),
     }
@@ -115,12 +122,22 @@ export const _getAddr = {
     }
 
     const publicResolver = await contracts?.getPublicResolver()!
+
+    if (coinType === 60 || coinType === '60') {
+      return {
+        to: '0x0000000000000000000000000000000000000000',
+        data: publicResolver.interface.encodeFunctionData('addr(bytes32)', [
+          namehash(name),
+        ]),
+      }
+    }
+
     if (bypassFormat) {
       return {
         to: '0x0000000000000000000000000000000000000000',
         data: publicResolver.interface.encodeFunctionData(
           'addr(bytes32,uint256)',
-          [ethers.utils.namehash(name), coinType],
+          [namehash(name), coinType],
         ),
       }
     }
@@ -139,7 +156,7 @@ export const _getAddr = {
       to: '0x0000000000000000000000000000000000000000',
       data: publicResolver.interface.encodeFunctionData(
         'addr(bytes32,uint256)',
-        [ethers.utils.namehash(name), formatter.coinType],
+        [namehash(name), formatter.coinType],
       ),
     }
   },
@@ -163,10 +180,19 @@ export const _getAddr = {
             typeof coinType === 'number' ? coinType : parseInt(coinType)
           ]
 
-    const [response] = publicResolver.interface.decodeFunctionResult(
-      'addr(bytes32,uint256)',
-      data,
-    )
+    let response: string
+
+    if (coinType === 60 || coinType === '60') {
+      ;[response] = publicResolver.interface.decodeFunctionResult(
+        'addr(bytes32)',
+        data,
+      )
+    } else {
+      ;[response] = publicResolver.interface.decodeFunctionResult(
+        'addr(bytes32,uint256)',
+        data,
+      )
+    }
 
     if (!response) return
 

package/src/functions/getSubnames.test.ts

@@ -0,0 +1,35 @@
+import { ENS } from '..'
+import setup from '../tests/setup'
+
+let ENSInstance: ENS
+
+beforeAll(async () => {
+  ;({ ENSInstance } = await setup())
+})
+
+const testProperties = (obj: object, ...properties: string[]) =>
+  properties.map((property) => expect(obj).toHaveProperty(property))
+
+describe('getSubnames', () => {
+  it.todo('should get the subnames for a name')
+  // it('should get the subnames for a name', async () => {
+  //   const result = await ENSInstance.getSubnames({
+  //     name: 'with-profile.eth',
+  //   })
+  //   expect(result).toBeTruthy()
+  //   if (result) {
+  //     console.log(result)
+  //     expect(result.length).toBeGreaterThan(0)
+  //     testProperties(
+  //       result[0],
+  //       'id',
+  //       'labelName',
+  //       'labelhash',
+  //       'name',
+  //       'isMigrated',
+  //       'owner',
+  //       'truncatedName',
+  //     )
+  //   }
+  // })
+})