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

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/cjs/functions/initialGetters.js

@@ -33,7 +33,8 @@ __export(initialGetters_exports, {
   getPrice: () => import_getPrice.default,
   getProfile: () => import_getProfile.default,
   getRecords: () => import_getRecords.default,
-  getSubnames: () => import_getSubnames.default
+  getSubnames: () => import_getSubnames.default,
+  supportsTLD: () => import_supportsTLD.default
 });
 module.exports = __toCommonJS(initialGetters_exports);
 var import_batch = __toESM(require("./batch"));
@@ -47,3 +48,4 @@ var import_getProfile = __toESM(require("./getProfile"));
 var import_getRecords = __toESM(require("./getRecords"));
 __reExport(initialGetters_exports, require("./getSpecificRecord"), module.exports);
 var import_getSubnames = __toESM(require("./getSubnames"));
+var import_supportsTLD = __toESM(require("./supportsTLD"));

package/dist/cjs/functions/supportsTLD.js

@@ -0,0 +1,48 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var supportsTLD_exports = {};
+__export(supportsTLD_exports, {
+  default: () => supportsTLD_default
+});
+module.exports = __toCommonJS(supportsTLD_exports);
+var import_DNSRegistrar_factory = require("../generated/factories/DNSRegistrar__factory");
+const DNSSEC_CLAIM_INTERFACE_IDS = ["0x2f435428", "0x17d8f49b", "0x1aa2e641"];
+async function supportsTLD_default({ getOwner, provider }, name) {
+  try {
+    const labels = name.split(".");
+    const tld = labels[labels.length - 1];
+    if (tld === "eth")
+      return true;
+    const tldOwner = await getOwner(tld, "registry");
+    if (!tldOwner?.owner)
+      return false;
+    const dnsRegistrar = import_DNSRegistrar_factory.DNSRegistrar__factory.connect(
+      tldOwner.owner,
+      provider
+    );
+    const supports = await Promise.all(
+      DNSSEC_CLAIM_INTERFACE_IDS.map(
+        (interfaceId) => dnsRegistrar.supportsInterface(interfaceId)
+      )
+    );
+    return supports.some((s) => !!s);
+  } catch {
+    return false;
+  }
+}

package/dist/cjs/index.js

@@ -261,6 +261,11 @@ class ENS {
     "getDNSOwner",
     []
   );
