@ensdomains/ensjs 3.0.0-alpha.40 → 3.0.0-alpha.41

package/dist/cjs/functions/getSpecificRecord.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,12 +17,18 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var getSpecificRecord_exports = {};
 __export(getSpecificRecord_exports, {
+  _getABI: () => _getABI,
   _getAddr: () => _getAddr,
   _getContentHash: () => _getContentHash,
   _getText: () => _getText,
+  getABI: () => getABI,
   getAddr: () => getAddr,
   getContentHash: () => getContentHash,
   getText: () => getText
@@ -28,6 +36,7 @@ __export(getSpecificRecord_exports, {
 module.exports = __toCommonJS(getSpecificRecord_exports);
 var import_address_encoder = require("@ensdomains/address-encoder");
 var import_bytes = require("@ethersproject/bytes");
+var import_strings = require("@ethersproject/strings");
 var import_contentHash = require("../utils/contentHash");
 var import_normalise = require("../utils/normalise");
 const _getContentHash = {
@@ -193,3 +202,77 @@ const getAddr = {
     return _getAddr.decode({ contracts }, urData.data, _name, coinType);
   }
 };
+const supportedContentTypes = "0xf";
+const _getABI = {
+  raw: async ({ contracts }, name) => {
+    const publicResolver = await (contracts == null ? void 0 : contracts.getPublicResolver());
+    return {
+      to: "0x0000000000000000000000000000000000000000",
+      data: publicResolver.interface.encodeFunctionData("ABI", [
+        (0, import_normalise.namehash)(name),
+        supportedContentTypes
+      ])
+    };
+  },
+  decode: async ({ contracts }, data) => {
+    const publicResolver = await (contracts == null ? void 0 : contracts.getPublicResolver());
+    const [bnContentType, encodedABIData] = publicResolver.interface.decodeFunctionResult("ABI", data);
+    if (!bnContentType || !data) {
+      return;
+    }
+    const contentType = bnContentType.toNumber();
+    if (!contentType) {
+      return;
+    }
+    let abiData;
+    let decoded = false;
+    switch (contentType) {
+      case 1:
+        abiData = JSON.parse((0, import_strings.toUtf8String)(encodedABIData));
+        decoded = true;
+        break;
+      case 2: {
+        const { inflate } = await import("pako/dist/pako_inflate.min.js");
+        abiData = JSON.parse(
+          inflate((0, import_bytes.arrayify)(encodedABIData), { to: "string" })
+        );
+        decoded = true;
+        break;
+      }
+      case 4: {
+        const { decodeFirst } = await import("cbor");
+        abiData = await decodeFirst((0, import_bytes.arrayify)(encodedABIData));
+        decoded = true;
+        break;
+      }
+      case 8:
+        abiData = (0, import_strings.toUtf8String)(encodedABIData);
+        decoded = false;
+        break;
+      default:
+        try {
+          abiData = (0, import_strings.toUtf8String)(encodedABIData);
+        } catch {
+          abiData = encodedABIData;
+        }
+        decoded = false;
+    }
+    return {
+      contentType,
+      decoded,
+      abi: abiData
+    };
+  }
+};
+const getABI = {
+  raw: async ({ contracts, universalWrapper }, name) => {
+    const prData = await _getABI.raw({ contracts }, name);
+    return universalWrapper.raw(name, prData.data);
+  },
+  decode: async ({ contracts, universalWrapper }, data) => {
+    const urData = await universalWrapper.decode(data);
+    if (!urData)
+      return;
+    return _getABI.decode({ contracts }, urData.data);
+  }
+};

package/dist/cjs/index.js

@@ -230,6 +230,16 @@ class ENS {
       ["contracts"],
       "_getText"
     );
+    this.getABI = this.generateRawFunction(
+      "initialGetters",
+      ["contracts", "universalWrapper"],
+      "getABI"
+    );
+    this._getABI = this.generateRawFunction(
+      "initialGetters",
+      ["contracts"],
+      "_getABI"
+    );
     this.getOwner = this.generateRawFunction(
       "initialGetters",
       ["contracts", "multicallWrapper", "gqlInstance"],

package/dist/cjs/utils/recordHelpers.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,15 +17,21 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var recordHelpers_exports = {};
 __export(recordHelpers_exports, {
+  generateABIInput: () => generateABIInput,
   generateRecordCallArray: () => generateRecordCallArray,
   generateSetAddr: () => generateSetAddr,
   generateSingleRecordCall: () => generateSingleRecordCall
 });
 module.exports = __toCommonJS(recordHelpers_exports);
 var import_address_encoder = require("@ensdomains/address-encoder");
+var import_utils = require("ethers/lib/utils");
 var import_contentHash = require("./contentHash");
 const generateSetAddr = (namehash, coinType, address, resolver) => {
   let coinTypeInstance;
@@ -39,6 +47,34 @@ const generateSetAddr = (namehash, coinType, address, resolver) => {
     [namehash, inputCoinType, encodedAddress]
   );
 };
+const generateABIInput = async (encodeAs, data) => {
+  let contentType;
+  let encodedData;
+  switch (encodeAs) {
+    case "json":
+      contentType = 1;
+      encodedData = JSON.stringify(data);
+      break;
+    case "zlib": {
+      contentType = 2;
+      const { deflate } = await import("pako/dist/pako_deflate.min.js");
+      encodedData = deflate(JSON.stringify(data));
+      break;
+    }
+    case "cbor": {
+      contentType = 4;
+      const { encode } = await import("cbor");
+      encodedData = encode(data);
+      break;
+    }
+    default: {
+      contentType = 8;
+      encodedData = data;
+      break;
+    }
+  }
+  return { contentType, data: encodedData };
+};
 function generateSingleRecordCall(namehash, resolver, type) {
   if (type === "contentHash") {
     return (_r) => {
@@ -56,6 +92,24 @@ function generateSingleRecordCall(namehash, resolver, type) {
       ]);
     };
   }
+  if (type === "abi") {
+    return (_r) => {
+      const record = _r;
+      const { contentType = 1, data } = record;
+      let encodedData = data;
+      if (!(0, import_utils.isBytesLike)(encodedData)) {
+        if (typeof encodedData === "object") {
+          encodedData = JSON.stringify(encodedData);
+        }
+        encodedData = (0, import_utils.toUtf8Bytes)(encodedData);
+      }
+      return resolver.interface.encodeFunctionData("setABI", [
+        namehash,
+        contentType,
+        encodedData
+      ]);
+    };
+  }
   return (_r) => {
     const record = _r;
     if (type === "text") {

package/dist/esm/functions/getSpecificRecord.mjs

@@ -1,6 +1,7 @@
 // src/functions/getSpecificRecord.ts
 import { formatsByCoinType, formatsByName } from "@ensdomains/address-encoder";
-import { hexStripZeros, isBytesLike } from "@ethersproject/bytes";
+import { arrayify, hexStripZeros, isBytesLike } from "@ethersproject/bytes";
+import { toUtf8String } from "@ethersproject/strings";
 import { decodeContenthash } from "../utils/contentHash.mjs";
 import { namehash } from "../utils/normalise.mjs";
 var _getContentHash = {
@@ -166,10 +167,86 @@ var getAddr = {
     return _getAddr.decode({ contracts }, urData.data, _name, coinType);
   }
 };
+var supportedContentTypes = "0xf";
+var _getABI = {
+  raw: async ({ contracts }, name) => {
+    const publicResolver = await contracts?.getPublicResolver();
+    return {
+      to: "0x0000000000000000000000000000000000000000",
+      data: publicResolver.interface.encodeFunctionData("ABI", [
+        namehash(name),
+        supportedContentTypes
+      ])
+    };
+  },
+  decode: async ({ contracts }, data) => {
+    const publicResolver = await contracts?.getPublicResolver();
+    const [bnContentType, encodedABIData] = publicResolver.interface.decodeFunctionResult("ABI", data);
+    if (!bnContentType || !data) {
+      return;
+    }
+    const contentType = bnContentType.toNumber();
+    if (!contentType) {
+      return;
+    }
+    let abiData;
+    let decoded = false;
+    switch (contentType) {
+      case 1:
+        abiData = JSON.parse(toUtf8String(encodedABIData));
+        decoded = true;
+        break;
+      case 2: {
+        const { inflate } = await import("pako/dist/pako_inflate.min.js");
+        abiData = JSON.parse(
+          inflate(arrayify(encodedABIData), { to: "string" })
+        );
+        decoded = true;
+        break;
+      }
+      case 4: {
+        const { decodeFirst } = await import("cbor");
+        abiData = await decodeFirst(arrayify(encodedABIData));
+        decoded = true;
+        break;
+      }
+      case 8:
+        abiData = toUtf8String(encodedABIData);
+        decoded = false;
+        break;
+      default:
+        try {
+          abiData = toUtf8String(encodedABIData);
+        } catch {
+          abiData = encodedABIData;
+        }
+        decoded = false;
+    }
+    return {
+      contentType,
+      decoded,
+      abi: abiData
+    };
+  }
+};
+var getABI = {
+  raw: async ({ contracts, universalWrapper }, name) => {
+    const prData = await _getABI.raw({ contracts }, name);
+    return universalWrapper.raw(name, prData.data);
+  },
+  decode: async ({ contracts, universalWrapper }, data) => {
+    const urData = await universalWrapper.decode(data);
+    if (!urData)
+      return;
+    return _getABI.decode({ contracts }, urData.data);
+  }
+};
 export {
+  _getABI,
   _getAddr,
   _getContentHash,
   _getText,
+  getABI,
   getAddr,
   getContentHash,
   getText

package/dist/esm/index.mjs

@@ -207,6 +207,16 @@ var ENS = class {
     ["contracts"],
     "_getText"
   );
+  getABI = this.generateRawFunction(
+    "initialGetters",
+    ["contracts", "universalWrapper"],
+    "getABI"
+  );
+  _getABI = this.generateRawFunction(
+    "initialGetters",
+    ["contracts"],
+    "_getABI"
+  );
   getOwner = this.generateRawFunction(
     "initialGetters",
     ["contracts", "multicallWrapper", "gqlInstance"],

package/dist/esm/utils/recordHelpers.mjs

@@ -1,5 +1,6 @@
 // src/utils/recordHelpers.ts
 import { formatsByCoinType, formatsByName } from "@ensdomains/address-encoder";
+import { isBytesLike, toUtf8Bytes } from "ethers/lib/utils";
 import { encodeContenthash } from "./contentHash.mjs";
 var generateSetAddr = (namehash, coinType, address, resolver) => {
   let coinTypeInstance;
@@ -15,6 +16,34 @@ var generateSetAddr = (namehash, coinType, address, resolver) => {
     [namehash, inputCoinType, encodedAddress]
   );
 };
+var generateABIInput = async (encodeAs, data) => {
+  let contentType;
+  let encodedData;
+  switch (encodeAs) {
+    case "json":
+      contentType = 1;
+      encodedData = JSON.stringify(data);
+      break;
+    case "zlib": {
+      contentType = 2;
+      const { deflate } = await import("pako/dist/pako_deflate.min.js");
+      encodedData = deflate(JSON.stringify(data));
+      break;
+    }
+    case "cbor": {
+      contentType = 4;
+      const { encode } = await import("cbor");
+      encodedData = encode(data);
+      break;
+    }
+    default: {
+      contentType = 8;
+      encodedData = data;
+      break;
+    }
+  }
+  return { contentType, data: encodedData };
+};
 function generateSingleRecordCall(namehash, resolver, type) {
   if (type === "contentHash") {
     return (_r) => {
@@ -32,6 +61,24 @@ function generateSingleRecordCall(namehash, resolver, type) {
       ]);
     };
   }
+  if (type === "abi") {
+    return (_r) => {
+      const record = _r;
+      const { contentType = 1, data } = record;
+      let encodedData = data;
+      if (!isBytesLike(encodedData)) {
+        if (typeof encodedData === "object") {
+          encodedData = JSON.stringify(encodedData);
+        }
+        encodedData = toUtf8Bytes(encodedData);
+      }
+      return resolver.interface.encodeFunctionData("setABI", [
+        namehash,
+        contentType,
+        encodedData
+      ]);
+    };
+  }
   return (_r) => {
     const record = _r;
     if (type === "text") {
@@ -69,6 +116,7 @@ var generateRecordCallArray = (namehash, records, resolver) => {
   return calls;
 };
 export {
+  generateABIInput,
   generateRecordCallArray,
   generateSetAddr,
   generateSingleRecordCall

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

@@ -1,3 +1,3 @@
 import { ENSArgs } from '..';
 import { FuseProps } from '../utils/fuses';
-export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, props: FuseProps): Promise<import("@ethersproject/contracts").PopulatedTransaction>;
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, props: FuseProps): Promise<import("ethers").PopulatedTransaction>;

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

@@ -7,20 +7,20 @@ export default function ({ contracts }: ENSArgs<'contracts'>, name: string, { re
     customData: {
         secret: string;
         commitment: string;
-        wrapperExpiry: import("@ethersproject/bignumber").BigNumberish;
+        wrapperExpiry: import("ethers").BigNumberish;
     };
     to?: string | undefined;
     from?: string | undefined;
     nonce?: number | undefined;
-    gasLimit?: import("@ethersproject/bignumber").BigNumber | undefined;
-    gasPrice?: import("@ethersproject/bignumber").BigNumber | undefined;
+    gasLimit?: import("ethers").BigNumber | undefined;
+    gasPrice?: import("ethers").BigNumber | undefined;
     data?: string | undefined;
-    value?: import("@ethersproject/bignumber").BigNumber | undefined;
+    value?: import("ethers").BigNumber | undefined;
     chainId?: number | undefined;
     type?: number | undefined;
     accessList?: import("@ethersproject/transactions").AccessList | undefined;
-    maxFeePerGas?: import("@ethersproject/bignumber").BigNumber | undefined;
-    maxPriorityFeePerGas?: import("@ethersproject/bignumber").BigNumber | undefined;
+    maxFeePerGas?: import("ethers").BigNumber | undefined;
+    maxPriorityFeePerGas?: import("ethers").BigNumber | undefined;
     ccipReadEnabled?: boolean | undefined;
 }>;
 export {};

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

@@ -12,5 +12,5 @@ declare type NameWrapperArgs = {
     expiry?: Expiry;
 } & BaseArgs;
 declare type Args = BaseArgs | NameWrapperArgs;
-export default function ({ contracts, signer, getExpiry, }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>, name: string, { owner, resolverAddress, contract, ...wrapperArgs }: Args): Promise<import("@ethersproject/contracts").PopulatedTransaction>;
+export default function ({ contracts, signer, getExpiry, }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>, name: string, { owner, resolverAddress, contract, ...wrapperArgs }: Args): Promise<import("ethers").PopulatedTransaction>;
 export {};

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

@@ -2,5 +2,5 @@ import { ENSArgs } from '..';
 declare type Args = {
     contract: 'registry' | 'nameWrapper';
 };
-export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>, name: string, { contract }: Args): Promise<import("@ethersproject/contracts").PopulatedTransaction>;
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>, name: string, { contract }: Args): Promise<import("ethers").PopulatedTransaction>;
 export {};

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

@@ -71,3 +71,25 @@ export declare const getAddr: {
         addr: string;
     } | undefined>;
 };
+export declare const _getABI: {
+    raw: ({ contracts }: ENSArgs<'contracts'>, name: string) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts }: ENSArgs<'contracts'>, data: string) => Promise<{
+        contentType: number;
+        decoded: boolean;
+        abi: string | object;
+    } | undefined>;
+};
+export declare const getABI: {
+    raw: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, name: string) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, data: string) => Promise<{
+        contentType: number;
+        decoded: boolean;
+        abi: string | object;
+    } | undefined>;
+};

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

@@ -4,4 +4,4 @@ export declare type ImportDNSSECNameProps = {
     address: string;
     proverResult: any;
 };
-export default function ({ contracts, provider }: ENSArgs<'contracts' | 'signer' | 'provider'>, name: string, { address, proverResult }: ImportDNSSECNameProps): Promise<import("@ethersproject/contracts").PopulatedTransaction | undefined>;
+export default function ({ contracts, provider }: ENSArgs<'contracts' | 'signer' | 'provider'>, name: string, { address, proverResult }: ImportDNSSECNameProps): Promise<import("ethers").PopulatedTransaction | undefined>;

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

@@ -4,5 +4,5 @@ import { BaseRegistrationParams } from '../utils/registerHelpers';
 declare type Params = BaseRegistrationParams & {
     value: BigNumber;
 };
-export default function ({ contracts }: ENSArgs<'contracts'>, name: string, { resolverAddress, value, ...params }: Params): Promise<import("@ethersproject/contracts").PopulatedTransaction>;
+export default function ({ contracts }: ENSArgs<'contracts'>, name: string, { resolverAddress, value, ...params }: Params): Promise<import("ethers").PopulatedTransaction>;
 export {};

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

@@ -8,6 +8,6 @@ declare type BaseProps = {
 export declare function renewNameWithData({ contracts }: ENSArgs<'contracts'>, name: string, { duration, value, fuses, wrapperExpiry, }: BaseProps & {
     fuses?: FuseProps;
     wrapperExpiry?: BigNumberish;
-}): Promise<import("@ethersproject/contracts").PopulatedTransaction>;
-export default function ({ contracts }: ENSArgs<'contracts'>, nameOrNames: string | string[], { duration, value }: BaseProps): Promise<import("@ethersproject/contracts").PopulatedTransaction>;
+}): Promise<import("ethers").PopulatedTransaction>;
+export default function ({ contracts }: ENSArgs<'contracts'>, nameOrNames: string | string[], { duration, value }: BaseProps): Promise<import("ethers").PopulatedTransaction>;
 export {};

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

@@ -2,4 +2,4 @@ import { ENSArgs } from '..';
 export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { address, resolver, }?: {
     address?: string;
     resolver?: string;
-}): Promise<import("@ethersproject/contracts").PopulatedTransaction>;
+}): Promise<import("ethers").PopulatedTransaction>;

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

