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

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

@@ -1,4 +1,5 @@
 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/dist/types/generated/index.d.ts

@@ -1,4 +1,5 @@
 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";
@@ -39,3 +40,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/dist/types/index.d.ts

@@ -8,7 +8,7 @@ import type commitName from './functions/commitName';
 import type createSubname from './functions/createSubname';
 import type deleteSubname from './functions/deleteSubname';
 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';
@@ -367,7 +367,7 @@ export declare class ENS {
         orderDirection?: "asc" | "desc" | undefined;
         orderBy?: "labelName" | "createdAt" | undefined;
         lastSubnames?: any[] | undefined;
-        isLargeQuery?: boolean | undefined;
+        search?: string | undefined;
     }) => Promise<{
         subnames: {
             id: string;
@@ -401,11 +401,11 @@ export declare class ENS {
         pageSize?: undefined;
     })) => Promise<import("./functions/getNames").Name[]>;
     getPrice: GeneratedRawFunction<{
-        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: ethers.BigNumber;
             premium: ethers.BigNumber;
         } | undefined>;
@@ -451,5 +451,5 @@ export declare class ENS {
     transferSubname: WriteFunction<typeof transferSubname>;
     commitName: WriteFunction<typeof commitName>;
     registerName: WriteFunction<typeof registerName>;
-    renewName: WriteFunction<typeof renewName>;
+    renewNames: WriteFunction<typeof renewNames>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ensdomains/ensjs",
-  "version": "3.0.0-alpha.20",
+  "version": "3.0.0-alpha.21",
   "description": "ENS javascript library for contract interaction",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.mjs",

package/src/contracts/bulkRenewal.ts

@@ -0,0 +1,6 @@
+import { ethers } from 'ethers'
+import { BulkRenewal__factory } from '../generated/factories/BulkRenewal__factory'
+
+// Use a higher-order function to overide the address that is passed in from getContractAddress()
+export default (provider: ethers.providers.JsonRpcProvider, address: string) =>
+  BulkRenewal__factory.connect(address, provider)

package/src/contracts/getContractAddress.ts

@@ -35,6 +35,7 @@ const addresses: Record<
     '1': '0x580AF46E06DaaD47eb5940526FD64d95b815Cb70',
     '4': '0x74e20bd2a1fe0cdbe45b9a1d89cb7e0a45b36376',
   },
+  BulkRenewal: '0xfF252725f6122A92551A5FA9a6b6bf10eb0Be035',
   /* eslint-enable @typescript-eslint/naming-convention */
 }
 

package/src/contracts/index.ts

@@ -9,6 +9,7 @@ import getRegistry from './registry'
 import getReverseRegistrar from './reverseRegistrar'
 import { ContractName } from './types'
 import getUniversalResolver from './universalResolver'
+import getBulkRenewal from './bulkRenewal'
 
 export default class ContractManager {
   private provider: ethers.providers.Provider
@@ -73,4 +74,9 @@ export default class ContractManager {
   )
 
   public getMulticall = this.generateContractGetter('Multicall', getMulticall)
+
+  public getBulkRenewal = this.generateContractGetter(
+    'BulkRenewal',
+    getBulkRenewal,
+  )
 }

package/src/contracts/types.ts

@@ -9,3 +9,4 @@ export type ContractName =
   | 'ENSRegistryWithFallback'
   | 'ReverseRegistrar'
   | 'UniversalResolver'
+  | 'BulkRenewal'

package/src/functions/deleteSubname.ts

@@ -1,17 +1,57 @@
+import { ethers } from 'ethers'
 import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
