@ensdomains/ensjs 3.0.0-alpha.2 → 3.0.0-alpha.21

package/dist/esm/utils/recordHelpers.mjs

@@ -0,0 +1,70 @@
+// src/utils/recordHelpers.ts
+import { formatsByCoinType, formatsByName } from "@ensdomains/address-encoder";
+import { encodeContenthash } from "./contentHash.mjs";
+var generateSetAddr = (namehash, coinType, address, resolver) => {
+  let coinTypeInstance;
+  if (!Number.isNaN(parseInt(coinType))) {
+    coinTypeInstance = formatsByCoinType[parseInt(coinType)];
+  } else {
+    coinTypeInstance = formatsByName[coinType.toUpperCase()];
+  }
+  const inputCoinType = coinTypeInstance.coinType;
+  const encodedAddress = coinTypeInstance.decoder(address);
+  return resolver?.interface.encodeFunctionData(
+    "setAddr(bytes32,uint256,bytes)",
+    [namehash, inputCoinType, encodedAddress]
+  );
+};
+function generateSingleRecordCall(namehash, resolver, type) {
+  if (type === "contentHash") {
+    return (_r) => {
+      const record = _r;
+      let _contentHash = "";
+      if (record !== _contentHash) {
+        const encoded = encodeContenthash(record);
+        if (encoded.error)
+          throw new Error(encoded.error);
+        _contentHash = encoded.encoded;
+      }
+      return resolver.interface.encodeFunctionData("setContenthash", [
+        namehash,
+        _contentHash
+      ]);
+    };
+  }
+  return (_r) => {
+    const record = _r;
+    if (type === "text") {
+      return resolver.interface.encodeFunctionData("setText", [
+        namehash,
+        record.key,
+        record.value
+      ]);
+    }
+    return generateSetAddr(namehash, record.key, record.value, resolver);
+  };
+}
+var generateRecordCallArray = (namehash, records, resolver) => {
+  const calls = [];
+  if (records.contentHash) {
+    const data = generateSingleRecordCall(
+      namehash,
+      resolver,
+      "contentHash"
+    )(records.contentHash);
+    if (data)
+      calls.push(data);
+  }
+  if (records.texts && records.texts.length > 0) {
+    records.texts.map(generateSingleRecordCall(namehash, resolver, "text")).forEach((call) => calls.push(call));
+  }
+  if (records.coinTypes && records.coinTypes.length > 0) {
+    records.coinTypes.map(generateSingleRecordCall(namehash, resolver, "addr")).forEach((call) => calls.push(call));
+  }
+  return calls;
+};
+export {
+  generateRecordCallArray,
+  generateSetAddr,
+  generateSingleRecordCall
+};

package/dist/esm/utils/registerHelpers.mjs

@@ -0,0 +1,95 @@
+// src/utils/registerHelpers.ts
+import { utils } from "ethers";
+import generateFuseInput from "./generateFuseInput.mjs";
+import { labelhash } from "./labels.mjs";
+import { namehash } from "./normalise.mjs";
+import { generateRecordCallArray } from "./recordHelpers.mjs";
+var randomSecret = () => {
+  const bytes = Buffer.allocUnsafe(32);
+  return `0x${crypto.getRandomValues(bytes).toString("hex")}`;
+};
+var makeCommitmentData = ({
+  name,
+  owner,
+  duration,
+  resolver,
+  records,
+  reverseRecord,
+  fuses,
+  wrapperExpiry,
+  secret
+}) => {
+  const label = labelhash(name.split(".")[0]);
+  const hash = namehash(name);
+  const resolverAddress = resolver.address;
+  const fuseData = fuses ? generateFuseInput(fuses) : "0";
+  if (reverseRecord) {
+    if (!records) {
+      records = { coinTypes: [{ key: "ETH", value: owner }] };
+    } else if (!records.coinTypes?.find((c) => c.key === "ETH")) {
+      if (!records.coinTypes)
+        records.coinTypes = [];
+      records.coinTypes.push({ key: "ETH", value: owner });
+    }
+  }
+  const data = records ? generateRecordCallArray(hash, records, resolver) : [];
+  return [
+    label,
+    owner,
+    duration,
+    resolverAddress,
+    data,
+    secret,
+    !!reverseRecord,
+    fuseData,
+    wrapperExpiry || Math.floor(Date.now() / 1e3) + duration
+  ];
+};
+var makeRegistrationData = (params) => {
+  const commitmentData = makeCommitmentData(params);
+  const label = params.name.split(".")[0];
+  commitmentData[0] = label;
+  const secret = commitmentData.splice(5, 1)[0];
+  commitmentData.splice(3, 0, secret);
+  return commitmentData;
+};
+var _makeCommitment = (params) => {
+  return utils.keccak256(
+    utils.defaultAbiCoder.encode(
+      [
+        "bytes32",
+        "address",
+        "uint256",
+        "address",
+        "bytes[]",
+        "bytes32",
+        "bool",
+        "uint32",
+        "uint64"
+      ],
+      params
+    )
+  );
+};
+var makeCommitment = ({
+  secret = randomSecret(),
+  ...inputParams
+}) => {
+  const generatedParams = makeCommitmentData({
+    ...inputParams,
+    secret
+  });
+  const commitment = _makeCommitment(generatedParams);
+  return {
+    secret,
+    commitment,
+    wrapperExpiry: generatedParams[8]
+  };
+};
+export {
+  _makeCommitment,
+  makeCommitment,
+  makeCommitmentData,
+  makeRegistrationData,
+  randomSecret
+};