@@ -11,7 +11,11 @@ declare type AddrOrTextInput = {
     record: RecordInput<'addr' | 'text'>;
     type: 'addr' | 'text';
 };
-export default function ({ contracts, provider, getResolver, signer, }: ENSArgs<'contracts' | 'provider' | 'getResolver' | 'signer'>, name: string, { record, type, resolverAddress, }: BaseInput & (ContentHashInput | AddrOrTextInput)): Promise<{
+declare type ABIInput = {
+    record: RecordInput<'abi'>;
+    type: 'abi';
+};
+export default function ({ contracts, provider, getResolver, signer, }: ENSArgs<'contracts' | 'provider' | 'getResolver' | 'signer'>, name: string, { record, type, resolverAddress, }: BaseInput & (ContentHashInput | AddrOrTextInput | ABIInput)): Promise<{
     to: string;
     data: string;
 }>;

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

@@ -3,4 +3,4 @@ import { RecordOptions } from '../utils/recordHelpers';
 export default function ({ contracts, provider, getResolver, signer, }: ENSArgs<'contracts' | 'provider' | 'getResolver' | 'signer'>, name: string, { records, resolverAddress, }: {
     records: RecordOptions;
     resolverAddress?: string;
-}): Promise<import("@ethersproject/contracts").PopulatedTransaction>;
+}): Promise<import("ethers").PopulatedTransaction>;

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

