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

package/src/functions/getSubnames.ts

@@ -22,22 +22,51 @@ type Params = {
   orderDirection?: 'asc' | 'desc'
   orderBy?: 'createdAt' | 'labelName'
   lastSubnames?: Array<any>
-  isLargeQuery?: boolean
+  search?: string
 }
 
 const largeQuery = async (
   { gqlInstance }: ENSArgs<'gqlInstance'>,
-  { name, pageSize = 10, orderDirection, orderBy, lastSubnames = [] }: Params,
+  {
+    name,
+    pageSize = 10,
+    orderDirection,
+    orderBy,
+    lastSubnames = [],
+    search = '',
+  }: Params,
 ) => {
   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
@@ -47,7 +76,9 @@ const largeQuery = async (
           first: $first
           orderBy: $orderBy
           orderDirection: $orderDirection
-          where: { createdAt_lt: $lastCreatedAt }
+          where: { 
+            ${whereFilter}
+          }
         ) {
           id
           labelName
@@ -63,107 +94,20 @@ const largeQuery = async (
       }
     }
   `
+
   const queryVars = {
     id: namehash(name),
     first: pageSize,
-    lastCreatedAt: lastSubnames[lastSubnames.length - 1]?.createdAt,
+    lastCreatedAt,
+    lastLabelName,
     orderBy,
     orderDirection,
+    search: search?.toLowerCase(),
   }
   const { domain } = await client.request(finalQuery, queryVars)
   const subdomains = domain.subdomains.map((subname: any) => {
     const decrypted = decryptName(subname.name)
-    return {
-      ...subname,
-      name: decrypted,
-      truncatedName: truncateFormat(decrypted),
-    }
-  })
 
-  return {
-    subnames: subdomains,
-    subnameCount: domain.subdomainCount,
-  }
-}
-
-const smallQuery = async (
-  { gqlInstance }: ENSArgs<'gqlInstance'>,
-  { name, page, pageSize = 10, orderDirection, orderBy }: Params,
-) => {
-  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: any) => {
-    const decrypted = decryptName(subname.name)
     return {
       ...subname,
       name: decrypted,
@@ -181,10 +125,7 @@ const getSubnames = (
   injected: ENSArgs<'gqlInstance'>,
   functionArgs: Params,
 ): Promise<{ subnames: Subname[]; subnameCount: number }> => {
-  if (functionArgs.isLargeQuery) {
-    return largeQuery(injected, functionArgs)
-  }
-  return smallQuery(injected, functionArgs)
+  return largeQuery(injected, functionArgs)
 }
 
 export default getSubnames

package/src/functions/{renewName.test.ts → renewNames.test.ts}

@@ -17,7 +17,7 @@ afterAll(async () => {
   await revert()
 })
 
-describe('registerName', () => {
+describe('renewNames', () => {
   beforeEach(async () => {
     await revert()
   })
@@ -31,7 +31,7 @@ describe('registerName', () => {
     const controller = await ensInstance.contracts!.getEthRegistrarController()!
     const [price] = await controller.rentPrice(label, duration)
 
-    const tx = await ensInstance.renewName(name, {
+    const tx = await ensInstance.renewNames(name, {
       value: price.mul(2),
       duration,
       addressOrIndex: accounts[1],
@@ -41,4 +41,24 @@ describe('registerName', () => {
     const newExpiry = await baseRegistrar.nameExpires(labelhash(label))
     expect(newExpiry.toNumber()).toBe(oldExpiry.add(31536000).toNumber())
   })
+
+  it('should return a renew transaction and succeed', async () => {
+    const names = ['to-be-renewed.eth', 'test123.eth']
+    const label = names[0].split('.')[0]
+    const duration = 31536000
+    const baseRegistrar = await ensInstance.contracts!.getBaseRegistrar()!
+    const oldExpiry = await baseRegistrar.nameExpires(labelhash(label))
+    const controller = await ensInstance.contracts!.getEthRegistrarController()!
+    const [price] = await controller.rentPrice(label, duration)
+
+    const tx = await ensInstance.renewNames(names, {
+      value: price.mul(4),
+      duration,
+      addressOrIndex: accounts[1],
+    })
+    await tx.wait()
+
+    const newExpiry = await baseRegistrar.nameExpires(labelhash(label))
+    expect(newExpiry.toNumber()).toBe(oldExpiry.add(31536000).toNumber())
+  })
 })

package/src/functions/renewNames.ts

@@ -0,0 +1,30 @@
+import { BigNumber } from 'ethers'
+import { ENSArgs } from '..'
+
+export default async function (
+  { contracts }: ENSArgs<'contracts'>,
+  nameOrNames: string | string[],
+  {
+    duration,
+    value,
+  }: {
+    duration: number
+    value: BigNumber
+  },
+) {
+  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 })
+}

package/src/generated/BulkRenewal.ts

@@ -0,0 +1,197 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+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/src/generated/factories/BulkRenewal__factory.ts

@@ -0,0 +1,108 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+
+import { Contract, Signer, utils } from "ethers";
+import type { Provider } from "@ethersproject/providers";
+import type { BulkRenewal, BulkRenewalInterface } from "../BulkRenewal";
+
+const _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",
+  },
+];
+
+export class BulkRenewal__factory {
+  static readonly abi = _abi;
+  static createInterface(): BulkRenewalInterface {
+    return new utils.Interface(_abi) as BulkRenewalInterface;
+  }
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): BulkRenewal {
+    return new Contract(address, _abi, signerOrProvider) as BulkRenewal;
+  }
+}

package/src/generated/factories/index.ts

@@ -2,6 +2,7 @@
 /* tslint:disable */
 /* eslint-disable */
 export { BaseRegistrarImplementation__factory } from "./BaseRegistrarImplementation__factory";
+export { BulkRenewal__factory } from "./BulkRenewal__factory";
 export { DNSRegistrar__factory } from "./DNSRegistrar__factory";
 export { DNSSECImpl__factory } from "./DNSSECImpl__factory";
 export { DefaultReverseResolver__factory } from "./DefaultReverseResolver__factory";

package/src/generated/index.ts

@@ -2,6 +2,7 @@
 /* tslint:disable */
 /* eslint-disable */
 export type { BaseRegistrarImplementation } from "./BaseRegistrarImplementation";
+export type { BulkRenewal } from "./BulkRenewal";
 export type { DNSRegistrar } from "./DNSRegistrar";
 export type { DNSSECImpl } from "./DNSSECImpl";
 export type { DefaultReverseResolver } from "./DefaultReverseResolver";
@@ -42,3 +43,4 @@ export { Multicall__factory } from "./factories/Multicall__factory";
 export { NameWrapper__factory } from "./factories/NameWrapper__factory";
 export { StaticMetadataService__factory } from "./factories/StaticMetadataService__factory";
 export { UniversalResolver__factory } from "./factories/UniversalResolver__factory";
+export { BulkRenewal__factory } from "./factories/BulkRenewal__factory";

package/src/index.ts

@@ -34,7 +34,7 @@ import type {
 } from './functions/getSpecificRecord'
 import type getSubnames from './functions/getSubnames'
 import type registerName from './functions/registerName'
-import type renewName from './functions/renewName'
+import type renewNames from './functions/renewNames'
 import type setName from './functions/setName'
 import type setRecord from './functions/setRecord'
 import type setRecords from './functions/setRecords'
@@ -588,7 +588,7 @@ export class ENS {
 
   public deleteSubname = this.generateWriteFunction<typeof deleteSubname>(
     'deleteSubname',
-    ['transferSubname'],
+    ['contracts'],
   )
 
   public transferSubname = this.generateWriteFunction<typeof transferSubname>(
@@ -606,7 +606,8 @@ export class ENS {
     ['contracts'],
   )
 
-  public renewName = this.generateWriteFunction<typeof renewName>('renewName', [
-    'contracts',
-  ])
+  public renewNames = this.generateWriteFunction<typeof renewNames>(
+    'renewNames',
+    ['contracts'],
+  )
 }

package/dist/esm/functions/renewName.mjs

@@ -1,14 +0,0 @@
-// src/functions/renewName.ts
-async function renewName_default({ contracts }, name, {
-  duration,
-  value
-}) {
-  const labels = name.split(".");
-  if (labels.length !== 2 || labels[1] !== "eth")
-    throw new Error("Currently only .eth TLD renewals are supported");
-  const controller = await contracts.getEthRegistrarController();
-  return controller.populateTransaction.renew(labels[0], duration, { value });
-}
-export {
-  renewName_default as default
-};

package/src/functions/renewName.ts

@@ -1,22 +0,0 @@
-import type { BigNumber } from 'ethers'
-import { ENSArgs } from '..'
-
-export default async function (
-  { contracts }: ENSArgs<'contracts'>,
-  name: string,
-  {
-    duration,
-    value,
-  }: {
-    duration: number
-    value: BigNumber
-  },
-) {
-  const labels = name.split('.')
-  if (labels.length !== 2 || labels[1] !== 'eth')
-    throw new Error('Currently only .eth TLD renewals are supported')
-
-  const controller = await contracts!.getEthRegistrarController()
-
-  return controller.populateTransaction.renew(labels[0], duration, { value })
-}