package/dist/esm/utils/singleCall.mjs

@@ -0,0 +1,5 @@
+// src/utils/singleCall.ts
+var singleCall_default = async (provider, ensData, func, ...data) => func.raw(ensData, ...data).then((rawData) => provider.call(rawData)).catch(() => null).then((ret) => func.decode(ensData, ret, ...data));
+export {
+  singleCall_default as default
+};

package/dist/esm/utils/validation.mjs

@@ -0,0 +1,67 @@
+// src/utils/validation.ts
+import { isAddress } from "ethers/lib/utils.js";
+import { isEncodedLabelhash, saveName } from "./labels.mjs";
+import { normalise } from "./normalise.mjs";
+var validateName = (name) => {
+  const nameArray = name.split(".");
+  const hasEmptyLabels = nameArray.some((label) => label.length === 0);
+  if (hasEmptyLabels)
+    throw new Error("Name cannot have empty labels");
+  const normalizedArray = nameArray.map((label) => {
+    if (label === "[root]") {
+      return label;
+    }
+    return isEncodedLabelhash(label) ? label : normalise(label);
+  });
+  const normalizedName = normalizedArray.join(".");
+  saveName(normalizedName);
+  return normalizedName;
+};
+var validateTLD = (name) => {
+  const labels = name.split(".");
+  return validateName(labels[labels.length - 1]);
+};
+var parseInputType = (input) => {
+  const validTLD = validateTLD(input);
+  const regex = /[^.]+$/;
+  try {
+    validateName(input);
+  } catch (e) {
+    return {
+      type: "unknown"
+    };
+  }
+  if (input.indexOf(".") !== -1) {
+    const termArray = input.split(".");
+    const tld = input.match(regex) ? input.match(regex)[0] : "";
+    if (validTLD) {
+      if (tld === "eth" && [...termArray[termArray.length - 2]].length < 3) {
+        return {
+          type: "name",
+          info: "short"
+        };
+      }
+      return {
+        type: "name",
+        info: "supported"
+      };
+    }
+    return {
+      type: "name",
+      info: "unsupported"
+    };
+  }
+  if (isAddress(input)) {
+    return {
+      type: "address"
+    };
+  }
+  return {
+    type: "label"
+  };
+};
+export {
+  parseInputType,
+  validateName,
+  validateTLD
+};

package/dist/esm/utils/wrapperExpiry.mjs

@@ -0,0 +1,25 @@
+// src/utils/wrapperExpiry.ts
+import { BigNumber } from "ethers";
+var MAX_EXPIRY = BigNumber.from(2).pow(64).sub(1);
+var makeExpiry = async ({ getExpiry }, name, expiry) => {
+  if (expiry) {
+    if (expiry instanceof Date) {
+      return BigNumber.from(expiry.getTime() / 1e3);
+    }
+    if (expiry instanceof BigNumber) {
+      return expiry;
+    }
+    return BigNumber.from(expiry);
+  }
+  if (name.endsWith(".eth")) {
+    const expResponse = await getExpiry(name);
+    if (!expResponse?.expiry)
+      throw new Error("Couldn't get expiry for name, please provide one.");
+    return BigNumber.from(expResponse.expiry.getTime() / 1e3);
+  }
+  return MAX_EXPIRY;
+};
+export {
+  MAX_EXPIRY,
+  makeExpiry
+};

