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

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/getNames.js

@@ -87,6 +87,7 @@ const getNames = async ({ gqlInstance }, {
     parent {
         name
     }
+    createdAt
   `;
   let queryVars = {};
   let finalQuery = "";
@@ -109,7 +110,6 @@ const getNames = async ({ gqlInstance }, {
           }
           domains(first: 1000) {
             ${domainQueryData}
-            createdAt
             registration {
               registrationDate
               expiryDate
@@ -144,7 +144,6 @@ const getNames = async ({ gqlInstance }, {
           account(id: $id) {
             domains(orderBy: $orderBy, orderDirection: $orderDirection) {
               ${domainQueryData}
-              createdAt
               registration {
                 registrationDate
                 expiryDate
@@ -175,7 +174,6 @@ const getNames = async ({ gqlInstance }, {
               orderDirection: $orderDirection
             ) {
               ${domainQueryData}
-              createdAt
             }
           }
         }
@@ -207,7 +205,6 @@ const getNames = async ({ gqlInstance }, {
             fuses
             domain {
               ${domainQueryData}
-              createdAt
             }
           }
         }
@@ -237,7 +234,6 @@ const getNames = async ({ gqlInstance }, {
             fuses
             domain {
               ${domainQueryData}
-              createdAt
             }
           }
         }

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/getNames.mjs

@@ -65,6 +65,7 @@ var getNames = async ({ gqlInstance }, {
     parent {
         name
     }
+    createdAt
   `;
   let queryVars = {};
   let finalQuery = "";
@@ -87,7 +88,6 @@ var getNames = async ({ gqlInstance }, {
           }
           domains(first: 1000) {
             ${domainQueryData}
-            createdAt
             registration {
               registrationDate
               expiryDate
@@ -122,7 +122,6 @@ var getNames = async ({ gqlInstance }, {
           account(id: $id) {
             domains(orderBy: $orderBy, orderDirection: $orderDirection) {
               ${domainQueryData}
-              createdAt
               registration {
                 registrationDate
                 expiryDate
@@ -153,7 +152,6 @@ var getNames = async ({ gqlInstance }, {
               orderDirection: $orderDirection
             ) {
               ${domainQueryData}
-              createdAt
             }
           }
         }
@@ -185,7 +183,6 @@ var getNames = async ({ gqlInstance }, {
             fuses
             domain {
               ${domainQueryData}
-              createdAt
             }
           }
         }
@@ -215,7 +212,6 @@ var getNames = async ({ gqlInstance }, {
             fuses
             domain {
               ${domainQueryData}
-              createdAt
             }
           }
         }

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.48",
   "description": "ENS javascript library for contract interaction",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.mjs",
@@ -66,7 +66,7 @@
     "cbor": "^8.1.0",
     "dns-packet": "^5.3.1",
     "graphql": "^16.3.0",
-    "graphql-request": "next",
+    "graphql-request": "5.1.0",
     "idna-uts46-hx": "3.4.0",
     "pako": "^2.1.0",
     "traverse": "^0.6.6"

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()