@@ -2,4 +2,4 @@ import { ENSArgs } from '..';
 export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { contract, resolver, }: {
     contract: 'registry' | 'nameWrapper';
     resolver?: string;
-}): Promise<import("@ethersproject/contracts").PopulatedTransaction>;
+}): Promise<import("ethers").PopulatedTransaction>;

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

@@ -2,4 +2,4 @@ import { ENSArgs } from '..';
 export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { newOwner, isOwner, }: {
     newOwner: string;
     isOwner: boolean;
-}): Promise<import("@ethersproject/contracts").PopulatedTransaction>;
+}): Promise<import("ethers").PopulatedTransaction>;

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

@@ -3,4 +3,4 @@ export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>,
     newOwner: string;
     contract: 'registry' | 'nameWrapper' | 'baseRegistrar';
     reclaim?: boolean;
-}): Promise<import("@ethersproject/contracts").PopulatedTransaction>;
+}): Promise<import("ethers").PopulatedTransaction>;

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

@@ -10,5 +10,5 @@ declare type NameWrapperArgs = {
     expiry?: Expiry;
 } & BaseArgs;
 declare type Args = BaseArgs | NameWrapperArgs;
-export default function ({ contracts, signer, getExpiry, }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>, name: string, { contract, owner, resolverAddress, ...wrapperArgs }: Args): Promise<import("@ethersproject/contracts").PopulatedTransaction>;
+export default function ({ contracts, signer, getExpiry, }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>, name: string, { contract, owner, resolverAddress, ...wrapperArgs }: Args): Promise<import("ethers").PopulatedTransaction>;
 export {};

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