+  supportsTLD = this.generateFunction(
+    "initialGetters",
+    ["getOwner", "provider"],
+    "supportsTLD"
+  );
   getAvailable = this.generateRawFunction(
     "getAvailable",
     ["contracts"]

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/esm/functions/initialGetters.mjs

@@ -10,6 +10,7 @@ import { default as default8 } from "./getProfile.mjs";
 import { default as default9 } from "./getRecords.mjs";
 export * from "./getSpecificRecord.mjs";
 import { default as default10 } from "./getSubnames.mjs";
+import { default as default11 } from "./supportsTLD.mjs";
 export {
   default2 as batch,
   default3 as getExpiry,
@@ -19,5 +20,6 @@ export {
   default7 as getPrice,
   default8 as getProfile,
   default9 as getRecords,
-  default10 as getSubnames
+  default10 as getSubnames,
+  default11 as supportsTLD
 };

package/dist/esm/functions/supportsTLD.mjs

@@ -0,0 +1,29 @@
+// src/functions/supportsTLD.ts
+import { DNSRegistrar__factory } from "../generated/factories/DNSRegistrar__factory.mjs";
+var DNSSEC_CLAIM_INTERFACE_IDS = ["0x2f435428", "0x17d8f49b", "0x1aa2e641"];
+async function supportsTLD_default({ getOwner, provider }, name) {
+  try {
+    const labels = name.split(".");
+    const tld = labels[labels.length - 1];
+    if (tld === "eth")
+      return true;
+    const tldOwner = await getOwner(tld, "registry");
+    if (!tldOwner?.owner)
+      return false;
+    const dnsRegistrar = DNSRegistrar__factory.connect(
+      tldOwner.owner,
+      provider
+    );
+    const supports = await Promise.all(
+      DNSSEC_CLAIM_INTERFACE_IDS.map(
+        (interfaceId) => dnsRegistrar.supportsInterface(interfaceId)
+      )
+    );
+    return supports.some((s) => !!s);
+  } catch {
+    return false;
+  }
+}
+export {
+  supportsTLD_default as default
+};

package/dist/esm/index.mjs

@@ -233,6 +233,11 @@ var ENS = class {
     "getDNSOwner",
     []
   );
+  supportsTLD = this.generateFunction(
+    "initialGetters",
+    ["getOwner", "provider"],
+    "supportsTLD"
+  );
   getAvailable = this.generateRawFunction(
     "getAvailable",
     ["contracts"]

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

@@ -9,3 +9,4 @@ export { default as getProfile } from './getProfile';
 export { default as getRecords } from './getRecords';
 export * from './getSpecificRecord';
 export { default as getSubnames } from './getSubnames';
+export { default as supportsTLD } from './supportsTLD';

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

@@ -0,0 +1,2 @@
+import { ENSArgs } from '..';
+export default function ({ getOwner, provider }: ENSArgs<'getOwner' | 'provider'>, name: string): Promise<boolean>;

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<{
@@ -354,7 +356,11 @@ export declare class ENS {
             registrant?: string | undefined;
             owner?: string | undefined;
             ownershipLevel: "nameWrapper" | "registrar" | "registry";
-        } | undefined>;
+        } | undefined>; /**
+         * Creates an object of ENS properties from an array
+         * @param {FunctionDeps} dependencies - An array of ENS properties
+         * @returns {Object} - An object of ENS properties
+         */
     }>;
     getExpiry: GeneratedRawFunction<{
         raw: (ensArgs: ENSArgs<"contracts" | "multicallWrapper">, name: string, { contract }?: {
@@ -427,6 +433,7 @@ export declare class ENS {
         } | undefined>;
     }>;
     getDNSOwner: (dnsName: string) => Promise<any>;
+    supportsTLD: (name: string) => Promise<boolean>;
     getAvailable: GeneratedRawFunction<{
         raw: ({ contracts }: ENSArgs<"contracts">, name: string) => Promise<{
             to: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ensdomains/ensjs",
-  "version": "3.0.0-alpha.35",
+  "version": "3.0.0-alpha.37",
   "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

package/src/functions/initialGetters.ts

@@ -9,3 +9,4 @@ export { default as getProfile } from './getProfile'
 export { default as getRecords } from './getRecords'
 export * from './getSpecificRecord'
 export { default as getSubnames } from './getSubnames'
+export { default as supportsTLD } from './supportsTLD'

package/src/functions/supportsTLD.test.ts

@@ -0,0 +1,45 @@
+import { ENS } from '..'
+import setup from '../tests/setup'
+
+let ensInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
+
+beforeAll(async () => {
+  ;({ ensInstance, revert } = await setup())
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+describe('supportsTLD', () => {
+  it('should return true for .eth tld', async () => {
+    const result = await ensInstance.supportsTLD('eth')
+    expect(result).toBeTruthy()
+  })
+
+  it('should return true for .xyz tld', async () => {
+    const result = await ensInstance.supportsTLD('xyz')
+    expect(result).toBeTruthy()
+  })
+
+  it('should return false for .com tld', async () => {
+    const result = await ensInstance.supportsTLD('com')
+    expect(result).toBeFalsy()
+  })
+
+  it('should return true for .eth name', async () => {
+    const result = await ensInstance.supportsTLD('test123.eth')
+    expect(result).toBeTruthy()
+  })
+
+  it('should return true for .xyz name', async () => {
+    const result = await ensInstance.supportsTLD('test123.xyz')
+    expect(result).toBeTruthy()
+  })
+
+  it('should return false for .com name', async () => {
+    const result = await ensInstance.supportsTLD('test123.com')
+    expect(result).toBeFalsy()
+  })
+})

package/src/functions/supportsTLD.ts

@@ -0,0 +1,38 @@
+import { DNSRegistrar__factory } from '../generated/factories/DNSRegistrar__factory'
+import { ENSArgs } from '..'
+
+/*
+ * 0x2f435428 -> interfaceId for latest IDNSRegistrar
+ * 0x17d8f49b, 0x1aa2e641 -> interfaceId for claims method of older DNSRegistrar
+ * */
+const DNSSEC_CLAIM_INTERFACE_IDS = ['0x2f435428', '0x17d8f49b', '0x1aa2e641']
+
+export default async function (
+  { getOwner, provider }: ENSArgs<'getOwner' | 'provider'>,
+  name: string,
+): Promise<boolean> {
+  try {
+    const labels = name.split('.')
+    const tld = labels[labels.length - 1]
+
+    if (tld === 'eth') return true
+
+    const tldOwner = await getOwner(tld, 'registry')
+    if (!tldOwner?.owner) return false
+
+    const dnsRegistrar = DNSRegistrar__factory.connect(
+      tldOwner.owner,
+      provider!,
+    )
+
+    const supports = await Promise.all(
+      DNSSEC_CLAIM_INTERFACE_IDS.map((interfaceId) =>
+        dnsRegistrar.supportsInterface(interfaceId),
+      ),
+    )
+
+    return supports.some((s) => !!s)
+  } catch {
+    return false
+  }
+}

package/src/index.ts

@@ -15,6 +15,7 @@ import type createSubname from './functions/createSubname'
 import type deleteSubname from './functions/deleteSubname'
 import type getAvailable from './functions/getAvailable'
 import type getDNSOwner from './functions/getDNSOwner'
+import type supportsTLD from './functions/supportsTLD'
 import type getExpiry from './functions/getExpiry'
 import type { getHistory } from './functions/getHistory'
 import type getName from './functions/getName'
@@ -548,6 +549,12 @@ export class ENS {
     [],
   )
 
+  public supportsTLD = this.generateFunction<typeof supportsTLD>(
+    'initialGetters',
+    ['getOwner', 'provider'],
+    'supportsTLD',
+  )
+
   public getAvailable = this.generateRawFunction<typeof getAvailable>(
     'getAvailable',
     ['contracts'],