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

package/dist/cjs/functions/getAvailable.js

@@ -0,0 +1,55 @@
+"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 getAvailable_exports = {};
+__export(getAvailable_exports, {
+  default: () => getAvailable_default
+});
+module.exports = __toCommonJS(getAvailable_exports);
+var import_labels = require("../utils/labels");
+const raw = async ({ contracts }, name) => {
+  const baseRegistrar = await contracts?.getBaseRegistrar();
+  const labels = name.split(".");
+  if (labels.length !== 2 || labels[1] !== "eth") {
+    throw new Error("Currently only .eth names can be checked for availability");
+  }
+  return {
+    to: baseRegistrar.address,
+    data: baseRegistrar.interface.encodeFunctionData("available", [
+      (0, import_labels.labelhash)(labels[0])
+    ])
+  };
+};
+const decode = async ({ contracts }, data) => {
+  if (data === null)
+    return;
+  const baseRegistrar = await contracts?.getBaseRegistrar();
+  try {
+    const result = baseRegistrar.interface.decodeFunctionResult(
+      "available",
+      data
+    );
+    return result["0"];
+  } catch {
+    return;
+  }
+};
+var getAvailable_default = {
+  raw,
+  decode
+};

package/dist/cjs/functions/getDNSOwner.js

@@ -31,18 +31,21 @@ __export(getDNSOwner_exports, {
 });
 module.exports = __toCommonJS(getDNSOwner_exports);
 var packet = __toESM(require("dns-packet"));
