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

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

@@ -1,5 +1,5 @@
 import { ENS } from '..'
-import setup from './setup'
+import setup from '../tests/setup'
 
 let ENSInstance: ENS
 
@@ -8,11 +8,11 @@ beforeAll(async () => {
 })
 
 const checkRecords = (
-  result: Record<string, any> | null,
+  result: Record<string, any> | undefined,
   textLength = 3,
   coinTypeLength = 5,
 ) => {
-  expect(result).toBeTruthy()
+  expect(result).toBeDefined()
   if (result) {
     expect(result.records?.texts).toHaveLength(textLength)
     expect(result.records?.coinTypes).toHaveLength(coinTypeLength)
@@ -22,24 +22,32 @@ const checkRecords = (
   }
 }
 
+jest.setTimeout(20000)
+
 describe('getProfile', () => {
   describe('with an address', () => {
     it('should return a profile object with no other args', async () => {
       const result = await ENSInstance.getProfile(
         '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
       )
-      expect((result as any).name).toBe('jefflau.eth')
-      expect((result as any).address).toBeUndefined()
-      checkRecords(result)
+      expect(result).toBeDefined()
+      if (result) {
+        expect((result as any).name).toBe('jefflau.eth')
+        expect((result as any).address).toBeUndefined()
+        checkRecords(result)
+      }
     })
     it('should return a profile object with specified records', async () => {
       const result = await ENSInstance.getProfile(
         '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
         { texts: ['description', 'url'], coinTypes: ['ETC', '0'] },
       )
-      expect((result as any).name).toBe('jefflau.eth')
-      expect((result as any).address).toBeUndefined()
-      checkRecords(result, 2, 3)
+      expect(result).toBeDefined()
+      if (result) {
+        expect((result as any).name).toBe('jefflau.eth')
+        expect((result as any).address).toBeUndefined()
+        checkRecords(result, 2, 3)
+      }
     })
     it('should return a profile object with all of each specified record type', async () => {
       const result = await ENSInstance.getProfile(
@@ -80,11 +88,22 @@ describe('getProfile', () => {
       })
       checkRecords(result)
     })
-    it('should return null for an unregistered name', async () => {
+    it('should return undefined for an unregistered name', async () => {
       const result = await ENSInstance.getProfile('test123123123cool.eth')
       expect(result).toBeUndefined()
     })
   })
+  describe('with an old resolver', () => {
+    it('should use fallback methods for a name with an older resolver (no multicall)', async () => {
+      const result = await ENSInstance.getProfile('pepeq6.eth')
+      expect(result).toBeDefined()
+      if (result) {
+        expect(result.address).toBe(
+          '0x6308F1c6f283583C8bf8E31Da793B87718b051eD',
+        )
+      }
+    })
+  })
   describe('with an unmigrated name', () => {
     beforeAll(async () => {
       ;({ ENSInstance } = await setup(true))
@@ -95,7 +114,6 @@ describe('getProfile', () => {
       expect(result).toBeTruthy()
       if (result) {
         expect(result.isMigrated).toBe(false)
-        expect(result.message).toBe("Records fetch didn't complete")
       }
     })
   })

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/{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',
+    )
+  })
+})

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

@@ -1,7 +1,7 @@
 import { ethers } from 'ethers'
 import { ENS } from '..'
 import { hexEncodeName } from '../utils/hexEncodedName'
-import setup from './setup'
+import setup from '../tests/setup'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']

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

@@ -1,7 +1,7 @@
-import { utils } from 'ethers'
 import { ENS } from '..'
 import { hexEncodeName } from '../utils/hexEncodedName'
-import setup from './setup'
+import { namehash } from '../utils/normalise'
+import setup from '../tests/setup'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
@@ -31,14 +31,14 @@ describe('setRecords', () => {
     const encodedText = await universalResolver.resolve(
       hexEncodeName('parthtejpal.eth'),
       publicResolver.interface.encodeFunctionData('text(bytes32,string)', [
-        utils.namehash('parthtejpal.eth'),
+        namehash('parthtejpal.eth'),
         'foo',
       ]),
     )
     const encodedAddr = await universalResolver.resolve(
       hexEncodeName('parthtejpal.eth'),
       publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [
-        utils.namehash('parthtejpal.eth'),
+        namehash('parthtejpal.eth'),
         '61',
       ]),
     )