@ensdomains/ensjs 3.0.0-alpha.14 → 3.0.0-alpha.17

package/dist/cjs/GqlManager.d.ts

@@ -1,6 +1,8 @@
-export declare const enter: (node: any) => any;
-export declare const requestMiddleware: (visit: any, parse: any) => (request: any) => any;
-export declare const responseMiddleware: (traverse: any) => (response: any) => any;
+import type { parse as Parse, print as Print, SelectionSetNode, visit as Visit } from 'graphql';
+import type Traverse from 'traverse';
+export declare const enter: (node: SelectionSetNode) => SelectionSetNode | undefined;
+export declare const requestMiddleware: (visit: typeof Visit, parse: typeof Parse, print: typeof Print) => (request: any) => any;
+export declare const responseMiddleware: (traverse: typeof Traverse) => (response: any) => any;
 export default class GqlManager {
     gql: any;
     client?: any | null;

package/dist/cjs/GqlManager.js

@@ -24,7 +24,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.responseMiddleware = exports.requestMiddleware = exports.enter = void 0;
-// @ts-nocheck
 const normalise_1 = require("./utils/normalise");
 const generateSelection = (selection) => ({
     kind: 'Field',
@@ -38,25 +37,34 @@ const generateSelection = (selection) => ({
     selectionSet: undefined,
 });
 const enter = (node) => {
-    if (node.kind === 'SelectionSet') {
-        const id = node.selections.find((x) => x.name && x.name.value === 'id');
-        const name = node.selections.find((x) => x.name && x.name.value === 'name');
-        if (!id && name) {
-            node.selections = [...node.selections, generateSelection('id')];
-            return node;
+    let hasName = false;
+    let hasId = false;
+    for (const selection of node.selections) {
+        if ('name' in selection) {
+            if (selection.name.value === 'name')
+                hasName = true;
+            else if (selection.name.value === 'id')
+                hasId = true;
         }
     }
+    if (hasName && !hasId) {
+        node.selections = [...node.selections, generateSelection('id')];
+        return node;
+    }
 };
 exports.enter = enter;
-const requestMiddleware = (visit, parse) => (request) => {
+const requestMiddleware = (visit, parse, print) => (request) => {
     const requestBody = JSON.parse(request.body);
     const rawQuery = requestBody.query;
     const parsedQuery = parse(rawQuery);
-    const updatedQuery = visit(parsedQuery, { enter: exports.enter });
-    const updatedBody = { ...requestBody, query: updatedQuery.loc.source.body };
+    const updatedQuery = visit(parsedQuery, {
+        SelectionSet: {
+            enter: exports.enter,
+        },
+    });
     return {
         ...request,
-        body: JSON.stringify(updatedBody),
+        body: JSON.stringify({ ...requestBody, query: print(updatedQuery) }),
     };
 };
 exports.requestMiddleware = requestMiddleware;
@@ -81,13 +89,13 @@ class GqlManager {
     client = null;
     setUrl = async (url) => {
         if (url) {
-            const [imported, traverse, { visit, parse }] = await Promise.all([
+            const [imported, traverse, { visit, parse, print }] = await Promise.all([
                 Promise.resolve().then(() => __importStar(require('graphql-request'))),
                 Promise.resolve().then(() => __importStar(require('traverse'))),
                 Promise.resolve().then(() => __importStar(require('graphql/language'))),
             ]);
             this.client = new imported.GraphQLClient(url, {
-                requestMiddleware: (0, exports.requestMiddleware)(visit, parse),
+                requestMiddleware: (0, exports.requestMiddleware)(visit, parse, print),
                 responseMiddleware: (0, exports.responseMiddleware)(traverse.default),
             });
             this.gql = imported.gql;

package/dist/cjs/functions/burnFuses.d.ts

@@ -4,7 +4,7 @@ declare type FuseObj = typeof fuseEnum;
 declare type UnnamedFuseType = typeof unnamedFuses;
 declare type Fuse = keyof FuseObj;
 declare type UnnamedFuseValues = UnnamedFuseType[number];
-declare type FuseArrayPossibilities = [Fuse] | [Fuse, Fuse] | [Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse, Fuse];
+export declare type FuseArrayPossibilities = [Fuse] | [Fuse, Fuse] | [Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse, Fuse];
 /**
  * This type creates a type error if there are any duplicate fuses.
  * It effectively works like a reduce function, starting with 0 included types, adding a type each time, and then checking for duplicates.
@@ -18,15 +18,16 @@ declare type FusesWithoutDuplicates<A, B = never> = A extends FuseArrayPossibili
     ...FusesWithoutDuplicates<Tail, Head | B>
 ] : A : [
 ];
-declare type FusePropsNamedArray<A extends FuseArrayPossibilities> = {
-    namedFusesToBurn: FusesWithoutDuplicates<A>;
+export declare type NamedFusesToBurn = FusesWithoutDuplicates<FuseArrayPossibilities>;
+export declare type FusePropsNamedArray = {
+    namedFusesToBurn: NamedFusesToBurn;
 };
-declare type FusePropsUnnamedArray = {
+export declare type FusePropsUnnamedArray = {
     unnamedFusesToBurn: UnnamedFuseValues[];
 };
-declare type FusePropsNumber = {
+export declare type FusePropsNumber = {
     fuseNumberToBurn: number;
 };
-declare type FuseProps<A extends FuseArrayPossibilities> = (Partial<FusePropsNamedArray<A>> & FusePropsUnnamedArray) | (FusePropsNamedArray<A> & Partial<FusePropsUnnamedArray>) | FusePropsNumber;
-export default function <A extends FuseArrayPossibilities>({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, props: FuseProps<A>): Promise<import("ethers").PopulatedTransaction>;
+export declare type FuseProps = (Partial<FusePropsNamedArray> & FusePropsUnnamedArray) | (FusePropsNamedArray & Partial<FusePropsUnnamedArray>) | FusePropsNumber;
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, props: FuseProps): Promise<import("ethers").PopulatedTransaction>;
 export {};

package/dist/cjs/functions/getFuses.js

@@ -20,10 +20,10 @@ const decode = async ({ contracts }, data) => {
             fuses.and(fuses_1.fuseEnum[fuse]).gt(0),
         ]));
         if (fuses.eq(0)) {
-            fuseObj.canDoEverything = true;
+            fuseObj.CAN_DO_EVERYTHING = true;
         }
         else {
-            fuseObj.canDoEverything = false;
+            fuseObj.CAN_DO_EVERYTHING = false;
         }
         const expiryDate = new Date(expiry * 1000);
         return {

package/dist/cjs/functions/getOwner.js

@@ -102,7 +102,8 @@ const decode = async ({ contracts, multicallWrapper }, data, name, contract) =>
         if (labels.length > 2 &&
             ethers_1.ethers.utils.hexStripZeros(registryOwner) !== '0x') {
             // this means that the subname is wrapped
-            if (registryOwner === nameWrapper.address) {
+            if (registryOwner === nameWrapper.address &&
+                ethers_1.ethers.utils.hexStripZeros(nameWrapperOwner) !== '0x') {
                 return {
                     owner: nameWrapperOwner,
                     ownershipLevel: 'nameWrapper',
@@ -121,7 +122,8 @@ const decode = async ({ contracts, multicallWrapper }, data, name, contract) =>
     // there will only ever be an owner for non .eth names, not a registrant
     // this is because for unwrapped names, there is no associated NFT
     // and for wrapped names, owner and registrant are the same thing
-    if (registryOwner == nameWrapper.address) {
+    if (registryOwner == nameWrapper.address &&
+        ethers_1.ethers.utils.hexStripZeros(nameWrapperOwner) !== '0x') {
         return {
             owner: nameWrapperOwner,
             ownershipLevel: 'nameWrapper',

package/dist/cjs/index.d.ts

@@ -18,6 +18,9 @@ import type transferSubname from './functions/transferSubname';
 import type unwrapName from './functions/unwrapName';
 import type wrapName from './functions/wrapName';
 import GqlManager from './GqlManager';
+import fuseEnum from './utils/fuses';
+export type { FusePropsNamedArray, FusePropsUnnamedArray, FusePropsNumber, FuseProps, NamedFusesToBurn } from './functions/burnFuses';
+export declare type FuseEnum = typeof fuseEnum;
 declare type ENSOptions = {
     graphURI?: string | null;
     getContractAddress?: typeof _getContractAddress;
@@ -464,4 +467,3 @@ export declare class ENS {
     registerName: WriteFunction<typeof registerName>;
     renewName: WriteFunction<typeof renewName>;
 }
-export {};

package/dist/esm/GqlManager.d.ts

@@ -1,6 +1,8 @@
-export declare const enter: (node: any) => any;
-export declare const requestMiddleware: (visit: any, parse: any) => (request: any) => any;
-export declare const responseMiddleware: (traverse: any) => (response: any) => any;
+import type { parse as Parse, print as Print, SelectionSetNode, visit as Visit } from 'graphql';
+import type Traverse from 'traverse';
+export declare const enter: (node: SelectionSetNode) => SelectionSetNode | undefined;
+export declare const requestMiddleware: (visit: typeof Visit, parse: typeof Parse, print: typeof Print) => (request: any) => any;
+export declare const responseMiddleware: (traverse: typeof Traverse) => (response: any) => any;
 export default class GqlManager {
     gql: any;
     client?: any | null;

package/dist/esm/GqlManager.js

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import { namehash } from './utils/normalise';
 const generateSelection = (selection) => ({
     kind: 'Field',
@@ -12,24 +11,33 @@ const generateSelection = (selection) => ({
     selectionSet: undefined,
 });
 export const enter = (node) => {
-    if (node.kind === 'SelectionSet') {
-        const id = node.selections.find((x) => x.name && x.name.value === 'id');
-        const name = node.selections.find((x) => x.name && x.name.value === 'name');
-        if (!id && name) {
-            node.selections = [...node.selections, generateSelection('id')];
-            return node;
+    let hasName = false;
+    let hasId = false;
+    for (const selection of node.selections) {
+        if ('name' in selection) {
+            if (selection.name.value === 'name')
+                hasName = true;
+            else if (selection.name.value === 'id')
+                hasId = true;
         }
     }
+    if (hasName && !hasId) {
+        node.selections = [...node.selections, generateSelection('id')];
+        return node;
+    }
 };
-export const requestMiddleware = (visit, parse) => (request) => {
+export const requestMiddleware = (visit, parse, print) => (request) => {
     const requestBody = JSON.parse(request.body);
     const rawQuery = requestBody.query;
     const parsedQuery = parse(rawQuery);
-    const updatedQuery = visit(parsedQuery, { enter });
-    const updatedBody = { ...requestBody, query: updatedQuery.loc.source.body };
+    const updatedQuery = visit(parsedQuery, {
+        SelectionSet: {
+            enter,
+        },
+    });
     return {
         ...request,
-        body: JSON.stringify(updatedBody),
+        body: JSON.stringify({ ...requestBody, query: print(updatedQuery) }),
     };
 };
 export const responseMiddleware = (traverse) => (response) => {
@@ -53,13 +61,13 @@ export default class GqlManager {
         this.client = null;
         this.setUrl = async (url) => {
             if (url) {
-                const [imported, traverse, { visit, parse }] = await Promise.all([
+                const [imported, traverse, { visit, parse, print }] = await Promise.all([
                     import('graphql-request'),
                     import('traverse'),
                     import('graphql/language'),
                 ]);
                 this.client = new imported.GraphQLClient(url, {
-                    requestMiddleware: requestMiddleware(visit, parse),
+                    requestMiddleware: requestMiddleware(visit, parse, print),
                     responseMiddleware: responseMiddleware(traverse.default),
                 });
                 this.gql = imported.gql;

package/dist/esm/functions/burnFuses.d.ts

@@ -4,7 +4,7 @@ declare type FuseObj = typeof fuseEnum;
 declare type UnnamedFuseType = typeof unnamedFuses;
 declare type Fuse = keyof FuseObj;
 declare type UnnamedFuseValues = UnnamedFuseType[number];
-declare type FuseArrayPossibilities = [Fuse] | [Fuse, Fuse] | [Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse, Fuse];
+export declare type FuseArrayPossibilities = [Fuse] | [Fuse, Fuse] | [Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse, Fuse];
 /**
  * This type creates a type error if there are any duplicate fuses.
  * It effectively works like a reduce function, starting with 0 included types, adding a type each time, and then checking for duplicates.
@@ -18,15 +18,16 @@ declare type FusesWithoutDuplicates<A, B = never> = A extends FuseArrayPossibili
     ...FusesWithoutDuplicates<Tail, Head | B>
 ] : A : [
 ];
-declare type FusePropsNamedArray<A extends FuseArrayPossibilities> = {
-    namedFusesToBurn: FusesWithoutDuplicates<A>;
+export declare type NamedFusesToBurn = FusesWithoutDuplicates<FuseArrayPossibilities>;
+export declare type FusePropsNamedArray = {
+    namedFusesToBurn: NamedFusesToBurn;
 };
-declare type FusePropsUnnamedArray = {
+export declare type FusePropsUnnamedArray = {
     unnamedFusesToBurn: UnnamedFuseValues[];
 };
-declare type FusePropsNumber = {
+export declare type FusePropsNumber = {
     fuseNumberToBurn: number;
 };
-declare type FuseProps<A extends FuseArrayPossibilities> = (Partial<FusePropsNamedArray<A>> & FusePropsUnnamedArray) | (FusePropsNamedArray<A> & Partial<FusePropsUnnamedArray>) | FusePropsNumber;
-export default function <A extends FuseArrayPossibilities>({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, props: FuseProps<A>): Promise<import("ethers").PopulatedTransaction>;
+export declare type FuseProps = (Partial<FusePropsNamedArray> & FusePropsUnnamedArray) | (FusePropsNamedArray & Partial<FusePropsUnnamedArray>) | FusePropsNumber;
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, props: FuseProps): Promise<import("ethers").PopulatedTransaction>;
 export {};

package/dist/esm/functions/getFuses.js

@@ -18,10 +18,10 @@ const decode = async ({ contracts }, data) => {
             fuses.and(fuseEnum[fuse]).gt(0),
         ]));
         if (fuses.eq(0)) {
-            fuseObj.canDoEverything = true;
+            fuseObj.CAN_DO_EVERYTHING = true;
         }
         else {
-            fuseObj.canDoEverything = false;
+            fuseObj.CAN_DO_EVERYTHING = false;
         }
         const expiryDate = new Date(expiry * 1000);
         return {

package/dist/esm/functions/getOwner.js

@@ -100,7 +100,8 @@ const decode = async ({ contracts, multicallWrapper }, data, name, contract) =>
         if (labels.length > 2 &&
             ethers.utils.hexStripZeros(registryOwner) !== '0x') {
             // this means that the subname is wrapped
-            if (registryOwner === nameWrapper.address) {
+            if (registryOwner === nameWrapper.address &&
+                ethers.utils.hexStripZeros(nameWrapperOwner) !== '0x') {
                 return {
                     owner: nameWrapperOwner,
                     ownershipLevel: 'nameWrapper',
@@ -119,7 +120,8 @@ const decode = async ({ contracts, multicallWrapper }, data, name, contract) =>
     // there will only ever be an owner for non .eth names, not a registrant
     // this is because for unwrapped names, there is no associated NFT
     // and for wrapped names, owner and registrant are the same thing
-    if (registryOwner == nameWrapper.address) {
+    if (registryOwner == nameWrapper.address &&
+        ethers.utils.hexStripZeros(nameWrapperOwner) !== '0x') {
         return {
             owner: nameWrapperOwner,
             ownershipLevel: 'nameWrapper',

package/dist/esm/index.d.ts

@@ -18,6 +18,9 @@ import type transferSubname from './functions/transferSubname';
 import type unwrapName from './functions/unwrapName';
 import type wrapName from './functions/wrapName';
 import GqlManager from './GqlManager';
+import fuseEnum from './utils/fuses';
+export type { FusePropsNamedArray, FusePropsUnnamedArray, FusePropsNumber, FuseProps, NamedFusesToBurn } from './functions/burnFuses';
+export declare type FuseEnum = typeof fuseEnum;
 declare type ENSOptions = {
     graphURI?: string | null;
     getContractAddress?: typeof _getContractAddress;
@@ -464,4 +467,3 @@ export declare class ENS {
     registerName: WriteFunction<typeof registerName>;
     renewName: WriteFunction<typeof renewName>;
 }
-export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ensdomains/ensjs",
-  "version": "3.0.0-alpha.14",
+  "version": "3.0.0-alpha.17",
   "description": "ENS javascript library for contract interaction",
   "main": "./dist/cjs/index.js",
   "types": "./dist/cjs/index.d.ts",
@@ -69,6 +69,7 @@
   },
   "scripts": {
     "tenv": "ens-test-env -a",
+    "denv": "pnpm tenv start -ns -nb",
     "generate-types": "ts-node scripts/runTypechain.ts",
     "generate-abis": "hardhat export-abi",
     "start": "ts-node --files src/index.test.ts",

package/src/GqlManager.test.ts

@@ -1,7 +1,7 @@
+import { parse, print, visit } from 'graphql'
 import traverse from 'traverse'
-import { visit, parse } from 'graphql'
 
-import { requestMiddleware, responseMiddleware, enter } from './GqlManager'
+import { requestMiddleware, responseMiddleware } from './GqlManager'
 import { namehash } from './utils/normalise'
 
 describe('GqlManager', () => {
@@ -153,8 +153,9 @@ query getNames($id: ID!, $expiryDate: Int) {
 
   describe('requestMiddleware', () => {
     it('should add id to a SelectionSet if name is present and id is not', () => {
-      const result = requestMiddleware(visit, parse)(mockRequest)
-      expect(result.body.includes('id')).toBe(true)
+      const result = requestMiddleware(visit, parse, print)(mockRequest)
+      const body = result.body as string
+      expect(body.match(/domain.*id.*id.*domains.*id.*id/)?.length).toBe(1)
     })
   })
   describe('responseMiddleware', () => {

package/src/GqlManager.ts

@@ -1,10 +1,17 @@
-// @ts-nocheck
+import type {
+  Kind,
+  parse as Parse,
+  print as Print,
+  SelectionSetNode,
+  visit as Visit,
+} from 'graphql'
+import type Traverse from 'traverse'
 import { namehash } from './utils/normalise'
 
 const generateSelection = (selection: any) => ({
-  kind: 'Field',
+  kind: 'Field' as Kind.FIELD,
   name: {
-    kind: 'Name',
+    kind: 'Name' as Kind.NAME,
     value: selection,
   },
   arguments: [],
@@ -13,47 +20,58 @@ const generateSelection = (selection: any) => ({
   selectionSet: undefined,
 })
 
-export const enter = (node: any) => {
-  if (node.kind === 'SelectionSet') {
-    const id = node.selections.find((x) => x.name && x.name.value === 'id')
-    const name = node.selections.find((x) => x.name && x.name.value === 'name')
+export const enter = (node: SelectionSetNode) => {
+  let hasName = false
+  let hasId = false
 
-    if (!id && name) {
-      node.selections = [...node.selections, generateSelection('id')]
-      return node
+  for (const selection of node.selections) {
+    if ('name' in selection) {
+      if (selection.name.value === 'name') hasName = true
+      else if (selection.name.value === 'id') hasId = true
     }
   }
+
+  if (hasName && !hasId) {
+    node.selections = [...node.selections, generateSelection('id')]
+    return node
+  }
 }
 
-export const requestMiddleware = (visit, parse) => (request: any) => {
-  const requestBody = JSON.parse(request.body)
-  const rawQuery = requestBody.query
-  const parsedQuery = parse(rawQuery)
-  const updatedQuery = visit(parsedQuery, { enter })
-  const updatedBody = { ...requestBody, query: updatedQuery.loc.source.body }
+export const requestMiddleware =
+  (visit: typeof Visit, parse: typeof Parse, print: typeof Print) =>
+  (request: any) => {
+    const requestBody = JSON.parse(request.body)
+    const rawQuery = requestBody.query
+    const parsedQuery = parse(rawQuery)
+    const updatedQuery = visit(parsedQuery, {
+      SelectionSet: {
+        enter,
+      },
+    })
 
-  return {
-    ...request,
-    body: JSON.stringify(updatedBody),
+    return {
+      ...request,
+      body: JSON.stringify({ ...requestBody, query: print(updatedQuery) }),
+    }
   }
-}
 
-export const responseMiddleware = (traverse) => (response: any) => {
-  traverse(response).forEach(function (responseItem: any) {
-    if (responseItem instanceof Object && responseItem.name) {
-      //Name already in hashed form
-      if (responseItem.name && responseItem.name.includes('[')) {
-        return
-      }
+export const responseMiddleware =
+  (traverse: typeof Traverse) => (response: any) => {
+    traverse(response).forEach(function (responseItem: any) {
+      if (responseItem instanceof Object && responseItem.name) {
+        //Name already in hashed form
+        if (responseItem.name && responseItem.name.includes('[')) {
+          return
+        }
 
-      const hashedName = namehash(responseItem.name)
-      if (responseItem.id !== hashedName) {
-        this.update({ ...responseItem, name: hashedName, invalidName: true })
+        const hashedName = namehash(responseItem.name)
+        if (responseItem.id !== hashedName) {
+          this.update({ ...responseItem, name: hashedName, invalidName: true })
+        }
       }
-    }
-  })
-  return response
-}
+    })
+    return response
+  }
 
 export default class GqlManager {
   public gql: any = () => null
@@ -61,14 +79,14 @@ export default class GqlManager {
 
   public setUrl = async (url: string | null) => {
     if (url) {
-      const [imported, traverse, { visit, parse }] = await Promise.all([
+      const [imported, traverse, { visit, parse, print }] = await Promise.all([
         import('graphql-request'),
         import('traverse'),
         import('graphql/language'),
       ])
 
       this.client = new imported.GraphQLClient(url, {
-        requestMiddleware: requestMiddleware(visit, parse),
+        requestMiddleware: requestMiddleware(visit, parse, print),
         responseMiddleware: responseMiddleware(traverse.default),
       })
       this.gql = imported.gql

package/src/functions/burnFuses.ts

@@ -5,11 +5,10 @@ import { namehash } from '../utils/normalise'
 type FuseObj = typeof fuseEnum
 type UnnamedFuseType = typeof unnamedFuses
 type Fuse = keyof FuseObj
-type NamedFuseValues = FuseObj[Fuse]
 type UnnamedFuseValues = UnnamedFuseType[number]
 
 // We need this type so that the following type isn't infinite. This type limits the max length of the fuse array to 7.
-type FuseArrayPossibilities =
+export type FuseArrayPossibilities =
   | [Fuse]
   | [Fuse, Fuse]
   | [Fuse, Fuse, Fuse]
@@ -40,27 +39,29 @@ type FusesWithoutDuplicates<A, B = never> = A extends FuseArrayPossibilities
   : // CLAUSE A > FALSE: Return an empty array as it isn't a fuse tuple.
     []
 
-type FusePropsNamedArray<A extends FuseArrayPossibilities> = {
-  namedFusesToBurn: FusesWithoutDuplicates<A>
+export type NamedFusesToBurn = FusesWithoutDuplicates<FuseArrayPossibilities>
+
+export type FusePropsNamedArray = {
+  namedFusesToBurn: NamedFusesToBurn 
 }
 
-type FusePropsUnnamedArray = {
+export type FusePropsUnnamedArray = {
   unnamedFusesToBurn: UnnamedFuseValues[]
 }
 
-type FusePropsNumber = {
+export type FusePropsNumber = {
   fuseNumberToBurn: number
 }
 
-type FuseProps<A extends FuseArrayPossibilities> =
-  | (Partial<FusePropsNamedArray<A>> & FusePropsUnnamedArray)
-  | (FusePropsNamedArray<A> & Partial<FusePropsUnnamedArray>)
+export type FuseProps =
+  | (Partial<FusePropsNamedArray> & FusePropsUnnamedArray)
+  | (FusePropsNamedArray & Partial<FusePropsUnnamedArray>)
   | FusePropsNumber
 
-export default async function <A extends FuseArrayPossibilities>(
+export default async function (
   { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
   name: string,
-  props: FuseProps<A>,
+  props: FuseProps,
 ) {
   const isNumber = 'fuseNumberToBurn' in props
   const hasNamedArray = 'namedFusesToBurn' in props

package/src/functions/getFuses.test.ts

@@ -19,7 +19,7 @@ const unwrappedNameDefault = {
     CANNOT_TRANSFER: false,
     CANNOT_UNWRAP: false,
     PARENT_CANNOT_CONTROL: false,
-    canDoEverything: true,
+    CAN_DO_EVERYTHING: true,
   },
   owner: '0x0000000000000000000000000000000000000000',
   rawFuses: BigNumber.from(0),
@@ -48,12 +48,12 @@ describe('getFuses', () => {
       unwrappedNameDefault,
     )
   })
-  it('should return with canDoEverything set to true for a name with no fuses burned', async () => {
+  it('should return with CAN_DO_EVERYTHING set to true for a name with no fuses burned', async () => {
     const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
     const result = await ENSInstance.getFuses('test.wrapped-with-subnames.eth')
     expect(result).toBeTruthy()
     if (result) {
-      expect(result.fuseObj.canDoEverything).toBe(true)
+      expect(result.fuseObj.CAN_DO_EVERYTHING).toBe(true)
       expect(
         Object.values(result.fuseObj).reduce(
           (prev, curr) => (curr ? prev + 1 : prev),
@@ -85,7 +85,7 @@ describe('getFuses', () => {
         CANNOT_SET_TTL: true,
         CANNOT_CREATE_SUBDOMAIN: true,
         PARENT_CANNOT_CONTROL: true,
-        canDoEverything: false,
+        CAN_DO_EVERYTHING: false,
       })
       expect(result.rawFuses.toHexString()).toBe('0x71')
     }

package/src/functions/getFuses.ts

@@ -33,9 +33,9 @@ const decode = async (
     )
 
     if (fuses.eq(0)) {
-      fuseObj.canDoEverything = true
+      fuseObj.CAN_DO_EVERYTHING = true
     } else {
-      fuseObj.canDoEverything = false
+      fuseObj.CAN_DO_EVERYTHING = false
     }
 
     const expiryDate = new Date(expiry * 1000)

package/src/functions/getOwner.test.ts

@@ -55,4 +55,17 @@ describe('getOwner', () => {
     expect(result?.ownershipLevel).toBe('registry')
     expect(result?.owner).toBe('0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC')
   })
+  it('should return registry ownership for a pseudo-wrapped name', async () => {
+    const nameWrapper = await ENSInstance.contracts!.getNameWrapper()
+    const tx = await ENSInstance.transferSubname('test.with-subnames.eth', {
+      contract: 'registry',
+      owner: nameWrapper.address,
+      addressOrIndex: 1,
+    })
+    await tx.wait()
+
+    const result = await ENSInstance.getOwner('test.with-subnames.eth')
+    expect(result?.ownershipLevel).toBe('registry')
+    expect(result?.owner).toBe(nameWrapper.address)
+  })
 })

package/src/functions/getOwner.ts

@@ -161,7 +161,10 @@ const decode = async (
       ethers.utils.hexStripZeros(registryOwner) !== '0x'
     ) {
       // this means that the subname is wrapped
-      if (registryOwner === nameWrapper.address) {
+      if (
+        registryOwner === nameWrapper.address &&
+        ethers.utils.hexStripZeros(nameWrapperOwner) !== '0x'
+      ) {
         return {
           owner: nameWrapperOwner,
           ownershipLevel: 'nameWrapper',
@@ -181,7 +184,10 @@ const decode = async (
   // there will only ever be an owner for non .eth names, not a registrant
   // this is because for unwrapped names, there is no associated NFT
   // and for wrapped names, owner and registrant are the same thing
-  if (registryOwner == nameWrapper.address) {
+  if (
+    registryOwner == nameWrapper.address &&
+    ethers.utils.hexStripZeros(nameWrapperOwner) !== '0x'
+  ) {
     return {
       owner: nameWrapperOwner,
       ownershipLevel: 'nameWrapper',

package/src/index.ts

@@ -48,6 +48,9 @@ import singleCall from './utils/singleCall'
 import writeTx from './utils/writeTx'
 import fuseEnum from './utils/fuses'
 
+export type { FusePropsNamedArray, FusePropsUnnamedArray, FusePropsNumber, FuseProps, NamedFusesToBurn } from './functions/burnFuses'
+export type FuseEnum = typeof fuseEnum 
+
 type ENSOptions = {
   graphURI?: string | null
   getContractAddress?: typeof _getContractAddress