package/dist/esm/utils/writeTx.mjs

@@ -0,0 +1,6 @@
+// src/utils/writeTx.ts
+var withCustomData = (tx, customData) => customData ? { ...tx, customData } : tx;
+var writeTx_default = (signer, populate) => ({ customData, ...tx }) => populate ? withCustomData(tx, customData) : signer.sendTransaction(tx).then((r) => withCustomData(r, customData));
+export {
+  writeTx_default as default
+};

package/dist/types/GqlManager.d.ts

@@ -0,0 +1,11 @@
+import type { parse as Parse, print as Print, SelectionSetNode, visit as Visit } from 'graphql';
+import type Traverse from 'traverse';
+export declare const enter: (node: SelectionSetNode) => SelectionSetNode | undefined;
+export declare const requestMiddleware: (visit: typeof Visit, parse: typeof Parse, print: typeof Print) => (request: any) => any;
+export declare const responseMiddleware: (traverse: typeof Traverse) => (response: any) => any;
+export default class GqlManager {
+    gql: any;
+    client?: any | null;
+    setUrl: (url: string | null) => Promise<void>;
+    request: (...arg: any[]) => any;
+}

package/dist/{cjs/contracts/ethRegistrarController.d.ts → types/contracts/bulkRenewal.d.ts}

@@ -1,3 +1,3 @@
 import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").ETHRegistrarController;
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/BulkRenewal").BulkRenewal;
 export default _default;

package/dist/{esm → types}/contracts/ethRegistrarController.d.ts

@@ -1,3 +1,3 @@
 import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").ETHRegistrarController;
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/ETHRegistrarController").ETHRegistrarController;
 export default _default;

package/dist/types/contracts/index.d.ts

@@ -0,0 +1,17 @@
+import { ethers } from 'ethers';
+import { ContractAddressFetch } from './getContractAddress';
+export default class ContractManager {
+    private provider;
+    private fetchAddress;
+    constructor(provider: ethers.providers.Provider, fetchAddress: ContractAddressFetch);
+    private generateContractGetter;
+    getPublicResolver: (passedProvider?: any, address?: string) => Promise<import("../generated/PublicResolver").PublicResolver>;
+    getUniversalResolver: (passedProvider?: any, address?: string) => Promise<import("../generated/UniversalResolver").UniversalResolver>;
+    getRegistry: (passedProvider?: any, address?: string) => Promise<import("../generated/ENSRegistry").ENSRegistry>;
+    getReverseRegistrar: (passedProvider?: any, address?: string) => Promise<import("../generated/ReverseRegistrar").ReverseRegistrar>;
+    getNameWrapper: (passedProvider?: any, address?: string) => Promise<import("../generated/NameWrapper").NameWrapper>;
+    getBaseRegistrar: (passedProvider?: any, address?: string) => Promise<import("../generated/BaseRegistrarImplementation").BaseRegistrarImplementation>;
+    getEthRegistrarController: (passedProvider?: any, address?: string) => Promise<import("../generated/ETHRegistrarController").ETHRegistrarController>;
+    getMulticall: (passedProvider?: any, address?: string) => Promise<import("../generated/Multicall").Multicall>;
+    getBulkRenewal: (passedProvider?: any, address?: string) => Promise<import("../generated/BulkRenewal").BulkRenewal>;
+}

package/dist/{esm → types}/contracts/nameWrapper.d.ts

@@ -1,3 +1,3 @@
 import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").NameWrapper;
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/NameWrapper").NameWrapper;
 export default _default;

package/dist/{esm → types}/contracts/publicResolver.d.ts

@@ -1,3 +1,3 @@
 import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").PublicResolver;
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/PublicResolver").PublicResolver;
 export default _default;

package/dist/{cjs → types}/contracts/reverseRegistrar.d.ts

@@ -1,3 +1,3 @@
 import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").ReverseRegistrar;
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/ReverseRegistrar").ReverseRegistrar;
 export default _default;

package/dist/{cjs → types}/contracts/types.d.ts

@@ -1,2 +1,2 @@
 export declare type SupportedNetworkId = '1' | '3' | '4' | '5' | '1337';
