@ensdomains/ensjs 3.0.0-alpha.17 → 3.0.0-alpha.18

package/src/functions/getProfile.ts

@@ -54,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) => ({
@@ -64,9 +64,10 @@ const makeMulticallData = async (
           type: 'text',
         })),
       )),
-    ])
-  options.coinTypes &&
-    (calls = [
+    ]
+
+  if (options.coinTypes)
+    calls = [
       ...calls,
       ...(await Promise.all(
         options.coinTypes.map(async (x) => ({
@@ -75,7 +76,8 @@ const makeMulticallData = async (
           type: 'addr',
         })),
       )),
-    ])
+    ]
+
   if (typeof options.contentHash === 'boolean' && options.contentHash) {
     calls.push({
       key: 'contentHash',
@@ -119,86 +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,
-  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 formatRecords = async (
   {
     _getText,
@@ -209,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
@@ -218,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
           }
@@ -255,9 +177,11 @@ const formatRecords = async (
                 ...itemRet,
                 value: await _getContentHash.decode(item),
               }
+              break
             } catch {
               return
             }
+          // no default
         }
         return itemRet
       }),
@@ -268,7 +192,7 @@ const formatRecords = async (
     })
     .filter((x) => x)
 
-  let returnedResponse: {
+  const returnedResponse: {
     contentHash?: string | null | DecodedContentHash
     coinTypes?: DataItem[]
     texts?: DataItem[]
@@ -310,6 +234,86 @@ 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,
@@ -351,7 +355,7 @@ const graphFetch = async (
     }
   `
 
-  const client = gqlInstance.client
+  const { client } = gqlInstance
 
   const id = namehash(name)
 
@@ -373,7 +377,7 @@ const graphFetch = async (
 
   const { isMigrated, createdAt } = domain
 
-  let returnedRecords: ProfileResponse = {}
+  const returnedRecords: ProfileResponse = {}
 
   if (!resolverResponse) return { isMigrated, createdAt }
 
@@ -436,12 +440,11 @@ const getProfileFromName = async (
 ) => {
   const { resolverAddress, ..._options } = options || {}
   const optsLength = Object.keys(_options).length
-  const usingOptions =
-    !optsLength || _options?.texts === true || _options?.coinTypes === true
-      ? optsLength
-        ? _options
-        : { contentHash: true, texts: true, coinTypes: true }
-      : undefined
+  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 },
@@ -559,11 +562,10 @@ export default async function (
 ): 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

@@ -19,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

@@ -1,15 +1,15 @@
 import { ENS } from '..'
 import setup from '../tests/setup'
 
-let ENSInstance: ENS
+let ensInstance: ENS
 
 beforeAll(async () => {
-  ;({ ENSInstance } = await setup())
+  ;({ 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')
+    const result = await ensInstance.getResolver('with-profile.eth')
     expect(result).toBe('0x1613beB3B2C4f22Ee086B2b38C1476A3cE7f78E8')
   })
 })

package/src/functions/getSpecificRecord.test.ts

@@ -1,24 +1,24 @@
 import { ENS } from '..'
 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('with-profile.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('with-contenthash.eth')
+      const result = await ensInstance.getContentHash('with-contenthash.eth')
       expect(result).toMatchObject({
         protocolType: 'ipfs',
         decoded: 'bafybeico3uuyj3vphxpvbowchdwjlrlrh62awxscrnii7w7flu5z6fk77y',
@@ -29,7 +29,7 @@ describe('getSpecificRecord', () => {
 
   describe('getText', () => {
     it('should return a record from a key', async () => {
-      const result = await ENSInstance.getText(
+      const result = await ensInstance.getText(
         'with-profile.eth',
         'description',
       )
@@ -37,7 +37,7 @@ describe('getSpecificRecord', () => {
     })
 
     it('should return null for a non-existent key', async () => {
-      const result = await ENSInstance.getText(
+      const result = await ensInstance.getText(
         'with-profile.eth',
         'thiskeydoesntexist',
       )
@@ -47,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('with-profile.eth')
+      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('with-profile.eth', 61)
+      const result = await ensInstance.getAddr('with-profile.eth', 61)
       expect((result as any).addr).toBe(
         '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('with-profile.eth', '61')
+      const result = await ensInstance.getAddr('with-profile.eth', '61')
       expect((result as any).addr).toBe(
         '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('with-profile.eth', 'ETC')
+      const result = await ensInstance.getAddr('with-profile.eth', 'ETC')
       expect((result as any).addr).toBe(
         '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       )
       expect((result as any).coin).toBe('ETC')
     })
     it('should return null for a non-existent coin', async () => {
-      const result = await ENSInstance.getAddr('with-profile.eth', 'BNB')
+      const result = await ensInstance.getAddr('with-profile.eth', 'BNB')
       expect(result).toBeUndefined()
     })
   })

package/src/functions/getSpecificRecord.ts

@@ -51,7 +51,7 @@ export const getContentHash = {
     name: string,
   ) => {
     const prData = await _getContentHash.raw({ contracts }, name)
-    return await universalWrapper.raw(name, prData.data)
+    return universalWrapper.raw(name, prData.data)
   },
   decode: async (
     { contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>,
@@ -59,7 +59,7 @@ export const getContentHash = {
   ) => {
     const urData = await universalWrapper.decode(data)
     if (!urData) return
-    return await _getContentHash.decode({ contracts }, urData.data)
+    return _getContentHash.decode({ contracts }, urData.data)
   },
 }
 
@@ -98,7 +98,7 @@ export const getText = {
     key: string,
   ) => {
     const prData = await _getText.raw({ contracts }, name, key)
-    return await universalWrapper.raw(name, prData.data)
+    return universalWrapper.raw(name, prData.data)
   },
   decode: async (
     { contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>,
@@ -106,7 +106,7 @@ export const getText = {
   ) => {
     const urData = await universalWrapper.decode(data)
     if (!urData) return
-    return await _getText.decode({ contracts }, urData.data)
+    return _getText.decode({ contracts }, urData.data)
   },
 }
 
@@ -142,7 +142,7 @@ export const _getAddr = {
       }
     }
     const formatter =
-      typeof coinType === 'string' && isNaN(parseInt(coinType))
+      typeof coinType === 'string' && Number.isNaN(parseInt(coinType))
         ? formatsByName[coinType]
         : formatsByCoinType[
             typeof coinType === 'number' ? coinType : parseInt(coinType)
@@ -174,7 +174,7 @@ export const _getAddr = {
 
     const publicResolver = await contracts?.getPublicResolver()!
     const formatter =
-      typeof coinType === 'string' && isNaN(parseInt(coinType))
+      typeof coinType === 'string' && Number.isNaN(parseInt(coinType))
         ? formatsByName[coinType]
         : formatsByCoinType[
             typeof coinType === 'number' ? coinType : parseInt(coinType)
@@ -221,7 +221,7 @@ export const getAddr = {
     coinType?: string | number,
   ) => {
     const prData = await _getAddr.raw({ contracts }, name, coinType)
-    return await universalWrapper.raw(name, prData.data)
+    return universalWrapper.raw(name, prData.data)
   },
   decode: async (
     { contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>,
@@ -231,141 +231,6 @@ export const getAddr = {
   ) => {
     const urData = await universalWrapper.decode(data)
     if (!urData) return
-    return await _getAddr.decode({ contracts }, urData.data, _name, coinType)
+    return _getAddr.decode({ contracts }, urData.data, _name, coinType)
   },
 }
-
-// export async function getAddr(
-//   { contracts }: ENSArgs<'contracts'>,
-//   name: string,
-//   coinType?: string | number,
-// ) {
-//   if (!coinType) {
-//     coinType = 60
-//   }
-
-//   const universalResolver = await contracts?.getUniversalResolver()
-//   const publicResolver = await contracts?.getPublicResolver()
-//   const formatter =
-//     typeof coinType === 'string'
-//       ? formatsByName[coinType]
-//       : formatsByCoinType[coinType]
-
-//   if (!formatter) {
-//     throw new Error(`Coin type ${coinType} is not supported`)
-//   }
-
-//   const data = publicResolver?.interface.encodeFunctionData(
-//     'addr(bytes32,uint256)',
-//     [ethers.utils.namehash(name), formatter.coinType],
-//   )
-//   const result = await universalResolver?.resolve(hexEncodeName(name), data)
-
-//   const [encodedAddr] = ethers.utils.defaultAbiCoder.decode(
-//     ['bytes'],
-//     result['0'],
-//   )
-
-//   if (ethers.utils.hexStripZeros(encodedAddr) === '0x') {
-//     return
-//   }
-
-//   const decodedAddr = formatter.encoder(
-//     Buffer.from(encodedAddr.slice(2), 'hex'),
-//   )
-
-//   if (!decodedAddr) {
-//     return
-//   }
-
-//   return decodedAddr
-// }
-
-// export const getContentHash = {
-//   raw: async ({ contracts }: ENSArgs<'contracts'>, name: string) => {
-//     const universalResolver = await contracts?.getUniversalResolver()!
-//     const publicResolver = await contracts?.getPublicResolver()!
-//     const prData = publicResolver.interface.encodeFunctionData(
-//       'contenthash(bytes32)',
-//       [ethers.utils.namehash(name)],
-//     )
-//     const urData = universalResolver.interface.encodeFunctionData(
-//       'resolve(bytes,bytes)',
-//       [hexEncodeName(name), prData],
-//     )
-
-//     return {
-//       to: universalResolver.address,
-//       data: urData,
-//     }
-//   },
-//   decode: async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
-//     const universalResolver = await contracts?.getUniversalResolver()!
-//     const publicResolver = await contracts?.getPublicResolver()!
-//     const response = universalResolver.interface.decodeFunctionResult(
-//       'resolve(bytes,bytes)',
-//       data,
-//     )
-
-//     if (!response || !response[1]) {
-//       return
-//     }
-
-//     const [encodedContentHash] = publicResolver.interface.decodeFunctionResult(
-//       'contenthash(bytes32)',
-//       response[0],
-//     )
-
-//     if (ethers.utils.hexStripZeros(encodedContentHash) === '0x') {
-//       return
-//     }
-
-//     return decodeContenthash(encodedContentHash)
-//   },
-// }
-
-// const getText = {
-//   raw: async (
-//     { contracts }: ENSArgs<'contracts'>,
-//     name: string,
-//     key: string,
-//   ) => {
-//     const universalResolver = await contracts?.getUniversalResolver()!
-//     const publicResolver = await contracts?.getPublicResolver()!
-//     const data = publicResolver.interface.encodeFunctionData(
-//       'text(bytes32,string)',
-//       [ethers.utils.namehash(name), key],
-//     )
-
-//     return {
-//       to: universalResolver.address,
-//       data: universalResolver.interface.encodeFunctionData(
-//         'resolve(bytes,bytes)',
-//         [hexEncodeName(name), data],
-//       ),
-//     }
-//   },
-//   decode: async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
-//     const universalResolver = await contracts?.getUniversalResolver()!
-//     const publicResolver = await contracts?.getPublicResolver()!
-//     const response = universalResolver.interface.decodeFunctionResult(
-//       'resolve(bytes,bytes)',
-//       data,
-//     )
-
-//     if (!response || !response[1]) {
-//       return
-//     }
-
-//     const [decodedText] = publicResolver.interface.decodeFunctionResult(
-//       'text(bytes32,string)',
-//       response[0],
-//     )
-
-//     if (decodedText === '') {
-//       return
-//     }
-
-//     return decodedText
-//   },
-// }

package/src/functions/getSubnames.test.ts

@@ -1,19 +1,19 @@
-import { ENS } from '..'
-import setup from '../tests/setup'
+// import { ENS } from '..'
+// import setup from '../tests/setup'
 
-let ENSInstance: ENS
+// let ensInstance: ENS
 
-beforeAll(async () => {
-  ;({ ENSInstance } = await setup())
-})
+// beforeAll(async () => {
+//   ;({ ensInstance } = await setup())
+// })
 
-const testProperties = (obj: object, ...properties: string[]) =>
-  properties.map((property) => expect(obj).toHaveProperty(property))
+// 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({
+  //   const result = await ensInstance.getSubnames({
   //     name: 'with-profile.eth',
   //   })
   //   expect(result).toBeTruthy()

package/src/functions/getSubnames.ts

@@ -27,18 +27,11 @@ type Params = {
 
 const largeQuery = async (
   { gqlInstance }: ENSArgs<'gqlInstance'>,
-  {
-    name,
-    page,
-    pageSize = 10,
-    orderDirection,
-    orderBy,
-    lastSubnames = [],
-  }: Params,
+  { name, pageSize = 10, orderDirection, orderBy, lastSubnames = [] }: Params,
 ) => {
-  const client = gqlInstance.client
+  const { client } = gqlInstance
 
-  let finalQuery = gqlInstance.gql`
+  const finalQuery = gqlInstance.gql`
     query getSubnames(
       $id: ID! 
       $first: Int
@@ -70,7 +63,7 @@ const largeQuery = async (
       }
     }
   `
-  let queryVars = {
+  const queryVars = {
     id: namehash(name),
     first: pageSize,
     lastCreatedAt: lastSubnames[lastSubnames.length - 1]?.createdAt,
@@ -97,7 +90,7 @@ const smallQuery = async (
   { gqlInstance }: ENSArgs<'gqlInstance'>,
   { name, page, pageSize = 10, orderDirection, orderBy }: Params,
 ) => {
-  const client = gqlInstance.client
+  const { client } = gqlInstance
   const subdomainsGql = `
   id
   labelName