@ensdomains/ensjs 3.0.0-alpha.25 → 3.0.0-alpha.27

package/src/contracts/getContractAddress.ts

@@ -20,19 +20,19 @@ const addresses: Record<
     '1': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
     '3': '0xa5627AB7Ae47063B533622C34FEBDb52d3281dF8',
     '4': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
-    '5': '0x4a16c6Bbee697b66706E7dc0101BfCA1d60cdE76',
+    '5': '0x9C51161bA2FB02Cc0a403332B607117685f34831',
   },
   Multicall: '0xcA11bde05977b3631167028862bE2a173976CA11',
   NameWrapper: {
     '1': '0x0000000000000000000000000000000000000000',
     '3': '0xF82155e2a43Be0871821E9654Fc8Ae894FB8307C',
     '4': '0x0000000000000000000000000000000000000000',
-    '5': '0x9c4C40960B53e9A01af429D3f90aEf02Bd0c4c72',
+    '5': '0x582224b8d4534F4749EFA4f22eF7241E0C56D4B8',
   },
   PublicResolver: {
     '1': '0x4976fb03C32e5B8cfe2b6cCB31c09Ba78EBaBa41',
     '3': '0x13F0659Ee6bb7484C884FEeFb7F75C93951ef837',
-    '5': '0x58e4627848223BF59F8Ce34265c426E7B05E8625',
+    '5': '0xE264d5bb84bA3b8061ADC38D3D76e6674aB91852',
   },
   ENSRegistryWithFallback: {
     '1': '0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e',
@@ -49,7 +49,7 @@ const addresses: Record<
     '1': '0x580AF46E06DaaD47eb5940526FD64d95b815Cb70',
     '3': '0x74e20bd2a1fe0cdbe45b9a1d89cb7e0a45b36376',
     '4': '0x74e20bd2a1fe0cdbe45b9a1d89cb7e0a45b36376',
-    '5': '0x9380F1974D2B7064eA0c0EC251968D8c69f0Ae31',
+    '5': '0x687c30Cc44bFA39A1449e86E172BF002E7b3f0b0',
   },
   BulkRenewal: {
     '1': '0xfF252725f6122A92551A5FA9a6b6bf10eb0Be035',

package/src/functions/batchWrappers.ts

@@ -1,5 +1,6 @@
 import { ethers } from 'ethers'
 import { ENSArgs } from '..'
+import ccipLookup from '../utils/ccip'
 import { hexEncodeName } from '../utils/hexEncodedName'
 
 export const universalWrapper = {
@@ -11,16 +12,16 @@ export const universalWrapper = {
     const universalResolver = await contracts?.getUniversalResolver()!
     return {
       to: universalResolver.address,
-      data: universalResolver.interface.encodeFunctionData('resolve', [
-        hexEncodeName(name),
-        data,
-      ]),
+      data: universalResolver.interface.encodeFunctionData(
+        'resolve(bytes,bytes)',
+        [hexEncodeName(name), data],
+      ),
     }
   },
   decode: async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
     const universalResolver = await contracts?.getUniversalResolver()!
     const response = universalResolver.interface.decodeFunctionResult(
-      'resolve',
+      'resolve(bytes,bytes)',
       data,
     )
     if (!response || !response[0]) {
@@ -75,7 +76,11 @@ export const multicallWrapper = {
       ]),
     }
   },
