@ensdomains/ensjs 3.0.0-alpha.35 → 3.0.0-alpha.36

package/dist/cjs/functions/getNames.js

@@ -303,9 +303,9 @@ const getNames = async ({ gqlInstance }, {
   const { account } = await client.request(finalQuery, queryVars);
   if (type === "all") {
     return [
-      ...account.domains.map(mapDomain),
-      ...account.registrations.map(mapRegistration),
-      ...account.wrappedDomains.map(mapWrappedDomain)
+      ...account?.domains.map(mapDomain) || [],
+      ...account?.registrations.map(mapRegistration) || [],
+      ...account?.wrappedDomains.map(mapWrappedDomain) || []
     ].sort((a, b) => {
       if (orderDirection === "desc") {
         if (orderBy === "labelName") {
@@ -320,11 +320,11 @@ const getNames = async ({ gqlInstance }, {
     });
   }
   if (type === "owner") {
-    return account.domains.map(mapDomain);
+    return account?.domains.map(mapDomain) || [];
   }
   if (type === "wrappedOwner") {
-    return account.wrappedDomains.map(mapWrappedDomain);
+    return account?.wrappedDomains.map(mapWrappedDomain) || [];
   }
-  return account.registrations.map(mapRegistration);
+  return account?.registrations.map(mapRegistration) || [];
 };
 var getNames_default = getNames;

package/dist/cjs/functions/getProfile.js

@@ -202,34 +202,45 @@ const getDataForName = async ({
       );
     }
   } else {
-    const resolvedData = await universalResolver["resolve(bytes,bytes[])"](
-      (0, import_hexEncodedName.hexEncodeName)(name),
-      data,
-      {
-        ccipReadEnabled: true
-      }
-    );
-    recordData = [...resolvedData["0"]];
-    resolverAddress = resolvedData["1"];
-    for (let i = 0; i < recordData.length; i += 1) {
-      if (recordData[i].startsWith("0x0d1947a9")) {
-        calls[i] = null;
-        recordData[i] = null;
+    try {
+      const resolvedData = await universalResolver["resolve(bytes,bytes[])"](
+        (0, import_hexEncodedName.hexEncodeName)(name),
+        data,
+        {
+          ccipReadEnabled: true
+        }
+      );
+      recordData = [...resolvedData["0"]];
+      resolverAddress = resolvedData["1"];
+      for (let i = 0; i < recordData.length; i += 1) {
+        if (recordData[i].startsWith("0x0d1947a9")) {
+          calls[i] = null;
+          recordData[i] = null;
+        }
       }
+    } catch {
+      const registryContract = await contracts?.getRegistry();
+      resolverAddress = await registryContract?.resolver((0, import_normalise.namehash)(name));
+      return {
+        address: void 0,
+        records: {},
+        resolverAddress,
+        isInvalidResolverAddress: true
+      };
     }
   }
   if (!resolverAddress || !recordData || (0, import_utils.hexStripZeros)(resolverAddress) === "0x") {
     return {
-      address: null,
+      address: void 0,
       records: {},
-      resolverAddress: null
+      resolverAddress: void 0
     };
   }
   const filteredCalls = calls.filter((x) => x);
   const filteredRecordData = recordData.filter((x) => x);
   const matchAddress = filteredRecordData[filteredCalls.findIndex((x) => x.key === "60")];
   return {
-    address: matchAddress && await _getAddr.decode(matchAddress),
+    address: matchAddress && await _getAddr.decode(matchAddress).catch(() => false),
     records: await formatRecords(
       { _getAddr, _getContentHash, _getText },
       filteredRecordData,

package/dist/esm/functions/getNames.mjs

@@ -281,9 +281,9 @@ var getNames = async ({ gqlInstance }, {
   const { account } = await client.request(finalQuery, queryVars);
   if (type === "all") {
     return [
-      ...account.domains.map(mapDomain),
-      ...account.registrations.map(mapRegistration),
-      ...account.wrappedDomains.map(mapWrappedDomain)
+      ...account?.domains.map(mapDomain) || [],
+      ...account?.registrations.map(mapRegistration) || [],
+      ...account?.wrappedDomains.map(mapWrappedDomain) || []
     ].sort((a, b) => {
       if (orderDirection === "desc") {
         if (orderBy === "labelName") {
@@ -298,12 +298,12 @@ var getNames = async ({ gqlInstance }, {
     });
   }
   if (type === "owner") {
-    return account.domains.map(mapDomain);
+    return account?.domains.map(mapDomain) || [];
   }
   if (type === "wrappedOwner") {
-    return account.wrappedDomains.map(mapWrappedDomain);
+    return account?.wrappedDomains.map(mapWrappedDomain) || [];
   }
-  return account.registrations.map(mapRegistration);
+  return account?.registrations.map(mapRegistration) || [];
 };
 var getNames_default = getNames;
 export {

package/dist/esm/functions/getProfile.mjs

@@ -180,34 +180,45 @@ var getDataForName = async ({
       );
     }
   } else {
-    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) {
-      if (recordData[i].startsWith("0x0d1947a9")) {
-        calls[i] = null;
-        recordData[i] = null;
+    try {
+      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) {
+        if (recordData[i].startsWith("0x0d1947a9")) {
+          calls[i] = null;
+          recordData[i] = null;
+        }
       }
+    } catch {
+      const registryContract = await contracts?.getRegistry();
+      resolverAddress = await registryContract?.resolver(namehash(name));
+      return {
+        address: void 0,
+        records: {},
+        resolverAddress,
+        isInvalidResolverAddress: true
+      };
     }
   }
   if (!resolverAddress || !recordData || hexStripZeros(resolverAddress) === "0x") {
     return {
-      address: null,
+      address: void 0,
       records: {},
-      resolverAddress: null
+      resolverAddress: void 0
     };
   }
   const filteredCalls = calls.filter((x) => x);
   const filteredRecordData = recordData.filter((x) => x);
   const matchAddress = filteredRecordData[filteredCalls.findIndex((x) => x.key === "60")];
   return {
-    address: matchAddress && await _getAddr.decode(matchAddress),
+    address: matchAddress && await _getAddr.decode(matchAddress).catch(() => false),
     records: await formatRecords(
       { _getAddr, _getContentHash, _getText },
       filteredRecordData,

package/dist/types/functions/getProfile.d.ts

@@ -24,6 +24,7 @@ declare type ResolvedProfile = {
         coinTypes?: DataItem[];
     };
     resolverAddress?: string;
+    isInvalidResolverAddress?: boolean;
     reverseResolverAddress?: string;
 };
 declare type ProfileOptions = {

package/dist/types/functions/getRecords.d.ts

@@ -28,6 +28,7 @@ export default function ({ getProfile }: ENSArgs<'getProfile'>, name: string, op
         }[] | undefined;
     } | undefined;
     resolverAddress?: string | undefined;
+    isInvalidResolverAddress?: boolean | undefined;
     reverseResolverAddress?: string | undefined;
 } | undefined>;
 export {};

package/dist/types/index.d.ts

@@ -182,6 +182,7 @@ export declare class ENS {
             }[] | undefined;
         } | undefined;
         resolverAddress?: string | undefined;
+        isInvalidResolverAddress?: boolean | undefined;
         reverseResolverAddress?: string | undefined;
     } | undefined>;
     getRecords: (name: string, options?: {
@@ -212,6 +213,7 @@ export declare class ENS {
             }[] | undefined;
         } | undefined;
         resolverAddress?: string | undefined;
+        isInvalidResolverAddress?: boolean | undefined;
         reverseResolverAddress?: string | undefined;
     } | undefined>;
     getName: GeneratedRawFunction<{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ensdomains/ensjs",
-  "version": "3.0.0-alpha.35",
+  "version": "3.0.0-alpha.36",
   "description": "ENS javascript library for contract interaction",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.mjs",

package/src/functions/getNames.ts

@@ -350,9 +350,9 @@ const getNames = async (
   const { account } = await client.request(finalQuery, queryVars)
   if (type === 'all') {
     return [
-      ...account.domains.map(mapDomain),
-      ...account.registrations.map(mapRegistration),
-      ...account.wrappedDomains.map(mapWrappedDomain),
+      ...(account?.domains.map(mapDomain) || []),
+      ...(account?.registrations.map(mapRegistration) || []),
+      ...(account?.wrappedDomains.map(mapWrappedDomain) || []),
     ].sort((a, b) => {
       if (orderDirection === 'desc') {
         if (orderBy === 'labelName') {
@@ -367,12 +367,12 @@ const getNames = async (
     }) as Name[]
   }
   if (type === 'owner') {
-    return account.domains.map(mapDomain) as Name[]
+    return (account?.domains.map(mapDomain) || []) as Name[]
   }
   if (type === 'wrappedOwner') {
-    return account.wrappedDomains.map(mapWrappedDomain) as Name[]
+    return (account?.wrappedDomains.map(mapWrappedDomain) || []) as Name[]
   }
-  return account.registrations.map(mapRegistration) as Name[]
+  return (account?.registrations.map(mapRegistration) || []) as Name[]
 }
 
 export default getNames

package/src/functions/getProfile.test.ts

@@ -15,6 +15,10 @@ beforeAll(async () => {
   accounts = await provider.listAccounts()
 })
 
+beforeEach(async () => {
+  await revert()
+})
+
 afterAll(async () => {
   await revert()
 })
@@ -143,4 +147,73 @@ describe('getProfile', () => {
       }
     })
   })
+  describe('with invalid resolver', () => {
+    it('should fail gracefully for a name with invalid resolver', async () => {
+      const tx = await ensInstance.setResolver('test123.eth', {
+        contract: 'registry',
+        resolver: '0xb794F5eA0ba39494cE839613fffBA74279579268',
+        addressOrIndex: 1,
+      })
+      expect(tx).toBeTruthy()
+      await tx.wait()
+      const result = await ensInstance.getProfile('test123.eth')
+      expect(result).toBeDefined()
+      if (result) {
+        expect(result.address).toBeUndefined()
+        expect(Object.keys(result.records!).length).toBe(0)
+        expect(result.resolverAddress).toBe(
+          '0xb794F5eA0ba39494cE839613fffBA74279579268',
+        )
+        expect(result.isInvalidResolverAddress).toBe(true)
+      }
+    })
+
+    it('should fail gracefully for a wrapped name with invalid resolver', async () => {
+      const tx = await ensInstance.setResolver('wrapped.eth', {
+        contract: 'nameWrapper',
+        resolver: '0xb794F5eA0ba39494cE839613fffBA74279579268',
+        addressOrIndex: 1,
+      })
+      expect(tx).toBeTruthy()
+      await tx.wait()
+      const result = await ensInstance.getProfile('wrapped.eth')
+      expect(result).toBeDefined()
+      if (result) {
+        expect(result.address).toBeUndefined()
+        expect(Object.keys(result.records!).length).toBe(0)
+        expect(result.resolverAddress).toBe(
+          '0xb794F5eA0ba39494cE839613fffBA74279579268',
+        )
+        expect(result.isInvalidResolverAddress).toBe(true)
+      }
+    })
+
+    it('should fail gracefully for name with invalid resolver option', async () => {
+      const result = await ensInstance.getProfile('test123.eth', {
+        resolverAddress: '0xb794F5eA0ba39494cE839613fffBA74279579268',
+      })
+      expect(result).toBeDefined()
+      if (result) {
+        expect(result.address).toBeFalsy()
+        expect(Object.keys(result.records!).length).toBe(0)
+        expect(result.resolverAddress).toBe(
+          '0xb794F5eA0ba39494cE839613fffBA74279579268',
+        )
+      }
+    })
+
+    it('should fail gracefully for wrapped name with invalid resolver option', async () => {
+      const result = await ensInstance.getProfile('wrapped.eth', {
+        resolverAddress: '0xb794F5eA0ba39494cE839613fffBA74279579268',
+      })
+      expect(result).toBeDefined()
+      if (result) {
+        expect(result.address).toBeFalsy()
+        expect(Object.keys(result.records!).length).toBe(0)
+        expect(result.resolverAddress).toBe(
+          '0xb794F5eA0ba39494cE839613fffBA74279579268',
+        )
+      }
+    })
+  })
 })

package/src/functions/getProfile.ts

@@ -45,6 +45,7 @@ type ResolvedProfile = {
     coinTypes?: DataItem[]
   }
   resolverAddress?: string
+  isInvalidResolverAddress?: boolean
   reverseResolverAddress?: string
 }
 
@@ -293,21 +294,32 @@ const getDataForName = async (
       )
     }
   } else {
-    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
+    try {
+      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
+        }
+      }
+    } catch {
+      const registryContract = await contracts?.getRegistry()
+      resolverAddress = await registryContract?.resolver(namehash(name))
+      return {
+        address: undefined,
+        records: {},
+        resolverAddress,
+        isInvalidResolverAddress: true,
       }
     }
   }
@@ -317,9 +329,9 @@ const getDataForName = async (
     hexStripZeros(resolverAddress) === '0x'
   ) {
     return {
-      address: null,
+      address: undefined,
       records: {},
-      resolverAddress: null,
+      resolverAddress: undefined,
     }
   }
 
@@ -330,7 +342,8 @@ const getDataForName = async (
     filteredRecordData[filteredCalls.findIndex((x) => x.key === '60')]
 
   return {
-    address: matchAddress && (await _getAddr.decode(matchAddress)),
+    address:
+      matchAddress && (await _getAddr.decode(matchAddress).catch(() => false)),
     records: await formatRecords(
       { _getAddr, _getContentHash, _getText },
       filteredRecordData,
@@ -456,7 +469,7 @@ const getProfileFromName = async (
   >,
   name: string,
   options?: InputProfileOptions,
-) => {
+): Promise<ResolvedProfile | undefined> => {
   const { resolverAddress, fallback, ..._options } = options || {}
   const optsLength = Object.keys(_options).length
   let usingOptions: InputProfileOptions | undefined