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

package/dist/esm/functions/deleteSubname.mjs

@@ -1,12 +1,44 @@
 // src/functions/deleteSubname.ts
-async function deleteSubname_default({ transferSubname, signer }, name, {
-  contract
-}) {
-  return transferSubname.populateTransaction(name, {
-    contract,
-    owner: "0x0000000000000000000000000000000000000000",
-    signer
-  });
+import { ethers } from "ethers";
+import { namehash } from "../utils/normalise.mjs";
+async function deleteSubname_default({ contracts, signer }, name, { contract }) {
+  const labels = name.split(".");
+  if (labels.length !== 3) {
+    throw new Error("ENS.js currently only supports deleting 2LDs, not TLDs");
+  }
+  if (labels[2] !== "eth") {
+    throw new Error("ENS.js currently only supports deleting .eth 2LDs");
+  }
+  const label = labels.shift();
+  const labelhash = ethers.utils.solidityKeccak256(["string"], [label]);
+  const parentNodehash = namehash(labels.join("."));
+  switch (contract) {
+    case "registry": {
+      const registry = (await contracts.getRegistry()).connect(signer);
+      return registry.populateTransaction.setSubnodeRecord(
+        parentNodehash,
+        labelhash,
+        "0x0000000000000000000000000000000000000000",
+        "0x0000000000000000000000000000000000000000",
+        0
+      );
+    }
+    case "nameWrapper": {
+      const nameWrapper = (await contracts.getNameWrapper()).connect(signer);
+      return nameWrapper.populateTransaction.setSubnodeRecord(
+        parentNodehash,
+        label,
+        "0x0000000000000000000000000000000000000000",
+        "0x0000000000000000000000000000000000000000",
+        0,
+        0,
+        0
+      );
+    }
+    default: {
+      throw new Error(`Unknown contract: ${contract}`);
+    }
+  }
 }
 export {
   deleteSubname_default as default

package/dist/esm/functions/getPrice.mjs

@@ -1,11 +1,35 @@
 // src/functions/getPrice.ts
-import { utils } from "ethers";
-var raw = async ({ contracts, multicallWrapper }, name, duration, legacy) => {
+import { BigNumber, utils } from "ethers";
+var raw = async ({ contracts, multicallWrapper }, nameOrNames, duration, legacy) => {
+  const names = Array.isArray(nameOrNames) ? nameOrNames : [nameOrNames];
+  if (names.length > 1) {
+    const bulkRenewal = await contracts?.getBulkRenewal();
+    const baseCall2 = {
+      to: bulkRenewal.address,
+      data: bulkRenewal.interface.encodeFunctionData("rentPrice", [
+        names,
+        duration
+      ])
+    };
+    if (legacy) {
+      return multicallWrapper.raw([
+        baseCall2,
+        {
+          to: bulkRenewal.address,
+          data: bulkRenewal.interface.encodeFunctionData("rentPrice", [
+            names,
+            0
+          ])
+        }
+      ]);
+    }
+    return baseCall2;
+  }
   const controller = await contracts?.getEthRegistrarController();
   const baseCall = {
     to: controller.address,
     data: controller.interface.encodeFunctionData("rentPrice", [
-      name,
+      names[0],
       duration
     ])
   };
@@ -14,20 +38,42 @@ var raw = async ({ contracts, multicallWrapper }, name, duration, legacy) => {
       baseCall,
       {
         to: controller.address,
-        data: controller.interface.encodeFunctionData("rentPrice", [name, 0])
+        data: controller.interface.encodeFunctionData("rentPrice", [
+          names[0],
+          0
+        ])
       }
     ]);
   }
   return baseCall;
 };
-var decode = async ({ contracts, multicallWrapper }, data, _name, _number, legacy) => {
+var decode = async ({ contracts, multicallWrapper }, data, _nameOrNames, _duration, legacy) => {
   if (data === null)
     return;
-  const controller = await contracts?.getEthRegistrarController();
   try {
     let base;
     let premium;
-    if (legacy) {
+    const isBulkRenewal = Array.isArray(_nameOrNames) && _nameOrNames.length > 1;
+    if (isBulkRenewal && legacy) {
+      const result = await multicallWrapper.decode(data);
+      const [price] = utils.defaultAbiCoder.decode(
+        ["uint256"],
+        result[0].returnData
+      );
+      [premium] = utils.defaultAbiCoder.decode(
+        ["uint256"],
+        result[1].returnData
+      );
+      base = price.sub(premium);
+    } else if (isBulkRenewal) {
+      const bulkRenewal = await contracts?.getBulkRenewal();
+      const result = bulkRenewal.interface.decodeFunctionResult(
+        "rentPrice",
+        data
+      );
+      [base] = result;
+      premium = BigNumber.from(0);
+    } else if (!isBulkRenewal && legacy) {
       const result = await multicallWrapper.decode(data);
       const [price] = utils.defaultAbiCoder.decode(
         ["uint256"],
@@ -39,11 +85,12 @@ var decode = async ({ contracts, multicallWrapper }, data, _name, _number, legac
       );
       base = price.sub(premium);
     } else {
-      ;
-      [[base, premium]] = controller.interface.decodeFunctionResult(
+      const controller = await contracts?.getEthRegistrarController();
+      const result = controller.interface.decodeFunctionResult(
         "rentPrice",
         data
       );
+      [base, premium] = result[0];
     }
     return {
       base,

package/dist/esm/functions/getSubnames.mjs

@@ -2,15 +2,36 @@
 import { truncateFormat } from "../utils/format.mjs";
 import { decryptName } from "../utils/labels.mjs";
 import { namehash } from "../utils/normalise.mjs";
-var largeQuery = async ({ gqlInstance }, { name, pageSize = 10, orderDirection, orderBy, lastSubnames = [] }) => {
+var largeQuery = async ({ gqlInstance }, {
+  name,
+  pageSize = 10,
+  orderDirection,
+  orderBy,
+  lastSubnames = [],
+  search = ""
+}) => {
   const { client } = gqlInstance;
+  const lastSubname = lastSubnames?.[lastSubnames.length - 1];
+  const lastCreatedAt = lastSubname?.createdAt;
+  const lastLabelName = lastSubname?.labelName;
+  let whereFilter = "";
+  if (orderBy === "createdAt" && lastCreatedAt) {
+    whereFilter += orderDirection === "asc" ? "createdAt_gt: $lastCreatedAt" : "createdAt_lt: $lastCreatedAt";
+  } else if (orderBy === "labelName" && lastLabelName) {
+    whereFilter += orderDirection === "asc" ? "labelName_gt: $lastLabelName" : "labelName_lt: $lastLabelName";
+  }
+  if (search) {
+    whereFilter += " labelName_contains: $search";
+  }
   const finalQuery = gqlInstance.gql`
     query getSubnames(
       $id: ID! 
       $first: Int
       $lastCreatedAt: BigInt
+      $lastLabelName: String
       $orderBy: Domain_orderBy 
       $orderDirection: OrderDirection
+      $search: String
     ) {
       domain(
         id: $id
@@ -20,7 +41,9 @@ var largeQuery = async ({ gqlInstance }, { name, pageSize = 10, orderDirection,
           first: $first
           orderBy: $orderBy
           orderDirection: $orderDirection
-          where: { createdAt_lt: $lastCreatedAt }
+          where: { 
+            ${whereFilter}
+          }
         ) {
           id
           labelName
@@ -39,9 +62,11 @@ var largeQuery = async ({ gqlInstance }, { name, pageSize = 10, orderDirection,
   const queryVars = {
     id: namehash(name),
     first: pageSize,
-    lastCreatedAt: lastSubnames[lastSubnames.length - 1]?.createdAt,
+    lastCreatedAt,
+    lastLabelName,
     orderBy,
-    orderDirection
+    orderDirection,
+    search: search?.toLowerCase()
   };
   const { domain } = await client.request(finalQuery, queryVars);
   const subdomains = domain.subdomains.map((subname) => {
@@ -57,97 +82,8 @@ var largeQuery = async ({ gqlInstance }, { name, pageSize = 10, orderDirection,
     subnameCount: domain.subdomainCount
   };
 };
-var smallQuery = async ({ gqlInstance }, { name, page, pageSize = 10, orderDirection, orderBy }) => {
-  const { client } = gqlInstance;
-  const subdomainsGql = `
-  id
-  labelName
-  labelhash
-  isMigrated
-  name
-  subdomainCount
-  createdAt
-  owner {
-    id
-  }
-`;
-  let queryVars = {};
-  let finalQuery = "";
-  if (typeof page !== "number") {
-    finalQuery = gqlInstance.gql`
-    query getSubnames(
-      $id: ID! 
-      $orderBy: Domain_orderBy 
-      $orderDirection: OrderDirection
-    ) {
-      domain(
-        id: $id
-      ) {
-        subdomains(
-          orderBy: $orderBy
-          orderDirection: $orderDirection
-        ) {
-          ${subdomainsGql}
-        }
-      }
-    }
-  `;
-    queryVars = {
-      id: namehash(name),
-      orderBy,
-      orderDirection
-    };
-  } else {
-    finalQuery = gqlInstance.gql`
-    query getSubnames(
-      $id: ID! 
-      $first: Int
-      $skip: Int
-      $orderBy: Domain_orderBy 
-      $orderDirection: OrderDirection
-    ) {
-      domain(
-        id: $id
-      ) {
-        subdomainCount
-        subdomains(
-          first: $first
-          skip: $skip
-          orderBy: $orderBy
-          orderDirection: $orderDirection
-        ) {
-          ${subdomainsGql}
-        }
-      }
-    }
-  `;
-    queryVars = {
-      id: namehash(name),
-      first: pageSize,
-      skip: (page || 0) * pageSize,
-      orderBy,
-      orderDirection
-    };
-  }
-  const { domain } = await client.request(finalQuery, queryVars);
-  const subdomains = domain.subdomains.map((subname) => {
-    const decrypted = decryptName(subname.name);
-    return {
-      ...subname,
-      name: decrypted,
-      truncatedName: truncateFormat(decrypted)
-    };
-  });
-  return {
-    subnames: subdomains,
-    subnameCount: domain.subdomainCount
-  };
-};
 var getSubnames = (injected, functionArgs) => {
-  if (functionArgs.isLargeQuery) {
-    return largeQuery(injected, functionArgs);
-  }
-  return smallQuery(injected, functionArgs);
+  return largeQuery(injected, functionArgs);
 };
 var getSubnames_default = getSubnames;
 export {

package/dist/esm/functions/renewNames.mjs

@@ -0,0 +1,23 @@
+// src/functions/renewNames.ts
+async function renewNames_default({ contracts }, nameOrNames, {
+  duration,
+  value
+}) {
+  const names = Array.isArray(nameOrNames) ? nameOrNames : [nameOrNames];
+  const labels = names.map((name) => {
+    const label = name.split(".");
+    if (label.length !== 2 || label[1] !== "eth") {
+      throw new Error("Currently only .eth TLD renewals are supported");
+    }
+    return label[0];
+  });
+  if (labels.length === 1) {
+    const controller = await contracts.getEthRegistrarController();
+    return controller.populateTransaction.renew(labels[0], duration, { value });
+  }
+  const bulkRenewal = await contracts.getBulkRenewal();
+  return bulkRenewal.populateTransaction.renewAll(labels, duration, { value });
+}
+export {
+  renewNames_default as default
+};

package/dist/esm/generated/factories/BulkRenewal__factory.mjs

@@ -0,0 +1,108 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// src/generated/factories/BulkRenewal__factory.ts
+import { Contract, utils } from "ethers";
+var _abi = [
+  {
+    inputs: [
+      {
+        internalType: "contract ENS",
+        name: "_ens",
+        type: "address"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "constructor"
+  },
+  {
+    inputs: [],
+    name: "ens",
+    outputs: [
+      {
+        internalType: "contract ENS",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "string[]",
+        name: "names",
+        type: "string[]"
+      },
+      {
+        internalType: "uint256",
+        name: "duration",
+        type: "uint256"
+      }
+    ],
+    name: "renewAll",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "string[]",
+        name: "names",
+        type: "string[]"
+      },
+      {
+        internalType: "uint256",
+        name: "duration",
+        type: "uint256"
+      }
+    ],
+    name: "rentPrice",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "total",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes4",
+        name: "interfaceID",
+        type: "bytes4"
+      }
+    ],
+    name: "supportsInterface",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  }
+];
+var BulkRenewal__factory = class {
+  static createInterface() {
+    return new utils.Interface(_abi);
+  }
+  static connect(address, signerOrProvider) {
+    return new Contract(address, _abi, signerOrProvider);
+  }
+};
+__publicField(BulkRenewal__factory, "abi", _abi);
+export {
+  BulkRenewal__factory
+};

package/dist/esm/generated/factories/index.mjs

@@ -1,5 +1,6 @@
 // src/generated/factories/index.ts
 import { BaseRegistrarImplementation__factory } from "./BaseRegistrarImplementation__factory.mjs";
+import { BulkRenewal__factory } from "./BulkRenewal__factory.mjs";
 import { DNSRegistrar__factory } from "./DNSRegistrar__factory.mjs";
 import { DNSSECImpl__factory } from "./DNSSECImpl__factory.mjs";
 import { DefaultReverseResolver__factory } from "./DefaultReverseResolver__factory.mjs";
@@ -21,6 +22,7 @@ import { TLDPublicSuffixList__factory } from "./TLDPublicSuffixList__factory.mjs
 import { UniversalResolver__factory } from "./UniversalResolver__factory.mjs";
 export {
   BaseRegistrarImplementation__factory,
+  BulkRenewal__factory,
   DNSRegistrar__factory,
   DNSSECImpl__factory,
   DefaultReverseResolver__factory,

package/dist/esm/generated/index.mjs

@@ -20,8 +20,10 @@ import { Multicall__factory } from "./factories/Multicall__factory.mjs";
 import { NameWrapper__factory } from "./factories/NameWrapper__factory.mjs";
 import { StaticMetadataService__factory } from "./factories/StaticMetadataService__factory.mjs";
 import { UniversalResolver__factory } from "./factories/UniversalResolver__factory.mjs";
+import { BulkRenewal__factory } from "./factories/BulkRenewal__factory.mjs";
 export {
   BaseRegistrarImplementation__factory,
+  BulkRenewal__factory,
   DNSRegistrar__factory,
   DNSSECImpl__factory,
   DefaultReverseResolver__factory,

package/dist/esm/index.mjs

@@ -280,7 +280,7 @@ var ENS = class {
   );
   deleteSubname = this.generateWriteFunction(
     "deleteSubname",
-    ["transferSubname"]
+    ["contracts"]
   );
   transferSubname = this.generateWriteFunction(
     "transferSubname",
@@ -294,9 +294,10 @@ var ENS = class {
     "registerName",
     ["contracts"]
   );
-  renewName = this.generateWriteFunction("renewName", [
-    "contracts"
-  ]);
+  renewNames = this.generateWriteFunction(
+    "renewNames",
+    ["contracts"]
+  );
 };
 export {
   ENS

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

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

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

@@ -13,4 +13,5 @@ export default class ContractManager {
     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/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/types/functions/deleteSubname.d.ts

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

package/dist/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/types/functions/getSubnames.d.ts

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

package/dist/types/functions/{renewName.d.ts → renewNames.d.ts}

@@ -1,6 +1,6 @@
-import type { BigNumber } from 'ethers';
+import { BigNumber } from 'ethers';
 import { ENSArgs } from '..';
-export default function ({ contracts }: ENSArgs<'contracts'>, name: string, { duration, value, }: {
+export default function ({ contracts }: ENSArgs<'contracts'>, nameOrNames: string | string[], { duration, value, }: {
     duration: number;
     value: BigNumber;
 }): Promise<import("ethers").PopulatedTransaction>;

package/dist/types/generated/BulkRenewal.d.ts

@@ -0,0 +1,76 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, PayableOverrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent, PromiseOrValue } from "./common";
+export interface BulkRenewalInterface extends utils.Interface {
+    functions: {
+        "ens()": FunctionFragment;
+        "renewAll(string[],uint256)": FunctionFragment;
+        "rentPrice(string[],uint256)": FunctionFragment;
+        "supportsInterface(bytes4)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "ens" | "renewAll" | "rentPrice" | "supportsInterface"): FunctionFragment;
+    encodeFunctionData(functionFragment: "ens", values?: undefined): string;
+    encodeFunctionData(functionFragment: "renewAll", values: [PromiseOrValue<string>[], PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "rentPrice", values: [PromiseOrValue<string>[], PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "supportsInterface", values: [PromiseOrValue<BytesLike>]): string;
+    decodeFunctionResult(functionFragment: "ens", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "renewAll", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rentPrice", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "supportsInterface", data: BytesLike): Result;
+    events: {};
+}
+export interface BulkRenewal extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: BulkRenewalInterface;
+    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
+    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
+    listeners(eventName?: string): Array<Listener>;
+    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
+    removeAllListeners(eventName?: string): this;
+    off: OnEvent<this>;
+    on: OnEvent<this>;
+    once: OnEvent<this>;
+    removeListener: OnEvent<this>;
+    functions: {
+        ens(overrides?: CallOverrides): Promise<[string]>;
+        renewAll(names: PromiseOrValue<string>[], duration: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        rentPrice(names: PromiseOrValue<string>[], duration: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[BigNumber] & {
+            total: BigNumber;
+        }>;
+        supportsInterface(interfaceID: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[boolean]>;
+    };
+    ens(overrides?: CallOverrides): Promise<string>;
+    renewAll(names: PromiseOrValue<string>[], duration: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    rentPrice(names: PromiseOrValue<string>[], duration: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+    supportsInterface(interfaceID: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
+    callStatic: {
+        ens(overrides?: CallOverrides): Promise<string>;
+        renewAll(names: PromiseOrValue<string>[], duration: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        rentPrice(names: PromiseOrValue<string>[], duration: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        supportsInterface(interfaceID: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
+    };
+    filters: {};
+    estimateGas: {
+        ens(overrides?: CallOverrides): Promise<BigNumber>;
+        renewAll(names: PromiseOrValue<string>[], duration: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        rentPrice(names: PromiseOrValue<string>[], duration: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        supportsInterface(interfaceID: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        ens(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        renewAll(names: PromiseOrValue<string>[], duration: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        rentPrice(names: PromiseOrValue<string>[], duration: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        supportsInterface(interfaceID: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

package/dist/types/generated/factories/BulkRenewal__factory.d.ts

@@ -0,0 +1,32 @@
+import { Signer } from "ethers";
+import type { Provider } from "@ethersproject/providers";
+import type { BulkRenewal, BulkRenewalInterface } from "../BulkRenewal";
+export declare class BulkRenewal__factory {
+    static readonly abi: ({
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        stateMutability: string;
+        type: string;
+        name?: undefined;
+        outputs?: undefined;
+    } | {
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        outputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        stateMutability: string;
+        type: string;
+    })[];
+    static createInterface(): BulkRenewalInterface;
+    static connect(address: string, signerOrProvider: Signer | Provider): BulkRenewal;
+}