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

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/{tests → functions}/getResolver.test.ts

@@ -1,5 +1,5 @@
 import { ENS } from '..'
-import setup from './setup'
+import setup from '../tests/setup'
 
 let ENSInstance: ENS
 

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
 

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,7 +10,7 @@ export const _getContentHash = {
     return {
       to: '0x0000000000000000000000000000000000000000',
       data: publicResolver.interface.encodeFunctionData('contenthash', [
-        ethers.utils.namehash(name),
+        namehash(name),
       ]),
     }
   },
@@ -66,7 +67,7 @@ export const _getText = {
     return {
       to: '0x0000000000000000000000000000000000000000',
       data: publicResolver.interface.encodeFunctionData('text', [
-        ethers.utils.namehash(name),
+        namehash(name),
         key,
       ]),
     }
@@ -115,12 +116,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 +150,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 +174,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/{tests → functions}/getSubnames.test.ts

@@ -1,5 +1,5 @@
 import { ENS } from '..'
-import setup from './setup'
+import setup from '../tests/setup'
 
 let ENSInstance: ENS
 

package/src/functions/getSubnames.ts

@@ -1,7 +1,7 @@
-import { namehash } from 'ethers/lib/utils';
 import { ENSArgs } from '..'
-import { truncateFormat } from '../utils/format';
-import { decryptName } from '../utils/labels';
+import { truncateFormat } from '../utils/format'
+import { decryptName } from '../utils/labels'
+import { namehash } from '../utils/normalise'
 
 type Subname = {
   id: string
@@ -26,12 +26,12 @@ type Params = {
 }
 
 const largeQuery = async (
-    { gqlInstance } : ENSArgs<'gqlInstance'>, 
-    { name, page, pageSize = 10, orderDirection, orderBy, lastSubnames }: Params
-  ) => {
-  const client = gqlInstance.client;
+  { gqlInstance }: ENSArgs<'gqlInstance'>,
+  { name, page, pageSize = 10, orderDirection, orderBy, lastSubnames }: Params,
+) => {
+  const client = gqlInstance.client
 
-  let finalQuery = gqlInstance.gql `
+  let finalQuery = gqlInstance.gql`
     query getSubnames(
       $id: ID! 
       $first: Int
@@ -62,35 +62,35 @@ const largeQuery = async (
         }
       }
     }
-  `;
-     let queryVars = {
-          id: namehash(name),
-          first: pageSize,
-          lastCreatedAt: lastSubnames[lastSubnames.length - 1]?.createdAt,
-          orderBy,
-          orderDirection,
-      };
-  const { domain } = await client.request(finalQuery, queryVars);
+  `
+  let queryVars = {
+    id: namehash(name),
+    first: pageSize,
+    lastCreatedAt: lastSubnames[lastSubnames.length - 1]?.createdAt,
+    orderBy,
+    orderDirection,
+  }
+  const { domain } = await client.request(finalQuery, queryVars)
   const subdomains = domain.subdomains.map((subname: any) => {
-      const decrypted = decryptName(subname.name);
-      return {
-          ...subname,
-          name: decrypted,
-          truncatedName: truncateFormat(decrypted),
-      };
-  });
+    const decrypted = decryptName(subname.name)
+    return {
+      ...subname,
+      name: decrypted,
+      truncatedName: truncateFormat(decrypted),
+    }
+  })
 
   return {
     subnames: subdomains,
-    subnameCount: domain.subdomainCount
+    subnameCount: domain.subdomainCount,
   }
-};
+}
 