@@ -15,7 +15,7 @@ import type getPrice from './getPrice';
 import type getProfile from './getProfile';
 import type getRecords from './getRecords';
 import type getResolver from './getResolver';
-import type { getAddr, getContentHash, getText, _getAddr, _getContentHash, _getText } from './getSpecificRecord';
+import type { getABI, getAddr, getContentHash, getText, _getABI, _getAddr, _getContentHash, _getText } from './getSpecificRecord';
 import type getSubnames from './getSubnames';
 import type getWrapperData from './getWrapperData';
 import type importDNSSECName from './importDNSSECName';
@@ -54,9 +54,11 @@ declare type Function = {
     getAddr: typeof getAddr;
     getContentHash: typeof getContentHash;
     getText: typeof getText;
+    getABI: typeof getABI;
     _getAddr: typeof _getAddr;
     _getContentHash: typeof _getContentHash;
     _getText: typeof _getText;
+    _getABI: typeof _getABI;
     getSubnames: typeof getSubnames;
     getWrapperData: typeof getWrapperData;
     importDNSSECName: typeof importDNSSECName;

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

@@ -2,4 +2,4 @@ import { ENSArgs } from '..';
 export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { newController, newRegistrant, }: {
     newController: string;
     newRegistrant?: string;
-}): Promise<import("@ethersproject/contracts").PopulatedTransaction>;
+}): Promise<import("ethers").PopulatedTransaction>;

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