-  async decode({ contracts }: ENSArgs<'contracts'>, data: string) {
+  async decode(
+    { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
+    data: string,
+    transactions: ethers.providers.TransactionRequest[],
+  ) {
     if (!data) return
     const multicall = await contracts?.getMulticall()!
     try {
@@ -83,9 +88,35 @@ export const multicallWrapper = {
         'tryAggregate',
         data,
       )
-      return result
-    } catch (e) {
-      return e
+      const ccipChecked = await Promise.all(
+        (result as [boolean, string][]).map(
+          async ([success, returnData], i) => {
+            let newArr: [boolean, string] = [success, returnData]
+            // OffchainLookup(address,string[],bytes,bytes4,bytes)
+            if (!success && returnData.startsWith('0x556f1830')) {
+              try {
+                const newData = await ccipLookup(
+                  provider!,
+                  transactions[i],
+                  returnData,
+                )
+                if (newData) {
+                  newArr = [true, newData]
+                }
+              } catch {}
+            }
+            return {
+              ...newArr,
+              success: newArr[0],
+              returnData: newArr[1],
+            }
+          },
+        ),
+      )
+      return ccipChecked
+    } catch (e: any) {
+      console.error(e)
+      return
     }
   },
 }

package/src/functions/deleteSubname.test.ts

@@ -29,7 +29,10 @@ describe('deleteSubname', () => {
     const result = await registry.owner(namehash('test.with-subnames.eth'))
     expect(result).toBe('0x0000000000000000000000000000000000000000')
   })
+
   it('should allow deleting a subname on the nameWrapper', async () => {
+    const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+
     const tx = await ensInstance.deleteSubname(
       'test.wrapped-with-subnames.eth',
       {
@@ -40,10 +43,27 @@ describe('deleteSubname', () => {
     expect(tx).toBeTruthy()
     await tx.wait()
 
-    const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
     const result = await nameWrapper.ownerOf(
       namehash('test.wrapped-with-subnames.eth'),
     )
     expect(result).toBe('0x0000000000000000000000000000000000000000')
   })
+
+  it('should not allow deleting 1LD', async () => {
+    await expect(
+      ensInstance.deleteSubname('eth', {
+        contract: 'nameWrapper',
+        addressOrIndex: 1,
+      }),
+    ).rejects.toThrow()
+  })
+
+  it('should not allow deleting 2LD', async () => {
+    await expect(
+      ensInstance.deleteSubname('test123.eth', {
+        contract: 'registry',
+        addressOrIndex: 1,
+      }),
+    ).rejects.toThrow()
+  })
 })

package/src/functions/deleteSubname.ts

@@ -13,12 +13,8 @@ export default async function (
 ) {
   const labels = name.split('.')
 
-  if (labels.length !== 3) {
-    throw new Error('ENS.js currently only supports deleting 2LDs, not TLDs')
-  }
-
-  if (labels[2] !== 'eth') {
-    throw new Error('ENS.js currently only supports deleting .eth 2LDs')
+  if (labels.length < 3) {
+    throw new Error(`${name} is not a valid subname`)
   }
 
   const label = labels.shift() as string

package/src/functions/getName.ts

@@ -6,7 +6,7 @@ const raw = async ({ contracts }: ENSArgs<'contracts'>, address: string) => {
   const reverseNode = `${address.toLowerCase().substring(2)}.addr.reverse`
   return {
     to: universalResolver.address,
-    data: universalResolver.interface.encodeFunctionData('reverse', [
+    data: universalResolver.interface.encodeFunctionData('reverse(bytes)', [
       hexEncodeName(reverseNode),
     ]),
   }
@@ -21,7 +21,7 @@ const decode = async (
   const universalResolver = await contracts?.getUniversalResolver()!
   try {
     const result = universalResolver.interface.decodeFunctionResult(
-      'reverse',
+      'reverse(bytes)',
       data,
     )
     return {

package/src/functions/getOwner.ts

@@ -100,7 +100,7 @@ const decode = async (
   name: string,
   contract?: 'nameWrapper' | 'registry' | 'registrar',
 ): Promise<Owner | undefined> => {
-  if (data === null) return
+  if (!data) return
   const labels = name.split('.')
   if (contract || labels.length === 1) {
     const singleOwner = singleContractOwnerDecode(data)
@@ -119,7 +119,7 @@ const decode = async (
     }
   }
   const result = await multicallWrapper.decode(data)
-  if (result === null) return
+  if (!result) return
   const nameWrapper = await contracts?.getNameWrapper()!
 
   const decodedData = [result[0][1], result[1][1], result[2]?.[1]].map(
@@ -163,6 +163,7 @@ const decode = async (
       // this means that the subname is wrapped
       if (
         registryOwner === nameWrapper.address &&
+        nameWrapperOwner &&
         ethers.utils.hexStripZeros(nameWrapperOwner) !== '0x'
       ) {
         return {
@@ -186,6 +187,7 @@ const decode = async (
   // and for wrapped names, owner and registrant are the same thing
   if (
     registryOwner === nameWrapper.address &&
+    nameWrapperOwner &&
     ethers.utils.hexStripZeros(nameWrapperOwner) !== '0x'
   ) {
     return {

package/src/functions/getProfile-ccip.test.ts

@@ -0,0 +1,29 @@
+import dotenv from 'dotenv'
+import { ENS } from '..'
+import setup from '../tests/setup'
+
+dotenv.config()
+
+let ensInstance: ENS
+
+beforeAll(async () => {
+  ;({ ensInstance } = await setup(true))
+})
+
+jest.setTimeout(20000)
+
+describe('getProfile', () => {
+  it('should return a profile from a ccip-read name', async () => {
+    const result = await ensInstance.getProfile('1.offchainexample.eth', {
+      fallback: {
+        texts: ['email', 'description'],
+        contentHash: true,
+        coinTypes: ['0', '60'],
+      },
+    })
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result.address).toBe('0x41563129cDbbD0c5D3e1c86cf9563926b243834d')
+    }
+  })
+})

package/src/functions/getProfile.test.ts

@@ -129,7 +129,7 @@ describe('getProfile', () => {
           '0x70997970C51812dc3A010C7d01b50e0d17dc79C8',
         )
         expect(result.resolverAddress).toBe(
-          deploymentAddresses.NoMulticallResolver.toLowerCase(),
+          deploymentAddresses.NoMulticallResolver,
         )
       }
     })

package/src/functions/getProfile.ts

@@ -1,5 +1,6 @@
 import { formatsByName } from '@ensdomains/address-encoder'
 import { ethers } from 'ethers'
+import { hexStripZeros } from 'ethers/lib/utils'
 import { ENSArgs } from '..'
 import { decodeContenthash, DecodedContentHash } from '../utils/contentHash'
 import { hexEncodeName } from '../utils/hexEncodedName'
@@ -18,6 +19,12 @@ type ProfileResponse = {
   coinTypes?: string[]
 }
 
+type FallbackRecords = {
+  contentHash?: boolean
+  texts?: string[]
+  coinTypes?: string[]
+}
+
 type DataItem = {
   key: string | number
   type: 'addr' | 'text' | 'contentHash'
@@ -41,19 +48,25 @@ type ResolvedProfile = {
   reverseResolverAddress?: string
 }
 
+type CallObj = {
+  key: string
+  data: {
+    to: string
+    data: string
+  }
+  type: 'addr' | 'text' | 'contentHash'
+}
+
 const makeMulticallData = async (
   {
     _getAddr,
     _getContentHash,
     _getText,
-    resolverMulticallWrapper,
-  }: ENSArgs<
-    '_getText' | '_getAddr' | '_getContentHash' | 'resolverMulticallWrapper'
-  >,
+  }: ENSArgs<'_getText' | '_getAddr' | '_getContentHash'>,
   name: string,
   options: InternalProfileOptions,
 ) => {
-  let calls: any[] = []
+  let calls: (CallObj | null)[] = []
   if (options.texts)
     calls = [
       ...calls,
@@ -61,7 +74,7 @@ const makeMulticallData = async (
         options.texts.map(async (x) => ({
           key: x,
           data: await _getText.raw(name, x),
-          type: 'text',
+          type: 'text' as const,
         })),
       )),
     ]
@@ -73,7 +86,7 @@ const makeMulticallData = async (
         options.coinTypes.map(async (x) => ({
           key: x,
           data: await _getAddr.raw(name, x, true),
-          type: 'addr',
+          type: 'addr' as const,
         })),
       )),
     ]
@@ -82,21 +95,19 @@ const makeMulticallData = async (
     calls.push({
       key: 'contentHash',
       data: await _getContentHash.raw(name),
-      type: 'contenthash',
+      type: 'contentHash' as const,
     })
   }
 
-  if (!calls.find((x) => x.key === '60')) {
+  if (!calls.find((x) => x!.key === '60')) {
     calls.push({
       key: '60',
       data: await _getAddr.raw(name, '60', true),
-      type: 'addr',
+      type: 'addr' as const,
     })
   }
 
-  const prRawData = await resolverMulticallWrapper.raw(calls.map((x) => x.data))
-
-  return { data: prRawData.data, calls }
+  return { data: calls.map((x) => x!.data.data), calls }
 }
 
 const fetchWithoutResolverMulticall = async (
@@ -116,9 +127,11 @@ const fetchWithoutResolverMulticall = async (
     data: call.data.data,
   }))
 
-  return (await multicallWrapper(callsWithResolver)).map(
-    (x: [boolean, string]) => x[1],
-  )
+  const results = await multicallWrapper(callsWithResolver)
+
+  if (!results || !results.length) return []
+
+  return results.map((x: [boolean, string]) => x[1])
 }
 
 const formatRecords = async (
@@ -139,7 +152,7 @@ const formatRecords = async (
           key: calls[i].key,
           type: calls[i].type,
         }
-        if (itemRet.type === 'contenthash') {
+        if (itemRet.type === 'contentHash') {
           ;[decodedFromAbi] = ethers.utils.defaultAbiCoder.decode(
             ['bytes'],
             item,
@@ -171,7 +184,7 @@ const formatRecords = async (
             } catch {
               return
             }
-          case 'contenthash':
+          case 'contentHash':
             try {
               itemRet = {
                 ...itemRet,
@@ -217,7 +230,7 @@ const formatRecords = async (
     }
   } else if (options.contentHash) {
     const foundRecord = returnedRecords.find(
-      (item: any) => item.type === 'contenthash',
+      (item: any) => item.type === 'contentHash',
     )
     returnedResponse.contentHash = foundRecord ? foundRecord.value : null
   }
@@ -240,7 +253,6 @@ const getDataForName = async (
     _getAddr,
     _getContentHash,
     _getText,
-    resolverMulticallWrapper,
     multicallWrapper,
   }: ENSArgs<
     | 'contracts'
@@ -252,62 +264,77 @@ const getDataForName = async (
   >,
   name: string,
   options: InternalProfileOptions,
-  fallbackResolver?: string,
   specificResolver?: string,
 ) => {
-  const universalResolver = await contracts?.getUniversalResolver()
+  const universalResolver = await contracts?.getUniversalResolver()!
 
   const { data, calls } = await makeMulticallData(
-    { _getAddr, _getContentHash, _getText, resolverMulticallWrapper },
+    { _getAddr, _getContentHash, _getText },
     name,
     options,
   )
 
-  let resolvedData: any
-  let useFallbackResolver = false
-  try {
-    if (specificResolver) {
+  let recordData: (string | null)[] | undefined
+  let resolverAddress: string | undefined = specificResolver
+
+  if (specificResolver) {
+    try {
       const publicResolver = await contracts?.getPublicResolver(
         undefined,
         specificResolver,
       )
-      resolvedData = await publicResolver?.callStatic.multicall(
-        calls.map((x) => x.data),
+      recordData = await publicResolver?.callStatic.multicall(data)
+    } catch (e: any) {
+      console.error('getProfile error:', e)
+      recordData = await fetchWithoutResolverMulticall(
+        { multicallWrapper },
+        calls as CallObj[],
+        resolverAddress!,
       )
-    } 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 resolvedData = await universalResolver['resolve(bytes,bytes[])'](
+      hexEncodeName(name),
+      data,
+      {
+        ccipReadEnabled: true,
+      },
+    )
+    recordData = [...resolvedData['0']]
+    resolverAddress = resolvedData['1']
+    for (let i = 0; i < recordData.length; i += 1) {
+      // error code for reverted call in batch
+      // this is expected when using offchain resolvers, so should be ignored
+      if (recordData[i]!.startsWith('0x0d1947a9')) {
+        calls[i] = null
+        recordData[i] = null
+      }
+    }
+  }
+  if (
+    !resolverAddress ||
+    !recordData ||
+    hexStripZeros(resolverAddress) === '0x'
+  ) {
+    return {
+      address: null,
+      records: {},
+      resolverAddress: null,
     }
   }
 
-  const matchAddress = recordData[calls.findIndex((x) => x.key === '60')]
+  const filteredCalls = calls.filter((x) => x) as CallObj[]
+  const filteredRecordData = recordData.filter((x) => x)
+
+  const matchAddress =
+    filteredRecordData[filteredCalls.findIndex((x) => x.key === '60')]
 
   return {
     address: matchAddress && (await _getAddr.decode(matchAddress)),
     records: await formatRecords(
       { _getAddr, _getContentHash, _getText },
-      recordData,
-      calls,
+      filteredRecordData,
+      filteredCalls,
       options,
     ),
     resolverAddress,
@@ -332,7 +359,6 @@ const graphFetch = async (
           addr {
             id
           }
-          address
         }
       }
     }
@@ -379,14 +405,7 @@ const graphFetch = async (
 
   const returnedRecords: ProfileResponse = {}
 
-  if (!resolverResponse) return { isMigrated, createdAt }
-
-  if (!wantedRecords)
-    return {
-      isMigrated,
-      createdAt,
-      graphResolverAddress: resolverResponse.address || resolverAddress,
-    }
+  if (!resolverResponse || !wantedRecords) return { isMigrated, createdAt }
 
   Object.keys(wantedRecords).forEach((key: string) => {
     const data = wantedRecords[key as keyof ProfileOptions]
@@ -403,7 +422,6 @@ const graphFetch = async (
     ...returnedRecords,
     isMigrated,
     createdAt,
-    graphResolverAddress: resolverResponse.address || resolverAddress,
   }
 }
 
@@ -415,6 +433,7 @@ type ProfileOptions = {
 
 type InputProfileOptions = ProfileOptions & {
   resolverAddress?: string
+  fallback?: FallbackRecords
 }
 
 const getProfileFromName = async (
@@ -438,7 +457,7 @@ const getProfileFromName = async (
   name: string,
   options?: InputProfileOptions,
 ) => {
-  const { resolverAddress, ..._options } = options || {}
+  const { resolverAddress, fallback, ..._options } = options || {}
   const optsLength = Object.keys(_options).length
   let usingOptions: InputProfileOptions | undefined
   if (!optsLength || _options?.texts === true || _options?.coinTypes === true) {
@@ -452,35 +471,69 @@ const getProfileFromName = async (
     usingOptions,
     resolverAddress,
   )
-  if (!graphResult) return
-  const {
-    isMigrated,
-    createdAt,
-    graphResolverAddress,
-    ...wantedRecords
-  }: {
-    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,
-      _getAddr,
-      _getContentHash,
-      _getText,
-      resolverMulticallWrapper,
-      multicallWrapper,
-    },
-    name,
-    usingOptions ? wantedRecords : (options as InternalProfileOptions),
-    graphResolverAddress,
-    options?.resolverAddress!,
-  )
-  if (!result)
-    return { isMigrated, createdAt, message: "Records fetch didn't complete" }
+  let isMigrated: boolean | null = null
+  let createdAt: string | null = null
+  let result: Awaited<ReturnType<typeof getDataForName>> | null = null
+  if (!graphResult) {
+    if (!fallback) return
+    result = await getDataForName(
+      {
+        contracts,
+        _getAddr,
+        _getContentHash,
+        _getText,
+        resolverMulticallWrapper,
+        multicallWrapper,
+      },
+      name,
+      fallback,
+      undefined,
+    )
+  } else {
+    const {
+      isMigrated: _isMigrated,
+      createdAt: _createdAt,
+      ...wantedRecords
+    }: {
+      isMigrated: boolean
+      createdAt: string
+    } & InternalProfileOptions = graphResult
+    isMigrated = _isMigrated
+    createdAt = _createdAt
+    let recordsWithFallback = usingOptions
+      ? wantedRecords
+      : (_options as InternalProfileOptions)
+    if (
+      (Object.keys(recordsWithFallback).length === 0 ||
+        (!recordsWithFallback.coinTypes &&
+          !recordsWithFallback.texts &&
+          Object.keys(recordsWithFallback.contentHash || {}).length === 0)) &&
+      fallback
+    ) {
+      recordsWithFallback = fallback
+    }
+    result = await getDataForName(
+      {
+        contracts,
+        _getAddr,
+        _getContentHash,
+        _getText,
+        resolverMulticallWrapper,
+        multicallWrapper,
+      },
+      name,
+      recordsWithFallback,
+      options?.resolverAddress!,
+    )
+  }
+  if (!result?.resolverAddress)
+    return {
+      isMigrated,
+      createdAt,
+      message: !result
+        ? "Records fetch didn't complete"
+        : "Name doesn't have a resolver",
+    }
   return { ...result, isMigrated, createdAt, message: undefined }
 }
 
@@ -537,6 +590,13 @@ const getProfileFromAddress = async (
   }
 }
 
+const mapCoinTypes = (coin: string) => {
+  if (!Number.isNaN(parseInt(coin))) {
+    return coin
+  }
+  return `${formatsByName[coin.toUpperCase()].coinType}`
+}
+
 export default async function (
   {
     contracts,
@@ -560,13 +620,13 @@ export default async function (
   nameOrAddress: string,
   options?: InputProfileOptions,
 ): Promise<ResolvedProfile | undefined> {
-  if (options && options.coinTypes && typeof options.coinTypes !== 'boolean') {
-    options.coinTypes = options.coinTypes.map((coin: string) => {
-      if (!Number.isNaN(parseInt(coin))) {
-        return coin
-      }
-      return `${formatsByName[coin.toUpperCase()].coinType}`
-    })
+  if (options) {
+    if (options.coinTypes && typeof options.coinTypes !== 'boolean') {
+      options.coinTypes = options.coinTypes.map(mapCoinTypes)
+    }
+    if (options.fallback && options.fallback.coinTypes) {
+      options.fallback.coinTypes = options.fallback.coinTypes.map(mapCoinTypes)
+    }
   }
 
   const inputType = parseInputType(nameOrAddress)