@ensdomains/ensjs 3.0.0-alpha.55 → 3.0.0-alpha.57

package/dist/cjs/contracts/getContractAddress.js

@@ -63,8 +63,8 @@ const addresses = {
     "5": "0x4f7A657451358a22dc397d5eE7981FfC526cd856"
   },
   UniversalResolver: {
-    "1": "0xE4Acdd618deED4e6d2f03b9bf62dc6118FC9A4da",
-    "5": "0xA292E2E58d4ddEb29C33c63173d0E8B7a2A4c62e"
+    "1": "0xc0497e381f536be9ce14b0dd3817cbcae57d2f62",
+    "5": "0x56522d00c410a43bffdf00a9a569489297385790"
   },
   BulkRenewal: {
     "1": "0xfF252725f6122A92551A5FA9a6b6bf10eb0Be035",

package/dist/cjs/functions/getNames.js

@@ -24,8 +24,10 @@ module.exports = __toCommonJS(getNames_exports);
 var import_format = require("../utils/format");
 var import_fuses = require("../utils/fuses");
 var import_labels = require("../utils/labels");
-const mapDomain = ({ name, ...domain }) => {
-  const decrypted = name ? (0, import_labels.decryptName)(name) : void 0;
+const mapDomain = (domain) => {
+  if (!domain)
+    return {};
+  const decrypted = domain.name ? (0, import_labels.decryptName)(domain.name) : void 0;
   return {
     ...domain,
     ...domain.registration ? {
@@ -59,15 +61,44 @@ const mapWrappedDomain = (wrappedDomain) => {
 };
 const mapRegistration = (registration) => {
   const decrypted = (0, import_labels.decryptName)(registration.domain.name);
+  const domain = mapDomain(registration.domain);
   return {
     expiryDate: new Date(parseInt(registration.expiryDate) * 1e3),
     registrationDate: new Date(parseInt(registration.registrationDate) * 1e3),
-    ...registration.domain,
+    ...domain,
     name: decrypted,
     truncatedName: (0, import_format.truncateFormat)(decrypted),
     type: "registration"
   };
 };
+const mapResolvedAddress = ({
+  wrappedDomain,
+  registration,
+  ...domain
+}) => {
+  const mappedDomain = mapDomain(domain);
+  if (wrappedDomain) {
+    const mappedWrappedDomain = mapWrappedDomain(wrappedDomain);
+    if (!mappedWrappedDomain)
+      return null;
+    return {
+      ...mappedDomain,
+      ...mappedWrappedDomain,
+      owner: wrappedDomain.owner.id
+    };
+  }
+  return {
+    ...mappedDomain,
+    ...registration ? {
+      expiryDate: new Date(parseInt(registration.expiryDate) * 1e3),
+      registrationDate: new Date(
+        parseInt(registration.registrationDate) * 1e3
+      ),
+      owner: registration.registrant.id
+    } : {},
+    manager: domain.owner.id
+  };
+};
 const getNames = async ({ gqlInstance }, {
   address: _address,
   type,
@@ -133,6 +164,46 @@ const getNames = async ({ gqlInstance }, {
       id: address,
       expiryDate: Math.floor(Date.now() / 1e3) - 90 * 24 * 60 * 60
     };
+  } else if (type === "resolvedAddress") {
+    finalQuery = gqlInstance.gql`
+    query getNames(
+      $id: String!
+      $orderBy: Domain_orderBy
+      $orderDirection: OrderDirection
+    ) {
+      domains(
+        first: 1000
+        where: { 
+           resolvedAddress: $id 
+        }
+        orderBy: $orderBy
+        orderDirection: $orderDirection
+      ) {
+        ${domainQueryData}
+        owner {
+          id
+        }
+        registration {
+          registrationDate
+          expiryDate
+          registrant {
+            id
+          }
+        }
+        wrappedDomain {
+          expiryDate
+          fuses
+          owner {
+            id
+          }
+        }
+      }
+    }`;
+    queryVars = {
+      id: address,
+      orderBy: orderBy === "labelName" ? "labelName" : "createdAt",
+      orderDirection: orderDirection === "asc" ? "asc" : "desc"
+    };
   } else if (type === "owner") {
     if (typeof page !== "number") {
       finalQuery = gqlInstance.gql`
@@ -332,6 +403,9 @@ const getNames = async ({ gqlInstance }, {
       return a.createdAt.getTime() - b.createdAt.getTime();
     });
   }
+  if (type === "resolvedAddress") {
+    return (response == null ? void 0 : response.domains.map(mapResolvedAddress).filter((d) => d)) || [];
+  }
   if (type === "owner") {
     return (account == null ? void 0 : account.domains.map(mapDomain)) || [];
   }

package/dist/cjs/functions/getWrapperData.js

@@ -21,7 +21,7 @@ __export(getWrapperData_exports, {
   default: () => getWrapperData_default
 });
 module.exports = __toCommonJS(getWrapperData_exports);
-var import_bignumber = require("@ethersproject/bignumber");
+var import_consts = require("../utils/consts");
 var import_fuses = require("../utils/fuses");
 var import_normalise = require("../utils/normalise");
 const raw = async ({ contracts }, name) => {
@@ -39,7 +39,15 @@ const decode = async ({ contracts }, data) => {
       data
     );
     const fuseObj = (0, import_fuses.decodeFuses)(fuses);
-    const expiryDate = expiry.gt(0) && expiry.lt(import_bignumber.BigNumber.from(2).pow(32)) ? new Date(expiry.mul(1e3).toNumber()) : void 0;
+    let expiryDate;
+    if (expiry.gt(0)) {
+      const msBigNumber = expiry.mul(1e3);
+      if (msBigNumber.gte(import_consts.MAX_DATE_INT)) {
+        expiryDate = new Date(import_consts.MAX_DATE_INT);
+      } else {
+        expiryDate = new Date(msBigNumber.toNumber());
+      }
+    }
     return {
       ...fuseObj,
       expiryDate,

package/dist/cjs/utils/consts.js

@@ -19,10 +19,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var consts_exports = {};
 __export(consts_exports, {
   EMPTY_ADDRESS: () => EMPTY_ADDRESS,
+  MAX_DATE_INT: () => MAX_DATE_INT,
   MAX_INT_64: () => MAX_INT_64,
   MINIMUM_DOT_ETH_CHARS: () => MINIMUM_DOT_ETH_CHARS
 });
 module.exports = __toCommonJS(consts_exports);
 const EMPTY_ADDRESS = "0x0000000000000000000000000000000000000000";
 const MAX_INT_64 = BigInt("18446744073709551615");
+const MAX_DATE_INT = 864e13;
 const MINIMUM_DOT_ETH_CHARS = 3;

package/dist/esm/contracts/getContractAddress.mjs

@@ -41,8 +41,8 @@ var addresses = {
     "5": "0x4f7A657451358a22dc397d5eE7981FfC526cd856"
   },
   UniversalResolver: {
-    "1": "0xE4Acdd618deED4e6d2f03b9bf62dc6118FC9A4da",
-    "5": "0xA292E2E58d4ddEb29C33c63173d0E8B7a2A4c62e"
+    "1": "0xc0497e381f536be9ce14b0dd3817cbcae57d2f62",
+    "5": "0x56522d00c410a43bffdf00a9a569489297385790"
   },
   BulkRenewal: {
     "1": "0xfF252725f6122A92551A5FA9a6b6bf10eb0Be035",

package/dist/esm/functions/getNames.mjs

@@ -2,8 +2,10 @@
 import { truncateFormat } from "../utils/format.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;
+var mapDomain = (domain) => {
+  if (!domain)
+    return {};
+  const decrypted = domain.name ? decryptName(domain.name) : void 0;
   return {
     ...domain,
     ...domain.registration ? {
@@ -37,15 +39,44 @@ var mapWrappedDomain = (wrappedDomain) => {
 };
 var mapRegistration = (registration) => {
   const decrypted = decryptName(registration.domain.name);
+  const domain = mapDomain(registration.domain);
   return {
     expiryDate: new Date(parseInt(registration.expiryDate) * 1e3),
     registrationDate: new Date(parseInt(registration.registrationDate) * 1e3),
-    ...registration.domain,
+    ...domain,
     name: decrypted,
     truncatedName: truncateFormat(decrypted),
     type: "registration"
   };
 };
+var mapResolvedAddress = ({
+  wrappedDomain,
+  registration,
+  ...domain
+}) => {
+  const mappedDomain = mapDomain(domain);
+  if (wrappedDomain) {
+    const mappedWrappedDomain = mapWrappedDomain(wrappedDomain);
+    if (!mappedWrappedDomain)
+      return null;
+    return {
+      ...mappedDomain,
+      ...mappedWrappedDomain,
+      owner: wrappedDomain.owner.id
+    };
+  }
+  return {
+    ...mappedDomain,
+    ...registration ? {
+      expiryDate: new Date(parseInt(registration.expiryDate) * 1e3),
+      registrationDate: new Date(
+        parseInt(registration.registrationDate) * 1e3
+      ),
+      owner: registration.registrant.id
+    } : {},
+    manager: domain.owner.id
+  };
+};
 var getNames = async ({ gqlInstance }, {
   address: _address,
   type,
@@ -111,6 +142,46 @@ var getNames = async ({ gqlInstance }, {
       id: address,
       expiryDate: Math.floor(Date.now() / 1e3) - 90 * 24 * 60 * 60
     };
+  } else if (type === "resolvedAddress") {
+    finalQuery = gqlInstance.gql`
+    query getNames(
+      $id: String!
+      $orderBy: Domain_orderBy
+      $orderDirection: OrderDirection
+    ) {
+      domains(
+        first: 1000
+        where: { 
+           resolvedAddress: $id 
+        }
+        orderBy: $orderBy
+        orderDirection: $orderDirection
+      ) {
+        ${domainQueryData}
+        owner {
+          id
+        }
+        registration {
+          registrationDate
+          expiryDate
+          registrant {
+            id
+          }
+        }
+        wrappedDomain {
+          expiryDate
+          fuses
+          owner {
+            id
+          }
+        }
+      }
+    }`;
+    queryVars = {
+      id: address,
+      orderBy: orderBy === "labelName" ? "labelName" : "createdAt",
+      orderDirection: orderDirection === "asc" ? "asc" : "desc"
+    };
   } else if (type === "owner") {
     if (typeof page !== "number") {
       finalQuery = gqlInstance.gql`
@@ -310,6 +381,9 @@ var getNames = async ({ gqlInstance }, {
       return a.createdAt.getTime() - b.createdAt.getTime();
     });
   }
+  if (type === "resolvedAddress") {
+    return response?.domains.map(mapResolvedAddress).filter((d) => d) || [];
+  }
   if (type === "owner") {
     return account?.domains.map(mapDomain) || [];
   }

package/dist/esm/functions/getWrapperData.mjs

@@ -1,5 +1,5 @@
 // src/functions/getWrapperData.ts
-import { BigNumber } from "@ethersproject/bignumber";
+import { MAX_DATE_INT } from "../utils/consts.mjs";
 import { decodeFuses } from "../utils/fuses.mjs";
 import { namehash } from "../utils/normalise.mjs";
 var raw = async ({ contracts }, name) => {
@@ -17,7 +17,15 @@ var decode = async ({ contracts }, data) => {
       data
     );
     const fuseObj = decodeFuses(fuses);
-    const expiryDate = expiry.gt(0) && expiry.lt(BigNumber.from(2).pow(32)) ? new Date(expiry.mul(1e3).toNumber()) : void 0;
+    let expiryDate;
+    if (expiry.gt(0)) {
+      const msBigNumber = expiry.mul(1e3);
+      if (msBigNumber.gte(MAX_DATE_INT)) {
+        expiryDate = new Date(MAX_DATE_INT);
+      } else {
+        expiryDate = new Date(msBigNumber.toNumber());
+      }
+    }
     return {
       ...fuseObj,
       expiryDate,

package/dist/esm/utils/consts.mjs

@@ -1,9 +1,11 @@
 // src/utils/consts.ts
 var EMPTY_ADDRESS = "0x0000000000000000000000000000000000000000";
 var MAX_INT_64 = BigInt("18446744073709551615");
+var MAX_DATE_INT = 864e13;
 var MINIMUM_DOT_ETH_CHARS = 3;
 export {
   EMPTY_ADDRESS,
+  MAX_DATE_INT,
   MAX_INT_64,
   MINIMUM_DOT_ETH_CHARS
 };

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

@@ -18,11 +18,13 @@ export declare type Name = {
         expiryDate: Date;
         registrationDate: Date;
     };
+    owner?: string;
+    manager?: string;
     type: 'domain' | 'registration' | 'wrappedDomain';
 };
 declare type BaseParams = {
     address: string;
-    type: 'registrant' | 'owner' | 'wrappedOwner' | 'all';
+    type: 'registrant' | 'owner' | 'wrappedOwner' | 'all' | 'resolvedAddress';
     page?: number;
     pageSize?: number;
     orderDirection?: 'asc' | 'desc';
@@ -45,6 +47,12 @@ declare type AllParams = {
     page?: never;
     pageSize?: never;
 };
-declare type Params = BaseParams & (RegistrantParams | OwnerParams | WrappedOwnerParams | AllParams);
+declare type ResolvedAddressParams = {
+    type: 'resolvedAddress';
+    orderBy?: 'labelName' | 'createdAt';
+    page?: never;
+    pageSize?: never;
+};
+declare type Params = BaseParams & (RegistrantParams | OwnerParams | WrappedOwnerParams | AllParams | ResolvedAddressParams);
 declare const getNames: ({ gqlInstance }: ENSArgs<'gqlInstance'>, { address: _address, type, page, pageSize, orderDirection, orderBy, }: Params) => Promise<Name[]>;
 export default getNames;

package/dist/types/index.d.ts

@@ -502,7 +502,7 @@ export declare class ENS {
     }>;
     getNames: (args_0: {
         address: string;
-        type: "owner" | "wrappedOwner" | "registrant" | "all";
+        type: "owner" | "wrappedOwner" | "registrant" | "all" | "resolvedAddress";
         page?: number | undefined;
         pageSize?: number | undefined;
         orderDirection?: "asc" | "desc" | undefined;
@@ -520,6 +520,11 @@ export declare class ENS {
         orderBy?: "labelName" | "creationDate" | undefined;
         page?: undefined;
         pageSize?: undefined;
+    } | {
+        type: "resolvedAddress";
+        orderBy?: "labelName" | "createdAt" | undefined;
+        page?: undefined;
+        pageSize?: undefined;
     })) => Promise<import("./functions/getNames").Name[]>;
     getPrice: GeneratedRawFunction<{
         raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, nameOrNames: string | string[], duration: number, legacy?: boolean | undefined) => Promise<{

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

@@ -1,3 +1,4 @@
 export declare const EMPTY_ADDRESS = "0x0000000000000000000000000000000000000000";
 export declare const MAX_INT_64: bigint;
+export declare const MAX_DATE_INT = 8640000000000000;
 export declare const MINIMUM_DOT_ETH_CHARS = 3;

package/package.json

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

package/src/contracts/getContractAddress.ts

@@ -46,8 +46,8 @@ const addresses: Record<
     '5': '0x4f7A657451358a22dc397d5eE7981FfC526cd856',
   },
   UniversalResolver: {
-    '1': '0xE4Acdd618deED4e6d2f03b9bf62dc6118FC9A4da',
-    '5': '0xA292E2E58d4ddEb29C33c63173d0E8B7a2A4c62e',
+    '1': '0xc0497e381f536be9ce14b0dd3817cbcae57d2f62',
+    '5': '0x56522d00c410a43bffdf00a9a569489297385790',
   },
   BulkRenewal: {
     '1': '0xfF252725f6122A92551A5FA9a6b6bf10eb0Be035',

package/src/functions/getNames.test.ts

@@ -1,12 +1,17 @@
+/* eslint-disable no-await-in-loop */
+import { ethers } from 'ethers'
 import { ENS } from '..'
 import setup from '../tests/setup'
 import { Name } from './getNames'
 import { names as wrappedNames } from '../../deploy/00_register_wrapped'
 
 let ensInstance: ENS
+let provider: ethers.providers.JsonRpcProvider
+let accounts: string[]
 
 beforeAll(async () => {
-  ;({ ensInstance } = await setup())
+  ;({ ensInstance, provider } = await setup())
+  accounts = await provider.listAccounts()
 })
 
 const testProperties = (obj: object, ...properties: string[]) =>
@@ -187,6 +192,70 @@ describe('getNames', () => {
     // the result here implies that the PCC expired name is not returned
     expect(pageOne).toHaveLength(nameCout - 1)
   })
+
+  describe('resolved addresses', () => {
+    /* eslint-disable @typescript-eslint/naming-convention */
+    const RESOLVED_ADDRESS_COUNT: { [key: string]: number } = {
+      '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266': 2,
+      '0x70997970C51812dc3A010C7d01b50e0d17dc79C8': 16,
+      '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC': 35,
+    }
+    /* eslint-enable @typescript-eslint/naming-convention */
+
+    it('should get the names that resolve to an address by labelName', async () => {
+      const ADDRESSES = [accounts[0], accounts[1], accounts[2]]
+      for (const ADDRESS of ADDRESSES) {
+        const pageOne = await ensInstance.getNames({
+          address: ADDRESS,
+          type: 'resolvedAddress',
+          orderBy: 'labelName',
+          orderDirection: 'asc',
+        })
+        expect(pageOne.length).toBe(RESOLVED_ADDRESS_COUNT[ADDRESS])
+        let prevLabelName = pageOne[0].labelName
+        for (const name of pageOne) {
+          expect(
+            !!name.labelName &&
+              prevLabelName &&
+              name.labelName >= prevLabelName,
+          ).toBe(true)
+          prevLabelName = name.labelName
+          const profile = await ensInstance.getProfile(name.name)
+          const eth = profile?.records?.coinTypes?.find(
+            (coin) => coin.coin === 'ETH',
+          )
+          expect((eth as any).addr).toBe(ADDRESS)
+        }
+      }
+    })
+
+    it('should get the names that resolve to an address by creationDate', async () => {
+      const ADDRESSES = [accounts[0], accounts[1], accounts[2]]
+      for (const ADDRESS of ADDRESSES) {
+        const pageOne = await ensInstance.getNames({
+          address: ADDRESS,
+          type: 'resolvedAddress',
+          orderBy: 'createdAt',
+          orderDirection: 'desc',
+        })
+        expect(pageOne.length).toBe(RESOLVED_ADDRESS_COUNT[ADDRESS])
+        let prevCreatedAt = pageOne[0].createdAt?.getTime()
+        for (const name of pageOne) {
+          expect(
+            !!name.createdAt &&
+              !!prevCreatedAt &&
+              name.createdAt.getTime() <= prevCreatedAt,
+          ).toBe(true)
+          prevCreatedAt = name.createdAt?.getTime()
+          const profile = await ensInstance.getProfile(name.name)
+          const eth = profile?.records?.coinTypes?.find(
+            (coin) => coin.coin === 'ETH',
+          )
+          expect((eth as any).addr).toBe(ADDRESS)
+        }
+      }
+    })
+  })
   describe('orderBy', () => {
     describe('registrations', () => {
       it('descending registrationDate', async () => {

package/src/functions/getNames.ts

@@ -22,12 +22,14 @@ export type Name = {
     expiryDate: Date
     registrationDate: Date
   }
+  owner?: string
+  manager?: string
   type: 'domain' | 'registration' | 'wrappedDomain'
 }
 
 type BaseParams = {
   address: string
-  type: 'registrant' | 'owner' | 'wrappedOwner' | 'all'
+  type: 'registrant' | 'owner' | 'wrappedOwner' | 'all' | 'resolvedAddress'
   page?: number
   pageSize?: number
   orderDirection?: 'asc' | 'desc'
@@ -55,12 +57,26 @@ type AllParams = {
   pageSize?: never
 }
 
+type ResolvedAddressParams = {
+  type: 'resolvedAddress'
+  orderBy?: 'labelName' | 'createdAt'
+  page?: never
+  pageSize?: never
+}
+
 type Params = BaseParams &
-  (RegistrantParams | OwnerParams | WrappedOwnerParams | AllParams)
+  (
+    | RegistrantParams
+    | OwnerParams
+    | WrappedOwnerParams
+    | AllParams
+    | ResolvedAddressParams
+  )
 
-const mapDomain = ({ name, ...domain }: Domain) => {
-  const decrypted = name ? decryptName(name) : undefined
+const mapDomain = (domain?: Domain) => {
+  if (!domain) return {}
 
+  const decrypted = domain.name ? decryptName(domain.name) : undefined
   return {
     ...domain,
     ...(domain.registration
@@ -112,16 +128,48 @@ const mapWrappedDomain = (wrappedDomain: WrappedDomain) => {
 
 const mapRegistration = (registration: Registration) => {
   const decrypted = decryptName(registration.domain.name!)
+  const domain = mapDomain(registration.domain)
   return {
     expiryDate: new Date(parseInt(registration.expiryDate) * 1000),
     registrationDate: new Date(parseInt(registration.registrationDate) * 1000),
-    ...registration.domain,
+    ...domain,
     name: decrypted,
     truncatedName: truncateFormat(decrypted),
     type: 'registration',
   }
 }
 
+const mapResolvedAddress = ({
+  wrappedDomain,
+  registration,
+  ...domain
+}: Domain) => {
+  const mappedDomain = mapDomain(domain)
+  if (wrappedDomain) {
+    const mappedWrappedDomain = mapWrappedDomain(wrappedDomain)
+    // If wrapped domain is expired then filter it out.
+    if (!mappedWrappedDomain) return null
+    return {
+      ...mappedDomain,
+      ...mappedWrappedDomain,
+      owner: wrappedDomain.owner.id,
+    }
+  }
+  return {
+    ...mappedDomain,
+    ...(registration
+      ? {
+          expiryDate: new Date(parseInt(registration.expiryDate) * 1000),
+          registrationDate: new Date(
+            parseInt(registration.registrationDate) * 1000,
+          ),
+          owner: registration.registrant.id,
+        }
+      : {}),
+    manager: domain.owner.id,
+  }
+}
+
 const getNames = async (
   { gqlInstance }: ENSArgs<'gqlInstance'>,
   {
@@ -192,6 +240,47 @@ const getNames = async (
       id: address,
       expiryDate: Math.floor(Date.now() / 1000) - 90 * 24 * 60 * 60,
     }
+  } else if (type === 'resolvedAddress') {
+    finalQuery = gqlInstance.gql`
+    query getNames(
+      $id: String!
+      $orderBy: Domain_orderBy
+      $orderDirection: OrderDirection
+    ) {
+      domains(
+        first: 1000
+        where: { 
+           resolvedAddress: $id 
+        }
+        orderBy: $orderBy
+        orderDirection: $orderDirection
+      ) {
+        ${domainQueryData}
+        owner {
+          id
+        }
+        registration {
+          registrationDate
+          expiryDate
+          registrant {
+            id
+          }
+        }
+        wrappedDomain {
+          expiryDate
+          fuses
+          owner {
+            id
+          }
+        }
+      }
+    }`
+
+    queryVars = {
+      id: address,
+      orderBy: orderBy === 'labelName' ? 'labelName' : 'createdAt',
+      orderDirection: orderDirection === 'asc' ? 'asc' : 'desc',
+    }
   } else if (type === 'owner') {
     if (typeof page !== 'number') {
       finalQuery = gqlInstance.gql`
@@ -398,6 +487,10 @@ const getNames = async (
       return a.createdAt.getTime() - b.createdAt.getTime()
     }) as Name[]
   }
+  if (type === 'resolvedAddress') {
+    return (response?.domains.map(mapResolvedAddress).filter((d: any) => d) ||
+      []) as Name[]
+  }
   if (type === 'owner') {
     return (account?.domains.map(mapDomain) || []) as Name[]
   }

package/src/functions/getWrapperData.test.ts

@@ -69,4 +69,22 @@ describe('getWrapperData', () => {
       expect(Number.isNaN(result.expiryDate?.getTime())).toBe(false)
     }
   })
+  it('should return correct expiry for large expiry', async () => {
+    const result = await ensInstance.getWrapperData('wrapped-big-duration.eth')
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result.expiryDate).toBeInstanceOf(Date)
+      expect(result.expiryDate!.getFullYear()).toBe(275760)
+      expect(Number.isNaN(result.expiryDate?.getTime())).toBe(false)
+    }
+  })
+  it('should return correct max expiry for expiry larger than maximum for date', async () => {
+    const result = await ensInstance.getWrapperData('wrapped-max-duration.eth')
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result.expiryDate).toBeInstanceOf(Date)
+      expect(result.expiryDate!.getFullYear()).toBe(275760)
+      expect(Number.isNaN(result.expiryDate?.getTime())).toBe(false)
+    }
+  })
 })

package/src/functions/getWrapperData.ts

@@ -1,5 +1,6 @@
 import { BigNumber } from '@ethersproject/bignumber'
 import { ENSArgs } from '../index'
+import { MAX_DATE_INT } from '../utils/consts'
 import { decodeFuses } from '../utils/fuses'
 import { namehash } from '../utils/normalise'
 
@@ -21,10 +22,16 @@ const decode = async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
 
     const fuseObj = decodeFuses(fuses)
 
-    const expiryDate =
-      expiry.gt(0) && expiry.lt(BigNumber.from(2).pow(32))
-        ? new Date(expiry.mul(1000).toNumber())
-        : undefined
+    let expiryDate: Date | undefined
+
+    if (expiry.gt(0)) {
+      const msBigNumber = expiry.mul(1000)
+      if (msBigNumber.gte(MAX_DATE_INT)) {
+        expiryDate = new Date(MAX_DATE_INT)
+      } else {
+        expiryDate = new Date(msBigNumber.toNumber())
+      }
+    }
 
     return {
       ...fuseObj,

package/src/utils/consts.ts

@@ -1,3 +1,4 @@
 export const EMPTY_ADDRESS = '0x0000000000000000000000000000000000000000'
 export const MAX_INT_64 = BigInt('18446744073709551615')
+export const MAX_DATE_INT = 8640000000000000
 export const MINIMUM_DOT_ETH_CHARS = 3