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

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

@@ -38,10 +38,13 @@ var ENS = class {
     const thisRef = this;
     const mainFunc = async function(...args) {
       await thisRef.checkInitialProvider();
-      const mod = await import(
+      let mod = await import(
         /* webpackMode: "lazy", webpackChunkName: "[request]", webpackPreload: true, webpackExclude: /.*\.ts$/ */
         `./functions/${path}`
       );
+      if (mod.default?.[exportName]) {
+        mod = mod.default;
+      }
       if (subFunc !== "combine") {
         const writeable = subFunc === "write" || subFunc === "populateTransaction";
         const func = subFunc && !writeable ? mod[exportName][subFunc] : mod[exportName];
@@ -233,6 +236,11 @@ var ENS = class {
     "getDNSOwner",
     []
   );
+  supportsTLD = this.generateFunction(
+    "initialGetters",
+    ["getOwner", "provider"],
+    "supportsTLD"
+  );
   getAvailable = this.generateRawFunction(
     "getAvailable",
     ["contracts"]

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

@@ -356,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 }?: {
@@ -429,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.36",
+  "version": "3.0.0-alpha.38",
   "description": "ENS javascript library for contract interaction",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.mjs",

package/src/contracts/getContractAddress.ts

@@ -46,7 +46,7 @@ const addresses: Record<
     '5': '0xD5610A08E370051a01fdfe4bB3ddf5270af1aA48',
   },
   UniversalResolver: {
-    '1': '0x580AF46E06DaaD47eb5940526FD64d95b815Cb70',
+    '1': '0x74E20Bd2A1fE0cdbe45b9A1d89cb7e0a45b36376',
     '3': '0x74e20bd2a1fe0cdbe45b9a1d89cb7e0a45b36376',
     '4': '0x74e20bd2a1fe0cdbe45b9a1d89cb7e0a45b36376',
     '5': '0x687c30Cc44bFA39A1449e86E172BF002E7b3f0b0',

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

@@ -45,6 +45,7 @@ import type setName from './functions/setName'
 import type setRecord from './functions/setRecord'
 import type setRecords from './functions/setRecords'
 import type setResolver from './functions/setResolver'
+import type supportsTLD from './functions/supportsTLD'
 import type transferController from './functions/transferController'
 import type transferName from './functions/transferName'
 import type transferSubname from './functions/transferSubname'
@@ -258,10 +259,14 @@ export class ENS {
       // check the initial provider and set if it exists
       await thisRef.checkInitialProvider()
       // import the module dynamically
-      const mod = await import(
+      let mod = await import(
         /* webpackMode: "lazy", webpackChunkName: "[request]", webpackPreload: true, webpackExclude: /.*\.ts$/ */
         `./functions/${path}`
       )
+      // if export is nested in default, use default
+      if (mod.default?.[exportName]) {
+        mod = mod.default
+      }
 
       // if combine isn't specified, run normally
       // otherwise, create a function from the raw and decode functions
@@ -548,6 +553,12 @@ export class ENS {
     [],
   )
 
+  public supportsTLD = this.generateFunction<typeof supportsTLD>(
+    'initialGetters',
+    ['getOwner', 'provider'],
+    'supportsTLD',
+  )
+
   public getAvailable = this.generateRawFunction<typeof getAvailable>(
     'getAvailable',
     ['contracts'],