+
+type Args = {
+  contract: 'registry' | 'nameWrapper'
+}
 
 export default async function (
-  { transferSubname, signer }: ENSArgs<'transferSubname' | 'signer'>,
+  { contracts, signer }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>,
   name: string,
-  {
-    contract,
-  }: {
-    contract: 'registry' | 'nameWrapper'
-  },
+  { contract }: Args,
 ) {
-  return transferSubname.populateTransaction(name, {
-    contract,
-    owner: '0x0000000000000000000000000000000000000000',
-    signer,
-  })
+  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() as string
+  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}`)
+    }
+  }
 }

package/src/functions/getNames.test.ts

@@ -30,9 +30,12 @@ const letterItems = [
 
 const domainLetterItems = [
   '[',
+  'x',
   'w',
   't',
   't',
+  'l',
+  'a',
   '9',
   '8',
   '7',
@@ -137,7 +140,13 @@ describe('getNames', () => {
       type: 'owner',
       page: 3,
     })
-    expect(pageFour).toHaveLength(totalOwnedNames % 10)
+    expect(pageFour).toHaveLength(10)
+    const pageFive = await ensInstance.getNames({
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+      type: 'owner',
+      page: 4,
+    })
+    expect(pageFive).toHaveLength(totalOwnedNames % 10)
   })
   describe('orderBy', () => {
     describe('registrations', () => {

package/src/functions/getPrice.test.ts

@@ -0,0 +1,52 @@
+import { ENS } from '..'
+import setup from '../tests/setup'
+
+let ensInstance: ENS
+
+beforeAll(async () => {
+  ;({ ensInstance } = await setup())
+})
+
+describe('getPrice', () => {
+  it('should return a base and premium price for an address', async () => {
+    const { base, premium } = (await ensInstance.getPrice(
+      'test123',
+      86400,
+      false,
+    ))!
+    expect(base.toNumber()).toBe(86400)
+    expect(premium.toNumber()).toBe(0)
+  })
+
+  it('should return a base and premium price for an array of names', async () => {
+    const { base, premium } = (await ensInstance.getPrice(
+      ['test123', 'to-be-renewed'],
+      86400,
+      false,
+    ))!
+    expect(base.toNumber()).toBe(86400 * 2)
+    expect(premium.toNumber()).toBe(0)
+  })
+
+  describe('legacy mode', () => {
+    it('should return a base and premium price for an address', async () => {
+      const { base, premium } = (await ensInstance.getPrice(
+        'test123',
+        86400,
+        true,
+      ))!
+      expect(base.toNumber()).toBe(86400)
+      expect(premium.toNumber()).toBe(0)
+    })
+
+    it('should return a base and premium price for an array of names', async () => {
+      const { base, premium } = (await ensInstance.getPrice(
+        ['test123', 'to-be-renewed'],
+        86400,
+        true,
+      ))!
+      expect(base.toNumber()).toBe(86400 * 2)
+      expect(premium.toNumber()).toBe(0)
+    })
+  })
+})

package/src/functions/getPrice.ts

@@ -3,16 +3,44 @@ import { ENSArgs } from '..'
 
 const raw = async (
   { contracts, multicallWrapper }: ENSArgs<'contracts' | 'multicallWrapper'>,
-  name: string,
+  nameOrNames: string | string[],
   duration: number,
   legacy?: boolean,
 ) => {
+  const names = Array.isArray(nameOrNames) ? nameOrNames : [nameOrNames]
+
+  if (names.length > 1) {
+    const bulkRenewal = await contracts?.getBulkRenewal()!
+    const baseCall = {
+      to: bulkRenewal.address,
+      data: bulkRenewal.interface.encodeFunctionData('rentPrice', [
+        names,
+        duration,
+      ]),
+    }
+
+    if (legacy) {
+      return multicallWrapper.raw([
+        baseCall,
+        {
+          to: bulkRenewal.address,
+          data: bulkRenewal.interface.encodeFunctionData('rentPrice', [
+            names,
+            0,
+          ]),
+        },
+      ])
+    }
+
+    return baseCall
+  }
+
   const controller = await contracts?.getEthRegistrarController()!
 
   const baseCall = {
     to: controller.address,
     data: controller.interface.encodeFunctionData('rentPrice', [
-      name,
+      names[0],
       duration,
     ]),
   }
@@ -22,27 +50,49 @@ const raw = async (
       baseCall,
       {
         to: controller.address,
-        data: controller.interface.encodeFunctionData('rentPrice', [name, 0]),
+        data: controller.interface.encodeFunctionData('rentPrice', [
+          names[0],
+          0,
+        ]),
       },
     ])
   }
-
   return baseCall
 }
 
 const decode = async (
   { contracts, multicallWrapper }: ENSArgs<'contracts' | 'multicallWrapper'>,
   data: string,
-  _name: string,
-  _number: number,
+  _nameOrNames: string | string[],
+  _duration: number,
   legacy?: boolean,
 ) => {
   if (data === null) return
-  const controller = await contracts?.getEthRegistrarController()!
   try {
     let base: BigNumber
     let premium: BigNumber
-    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,
+      ) as [BigNumber]
+      ;[premium] = utils.defaultAbiCoder.decode(
+        ['uint256'],
+        result[1].returnData,
+      ) as [BigNumber]
+      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'],
@@ -54,10 +104,12 @@ const decode = async (
       ) as [BigNumber]
       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] as [BigNumber, BigNumber]
     }
     return {
       base,

package/src/functions/getProfile.test.ts

@@ -1,7 +1,10 @@
 import { ethers } from 'ethers'
+import dotenv from 'dotenv'
 import { ENS } from '..'
 import setup from '../tests/setup'
 
+dotenv.config()
+
 let ensInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
 let provider: ethers.providers.JsonRpcProvider
@@ -120,13 +123,14 @@ describe('getProfile', () => {
   describe('with an old resolver', () => {
     it('should use fallback methods for a name with an older resolver (no multicall)', async () => {
       const result = await ensInstance.getProfile('with-legacy-resolver.eth')
+      const deploymentAddresses = JSON.parse(process.env.DEPLOYMENT_ADDRESSES!)
       expect(result).toBeDefined()
       if (result) {
         expect(result.address).toBe(
           '0x70997970C51812dc3A010C7d01b50e0d17dc79C8',
         )
         expect(result.resolverAddress).toBe(
-          '0x5f3f1dbd7b74c6b46e8c44f98792a1daf8d69154',
+          deploymentAddresses.NoMulticallResolver.toLowerCase(),
         )
       }
     })