-export declare type ContractName = 'BaseRegistrarImplementation' | 'ETHRegistrarController' | 'Multicall' | 'NameWrapper' | 'PublicResolver' | 'ENSRegistryWithFallback' | 'ReverseRegistrar' | 'UniversalResolver';
+export declare type ContractName = 'BaseRegistrarImplementation' | 'ETHRegistrarController' | 'Multicall' | 'NameWrapper' | 'PublicResolver' | 'ENSRegistryWithFallback' | 'ReverseRegistrar' | 'UniversalResolver' | 'BulkRenewal';

package/dist/{cjs → types}/contracts/universalResolver.d.ts

@@ -1,3 +1,3 @@
 import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").UniversalResolver;
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/UniversalResolver").UniversalResolver;
 export default _default;

package/dist/{esm → types}/functions/batchWrappers.d.ts

@@ -21,9 +21,9 @@ export declare const resolverMulticallWrapper: {
     decode: ({ contracts }: ENSArgs<'contracts'>, data: string) => Promise<ethers.utils.Result | undefined>;
 };
 export declare const multicallWrapper: {
-    raw: ({ contracts }: ENSArgs<'contracts'>, transactions: ethers.providers.TransactionRequest[], requireSuccess?: boolean) => Promise<{
+    raw({ contracts }: ENSArgs<'contracts'>, transactions: ethers.providers.TransactionRequest[], requireSuccess?: boolean): Promise<{
         to: string;
         data: string;
     }>;
-    decode: ({ contracts }: ENSArgs<'contracts'>, data: string) => Promise<any>;
+    decode({ contracts }: ENSArgs<'contracts'>, data: string): Promise<any>;
 };

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

@@ -0,0 +1,13 @@
+import { ENSArgs } from '..';
+import { NamedFusesToBurn, UnnamedFuseValues } from '../utils/fuses';
+export declare type FusePropsNamedArray = {
+    namedFusesToBurn: NamedFusesToBurn;
+};
+export declare type FusePropsUnnamedArray = {
+    unnamedFusesToBurn: UnnamedFuseValues[];
+};
+export declare type FusePropsNumber = {
+    fuseNumberToBurn: number;
+};
+export declare type FuseProps = (Partial<FusePropsNamedArray> & FusePropsUnnamedArray) | (FusePropsNamedArray & Partial<FusePropsUnnamedArray>) | FusePropsNumber;
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, props: FuseProps): Promise<import("ethers").PopulatedTransaction>;

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

@@ -0,0 +1,26 @@
+import { ENSArgs } from '..';
+import { CommitmentParams } from '../utils/registerHelpers';
+declare type Params = Omit<CommitmentParams, 'resolver' | 'name'> & {
+    resolverAddress?: string;
+};
+export default function ({ contracts }: ENSArgs<'contracts'>, name: string, { resolverAddress, ...params }: Params): Promise<{
+    customData: {
+        secret: string;
+        commitment: string;
+        wrapperExpiry: number;
+    };
+    to?: string | undefined;
+    from?: string | undefined;
+    nonce?: number | undefined;
+    gasLimit?: import("ethers").BigNumber | undefined;
+    gasPrice?: import("ethers").BigNumber | undefined;
+    data?: string | undefined;
+    value?: import("ethers").BigNumber | undefined;
+    chainId?: number | undefined;
+    type?: number | undefined;
+    accessList?: import("ethers/lib/utils").AccessList | undefined;
+    maxFeePerGas?: import("ethers").BigNumber | undefined;
+    maxPriorityFeePerGas?: import("ethers").BigNumber | undefined;
+    ccipReadEnabled?: boolean | undefined;
+}>;
+export {};

package/dist/{esm → types}/functions/createSubname.d.ts

@@ -1,19 +1,17 @@
 import { ethers } from 'ethers';
 import { ENSArgs } from '..';
 import { FuseOptions } from '../@types/FuseOptions';
+import { Expiry } from '../utils/wrapperExpiry';
 declare type BaseArgs = {
-    name: string;
     owner: string;
     resolverAddress?: string;
     contract: 'registry' | 'nameWrapper';
-    options?: {
-        addressOrIndex?: string | number;
-    };
 };
 declare type NameWrapperArgs = {
     contract: 'nameWrapper';
     fuses?: FuseOptions;
+    expiry?: Expiry;
 } & BaseArgs;
 declare type Args = BaseArgs | NameWrapperArgs;