-const smallQuery =  async (
-  { gqlInstance } : ENSArgs<'gqlInstance'>, 
-  { name, page, pageSize = 10, orderDirection, orderBy } : Params
-  ) => {
-  const client = gqlInstance.client;
+const smallQuery = async (
+  { gqlInstance }: ENSArgs<'gqlInstance'>,
+  { name, page, pageSize = 10, orderDirection, orderBy }: Params,
+) => {
+  const client = gqlInstance.client
   const subdomainsGql = `
   id
   labelName
@@ -102,11 +102,11 @@ const smallQuery =  async (
   owner {
     id
   }
-`;
-  let queryVars = {};
-  let finalQuery = '';
+`
+  let queryVars = {}
+  let finalQuery = ''
   if (typeof page !== 'number') {
-      finalQuery = gqlInstance.gql `
+    finalQuery = gqlInstance.gql`
     query getSubnames(
       $id: ID! 
       $orderBy: Domain_orderBy 
@@ -123,15 +123,14 @@ const smallQuery =  async (
         }
       }
     }
-  `;
-      queryVars = {
-          id: namehash(name),
-          orderBy,
-          orderDirection,
-      };
-  }
-  else {
-      finalQuery = gqlInstance.gql `
+  `
+    queryVars = {
+      id: namehash(name),
+      orderBy,
+      orderDirection,
+    }
+  } else {
+    finalQuery = gqlInstance.gql`
     query getSubnames(
       $id: ID! 
       $first: Int
@@ -153,36 +152,39 @@ const smallQuery =  async (
         }
       }
     }
-  `;
-      queryVars = {
-          id: namehash(name),
-          first: pageSize,
-          skip: (page || 0) * pageSize,
-          orderBy,
-          orderDirection,
-      };
+  `
+    queryVars = {
+      id: namehash(name),
+      first: pageSize,
+      skip: (page || 0) * pageSize,
+      orderBy,
+      orderDirection,
+    }
   }
-  const { domain } = await client.request(finalQuery, queryVars);
+  const { domain } = await client.request(finalQuery, queryVars)
   const subdomains = domain.subdomains.map((subname: any) => {
-      const decrypted = decryptName(subname.name);
-      return {
-          ...subname,
-          name: decrypted,
-          truncatedName: truncateFormat(decrypted),
-      };
-  });
+    const decrypted = decryptName(subname.name)
+    return {
+      ...subname,
+      name: decrypted,
+      truncatedName: truncateFormat(decrypted),
+    }
+  })
 
   return {
     subnames: subdomains,
-    subnameCount: domain.subdomainCount
+    subnameCount: domain.subdomainCount,
   }
-};
+}
 
-const getSubnames = (injected : ENSArgs<'gqlInstance'>, functionArgs: Params): Promise<{ subnames: Subname[], subnameCount: number}> => {
-  if(functionArgs.isLargeQuery) {
+const getSubnames = (
+  injected: ENSArgs<'gqlInstance'>,
+  functionArgs: Params,
+): Promise<{ subnames: Subname[]; subnameCount: number }> => {
+  if (functionArgs.isLargeQuery) {
     return largeQuery(injected, functionArgs)
-  }  
+  }
   return smallQuery(injected, functionArgs)
 }
 
-export default getSubnames;
+export default getSubnames

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

@@ -1,6 +1,6 @@
 import { ENS } from '..'
 import { makeCommitment } from '../utils/registerHelpers'
-import setup from './setup'
+import setup from '../tests/setup'
 
 let ENSInstance: ENS
 

package/src/functions/normalise.test.ts

@@ -0,0 +1,22 @@
+import { namehash } from '../utils/normalise'
+
+describe('normalise', () => {
+  it('should namehash an empty string', () => {
+    const hash = namehash('')
+    expect(hash).toEqual(
+      '0x0000000000000000000000000000000000000000000000000000000000000000',
+    )
+  })
+  it('should namehash a TLD', () => {
+    const hash = namehash('eth')
+    expect(hash).toEqual(
+      '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae',
+    )
+  })
+  it('should namehash a 2LD', () => {
+    const hash = namehash('foo.eth')
+    expect(hash).toEqual(
+      '0xde9b09fd7c5f901e23a3f19fecc54828e9c848539801e86591bd9801b019f84f',
+    )
+  })
+})