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

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;
+}

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/dist/types/utils/fuses.d.ts

@@ -21,6 +21,8 @@ declare const fullFuseEnum: {
 export declare type FuseObj = typeof fuseEnum;
 export declare type CurrentFuses = {
     [f in keyof FuseObj]: boolean;
+} & {
+    CAN_DO_EVERYTHING: boolean;
 };
 export declare type UnnamedFuseType = typeof unnamedFuses;
 export declare type Fuse = keyof FuseObj;

package/dist/types/utils/registerHelpers.d.ts

@@ -1,20 +1,24 @@
+import { BigNumberish } from 'ethers';
 import type { FuseOptions } from '../@types/FuseOptions';
 import type { PublicResolver } from '../generated';
 import { RecordOptions } from './recordHelpers';
-export declare type RegistrationParams = {
-    name: string;
+export declare type BaseRegistrationParams = {
     owner: string;
     duration: number;
     secret: string;
-    resolver: PublicResolver;
+    resolverAddress?: string;
     records?: RecordOptions;
     reverseRecord?: boolean;
     fuses?: FuseOptions;
-    wrapperExpiry: number;
+    wrapperExpiry?: BigNumberish;
+};
+export declare type RegistrationParams = Omit<BaseRegistrationParams, 'resolverAddress'> & {
+    name: string;
+    resolver: PublicResolver;
 };
 export declare type CommitmentParams = Omit<RegistrationParams, 'secret' | 'wrapperExpiry'> & {
     secret?: string;
-    wrapperExpiry?: number;
+    wrapperExpiry?: BigNumberish;
 };
 export declare type RegistrationTuple = [
     name: string,
@@ -25,7 +29,7 @@ export declare type RegistrationTuple = [
     data: string[],
     reverseRecord: boolean,
     fuses: string,
-    wrapperExpiry: number
+    wrapperExpiry: BigNumberish
 ];
 export declare type CommitmentTuple = [
     labelhash: string,
@@ -36,12 +40,12 @@ export declare type CommitmentTuple = [
     secret: string,
     reverseRecord: boolean,
     fuses: string,
-    wrapperExpiry: number
+    wrapperExpiry: BigNumberish
 ];
 export declare const randomSecret: () => string;
 export declare const makeCommitmentData: ({ name, owner, duration, resolver, records, reverseRecord, fuses, wrapperExpiry, secret, }: Omit<RegistrationParams, "secret" | "wrapperExpiry"> & {
     secret?: string | undefined;
-    wrapperExpiry?: number | undefined;
+    wrapperExpiry?: BigNumberish | undefined;
 } & {
     secret: string;
 }) => CommitmentTuple;
@@ -50,5 +54,5 @@ export declare const _makeCommitment: (params: CommitmentTuple) => string;
 export declare const makeCommitment: ({ secret, ...inputParams }: CommitmentParams) => {
     secret: string;
     commitment: string;
-    wrapperExpiry: number;
+    wrapperExpiry: BigNumberish;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ensdomains/ensjs",
-  "version": "3.0.0-alpha.20",
+  "version": "3.0.0-alpha.22",
   "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(),
         )
       }
     })