+var import_utils = require("ethers/lib/utils");
 function encodeURLParams(p) {
   return Object.entries(p).map((kv) => kv.map(encodeURIComponent).join("=")).join("&");
 }
 const getDNS = async (q) => {
-  const response = await global.fetch(
-    `https://cloudflare-dns.com/dns-query?${encodeURLParams({
-      ct: "application/dns-udpwireformat",
-      dns: packet.encode(q)?.toString("base64"),
-      ts: Date.now().toString()
-    })}`
+  const url = `https://cloudflare-dns.com/dns-query?${encodeURLParams({
+    ct: "application/dns-udpwireformat",
+    dns: packet.encode(q)?.toString("base64"),
+    ts: Date.now().toString()
+  })}`;
+  const response = await (0, import_utils._fetchData)(url, void 0);
+  const arrayBuffer = response.buffer.slice(
+    response.byteOffset,
+    response.byteLength + response.byteOffset
   );
-  const arrayBuffer = await response.arrayBuffer();
   const fromArrayBuffer = Buffer.from(arrayBuffer);
   return packet.decode(fromArrayBuffer);
 };

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/index.js

@@ -261,6 +261,10 @@ class ENS {
     "getDNSOwner",
     []
   );
+  getAvailable = this.generateRawFunction(
+    "getAvailable",
+    ["contracts"]
+  );
   universalWrapper = this.generateRawFunction(
     "initialGetters",
     ["contracts"],

package/dist/esm/functions/getAvailable.mjs

@@ -0,0 +1,36 @@
+// src/functions/getAvailable.ts
+import { labelhash } from "../utils/labels.mjs";
+var raw = async ({ contracts }, name) => {
+  const baseRegistrar = await contracts?.getBaseRegistrar();
+  const labels = name.split(".");
+  if (labels.length !== 2 || labels[1] !== "eth") {
+    throw new Error("Currently only .eth names can be checked for availability");
+  }
+  return {
+    to: baseRegistrar.address,
+    data: baseRegistrar.interface.encodeFunctionData("available", [
+      labelhash(labels[0])
+    ])
+  };
+};
+var decode = async ({ contracts }, data) => {
+  if (data === null)
+    return;
+  const baseRegistrar = await contracts?.getBaseRegistrar();
+  try {
+    const result = baseRegistrar.interface.decodeFunctionResult(
+      "available",
+      data
+    );
+    return result["0"];
+  } catch {
+    return;
+  }
+};
+var getAvailable_default = {
+  raw,
+  decode
+};
+export {
+  getAvailable_default as default
+};

package/dist/esm/functions/getDNSOwner.mjs

@@ -1,17 +1,20 @@
 // src/functions/getDNSOwner.ts
 import * as packet from "dns-packet";
+import { _fetchData } from "ethers/lib/utils.js";
 function encodeURLParams(p) {
   return Object.entries(p).map((kv) => kv.map(encodeURIComponent).join("=")).join("&");
 }
 var getDNS = async (q) => {
-  const response = await global.fetch(
-    `https://cloudflare-dns.com/dns-query?${encodeURLParams({
-      ct: "application/dns-udpwireformat",
-      dns: packet.encode(q)?.toString("base64"),
-      ts: Date.now().toString()
-    })}`
+  const url = `https://cloudflare-dns.com/dns-query?${encodeURLParams({
+    ct: "application/dns-udpwireformat",
+    dns: packet.encode(q)?.toString("base64"),
+    ts: Date.now().toString()
+  })}`;
+  const response = await _fetchData(url, void 0);
+  const arrayBuffer = response.buffer.slice(
+    response.byteOffset,
+    response.byteLength + response.byteOffset
   );
-  const arrayBuffer = await response.arrayBuffer();
   const fromArrayBuffer = Buffer.from(arrayBuffer);
   return packet.decode(fromArrayBuffer);
 };

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/index.mjs

@@ -233,6 +233,10 @@ var ENS = class {
     "getDNSOwner",
     []
   );
+  getAvailable = this.generateRawFunction(
+    "getAvailable",
+    ["contracts"]
+  );
   universalWrapper = this.generateRawFunction(
     "initialGetters",
     ["contracts"],

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

@@ -0,0 +1,9 @@
+import { ENSArgs } from '..';
+declare const _default: {
+    raw: ({ contracts }: ENSArgs<"contracts">, name: string) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<boolean | undefined>;
+};
+export default _default;

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

@@ -42,14 +42,14 @@ export declare const _getText: {
         to: string;
         data: string;
     }>;
-    decode: ({ contracts }: ENSArgs<'contracts'>, data: string) => Promise<any>;
+    decode: ({ contracts }: ENSArgs<'contracts'>, data: string) => Promise<string | undefined>;
 };
 export declare const getText: {
     raw: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, name: string, key: string) => Promise<{
         to: string;
         data: string;
     }>;
-    decode: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, data: string) => Promise<any>;
+    decode: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, data: string) => Promise<string | undefined>;
 };
 export declare const _getAddr: {
     raw: ({ contracts }: ENSArgs<'contracts'>, name: string, coinType?: string | number, bypassFormat?: boolean) => Promise<{

package/dist/types/index.d.ts

@@ -7,7 +7,7 @@ import type burnFuses from './functions/burnFuses';
 import type commitName from './functions/commitName';
 import type createSubname from './functions/createSubname';
 import type deleteSubname from './functions/deleteSubname';
-import importDNSSECName from './functions/importDNSSECName';
+import type importDNSSECName from './functions/importDNSSECName';
 import type registerName from './functions/registerName';
 import type { default as renewNames, renewNameWithData } from './functions/renewNames';
 import type setName from './functions/setName';
@@ -69,6 +69,12 @@ interface GeneratedRawFunction<F extends RawFunction> extends Function, RawFunct
 }
 export interface GenericGeneratedRawFunction extends Function, RawFunctionWithBatch {
 }
+interface GeneratedBatchFunction<F extends RawFunction> extends Function, RawFunction {
+    <I extends BatchFunctionResult<RawFunction>[]>(...args: I): Promise<{
+        [N in keyof I]: I[N] extends BatchFunctionResult<infer U> ? Awaited<ReturnType<U['decode']>> : never;
+    } | undefined>;
+    batch: BatchFunction<F>;
+}
 export declare class ENS {
     [x: string]: any;
     protected options?: ENSOptions;
@@ -135,7 +141,7 @@ export declare class ENS {
      * @returns {ENS} - A new ENS instance with the given provider
      */
     withProvider: (provider: ethers.providers.JsonRpcProvider) => ENS;
-    batch: GeneratedRawFunction<{
+    batch: GeneratedBatchFunction<{
         raw: ({ multicallWrapper }: ENSArgs<"multicallWrapper">, ...items: BatchFunctionResult<RawFunction>[]) => Promise<{
             to: string;
             data: string;
@@ -176,6 +182,7 @@ export declare class ENS {
             }[] | undefined;
         } | undefined;
         resolverAddress?: string | undefined;
+        isInvalidResolverAddress?: boolean | undefined;
         reverseResolverAddress?: string | undefined;
     } | undefined>;
     getRecords: (name: string, options?: {
@@ -206,6 +213,7 @@ export declare class ENS {
             }[] | undefined;
         } | undefined;
         resolverAddress?: string | undefined;
+        isInvalidResolverAddress?: boolean | undefined;
         reverseResolverAddress?: string | undefined;
     } | undefined>;
     getName: GeneratedRawFunction<{
@@ -330,14 +338,14 @@ export declare class ENS {
             to: string;
             data: string;
         }>;
-        decode: ({ contracts, universalWrapper }: ENSArgs<"contracts" | "universalWrapper">, data: string) => Promise<any>;
+        decode: ({ contracts, universalWrapper }: ENSArgs<"contracts" | "universalWrapper">, data: string) => Promise<string | undefined>;
     }>;
     _getText: GeneratedRawFunction<{
         raw: ({ contracts }: ENSArgs<"contracts">, name: string, key: string) => Promise<{
             to: string;
             data: string;
         }>;
-        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<any>;
+        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<string | undefined>;
     }>;
     getOwner: GeneratedRawFunction<{
         raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, name: string, contract?: "nameWrapper" | "registrar" | "registry" | undefined) => Promise<{
@@ -421,6 +429,13 @@ export declare class ENS {
         } | undefined>;
     }>;
     getDNSOwner: (dnsName: string) => Promise<any>;
+    getAvailable: GeneratedRawFunction<{
+        raw: ({ contracts }: ENSArgs<"contracts">, name: string) => Promise<{
+            to: string;
+            data: string;
+        }>;
+        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<boolean | undefined>;
+    }>;
     universalWrapper: GeneratedRawFunction<{
         raw: ({ contracts }: ENSArgs<"contracts">, name: string, data: string) => Promise<{
             to: string;

package/package.json

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

@@ -0,0 +1,21 @@
+import { ENS } from '..'
+import setup from '../tests/setup'
+
+let ensInstance: ENS
+
+beforeAll(async () => {
+  ;({ ensInstance } = await setup())
+})
+
+describe('getAvailable', () => {
+  it('should return false for a name that is unavailable', async () => {
+    const result = await ensInstance.getAvailable('test123.eth')
+    expect(typeof result).toBe('boolean')
+    expect(result).toBe(false)
+  })
+  it('should return true for a name that is available', async () => {
+    const result = await ensInstance.getAvailable('available-name.eth')
+    expect(typeof result).toBe('boolean')
+    expect(result).toBe(true)
+  })
+})

package/src/functions/getAvailable.ts

@@ -0,0 +1,37 @@
+import { ENSArgs } from '..'
+import { labelhash } from '../utils/labels'
+
+const raw = async ({ contracts }: ENSArgs<'contracts'>, name: string) => {
+  const baseRegistrar = await contracts?.getBaseRegistrar()!
+
+  const labels = name.split('.')
+  if (labels.length !== 2 || labels[1] !== 'eth') {
+    throw new Error('Currently only .eth names can be checked for availability')
+  }
+
+  return {
+    to: baseRegistrar.address,
+    data: baseRegistrar.interface.encodeFunctionData('available', [
+      labelhash(labels[0]),
+    ]),
+  }
+}
+
+const decode = async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
+  if (data === null) return
+  const baseRegistrar = await contracts?.getBaseRegistrar()!
+  try {
+    const result = baseRegistrar.interface.decodeFunctionResult(
+      'available',
+      data,
+    )
+    return result['0'] as boolean
+  } catch {
+    return
+  }
+}
+
+export default {
+  raw,
+  decode,
+}

package/src/functions/getDNSOwner.test.ts

@@ -1,5 +1,4 @@
 import nock from 'nock'
-import fetch from 'node-fetch'
 import getDNSOwner, { encodeURLParams } from './getDNSOwner'
 
 function hexDecode(string: string) {
@@ -24,12 +23,6 @@ describe('encodeURLParams', () => {
 })
 
 describe('getDNSOwner', () => {
-  beforeAll(() => {
-    global.fetch = fetch as any
-  })
-  afterAll(() => {
-    global.fetch = undefined as any
-  })
   it('should return the address from the result of a dnsQuery', async () => {
     const dnsName = 'brantly.xyz'
 

package/src/functions/getDNSOwner.ts

@@ -1,4 +1,5 @@
 import * as packet from 'dns-packet'
+import { _fetchData } from 'ethers/lib/utils'
 
 export function encodeURLParams(p: { [key: string]: string }): string {
   return Object.entries(p)
@@ -7,15 +8,16 @@ export function encodeURLParams(p: { [key: string]: string }): string {
 }
 
 export const getDNS = async (q: packet.Packet): Promise<packet.Packet> => {
-  const response = await global.fetch(
-    `https://cloudflare-dns.com/dns-query?${encodeURLParams({
-      ct: 'application/dns-udpwireformat',
-      dns: packet.encode(q)?.toString('base64'),
-      ts: Date.now().toString(),
-    })}`,
+  const url = `https://cloudflare-dns.com/dns-query?${encodeURLParams({
+    ct: 'application/dns-udpwireformat',
+    dns: packet.encode(q)?.toString('base64'),
+    ts: Date.now().toString(),
+  })}`
+  const response = await _fetchData(url, undefined)
+  const arrayBuffer = response.buffer.slice(
+    response.byteOffset,
+    response.byteLength + response.byteOffset,
   )
-  const arrayBuffer = await response.arrayBuffer()
-  // @ts-ignore:next-line
   const fromArrayBuffer = Buffer.from(arrayBuffer)
   return packet.decode(fromArrayBuffer)
 }

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/getSpecificRecord.ts

@@ -87,7 +87,7 @@ export const _getText = {
     if (!response) {
       return
     }
-    return response
+    return response as string
   },
 }
 

package/src/index.ts

@@ -13,6 +13,7 @@ import type burnFuses from './functions/burnFuses'
 import type commitName from './functions/commitName'
 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 getExpiry from './functions/getExpiry'
 import type { getHistory } from './functions/getHistory'
@@ -33,7 +34,7 @@ import type {
 } from './functions/getSpecificRecord'
 import type getSubnames from './functions/getSubnames'
 import type getWrapperData from './functions/getWrapperData'
-import importDNSSECName from './functions/importDNSSECName'
+import type importDNSSECName from './functions/importDNSSECName'
 import type registerName from './functions/registerName'
 import type {
   // eslint-disable-next-line import/no-named-default
@@ -165,6 +166,20 @@ export interface GenericGeneratedRawFunction
   extends Function,
     RawFunctionWithBatch {}
 
+interface GeneratedBatchFunction<F extends RawFunction>
+  extends Function,
+    RawFunction {
+  <I extends BatchFunctionResult<RawFunction>[]>(...args: I): Promise<
+    | {
+        [N in keyof I]: I[N] extends BatchFunctionResult<infer U>
+          ? Awaited<ReturnType<U['decode']>>
+          : never
+      }
+    | undefined
+  >
+  batch: BatchFunction<F>
+}
+
 export class ENS {
   [x: string]: any
 
@@ -417,7 +432,7 @@ export class ENS {
     'initialGetters',
     ['multicallWrapper'],
     'batch',
-  )
+  ) as GeneratedBatchFunction<typeof batch>
 
   public getProfile = this.generateFunction<typeof getProfile>(
     'initialGetters',
@@ -533,6 +548,11 @@ export class ENS {
     [],
   )
 
+  public getAvailable = this.generateRawFunction<typeof getAvailable>(
+    'getAvailable',
+    ['contracts'],
+  )
+
   public universalWrapper = this.generateRawFunction<typeof universalWrapper>(
     'initialGetters',
     ['contracts'],