-export default function ({ contracts, provider }: ENSArgs<'contracts' | 'provider'>, { name, owner, resolverAddress, contract, options, ...wrapperArgs }: Args): Promise<ethers.ContractTransaction>;
+export default function ({ contracts, signer, getExpiry, }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>, name: string, { owner, resolverAddress, contract, ...wrapperArgs }: Args): Promise<ethers.PopulatedTransaction>;
 export {};

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

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

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

@@ -0,0 +1,7 @@
+import * as packet from 'dns-packet';
+export declare function encodeURLParams(p: {
+    [key: string]: string;
+}): string;
+export declare const getDNS: (q: packet.Packet) => Promise<packet.Packet>;
+export declare const dnsQuery: (qtype: string, qname: string) => Promise<packet.Packet>;
+export default function (_: any, dnsName: string): Promise<any>;

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

@@ -0,0 +1,19 @@
+import { ENSArgs } from '..';
+declare type ContractOption = 'registrar' | 'nameWrapper';
+declare type Args = {
+    contract?: ContractOption;
+};
+declare const _default: {
+    raw: (ensArgs: ENSArgs<"contracts" | "multicallWrapper">, name: string, { contract }?: Args) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: (ensArgs: ENSArgs<"contracts" | "multicallWrapper">, data: string, name: string, { contract }?: Args) => Promise<{
+        expiry: Date;
+        gracePeriod: null;
+    } | {
+        expiry: Date | null;
+        gracePeriod: number;
+    } | undefined>;
+};
+export default _default;

package/dist/{cjs → types}/functions/getFuses.d.ts

@@ -1,17 +1,16 @@
 import { BigNumber } from 'ethers';
 import { ENSArgs } from '..';
+import { CurrentFuses } from '../utils/fuses';
 declare const _default: {
     raw: ({ contracts }: ENSArgs<"contracts">, name: string) => Promise<{
         to: string;
         data: string;
     }>;
-    decode: ({ contracts }: ENSArgs<"contracts">, data: string, name: string) => Promise<{
-        fuseObj: {
-            [k: string]: any;
-        };
-        vulnerability: any;
-        vulnerableNode: null;
+    decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<{
+        fuseObj: CurrentFuses;
+        expiryDate: Date;
         rawFuses: BigNumber;
+        owner: any;
     } | undefined>;
 };
 export default _default;

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

@@ -0,0 +1,28 @@
+import { ENSArgs } from '..';
+declare type DomainEvent = 'NewOwner' | 'NewResolver' | 'Transfer' | 'NewTTL';
+declare type RegistrationEvent = 'NameRegistered' | 'NameRenewed' | 'NameTransferred';
+declare type ResolverEvent = 'AddrChanged' | 'MulticoinAddrChanged' | 'NameChanged' | 'AbiChanged' | 'PubkeyChanged' | 'TextChanged' | 'ContenthashChanged' | 'InterfaceChanged' | 'AuthorisationChanged';
+export declare function getHistory({ gqlInstance }: ENSArgs<'gqlInstance'>, name: string): Promise<{
+    domain: {
+        type: DomainEvent;
+        blockNumber: number;
+        transactionHash: string;
+        id: string;
+        data: object;
+    }[];
+    registration: {
+        type: RegistrationEvent;
+        blockNumber: number;
+        transactionHash: string;
+        id: string;
+        data: object;
+    }[];
+    resolver: {
+        type: ResolverEvent;
+        blockNumber: number;
+        transactionHash: string;
+        id: string;
+        data: object;
+    }[];
+} | undefined>;
+export {};

package/dist/{cjs → types}/functions/getName.d.ts

@@ -10,8 +10,8 @@ declare const _default: {
         reverseResolverAddress: any;
         resolverAddress: any;
     } | {
-        name: null;
-        match: boolean;
+        name: undefined;
+        match?: undefined;
         reverseResolverAddress?: undefined;
         resolverAddress?: undefined;
     } | undefined>;

package/dist/{esm → types}/functions/getPrice.d.ts

@@ -1,11 +1,11 @@
 import { BigNumber } from 'ethers';
 import { ENSArgs } from '..';
 declare const _default: {
-    raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, name: string, duration: number, legacy?: boolean | undefined) => Promise<{
+    raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, nameOrNames: string | string[], duration: number, legacy?: boolean | undefined) => Promise<{
         to: string;
         data: string;
     }>;
-    decode: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, data: string, _name: string, _number: number, legacy?: boolean | undefined) => Promise<{
+    decode: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, data: string, _nameOrNames: string | string[], _duration: number, legacy?: boolean | undefined) => Promise<{
         base: BigNumber;
         premium: BigNumber;
     } | undefined>;

