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

package/src/functions/getProfile.ts

@@ -96,10 +96,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 +125,18 @@ const getDataForName = async (
     _getContentHash,
     _getText,
     resolverMulticallWrapper,
+    multicallWrapper,
   }: ENSArgs<
     | 'contracts'
     | '_getText'
     | '_getAddr'
     | '_getContentHash'
     | 'resolverMulticallWrapper'
+    | 'multicallWrapper'
   >,
   name: string,
   options: InternalProfileOptions,
+  fallbackResolver: string,
 ) => {
   const universalResolver = await contracts?.getUniversalResolver()
 
@@ -126,14 +146,28 @@ const getDataForName = async (
     options,
   )
 
-  let resolver: any
+  let resolvedData: any
+  let useFallbackResolver = false
   try {
-    resolver = await universalResolver?.resolve(hexEncodeName(name), data)
+    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 = 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')]
 
@@ -145,7 +179,7 @@ const getDataForName = async (
       calls,
       options,
     ),
-    resolverAddress: resolver['1'],
+    resolverAddress,
   }
 }
 
@@ -167,7 +201,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,
@@ -277,6 +311,7 @@ const graphFetch = async (
           addr {
             id
           }
+          address
         }
       }
     }
@@ -292,7 +327,14 @@ const graphFetch = async (
 
   let returnedRecords: ProfileResponse = {}
 
-  if (!wantedRecords) return { isMigrated, createdAt }
+  if (!resolverResponse) return { isMigrated, createdAt }
+
+  if (!wantedRecords)
+    return {
+      isMigrated,
+      createdAt,
+      graphResolverAddress: resolverResponse.address,
+    }
 
   Object.keys(wantedRecords).forEach((key: string) => {
     const data = wantedRecords[key as keyof ProfileOptions]
@@ -305,7 +347,12 @@ const graphFetch = async (
     }
   })
 
-  return { ...returnedRecords, isMigrated, createdAt }
+  return {
+    ...returnedRecords,
+    isMigrated,
+    createdAt,
+    graphResolverAddress: resolverResponse.address,
+  }
 }
 
 type ProfileOptions = {
@@ -322,6 +369,7 @@ const getProfileFromName = async (
     _getContentHash,
     _getText,
     resolverMulticallWrapper,
+    multicallWrapper,
   }: ENSArgs<
     | 'contracts'
     | 'gqlInstance'
@@ -329,6 +377,7 @@ const getProfileFromName = async (
     | '_getAddr'
     | '_getContentHash'
     | 'resolverMulticallWrapper'
+    | 'multicallWrapper'
   >,
   name: string,
   options?: ProfileOptions,
@@ -342,9 +391,15 @@ const getProfileFromName = async (
   const {
     isMigrated,
     createdAt,
+    graphResolverAddress,
     ...wantedRecords
-  }: { isMigrated: boolean; createdAt: string } & InternalProfileOptions =
-    graphResult
+  }: {
+    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,
@@ -352,9 +407,11 @@ const getProfileFromName = async (
       _getContentHash,
       _getText,
       resolverMulticallWrapper,
+      multicallWrapper,
     },
     name,
     usingOptions ? wantedRecords : (options as InternalProfileOptions),
+    graphResolverAddress,
   )
   if (!result)
     return { isMigrated, createdAt, message: "Records fetch didn't complete" }
@@ -370,6 +427,7 @@ const getProfileFromAddress = async (
     _getContentHash,
     _getText,
     resolverMulticallWrapper,
+    multicallWrapper,
   }: ENSArgs<
     | 'contracts'
     | 'gqlInstance'
@@ -378,6 +436,7 @@ const getProfileFromAddress = async (
     | '_getAddr'
     | '_getContentHash'
     | 'resolverMulticallWrapper'
+    | 'multicallWrapper'
   >,
   address: string,
   options?: ProfileOptions,
@@ -398,6 +457,7 @@ const getProfileFromAddress = async (
       _getContentHash,
       _getText,
       resolverMulticallWrapper,
+      multicallWrapper,
     },
     name.name,
     options,
@@ -420,6 +480,7 @@ export default async function (
     _getContentHash,
     _getText,
     resolverMulticallWrapper,
+    multicallWrapper,
   }: ENSArgs<
     | 'contracts'
     | 'gqlInstance'
@@ -428,6 +489,7 @@ export default async function (
     | '_getAddr'
     | '_getContentHash'
     | 'resolverMulticallWrapper'
+    | 'multicallWrapper'
   >,
   nameOrAddress: string,
   options?: ProfileOptions,
@@ -458,6 +520,7 @@ export default async function (
         _getContentHash,
         _getText,
         resolverMulticallWrapper,
+        multicallWrapper,
       },
       nameOrAddress,
       options,
@@ -472,6 +535,7 @@ export default async function (
       _getContentHash,
       _getText,
       resolverMulticallWrapper,
+      multicallWrapper,
     },
     nameOrAddress,
     options,

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/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/functions/setRecords.ts

@@ -1,5 +1,5 @@
-import { ethers } from 'ethers'
 import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
 import { generateRecordCallArray, RecordOptions } from '../utils/recordHelpers'
 
 export default async function (
@@ -30,9 +30,9 @@ export default async function (
   const resolver = (
     await contracts?.getPublicResolver(provider, resolverAddress)
   )?.connect(provider?.getSigner()!)
-  const namehash = ethers.utils.namehash(name)
+  const hash = namehash(name)
 
-  const calls: string[] = generateRecordCallArray(namehash, records, resolver!)
+  const calls: string[] = generateRecordCallArray(hash, records, resolver!)
 
   return resolver?.multicall(calls)
 }

package/src/functions/setResolver.ts

@@ -1,5 +1,5 @@
-import { ethers } from 'ethers'
 import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
 
 export default async function (
   { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
@@ -25,13 +25,13 @@ export default async function (
       const registry = (await contracts?.getRegistry())!.connect(
         provider?.getSigner(options?.addressOrIndex)!,
       )
-      return registry.setResolver(ethers.utils.namehash(name), resolver)
+      return registry.setResolver(namehash(name), resolver)
     }
     case 'nameWrapper': {
       const nameWrapper = (await contracts?.getNameWrapper())!.connect(
         provider?.getSigner(options?.addressOrIndex)!,
       )
-      return nameWrapper.setResolver(ethers.utils.namehash(name), resolver)
+      return nameWrapper.setResolver(namehash(name), resolver)
     }
     default: {
       throw new Error(`Unknown contract: ${contract}`)

package/src/functions/transferName.ts

@@ -1,5 +1,6 @@
 import { ethers } from 'ethers'
 import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
 
 export default async function (
   { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
@@ -21,7 +22,7 @@ export default async function (
       const registry = (await contracts?.getRegistry())!.connect(
         provider?.getSigner(options?.addressOrIndex)!,
       )
-      return registry.setOwner(ethers.utils.namehash(name), newOwner)
+      return registry.setOwner(namehash(name), newOwner)
     }
     case 'baseRegistrar': {
       const baseRegistrar = (await contracts?.getBaseRegistrar())!.connect(
@@ -44,7 +45,7 @@ export default async function (
       return nameWrapper.safeTransferFrom(
         address,
         newOwner,
-        ethers.utils.namehash(name),
+        namehash(name),
         1,
         '0x',
       )

package/src/functions/transferSubname.ts

@@ -1,5 +1,6 @@
 import { ethers } from 'ethers'
 import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
 
 export default async function (
   { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
@@ -17,7 +18,7 @@ export default async function (
   const labels = name.split('.')
   const label = labels.shift() as string
   const labelhash = ethers.utils.solidityKeccak256(['string'], [label])
-  const parentNodehash = ethers.utils.namehash(labels.join('.'))
+  const parentNodehash = namehash(labels.join('.'))
 
   switch (contract) {
     case 'registry': {

package/src/functions/unwrapName.ts

@@ -1,5 +1,6 @@
 import { utils } from 'ethers'
 import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
 
 export default async function (
   { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
@@ -18,7 +19,7 @@ export default async function (
 
   const labels = name.split('.')
   const labelhash = utils.solidityKeccak256(['string'], [labels[0]])
-  const parentNodehash = utils.namehash(labels.slice(1).join('.'))
+  const parentNodehash = namehash(labels.slice(1).join('.'))
 
   const nameWrapper = (await contracts?.getNameWrapper()!).connect(signer)
 

package/src/index.ts

@@ -321,6 +321,7 @@ export class ENS {
       'gqlInstance',
       'getName',
       'resolverMulticallWrapper',
+      'multicallWrapper',
       '_getAddr',
       '_getContentHash',
       '_getText',

package/src/tests/burnFuses.test.ts

@@ -1,5 +1,6 @@
-import { BigNumber, ethers, utils } from 'ethers'
+import { BigNumber, ethers } from 'ethers'
 import { ENS } from '..'
+import { namehash } from '../utils/normalise'
 import setup from './setup'
 
 let ENSInstance: ENS
@@ -36,7 +37,7 @@ describe('burnFuses', () => {
     await tx.wait()
 
     const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
-    const result = await nameWrapper.getFuses(utils.namehash('parthtejpal.eth'))
+    const result = await nameWrapper.getFuses(namehash('parthtejpal.eth'))
     const fuseBN = result.fuses as BigNumber
     expect(fuseBN.toHexString()).toBe('0x71')
   })

package/src/tests/createSubname.test.ts

@@ -1,5 +1,6 @@
-import { ethers, utils } from 'ethers'
+import { ethers } from 'ethers'
 import { ENS } from '..'
+import { namehash } from '../utils/normalise'
 import setup from './setup'
 
 let ENSInstance: ENS
@@ -32,7 +33,7 @@ describe('createSubname', () => {
     await tx.wait()
 
     const registry = await ENSInstance.contracts!.getRegistry()!
-    const result = await registry.owner(utils.namehash('test.parthtejpal.eth'))
+    const result = await registry.owner(namehash('test.parthtejpal.eth'))
     expect(result).toBe(accounts[0])
   })
   it('should allow creating a subname on the namewrapper', async () => {
@@ -51,9 +52,7 @@ describe('createSubname', () => {
     await tx.wait()
 
     const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
-    const result = await nameWrapper.ownerOf(
-      utils.namehash('test.parthtejpal.eth'),
-    )
+    const result = await nameWrapper.ownerOf(namehash('test.parthtejpal.eth'))
     expect(result).toBe(accounts[0])
   })
 })

package/src/tests/deleteSubname.test.ts

@@ -1,5 +1,6 @@
-import { ethers, utils } from 'ethers'
+import { ethers } from 'ethers'
 import { ENS } from '..'
+import { namehash } from '../utils/normalise'
 import setup from './setup'
 
 let ENSInstance: ENS
@@ -38,7 +39,7 @@ describe('deleteSubname', () => {
     await tx.wait()
 
     const registry = await ENSInstance.contracts!.getRegistry()!
-    const result = await registry.owner(utils.namehash('test.parthtejpal.eth'))
+    const result = await registry.owner(namehash('test.parthtejpal.eth'))
     expect(result).toBe('0x0000000000000000000000000000000000000000')
   })
   it('should allow deleting a subname on the nameWrapper', async () => {
@@ -64,9 +65,7 @@ describe('deleteSubname', () => {
     await tx.wait()
 
     const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
-    const result = await nameWrapper.ownerOf(
-      utils.namehash('test.parthtejpal.eth'),
-    )
+    const result = await nameWrapper.ownerOf(namehash('test.parthtejpal.eth'))
     expect(result).toBe('0x0000000000000000000000000000000000000000')
   })
 })