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

package/dist/cjs/functions/getNames.js

@@ -28,6 +28,16 @@ const mapDomain = ({ name, ...domain }) => {
   const decrypted = name ? (0, import_labels.decryptName)(name) : void 0;
   return {
     ...domain,
+    ...domain.registration ? {
+      registration: {
+        expiryDate: new Date(
+          parseInt(domain.registration.expiryDate) * 1e3
+        ),
+        registrationDate: new Date(
+          parseInt(domain.registration.registrationDate) * 1e3
+        )
+      }
+    } : {},
     name: decrypted,
     truncatedName: decrypted ? (0, import_format.truncateFormat)(decrypted) : void 0,
     createdAt: new Date(parseInt(domain.createdAt) * 1e3),
@@ -35,19 +45,13 @@ const mapDomain = ({ name, ...domain }) => {
   };
 };
 const mapWrappedDomain = (wrappedDomain) => {
-  const domain = mapDomain(wrappedDomain.domain);
-  if (domain.registration) {
-    domain.registration = {
-      expiryDate: new Date(
-        parseInt(domain.registration.expiryDate) * 1e3
-      ),
-      registrationDate: new Date(
-        parseInt(domain.registration.registrationDate) * 1e3
-      )
-    };
+  const expiryDate = wrappedDomain.expiryDate && wrappedDomain.expiryDate !== "0" ? new Date(parseInt(wrappedDomain.expiryDate) * 1e3) : void 0;
+  if (expiryDate && expiryDate < new Date() && (0, import_fuses.checkPCCBurned)(wrappedDomain.fuses)) {
+    return null;
   }
+  const domain = mapDomain(wrappedDomain.domain);
   return {
-    expiryDate: new Date(parseInt(wrappedDomain.expiryDate) * 1e3),
+    expiryDate,
     fuses: (0, import_fuses.decodeFuses)(wrappedDomain.fuses),
     ...domain,
     type: "wrappedDomain"
@@ -106,6 +110,10 @@ const getNames = async ({ gqlInstance }, {
           domains(first: 1000) {
             ${domainQueryData}
             createdAt
+            registration {
+              registrationDate
+              expiryDate
+            }
           }
           wrappedDomains(first: 1000) {
             expiryDate
@@ -137,6 +145,10 @@ const getNames = async ({ gqlInstance }, {
             domains(orderBy: $orderBy, orderDirection: $orderDirection) {
               ${domainQueryData}
               createdAt
+              registration {
+                registrationDate
+                expiryDate
+              }
             }
           }
         }
@@ -310,7 +322,7 @@ const getNames = async ({ gqlInstance }, {
     return [
       ...(account == null ? void 0 : account.domains.map(mapDomain)) || [],
       ...(account == null ? void 0 : account.registrations.map(mapRegistration)) || [],
-      ...(account == null ? void 0 : account.wrappedDomains.map(mapWrappedDomain)) || []
+      ...(account == null ? void 0 : account.wrappedDomains.map(mapWrappedDomain).filter((d) => d)) || []
     ].sort((a, b) => {
       if (orderDirection === "desc") {
         if (orderBy === "labelName") {
@@ -328,7 +340,7 @@ const getNames = async ({ gqlInstance }, {
     return (account == null ? void 0 : account.domains.map(mapDomain)) || [];
   }
   if (type === "wrappedOwner") {
-    return (account == null ? void 0 : account.wrappedDomains.map(mapWrappedDomain)) || [];
+    return (account == null ? void 0 : account.wrappedDomains.map(mapWrappedDomain).filter((d) => d)) || [];
   }
   return (account == null ? void 0 : account.registrations.map(mapRegistration)) || [];
 };

package/dist/cjs/functions/getSubnames.js

@@ -22,6 +22,7 @@ __export(getSubnames_exports, {
 });
 module.exports = __toCommonJS(getSubnames_exports);
 var import_format = require("../utils/format");
+var import_fuses = require("../utils/fuses");
 var import_labels = require("../utils/labels");
 var import_normalise = require("../utils/normalise");
 const largeQuery = async ({ gqlInstance }, {
@@ -77,6 +78,13 @@ const largeQuery = async ({ gqlInstance }, {
           owner {
             id
           }
+          wrappedDomain {
+            fuses
+            expiryDate
+            owner {
+              id
+            }
+          }
         }
       }
     }
@@ -92,14 +100,30 @@ const largeQuery = async ({ gqlInstance }, {
   };
   const response = await client.request(finalQuery, queryVars);
   const domain = response == null ? void 0 : response.domain;
-  const subdomains = domain.subdomains.map((subname) => {
-    const decrypted = (0, import_labels.decryptName)(subname.name);
-    return {
-      ...subname,
-      name: decrypted,
-      truncatedName: (0, import_format.truncateFormat)(decrypted)
-    };
-  });
+  const subdomains = domain.subdomains.map(
+    ({ wrappedDomain, ...subname }) => {
+      const decrypted = (0, import_labels.decryptName)(subname.name);
+      const obj = {
+        ...subname,
+        labelName: subname.labelName || null,
+        labelhash: subname.labelhash || "",
+        name: decrypted,
+        truncatedName: (0, import_format.truncateFormat)(decrypted),
+        owner: subname.owner.id,
+        type: "domain"
+      };
+      if (wrappedDomain) {
+        obj.type = "wrappedDomain";
+        const expiryDateAsDate = wrappedDomain.expiryDate && wrappedDomain.expiryDate !== "0" ? new Date(parseInt(wrappedDomain.expiryDate) * 1e3) : void 0;
+        const hasExpired = expiryDateAsDate && expiryDateAsDate < new Date();
+        obj.expiryDate = expiryDateAsDate;
+        obj.fuses = (0, import_fuses.decodeFuses)(hasExpired ? 0 : wrappedDomain.fuses);
+        obj.pccExpired = hasExpired ? (0, import_fuses.checkPCCBurned)(wrappedDomain.fuses) : false;
+        obj.owner = obj.pccExpired ? void 0 : wrappedDomain.owner.id;
+      }
+      return obj;
+    }
+  );
   return {
     subnames: subdomains,
     subnameCount: domain.subdomainCount

package/dist/cjs/utils/consts.js

@@ -23,4 +23,4 @@ __export(consts_exports, {
 });
 module.exports = __toCommonJS(consts_exports);
 const EMPTY_ADDRESS = "0x0000000000000000000000000000000000000000";
-const MAX_INT_64 = 2n ** 64n - 1n;
+const MAX_INT_64 = BigInt("18446744073709551615");

package/dist/cjs/utils/fuses.js

@@ -21,6 +21,7 @@ __export(fuses_exports, {
   CHILD_CONTROLLED_FUSES: () => CHILD_CONTROLLED_FUSES,
   PARENT_CONTROLLED_FUSES: () => PARENT_CONTROLLED_FUSES,
   USER_SETTABLE_FUSES: () => USER_SETTABLE_FUSES,
+  checkPCCBurned: () => checkPCCBurned,
   childFuseEnum: () => childFuseEnum,
   childFuseKeys: () => childFuseKeys,
   decodeFuses: () => decodeFuses,
@@ -297,4 +298,5 @@ const decodeFuses = (fuses) => {
     }
   };
 };
+const checkPCCBurned = (fuses) => (fuses & PARENT_CANNOT_CONTROL) === PARENT_CANNOT_CONTROL;
 var fuses_default = fullFuseEnum;

package/dist/esm/functions/getNames.mjs

@@ -1,11 +1,21 @@
 // src/functions/getNames.ts
 import { truncateFormat } from "../utils/format.mjs";
-import { decodeFuses } from "../utils/fuses.mjs";
+import { checkPCCBurned, decodeFuses } from "../utils/fuses.mjs";
 import { decryptName } from "../utils/labels.mjs";
 var mapDomain = ({ name, ...domain }) => {
   const decrypted = name ? decryptName(name) : void 0;
   return {
     ...domain,
+    ...domain.registration ? {
+      registration: {
+        expiryDate: new Date(
+          parseInt(domain.registration.expiryDate) * 1e3
+        ),
+        registrationDate: new Date(
+          parseInt(domain.registration.registrationDate) * 1e3
+        )
+      }
+    } : {},
     name: decrypted,
     truncatedName: decrypted ? truncateFormat(decrypted) : void 0,
     createdAt: new Date(parseInt(domain.createdAt) * 1e3),
@@ -13,19 +23,13 @@ var mapDomain = ({ name, ...domain }) => {
   };
 };
 var mapWrappedDomain = (wrappedDomain) => {
-  const domain = mapDomain(wrappedDomain.domain);
-  if (domain.registration) {
-    domain.registration = {
-      expiryDate: new Date(
-        parseInt(domain.registration.expiryDate) * 1e3
-      ),
-      registrationDate: new Date(
-        parseInt(domain.registration.registrationDate) * 1e3
-      )
-    };
+  const expiryDate = wrappedDomain.expiryDate && wrappedDomain.expiryDate !== "0" ? new Date(parseInt(wrappedDomain.expiryDate) * 1e3) : void 0;
+  if (expiryDate && expiryDate < new Date() && checkPCCBurned(wrappedDomain.fuses)) {
+    return null;
   }
+  const domain = mapDomain(wrappedDomain.domain);
   return {
-    expiryDate: new Date(parseInt(wrappedDomain.expiryDate) * 1e3),
+    expiryDate,
     fuses: decodeFuses(wrappedDomain.fuses),
     ...domain,
     type: "wrappedDomain"
@@ -84,6 +88,10 @@ var getNames = async ({ gqlInstance }, {
           domains(first: 1000) {
             ${domainQueryData}
             createdAt
+            registration {
+              registrationDate
+              expiryDate
+            }
           }
           wrappedDomains(first: 1000) {
             expiryDate
@@ -115,6 +123,10 @@ var getNames = async ({ gqlInstance }, {
             domains(orderBy: $orderBy, orderDirection: $orderDirection) {
               ${domainQueryData}
               createdAt
+              registration {
+                registrationDate
+                expiryDate
+              }
             }
           }
         }
@@ -288,7 +300,7 @@ var getNames = async ({ gqlInstance }, {
     return [
       ...account?.domains.map(mapDomain) || [],
       ...account?.registrations.map(mapRegistration) || [],
-      ...account?.wrappedDomains.map(mapWrappedDomain) || []
+      ...account?.wrappedDomains.map(mapWrappedDomain).filter((d) => d) || []
     ].sort((a, b) => {
       if (orderDirection === "desc") {
         if (orderBy === "labelName") {
@@ -306,7 +318,7 @@ var getNames = async ({ gqlInstance }, {
     return account?.domains.map(mapDomain) || [];
   }
   if (type === "wrappedOwner") {
-    return account?.wrappedDomains.map(mapWrappedDomain) || [];
+    return account?.wrappedDomains.map(mapWrappedDomain).filter((d) => d) || [];
   }
   return account?.registrations.map(mapRegistration) || [];
 };

package/dist/esm/functions/getSubnames.mjs

@@ -1,5 +1,6 @@
 // src/functions/getSubnames.ts
 import { truncateFormat } from "../utils/format.mjs";
+import { checkPCCBurned, decodeFuses } from "../utils/fuses.mjs";
 import { decryptName } from "../utils/labels.mjs";
 import { namehash } from "../utils/normalise.mjs";
 var largeQuery = async ({ gqlInstance }, {
@@ -55,6 +56,13 @@ var largeQuery = async ({ gqlInstance }, {
           owner {
             id
           }
+          wrappedDomain {
+            fuses
+            expiryDate
+            owner {
+              id
+            }
+          }
         }
       }
     }
@@ -70,14 +78,30 @@ var largeQuery = async ({ gqlInstance }, {
   };
   const response = await client.request(finalQuery, queryVars);
   const domain = response?.domain;
-  const subdomains = domain.subdomains.map((subname) => {
-    const decrypted = decryptName(subname.name);
-    return {
-      ...subname,
-      name: decrypted,
-      truncatedName: truncateFormat(decrypted)
-    };
-  });
+  const subdomains = domain.subdomains.map(
+    ({ wrappedDomain, ...subname }) => {
+      const decrypted = decryptName(subname.name);
+      const obj = {
+        ...subname,
+        labelName: subname.labelName || null,
+        labelhash: subname.labelhash || "",
+        name: decrypted,
+        truncatedName: truncateFormat(decrypted),
+        owner: subname.owner.id,
+        type: "domain"
+      };
+      if (wrappedDomain) {
+        obj.type = "wrappedDomain";
+        const expiryDateAsDate = wrappedDomain.expiryDate && wrappedDomain.expiryDate !== "0" ? new Date(parseInt(wrappedDomain.expiryDate) * 1e3) : void 0;
+        const hasExpired = expiryDateAsDate && expiryDateAsDate < new Date();
+        obj.expiryDate = expiryDateAsDate;
+        obj.fuses = decodeFuses(hasExpired ? 0 : wrappedDomain.fuses);
+        obj.pccExpired = hasExpired ? checkPCCBurned(wrappedDomain.fuses) : false;
+        obj.owner = obj.pccExpired ? void 0 : wrappedDomain.owner.id;
+      }
+      return obj;
+    }
+  );
   return {
     subnames: subdomains,
     subnameCount: domain.subdomainCount

package/dist/esm/utils/consts.mjs

@@ -1,6 +1,6 @@
 // src/utils/consts.ts
 var EMPTY_ADDRESS = "0x0000000000000000000000000000000000000000";
-var MAX_INT_64 = 2n ** 64n - 1n;
+var MAX_INT_64 = BigInt("18446744073709551615");
 export {
   EMPTY_ADDRESS,
   MAX_INT_64

package/dist/esm/utils/fuses.mjs

@@ -257,11 +257,13 @@ var decodeFuses = (fuses) => {
     }
   };
 };
+var checkPCCBurned = (fuses) => (fuses & PARENT_CANNOT_CONTROL) === PARENT_CANNOT_CONTROL;
 var fuses_default = fullFuseEnum;
 export {
   CHILD_CONTROLLED_FUSES,
   PARENT_CONTROLLED_FUSES,
   USER_SETTABLE_FUSES,
+  checkPCCBurned,
   childFuseEnum,
   childFuseKeys,
   decodeFuses,

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

@@ -1,15 +1,27 @@
 import { ENSArgs } from '..';
-declare type Subname = {
+import { AllCurrentFuses } from '../utils/fuses';
+declare type BaseSubname = {
     id: string;
     labelName: string | null;
     truncatedName?: string;
     labelhash: string;
     isMigrated: boolean;
     name: string;
-    owner: {
-        id: string;
-    };
+    owner: string | undefined;
 };
+declare type UnwrappedSubname = BaseSubname & {
+    fuses?: never;
+    expiryDate?: never;
+    pccExpired?: never;
+    type: 'domain';
+};
+declare type WrappedSubname = BaseSubname & {
+    fuses: AllCurrentFuses;
+    expiryDate: Date;
+    pccExpired: boolean;
+    type: 'wrappedDomain';
+};
+declare type Subname = WrappedSubname | UnwrappedSubname;
 declare type Params = {
     name: string;
     page?: number;

package/dist/types/index.d.ts

@@ -461,17 +461,75 @@ export declare class ENS {
         lastSubnames?: any[] | undefined;
         search?: string | undefined;
     }) => Promise<{
-        subnames: {
+        subnames: (({
             id: string;
             labelName: string | null;
             truncatedName?: string | undefined;
             labelhash: string;
             isMigrated: boolean;
             name: string;
-            owner: {
-                id: string;
+            owner: string | undefined;
+        } & {
+            fuses?: undefined;
+            expiryDate?: undefined;
+            pccExpired?: undefined;
+            type: "domain";
+        }) | ({
+            id: string;
+            labelName: string | null;
+            truncatedName?: string | undefined;
+            labelhash: string;
+            isMigrated: boolean;
+            name: string;
+            owner: string | undefined;
+        } & {
+            fuses: {
+                parent: {
+                    unnamed: {
+                        524288: boolean;
+                        1048576: boolean;
+                        2097152: boolean;
+                        4194304: boolean;
+                        8388608: boolean;
+                        16777216: boolean;
+                        33554432: boolean;
+                        67108864: boolean;
+                        134217728: boolean;
+                        268435456: boolean;
+                        536870912: boolean;
+                        1073741824: boolean;
+                        2147483648: boolean;
+                    };
+                    IS_DOT_ETH: boolean;
+                    PARENT_CANNOT_CONTROL: boolean;
+                    CAN_EXTEND_EXPIRY: boolean;
+                };
+                child: {
+                    CAN_DO_EVERYTHING: boolean;
+                    unnamed: {
+                        1024: boolean;
+                        64: boolean;
+                        128: boolean;
+                        256: boolean;
+                        512: boolean;
+                        2048: boolean;
+                        4096: boolean;
+                        8192: boolean;
+                        16384: boolean;
+                        32768: boolean;
+                    };
+                    CANNOT_UNWRAP: boolean;
+                    CANNOT_BURN_FUSES: boolean;
+                    CANNOT_TRANSFER: boolean;
+                    CANNOT_SET_RESOLVER: boolean;
+                    CANNOT_SET_TTL: boolean;
+                    CANNOT_CREATE_SUBDOMAIN: boolean;
+                };
             };
-        }[];
+            expiryDate: Date;
+            pccExpired: boolean;
+            type: "wrappedDomain";
+        }))[];
         subnameCount: number;
     }>;
     getNames: (args_0: {

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

@@ -128,5 +128,6 @@ export declare const decodeFuses: (fuses: number) => {
         CANNOT_CREATE_SUBDOMAIN: boolean;
     };
 };
+export declare const checkPCCBurned: (fuses: number) => boolean;
 export declare type AllCurrentFuses = ReturnType<typeof decodeFuses>;
 export default fullFuseEnum;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ensdomains/ensjs",
-  "version": "3.0.0-alpha.44",
+  "version": "3.0.0-alpha.46",
   "description": "ENS javascript library for contract interaction",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.mjs",
@@ -9,22 +9,26 @@
     ".": {
       "import": "./dist/esm/index.mjs",
       "require": "./dist/cjs/index.js",
-      "default": "./dist/esm/index.mjs"
+      "default": "./dist/esm/index.mjs",
+      "types": "./dist/types/index.d.ts"
     },
     "./*.js": {
       "import": "./dist/esm/*.mjs",
       "require": "./dist/cjs/*.js",
-      "default": "./dist/esm/*.mjs"
+      "default": "./dist/esm/*.mjs",
+      "types": "./dist/types/*.d.ts"
     },
     "./*.mjs": {
       "import": "./dist/esm/*.mjs",
       "require": "./dist/cjs/*.js",
-      "default": "./dist/esm/*.mjs"
+      "default": "./dist/esm/*.mjs",
+      "types": "./dist/types/*.d.ts"
     },
     "./*": {
       "import": "./dist/esm/*.mjs",
       "require": "./dist/cjs/*.js",
-      "default": "./dist/esm/*.mjs"
+      "default": "./dist/esm/*.mjs",
+      "types": "./dist/types/*.d.ts"
     }
   },
   "typesVersions": {

package/src/functions/getNames.test.ts

@@ -166,13 +166,16 @@ describe('getNames', () => {
     })
     expect(pageFive).toHaveLength(totalOwnedNames % 10)
   })
-  it('should get wrapped domains for an address with pagination', async () => {
+  it('should get wrapped domains for an address with pagination, and filter out pcc expired names', async () => {
     const pageOne = await ensInstance.getNames({
       address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       type: 'wrappedOwner',
       page: 0,
     })
-    expect(pageOne).toHaveLength(2)
+    // 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)
   })
   describe('orderBy', () => {
     describe('registrations', () => {

package/src/functions/getNames.ts

@@ -1,6 +1,6 @@
 import { ENSArgs } from '..'
 import { truncateFormat } from '../utils/format'
-import { AllCurrentFuses, decodeFuses } from '../utils/fuses'
+import { AllCurrentFuses, checkPCCBurned, decodeFuses } from '../utils/fuses'
 import { decryptName } from '../utils/labels'
 import { Domain, Registration, WrappedDomain } from '../utils/subgraph-types'
 
@@ -60,8 +60,21 @@ type Params = BaseParams &
 
 const mapDomain = ({ name, ...domain }: Domain) => {
   const decrypted = name ? decryptName(name) : undefined
+
   return {
     ...domain,
+    ...(domain.registration
+      ? {
+          registration: {
+            expiryDate: new Date(
+              parseInt(domain.registration.expiryDate) * 1000,
+            ),
+            registrationDate: new Date(
+              parseInt(domain.registration.registrationDate) * 1000,
+            ),
+          },
+        }
+      : {}),
     name: decrypted,
     truncatedName: decrypted ? truncateFormat(decrypted) : undefined,
     createdAt: new Date(parseInt(domain.createdAt) * 1000),
@@ -70,27 +83,27 @@ const mapDomain = ({ name, ...domain }: Domain) => {
 }
 
 const mapWrappedDomain = (wrappedDomain: WrappedDomain) => {
-  const domain = mapDomain(wrappedDomain.domain) as Omit<
-    ReturnType<typeof mapDomain>,
-    'registration'
-  > & {
-    registration?: {
-      expiryDate: string | Date
-      registrationDate: string | Date
-    }
-  }
-  if (domain.registration) {
-    domain.registration = {
-      expiryDate: new Date(
-        parseInt(domain.registration.expiryDate as string) * 1000,
-      ),
-      registrationDate: new Date(
-        parseInt(domain.registration.registrationDate as string) * 1000,
-      ),
-    }
+  const expiryDate =
+    wrappedDomain.expiryDate && wrappedDomain.expiryDate !== '0'
+      ? new Date(parseInt(wrappedDomain.expiryDate) * 1000)
+      : undefined
+  if (
+    expiryDate &&
+    expiryDate < new Date() &&
+    checkPCCBurned(wrappedDomain.fuses)
+  ) {
+    // PCC was burned previously and now the fuses are expired meaning that the
+    // owner is now 0x0 so we need to filter this out
+    // if a user's local time is out of sync with the blockchain, this could potentially
+    // be incorrect. the likelihood of that happening though is very low, and devs
+    // shouldn't be relying on this value for anything critical anyway.
+    return null
   }
+
+  const domain = mapDomain(wrappedDomain.domain)
+
   return {
-    expiryDate: new Date(parseInt(wrappedDomain.expiryDate) * 1000),
+    expiryDate,
     fuses: decodeFuses(wrappedDomain.fuses),
     ...domain,
     type: 'wrappedDomain',
@@ -156,6 +169,10 @@ const getNames = async (
           domains(first: 1000) {
             ${domainQueryData}
             createdAt
+            registration {
+              registrationDate
+              expiryDate
+            }
           }
           wrappedDomains(first: 1000) {
             expiryDate
@@ -187,6 +204,10 @@ const getNames = async (
             domains(orderBy: $orderBy, orderDirection: $orderDirection) {
               ${domainQueryData}
               createdAt
+              registration {
+                registrationDate
+                expiryDate
+              }
             }
           }
         }
@@ -366,7 +387,8 @@ const getNames = async (
     return [
       ...(account?.domains.map(mapDomain) || []),
       ...(account?.registrations.map(mapRegistration) || []),
-      ...(account?.wrappedDomains.map(mapWrappedDomain) || []),
+      ...(account?.wrappedDomains.map(mapWrappedDomain).filter((d: any) => d) ||
+        []),
     ].sort((a, b) => {
       if (orderDirection === 'desc') {
         if (orderBy === 'labelName') {
@@ -384,7 +406,9 @@ const getNames = async (
     return (account?.domains.map(mapDomain) || []) as Name[]
   }
   if (type === 'wrappedOwner') {
-    return (account?.wrappedDomains.map(mapWrappedDomain) || []) as Name[]
+    return (account?.wrappedDomains
+      .map(mapWrappedDomain)
+      .filter((d: any) => d) || []) as Name[]
   }
   return (account?.registrations.map(mapRegistration) || []) as Name[]
 }

package/src/functions/getSubnames.test.ts

@@ -1,5 +1,6 @@
 import { ENS } from '..'
 import setup from '../tests/setup'
+import { decodeFuses } from '../utils/fuses'
 
 let ensInstance: ENS
 
@@ -130,6 +131,56 @@ describe('getSubnames', () => {
       'truncatedName',
     )
   })
+  describe('wrapped subnames', () => {
+    it('should return fuses', async () => {
+      const result = await ensInstance.getSubnames({
+        name: 'wrapped-with-subnames.eth',
+        pageSize: 10,
+        orderBy: 'createdAt',
+        orderDirection: 'desc',
+      })
+
+      expect(result).toBeTruthy()
+      expect(result.subnames.length).toBe(1)
+      expect(result.subnameCount).toBe(1)
+      expect(result.subnames[0].fuses).toBeDefined()
+    })
+    it('should return expiry as undefined if 0', async () => {
+      const result = await ensInstance.getSubnames({
+        name: 'wrapped-with-expiring-subnames.eth',
+        pageSize: 10,
+        orderBy: 'createdAt',
+        orderDirection: 'desc',
+      })
+
+      expect(result).toBeTruthy()
+      expect(result.subnames[1].expiryDate).toBeUndefined()
+    })
+    it('should return expiry', async () => {
+      const result = await ensInstance.getSubnames({
+        name: 'wrapped-with-expiring-subnames.eth',
+        pageSize: 10,
+        orderBy: 'createdAt',
+        orderDirection: 'desc',
+      })
+
+      expect(result).toBeTruthy()
+      expect(result.subnames[2].expiryDate).toBeInstanceOf(Date)
+    })
+    it('should return owner as undefined, fuses as 0, and pccExpired as true if pcc expired', async () => {
+      const result = await ensInstance.getSubnames({
+        name: 'wrapped-with-expiring-subnames.eth',
+        pageSize: 10,
+        orderBy: 'createdAt',
+        orderDirection: 'desc',
+      })
+
+      expect(result).toBeTruthy()
+      expect(result.subnames[0].owner).toBeUndefined()
+      expect(result.subnames[0].fuses).toStrictEqual(decodeFuses(0))
+      expect(result.subnames[0].pccExpired).toBe(true)
+    })
+  })
 
   describe('with pagination', () => {
     it('should get paginated subnames for a name ordered by createdAt in desc order', async () => {

package/src/functions/getSubnames.ts

@@ -1,20 +1,36 @@
 import { ENSArgs } from '..'
 import { truncateFormat } from '../utils/format'
+import { AllCurrentFuses, checkPCCBurned, decodeFuses } from '../utils/fuses'
 import { decryptName } from '../utils/labels'
 import { namehash } from '../utils/normalise'
+import { Domain } from '../utils/subgraph-types'
 
-type Subname = {
+type BaseSubname = {
   id: string
   labelName: string | null
   truncatedName?: string
   labelhash: string
   isMigrated: boolean
   name: string
-  owner: {
-    id: string
-  }
+  owner: string | undefined
+}
+
+type UnwrappedSubname = BaseSubname & {
+  fuses?: never
+  expiryDate?: never
+  pccExpired?: never
+  type: 'domain'
 }
 
+type WrappedSubname = BaseSubname & {
+  fuses: AllCurrentFuses
+  expiryDate: Date
+  pccExpired: boolean
+  type: 'wrappedDomain'
+}
+
+type Subname = WrappedSubname | UnwrappedSubname
+
 type Params = {
   name: string
   page?: number
@@ -90,6 +106,13 @@ const largeQuery = async (
           owner {
             id
           }
+          wrappedDomain {
+            fuses
+            expiryDate
+            owner {
+              id
+            }
+          }
         }
       }
     }
@@ -106,18 +129,44 @@ const largeQuery = async (
   }
   const response = await client.request(finalQuery, queryVars)
   const domain = response?.domain
-  const subdomains = domain.subdomains.map((subname: any) => {
-    const decrypted = decryptName(subname.name)
+  const subdomains = domain.subdomains.map(
+    ({ wrappedDomain, ...subname }: Domain) => {
+      const decrypted = decryptName(subname.name!)
 
-    return {
-      ...subname,
-      name: decrypted,
-      truncatedName: truncateFormat(decrypted),
-    }
-  })
+      const obj = {
+        ...subname,
+        labelName: subname.labelName || null,
+        labelhash: subname.labelhash || '',
+        name: decrypted,
+        truncatedName: truncateFormat(decrypted),
+        owner: subname.owner.id,
+        type: 'domain',
+      } as Subname
+
+      if (wrappedDomain) {
+        obj.type = 'wrappedDomain'
+        const expiryDateAsDate =
+          wrappedDomain.expiryDate && wrappedDomain.expiryDate !== '0'
+            ? new Date(parseInt(wrappedDomain.expiryDate) * 1000)
+            : undefined
+        // if a user's local time is out of sync with the blockchain, this could potentially
+        // be incorrect. the likelihood of that happening though is very low, and devs
+        // shouldn't be relying on this value for anything critical anyway.
+        const hasExpired = expiryDateAsDate && expiryDateAsDate < new Date()
+        obj.expiryDate = expiryDateAsDate
+        obj.fuses = decodeFuses(hasExpired ? 0 : wrappedDomain.fuses)
+        obj.pccExpired = hasExpired
+          ? checkPCCBurned(wrappedDomain.fuses)
+          : false
+        obj.owner = obj.pccExpired ? undefined : wrappedDomain.owner.id
+      }
+
+      return obj
+    },
+  )
 
   return {
-    subnames: subdomains,
+    subnames: subdomains as Subname[],
     subnameCount: domain.subdomainCount,
   }
 }

package/src/utils/consts.ts

@@ -1,2 +1,2 @@
 export const EMPTY_ADDRESS = '0x0000000000000000000000000000000000000000'
-export const MAX_INT_64 = 2n ** 64n - 1n
+export const MAX_INT_64 = BigInt('18446744073709551615')

package/src/utils/fuses.ts

@@ -352,6 +352,9 @@ export const decodeFuses = (fuses: number) => {
   }
 }
 
+export const checkPCCBurned = (fuses: number) =>
+  (fuses & PARENT_CANNOT_CONTROL) === PARENT_CANNOT_CONTROL
+
 export type AllCurrentFuses = ReturnType<typeof decodeFuses>
 
 export default fullFuseEnum