package/dist/{esm → types}/functions/getProfile.d.ts

@@ -26,5 +26,8 @@ declare type ProfileOptions = {
     texts?: boolean | string[];
     coinTypes?: boolean | string[];
 };
-export default function ({ contracts, gqlInstance, getName, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, multicallWrapper, }: ENSArgs<'contracts' | 'gqlInstance' | 'getName' | '_getText' | '_getAddr' | '_getContentHash' | 'resolverMulticallWrapper' | 'multicallWrapper'>, nameOrAddress: string, options?: ProfileOptions): Promise<ResolvedProfile | undefined>;
+declare type InputProfileOptions = ProfileOptions & {
+    resolverAddress?: string;
+};
+export default function ({ contracts, gqlInstance, getName, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, multicallWrapper, }: ENSArgs<'contracts' | 'gqlInstance' | 'getName' | '_getText' | '_getAddr' | '_getContentHash' | 'resolverMulticallWrapper' | 'multicallWrapper'>, nameOrAddress: string, options?: InputProfileOptions): Promise<ResolvedProfile | undefined>;
 export {};

package/dist/{esm → types}/functions/getRecords.d.ts

@@ -3,6 +3,7 @@ declare type ProfileOptions = {
     contentHash?: boolean;
     texts?: boolean | string[];
     coinTypes?: boolean | string[];
+    resolverAddress?: string;
 };
 export default function ({ getProfile }: ENSArgs<'getProfile'>, name: string, options?: ProfileOptions): Promise<{
     isMigrated: boolean | null;

package/dist/{esm → types}/functions/getSpecificRecord.d.ts

@@ -52,21 +52,21 @@ export declare const getText: {
     decode: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, data: string) => Promise<any>;
 };
 export declare const _getAddr: {
-    raw: ({ contracts }: ENSArgs<'contracts'>, name: string, coinType?: string | number | undefined, bypassFormat?: boolean | undefined) => Promise<{
+    raw: ({ contracts }: ENSArgs<'contracts'>, name: string, coinType?: string | number, bypassFormat?: boolean) => Promise<{
         to: string;
         data: string;
     }>;
-    decode: ({ contracts }: ENSArgs<'contracts'>, data: string, _name: string, coinType?: string | number | undefined) => Promise<string | {
+    decode: ({ contracts }: ENSArgs<'contracts'>, data: string, _name: string, coinType?: string | number) => Promise<string | {
         coin: string;
         addr: string;
     } | undefined>;
 };
 export declare const getAddr: {
-    raw: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, name: string, coinType?: string | number | undefined) => Promise<{
+    raw: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, name: string, coinType?: string | number) => Promise<{
         to: string;
         data: string;
     }>;
-    decode: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, data: string, _name: string, coinType?: string | number | undefined) => Promise<string | {
+    decode: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, data: string, _name: string, coinType?: string | number) => Promise<string | {
         coin: string;
         addr: string;
     } | undefined>;

package/dist/{esm → types}/functions/getSubnames.d.ts

@@ -16,8 +16,8 @@ declare type Params = {
     pageSize?: number;
     orderDirection?: 'asc' | 'desc';
     orderBy?: 'createdAt' | 'labelName';
-    lastSubnames: Array<any>;
-    isLargeQuery?: boolean;
+    lastSubnames?: Array<any>;
+    search?: string;
 };
 declare const getSubnames: (injected: ENSArgs<'gqlInstance'>, functionArgs: Params) => Promise<{
     subnames: Subname[];

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

@@ -0,0 +1,11 @@
+import { BigNumber } from 'ethers';
+import { ENSArgs } from '..';
+import { CommitmentParams } from '../utils/registerHelpers';
+declare type Params = Omit<CommitmentParams, 'name' | 'resolver'> & {
+    resolverAddress?: string;
+    secret: string;
+    wrapperExpiry: number;
+    value: BigNumber;
+};
+export default function ({ contracts }: ENSArgs<'contracts'>, name: string, { resolverAddress, value, ...params }: Params): Promise<import("ethers").PopulatedTransaction>;
+export {};