@ensdomains/ensjs 3.0.0-alpha.46 → 3.0.0-alpha.47

package/dist/cjs/functions/deleteSubname.js

@@ -23,17 +23,17 @@ __export(deleteSubname_exports, {
 module.exports = __toCommonJS(deleteSubname_exports);
 var import_solidity = require("@ethersproject/solidity");
 var import_normalise = require("../utils/normalise");
-async function deleteSubname_default({ contracts, signer }, name, { contract }) {
+async function deleteSubname_default({ contracts, signer }, name, { contract, ...args }) {
   const labels = name.split(".");
   if (labels.length < 3) {
     throw new Error(`${name} is not a valid subname`);
   }
-  const label = labels.shift();
-  const labelhash = (0, import_solidity.keccak256)(["string"], [label]);
-  const parentNodehash = (0, import_normalise.namehash)(labels.join("."));
   switch (contract) {
     case "registry": {
       const registry = (await contracts.getRegistry()).connect(signer);
+      const label = labels.shift();
+      const labelhash = (0, import_solidity.keccak256)(["string"], [label]);
+      const parentNodehash = (0, import_normalise.namehash)(labels.join("."));
       return registry.populateTransaction.setSubnodeRecord(
         parentNodehash,
         labelhash,
@@ -44,12 +44,22 @@ async function deleteSubname_default({ contracts, signer }, name, { contract })
     }
     case "nameWrapper": {
       const nameWrapper = (await contracts.getNameWrapper()).connect(signer);
-      return nameWrapper.populateTransaction.setSubnodeRecord(
+      const { method } = args;
+      if (method === "setRecord") {
+        const node = (0, import_normalise.namehash)(name);
+        return nameWrapper.populateTransaction.setRecord(
+          node,
+          "0x0000000000000000000000000000000000000000",
+          "0x0000000000000000000000000000000000000000",
+          0
+        );
+      }
+      const label = labels.shift();
+      const parentNodehash = (0, import_normalise.namehash)(labels.join("."));
+      return nameWrapper.populateTransaction.setSubnodeOwner(
         parentNodehash,
         label,
         "0x0000000000000000000000000000000000000000",
-        "0x0000000000000000000000000000000000000000",
-        0,
         0,
         0
       );

package/dist/cjs/functions/transferSubname.js

@@ -24,11 +24,7 @@ module.exports = __toCommonJS(transferSubname_exports);
 var import_solidity = require("@ethersproject/solidity");
 var import_normalise = require("../utils/normalise");
 var import_wrapper = require("../utils/wrapper");
-async function transferSubname_default({
-  contracts,
-  signer,
-  getExpiry
-}, name, { contract, owner, resolverAddress, ...wrapperArgs }) {
+async function transferSubname_default({ contracts, signer }, name, { contract, owner, resolverAddress, ...wrapperArgs }) {
   const labels = name.split(".");
   const label = labels.shift();
   const labelhash = (0, import_solidity.keccak256)(["string"], [label]);
@@ -44,10 +40,9 @@ async function transferSubname_default({
     }
     case "nameWrapper": {
       const nameWrapper = (await contracts.getNameWrapper()).connect(signer);
-      const expiry = await (0, import_wrapper.makeExpiry)(
-        { getExpiry },
-        labels.join("."),
-        "expiry" in wrapperArgs ? wrapperArgs.expiry : void 0
+      const expiry = (0, import_wrapper.expiryToBigNumber)(
+        wrapperArgs.expiry,
+        0
       );
       return nameWrapper.populateTransaction.setSubnodeOwner(
         parentNodehash,

package/dist/cjs/index.js

@@ -316,7 +316,7 @@ class ENS {
     this.importDNSSECName = this.generateWriteFunction("importDNSSECName", ["contracts", "provider", "signer"]);
     this.createSubname = this.generateWriteFunction("createSubname", ["contracts", "getExpiry"]);
     this.deleteSubname = this.generateWriteFunction("deleteSubname", ["contracts"]);
-    this.transferSubname = this.generateWriteFunction("transferSubname", ["contracts", "getExpiry"]);
+    this.transferSubname = this.generateWriteFunction("transferSubname", ["contracts"]);
     this.commitName = this.generateWriteFunction(
       "commitName",
       ["contracts"]

package/dist/cjs/utils/registry.js

@@ -0,0 +1,32 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var registry_exports = {};
+__export(registry_exports, {
+  makeResolver: () => makeResolver
+});
+module.exports = __toCommonJS(registry_exports);
+var import_normalise = require("./normalise");
+const makeResolver = async ({ contracts }, name, resolver) => {
+  if (resolver)
+    return resolver;
+  const registry = await contracts.getRegistry();
+  const node = (0, import_normalise.namehash)(name);
+  const _resolver = await registry.resolver(node);
+  return _resolver;
+};

package/dist/cjs/utils/wrapper.js

@@ -19,6 +19,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var wrapper_exports = {};
 __export(wrapper_exports, {
   MAX_EXPIRY: () => MAX_EXPIRY,
+  expiryToBigNumber: () => expiryToBigNumber,
   makeExpiry: () => makeExpiry,
   wrappedLabelLengthCheck: () => wrappedLabelLengthCheck
 });
@@ -26,16 +27,20 @@ module.exports = __toCommonJS(wrapper_exports);
 var import_bignumber = require("@ethersproject/bignumber");
 var import_strings = require("@ethersproject/strings");
 const MAX_EXPIRY = import_bignumber.BigNumber.from(2).pow(64).sub(1);
-const makeExpiry = async ({ getExpiry }, name, expiry) => {
-  if (expiry) {
-    if (expiry instanceof Date) {
-      return import_bignumber.BigNumber.from(expiry.getTime() / 1e3);
-    }
-    if (expiry instanceof import_bignumber.BigNumber) {
-      return expiry;
-    }
-    return import_bignumber.BigNumber.from(expiry);
+const expiryToBigNumber = (expiry, defaultValue = 0) => {
+  if (!expiry)
+    return import_bignumber.BigNumber.from(defaultValue);
+  if (expiry instanceof Date) {
+    return import_bignumber.BigNumber.from(expiry.getTime() / 1e3);
+  }
+  if (expiry instanceof import_bignumber.BigNumber) {
+    return expiry;
   }
+  return import_bignumber.BigNumber.from(expiry);
+};
+const makeExpiry = async ({ getExpiry }, name, expiry) => {
+  if (expiry)
+    return expiryToBigNumber(expiry);
   if (name.endsWith(".eth")) {
     const expResponse = await getExpiry(name);
     if (!(expResponse == null ? void 0 : expResponse.expiry))

package/dist/esm/functions/deleteSubname.mjs

@@ -1,17 +1,17 @@
 // src/functions/deleteSubname.ts
 import { keccak256 as solidityKeccak256 } from "@ethersproject/solidity";
 import { namehash } from "../utils/normalise.mjs";
-async function deleteSubname_default({ contracts, signer }, name, { contract }) {
+async function deleteSubname_default({ contracts, signer }, name, { contract, ...args }) {
   const labels = name.split(".");
   if (labels.length < 3) {
     throw new Error(`${name} is not a valid subname`);
   }
-  const label = labels.shift();
-  const labelhash = solidityKeccak256(["string"], [label]);
-  const parentNodehash = namehash(labels.join("."));
   switch (contract) {
     case "registry": {
       const registry = (await contracts.getRegistry()).connect(signer);
+      const label = labels.shift();
+      const labelhash = solidityKeccak256(["string"], [label]);
+      const parentNodehash = namehash(labels.join("."));
       return registry.populateTransaction.setSubnodeRecord(
         parentNodehash,
         labelhash,
@@ -22,12 +22,22 @@ async function deleteSubname_default({ contracts, signer }, name, { contract })
     }
     case "nameWrapper": {
       const nameWrapper = (await contracts.getNameWrapper()).connect(signer);
-      return nameWrapper.populateTransaction.setSubnodeRecord(
+      const { method } = args;
+      if (method === "setRecord") {
+        const node = namehash(name);
+        return nameWrapper.populateTransaction.setRecord(
+          node,
+          "0x0000000000000000000000000000000000000000",
+          "0x0000000000000000000000000000000000000000",
+          0
+        );
+      }
+      const label = labels.shift();
+      const parentNodehash = namehash(labels.join("."));
+      return nameWrapper.populateTransaction.setSubnodeOwner(
         parentNodehash,
         label,
         "0x0000000000000000000000000000000000000000",
-        "0x0000000000000000000000000000000000000000",
-        0,
         0,
         0
       );

package/dist/esm/functions/transferSubname.mjs

@@ -1,12 +1,8 @@
 // src/functions/transferSubname.ts
 import { keccak256 as solidityKeccak256 } from "@ethersproject/solidity";
 import { namehash } from "../utils/normalise.mjs";
-import { makeExpiry } from "../utils/wrapper.mjs";
-async function transferSubname_default({
-  contracts,
-  signer,
-  getExpiry
-}, name, { contract, owner, resolverAddress, ...wrapperArgs }) {
+import { expiryToBigNumber } from "../utils/wrapper.mjs";
+async function transferSubname_default({ contracts, signer }, name, { contract, owner, resolverAddress, ...wrapperArgs }) {
   const labels = name.split(".");
   const label = labels.shift();
   const labelhash = solidityKeccak256(["string"], [label]);
@@ -22,10 +18,9 @@ async function transferSubname_default({
     }
     case "nameWrapper": {
       const nameWrapper = (await contracts.getNameWrapper()).connect(signer);
-      const expiry = await makeExpiry(
-        { getExpiry },
-        labels.join("."),
-        "expiry" in wrapperArgs ? wrapperArgs.expiry : void 0
+      const expiry = expiryToBigNumber(
+        wrapperArgs.expiry,
+        0
       );
       return nameWrapper.populateTransaction.setSubnodeOwner(
         parentNodehash,

package/dist/esm/index.mjs

@@ -293,7 +293,7 @@ var ENS = class {
   importDNSSECName = this.generateWriteFunction("importDNSSECName", ["contracts", "provider", "signer"]);
   createSubname = this.generateWriteFunction("createSubname", ["contracts", "getExpiry"]);
   deleteSubname = this.generateWriteFunction("deleteSubname", ["contracts"]);
-  transferSubname = this.generateWriteFunction("transferSubname", ["contracts", "getExpiry"]);
+  transferSubname = this.generateWriteFunction("transferSubname", ["contracts"]);
   commitName = this.generateWriteFunction(
     "commitName",
     ["contracts"]

package/dist/esm/utils/registry.mjs

@@ -0,0 +1,13 @@
+// src/utils/registry.ts
+import { namehash } from "./normalise.mjs";
+var makeResolver = async ({ contracts }, name, resolver) => {
+  if (resolver)
+    return resolver;
+  const registry = await contracts.getRegistry();
+  const node = namehash(name);
+  const _resolver = await registry.resolver(node);
+  return _resolver;
+};
+export {
+  makeResolver
+};

package/dist/esm/utils/wrapper.mjs

@@ -2,16 +2,20 @@
 import { BigNumber } from "@ethersproject/bignumber";
 import { toUtf8Bytes } from "@ethersproject/strings";
 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);
+var expiryToBigNumber = (expiry, defaultValue = 0) => {
+  if (!expiry)
+    return BigNumber.from(defaultValue);
+  if (expiry instanceof Date) {
+    return BigNumber.from(expiry.getTime() / 1e3);
+  }
+  if (expiry instanceof BigNumber) {
+    return expiry;
   }
+  return BigNumber.from(expiry);
+};
+var makeExpiry = async ({ getExpiry }, name, expiry) => {
+  if (expiry)
+    return expiryToBigNumber(expiry);
   if (name.endsWith(".eth")) {
     const expResponse = await getExpiry(name);
     if (!expResponse?.expiry)
@@ -27,6 +31,7 @@ var wrappedLabelLengthCheck = (label) => {
 };
 export {
   MAX_EXPIRY,
+  expiryToBigNumber,
   makeExpiry,
   wrappedLabelLengthCheck
 };

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

@@ -1,6 +1,12 @@
 import { ENSArgs } from '..';
-declare type Args = {
+declare type BaseArgs = {
     contract: 'registry' | 'nameWrapper';
+    method?: 'setRecord' | 'setSubnodeOwner';
 };
-export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>, name: string, { contract }: Args): Promise<import("ethers").PopulatedTransaction>;
+declare type NameWrapperArgs = {
+    contract: 'nameWrapper';
+    method: 'setRecord' | 'setSubnodeOwner';
+};
+declare type Args = BaseArgs | NameWrapperArgs;
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { contract, ...args }: Args): Promise<import("ethers").PopulatedTransaction>;
 export {};

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

@@ -10,5 +10,5 @@ declare type NameWrapperArgs = {
     expiry?: Expiry;
 } & BaseArgs;
 declare type Args = BaseArgs | NameWrapperArgs;
-export default function ({ contracts, signer, getExpiry, }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>, name: string, { contract, owner, resolverAddress, ...wrapperArgs }: Args): Promise<import("ethers").PopulatedTransaction>;
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { contract, owner, resolverAddress, ...wrapperArgs }: Args): Promise<import("ethers").PopulatedTransaction>;
 export {};

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

@@ -0,0 +1,2 @@
+import { ENSArgs } from '../index';
+export declare const makeResolver: ({ contracts }: ENSArgs<'contracts'>, name: string, resolver?: string) => Promise<string>;

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

@@ -2,5 +2,6 @@ import { BigNumber } from '@ethersproject/bignumber';
 import { ENSArgs } from '../index';
 export declare type Expiry = string | number | Date | BigNumber;
 export declare const MAX_EXPIRY: BigNumber;
+export declare const expiryToBigNumber: (expiry?: Expiry, defaultValue?: number) => BigNumber;
 export declare const makeExpiry: ({ getExpiry }: ENSArgs<'getExpiry'>, name: string, expiry?: Expiry) => Promise<BigNumber>;
 export declare const wrappedLabelLengthCheck: (label: string) => void;

package/package.json

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

package/src/functions/deleteSubname.test.ts

@@ -1,12 +1,20 @@
+import { ethers } from 'ethers'
 import { ENS } from '..'
 import setup from '../tests/setup'
 import { namehash } from '../utils/normalise'
 
 let ensInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
+let provider: ethers.providers.JsonRpcProvider
+let accounts: string[]
 
 beforeAll(async () => {
-  ;({ ensInstance, revert } = await setup())
+  ;({ ensInstance, revert, provider } = await setup())
+  accounts = await provider.listAccounts()
+})
+
+beforeEach(async () => {
+  await revert()
 })
 
 afterAll(async () => {
@@ -17,27 +25,34 @@ describe('deleteSubname', () => {
   beforeEach(async () => {
     await revert()
   })
-  it('should allow deleting a subname on the registry', async () => {
+  it('should allow deleting a subname on the registry by parent owner', async () => {
+    const registry = await ensInstance.contracts!.getRegistry()!
+    const parentOwner = await registry.owner(namehash('with-subnames.eth'))
+
     const tx = await ensInstance.deleteSubname('test.with-subnames.eth', {
       contract: 'registry',
-      addressOrIndex: 1,
+      addressOrIndex: parentOwner,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
 
-    const registry = await ensInstance.contracts!.getRegistry()!
     const result = await registry.owner(namehash('test.with-subnames.eth'))
     expect(result).toBe('0x0000000000000000000000000000000000000000')
   })
 
-  it('should allow deleting a subname on the nameWrapper', async () => {
+  it('should allow deleting a subname on the nameWrapper by parent owner', async () => {
     const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
 
+    const parentOwner = await nameWrapper.ownerOf(
+      namehash('wrapped-with-subnames.eth'),
+    )
+
     const tx = await ensInstance.deleteSubname(
       'test.wrapped-with-subnames.eth',
       {
         contract: 'nameWrapper',
-        addressOrIndex: 1,
+        method: 'setSubnodeOwner',
+        addressOrIndex: parentOwner,
       },
     )
     expect(tx).toBeTruthy()
@@ -49,10 +64,128 @@ describe('deleteSubname', () => {
     expect(result).toBe('0x0000000000000000000000000000000000000000')
   })
 
+  it('should allow deleting a subname on the nameWrapper by name owner', async () => {
+    const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+
+    const nameOwner = await nameWrapper.ownerOf(
+      namehash('addr.wrapped-with-subnames.eth'),
+    )
+
+    await ensInstance.deleteSubname('addr.wrapped-with-subnames.eth', {
+      contract: 'nameWrapper',
+      method: 'setRecord',
+      addressOrIndex: nameOwner,
+    })
+
+    const result = await nameWrapper.ownerOf(
+      namehash('addr.wrapped-with-subnames.eth'),
+    )
+    expect(result).toBe('0x0000000000000000000000000000000000000000')
+  })
+
+  it('should allow deleting a subname on the nameWrapper with PCC burned by name owner', async () => {
+    const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+
+    const parentOwner = await nameWrapper.ownerOf(
+      namehash('wrapped-with-subnames.eth'),
+    )
+
+    const tx0 = await ensInstance.setFuses('wrapped-with-subnames.eth', {
+      named: ['CANNOT_UNWRAP'],
+      addressOrIndex: parentOwner,
+    })
+    expect(tx0).toBeTruthy()
+    await tx0.wait()
+
+    const tx1 = await ensInstance.setChildFuses(
+      'xyz.wrapped-with-subnames.eth',
+      {
+        fuses: {
+          parent: {
+            named: ['PARENT_CANNOT_CONTROL'],
+          },
+        },
+        addressOrIndex: parentOwner,
+      },
+    )
+    expect(tx1).toBeTruthy()
+    await tx1.wait()
+
+    const nameOwner = await nameWrapper.ownerOf(
+      namehash('xyz.wrapped-with-subnames.eth'),
+    )
+
+    expect(parentOwner === nameOwner).toBe(false)
+
+    const tx = await ensInstance.deleteSubname(
+      'xyz.wrapped-with-subnames.eth',
+      {
+        contract: 'nameWrapper',
+        method: 'setRecord',
+        addressOrIndex: nameOwner,
+      },
+    )
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const result = await nameWrapper.ownerOf(
+      namehash('xyz.wrapped-with-subnames.eth'),
+    )
+    expect(result).toBe('0x0000000000000000000000000000000000000000')
+  })
+
+  it('should NOT allow deleting a subname on the nameWrapper with PCC burned by parent owner', async () => {
+    const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+
+    const parentOwner = await nameWrapper.ownerOf(
+      namehash('wrapped-with-subnames.eth'),
+    )
+
+    const tx0 = await ensInstance.setFuses('wrapped-with-subnames.eth', {
+      named: ['CANNOT_UNWRAP'],
+      addressOrIndex: parentOwner,
+    })
+    expect(tx0).toBeTruthy()
+    await tx0.wait()
+
+    const tx1 = await ensInstance.setChildFuses(
+      'legacy.wrapped-with-subnames.eth',
+      {
+        fuses: {
+          parent: {
+            named: ['PARENT_CANNOT_CONTROL'],
+          },
+        },
+        addressOrIndex: parentOwner,
+      },
+    )
+    expect(tx1).toBeTruthy()
+    await tx1.wait()
+
+    const checkOwner = await nameWrapper.ownerOf(
+      namehash('legacy.wrapped-with-subnames.eth'),
+    )
+    expect(checkOwner).toBe(accounts[2])
+
+    await expect(
+      ensInstance.deleteSubname('legacy.wrapped-with-subnames.eth', {
+        contract: 'nameWrapper',
+        method: 'setSubnodeOwner',
+        addressOrIndex: parentOwner,
+      }),
+    ).rejects.toThrow()
+
+    const result = await nameWrapper.ownerOf(
+      namehash('legacy.wrapped-with-subnames.eth'),
+    )
+    expect(result).toBe(accounts[2])
+  })
+
   it('should not allow deleting 1LD', async () => {
     await expect(
       ensInstance.deleteSubname('eth', {
         contract: 'nameWrapper',
+        method: 'setRecord',
         addressOrIndex: 1,
       }),
     ).rejects.toThrow()

package/src/functions/deleteSubname.ts

@@ -2,28 +2,34 @@ import { keccak256 as solidityKeccak256 } from '@ethersproject/solidity'
 import { ENSArgs } from '..'
 import { namehash } from '../utils/normalise'
 
-type Args = {
+type BaseArgs = {
   contract: 'registry' | 'nameWrapper'
+  method?: 'setRecord' | 'setSubnodeOwner'
 }
 
+type NameWrapperArgs = {
+  contract: 'nameWrapper'
+  method: 'setRecord' | 'setSubnodeOwner'
+}
+
+type Args = BaseArgs | NameWrapperArgs
+
 export default async function (
-  { contracts, signer }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>,
+  { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
   name: string,
-  { contract }: Args,
+  { contract, ...args }: Args,
 ) {
   const labels = name.split('.')
-
   if (labels.length < 3) {
     throw new Error(`${name} is not a valid subname`)
   }
 
-  const label = labels.shift() as string
-  const labelhash = solidityKeccak256(['string'], [label])
-  const parentNodehash = namehash(labels.join('.'))
-
   switch (contract) {
     case 'registry': {
       const registry = (await contracts!.getRegistry()!).connect(signer)
+      const label = labels.shift() as string
+      const labelhash = solidityKeccak256(['string'], [label])
+      const parentNodehash = namehash(labels.join('.'))
 
       return registry.populateTransaction.setSubnodeRecord(
         parentNodehash,
@@ -35,13 +41,24 @@ export default async function (
     }
     case 'nameWrapper': {
       const nameWrapper = (await contracts!.getNameWrapper()!).connect(signer)
+      const { method } = args as NameWrapperArgs
+
+      if (method === 'setRecord') {
+        const node = namehash(name)
+        return nameWrapper.populateTransaction.setRecord(
+          node,
+          '0x0000000000000000000000000000000000000000',
+          '0x0000000000000000000000000000000000000000',
+          0,
+        )
+      }
 
-      return nameWrapper.populateTransaction.setSubnodeRecord(
+      const label = labels.shift() as string
+      const parentNodehash = namehash(labels.join('.'))
+      return nameWrapper.populateTransaction.setSubnodeOwner(
         parentNodehash,
         label,
         '0x0000000000000000000000000000000000000000',
-        '0x0000000000000000000000000000000000000000',
-        0,
         0,
         0,
       )

package/src/functions/getNames.test.ts

@@ -1,6 +1,7 @@
 import { ENS } from '..'
 import setup from '../tests/setup'
 import { Name } from './getNames'
+import { names as wrappedNames } from '../../deploy/00_register_wrapped'
 
 let ensInstance: ENS
 
@@ -172,10 +173,19 @@ describe('getNames', () => {
       type: 'wrappedOwner',
       page: 0,
     })
+
+    const nameCout = wrappedNames.reduce<number>((count, name) => {
+      if (name.namedOwner === 'owner2') count += 1
+      ;(name.subnames || []).forEach((subname: any) => {
+        if (subname.namedOwner === 'owner2') count += 1
+      })
+      return count
+    }, 0)
+
     // length of page one should be all the names on 0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC
     // minus 1 for the PCC expired name.
     // the result here implies that the PCC expired name is not returned
-    expect(pageOne).toHaveLength(4)
+    expect(pageOne).toHaveLength(nameCout - 1)
   })
   describe('orderBy', () => {
     describe('registrations', () => {