@@ -6,4 +6,4 @@ export default function ({ contracts, signer, getExpiry, }: ENSArgs<'contracts'
     fuseOptions?: FuseOptions | string | number;
     expiry?: Expiry;
     resolverAddress?: string;
-}): Promise<import("@ethersproject/contracts").PopulatedTransaction>;
+}): Promise<import("ethers").PopulatedTransaction>;

package/dist/types/index.d.ts

@@ -238,7 +238,7 @@ export declare class ENS {
         decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<{
             fuseObj: import("./utils/fuses").CurrentFuses;
             expiryDate: Date;
-            rawFuses: import("@ethersproject/bignumber").BigNumber;
+            rawFuses: import("ethers").BigNumber;
             owner: any;
         } | undefined>;
     }>;
@@ -337,6 +337,28 @@ export declare class ENS {
         }>;
         decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<string | undefined>;
     }>;
+    getABI: GeneratedRawFunction<{
+        raw: ({ contracts, universalWrapper }: ENSArgs<"contracts" | "universalWrapper">, name: string) => Promise<{
+            to: string;
+            data: string;
+        }>;
+        decode: ({ contracts, universalWrapper }: ENSArgs<"contracts" | "universalWrapper">, data: string) => Promise<{
+            contentType: number;
+            decoded: boolean;
+            abi: string | object;
+        } | undefined>;
+    }>;
+    _getABI: GeneratedRawFunction<{
+        raw: ({ contracts }: ENSArgs<"contracts">, name: string) => Promise<{
+            to: string;
+            data: string;
+        }>;
+        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<{
+            contentType: number;
+            decoded: boolean;
+            abi: string | object;
+        } | undefined>;
+    }>;
     getOwner: GeneratedRawFunction<{
         raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, name: string, contract?: "nameWrapper" | "registrar" | "registry" | undefined) => Promise<{
             to: string;
@@ -414,8 +436,8 @@ export declare class ENS {
             data: string;
         }>;
         decode: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, data: string, _nameOrNames: string | string[], _duration: number, legacy?: boolean | undefined) => Promise<{
-            base: import("@ethersproject/bignumber").BigNumber;
-            premium: import("@ethersproject/bignumber").BigNumber;
+            base: import("ethers").BigNumber;
+            premium: import("ethers").BigNumber;
         } | undefined>;
     }>;
     getDNSOwner: (dnsName: string) => Promise<any>;