@ensdomains/ensjs 3.0.0-alpha.41 → 3.0.0-alpha.43

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

@@ -1,8 +1,6 @@
-import { BigNumberish } from '@ethersproject/bignumber/lib/bignumber';
 import type { PublicResolver } from '../generated';
-import { FuseOptions } from './fuses';
+import { CombinedFuseInput } from './fuses';
 import { RecordOptions } from './recordHelpers';
-export declare const MAX_INT_64: bigint;
 export declare type BaseRegistrationParams = {
     owner: string;
     duration: number;
@@ -10,16 +8,14 @@ export declare type BaseRegistrationParams = {
     resolverAddress?: string;
     records?: RecordOptions;
     reverseRecord?: boolean;
-    fuses?: FuseOptions;
-    wrapperExpiry?: BigNumberish;
+    fuses?: CombinedFuseInput['child'];
 };
 export declare type RegistrationParams = Omit<BaseRegistrationParams, 'resolverAddress'> & {
     name: string;
     resolver: PublicResolver;
 };
-export declare type CommitmentParams = Omit<RegistrationParams, 'secret' | 'wrapperExpiry'> & {
+export declare type CommitmentParams = Omit<RegistrationParams, 'secret'> & {
     secret?: string;
-    wrapperExpiry?: BigNumberish;
 };
 export declare type RegistrationTuple = [
     name: string,
@@ -29,31 +25,17 @@ export declare type RegistrationTuple = [
     resolver: string,
     data: string[],
     reverseRecord: boolean,
-    fuses: string,
-    wrapperExpiry: BigNumberish
-];
-export declare type CommitmentTuple = [
-    labelhash: string,
-    owner: string,
-    duration: number,
-    resolver: string,
-    data: string[],
-    secret: string,
-    reverseRecord: boolean,
-    fuses: string,
-    wrapperExpiry: BigNumberish
+    ownerControlledFuses: number
 ];
 export declare const randomSecret: () => string;
-export declare const makeCommitmentData: ({ name, owner, duration, resolver, records, reverseRecord, fuses, wrapperExpiry, secret, }: Omit<RegistrationParams, "secret" | "wrapperExpiry"> & {
+export declare const makeCommitmentData: ({ name, owner, duration, resolver, records, reverseRecord, fuses, secret, }: Omit<RegistrationParams, "secret"> & {
     secret?: string | undefined;
-    wrapperExpiry?: BigNumberish | undefined;
 } & {
     secret: string;
-}) => CommitmentTuple;
+}) => RegistrationTuple;
 export declare const makeRegistrationData: (params: RegistrationParams) => RegistrationTuple;
-export declare const _makeCommitment: (params: CommitmentTuple) => string;
+export declare const _makeCommitment: (params: RegistrationTuple) => string;
 export declare const makeCommitment: ({ secret, ...inputParams }: CommitmentParams) => {
     secret: string;
     commitment: string;
-    wrapperExpiry: BigNumberish;
 };

package/dist/types/utils/subgraph-types.d.ts

@@ -0,0 +1,284 @@
+export declare type Maybe<T> = T | null;
+export declare type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export declare type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export declare type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+/** All built-in and custom scalars, mapped to their actual values */
+export declare type Scalars = {
+    ID: string;
+    String: string;
+    Boolean: boolean;
+    Int: number;
+    Float: number;
+    Bytes: string;
+    BigInt: string;
+};
+export declare type Domain = {
+    __typename?: 'Domain';
+    id: Scalars['ID'];
+    name?: Maybe<Scalars['String']>;
+    labelName?: Maybe<Scalars['String']>;
+    labelhash?: Maybe<Scalars['Bytes']>;
+    parent?: Maybe<Domain>;
+    subdomains: Array<Domain>;
+    subdomainCount: Scalars['Int'];
+    resolvedAddress?: Maybe<Account>;
+    owner: Account;
+    resolver?: Maybe<Resolver>;
+    ttl?: Maybe<Scalars['BigInt']>;
+    isMigrated: Scalars['Boolean'];
+    createdAt: Scalars['BigInt'];
+    events: Array<DomainEvent>;
+    registration?: Maybe<Registration>;
+    wrappedDomain?: Maybe<WrappedDomain>;
+};
+export declare type DomainEvent = {
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+};
+export declare type Transfer = DomainEvent & {
+    __typename?: 'Transfer';
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    owner: Account;
+};
+export declare type NewOwner = DomainEvent & {
+    __typename?: 'NewOwner';
+    id: Scalars['ID'];
+    parentDomain: Domain;
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    owner: Account;
+};
+export declare type NewResolver = DomainEvent & {
+    __typename?: 'NewResolver';
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    resolver: Resolver;
+};
+export declare type NewTtl = DomainEvent & {
+    __typename?: 'NewTTL';
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    ttl: Scalars['BigInt'];
+};
+export declare type WrappedTransfer = DomainEvent & {
+    __typename?: 'WrappedTransfer';
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    owner: Account;
+};
+export declare type NameWrapped = DomainEvent & {
+    __typename?: 'NameWrapped';
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    name: Scalars['String'];
+    fuses: Scalars['Int'];
+    owner: Account;
+    expiryDate: Scalars['BigInt'];
+};
+export declare type NameUnwrapped = DomainEvent & {
+    __typename?: 'NameUnwrapped';
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    owner: Account;
+};
+export declare type FusesSet = DomainEvent & {
+    __typename?: 'FusesSet';
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    fuses: Scalars['Int'];
+};
+export declare type ExpiryExtended = DomainEvent & {
+    __typename?: 'ExpiryExtended';
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    expiryDate: Scalars['BigInt'];
+};
+export declare type Registration = {
+    __typename?: 'Registration';
+    id: Scalars['ID'];
+    domain: Domain;
+    registrationDate: Scalars['BigInt'];
+    expiryDate: Scalars['BigInt'];
+    cost?: Maybe<Scalars['BigInt']>;
+    registrant: Account;
+    labelName?: Maybe<Scalars['String']>;
+    events: Array<RegistrationEvent>;
+};
+export declare type RegistrationEvent = {
+    id: Scalars['ID'];
+    registration: Registration;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+};
+export declare type NameRegistered = RegistrationEvent & {
+    __typename?: 'NameRegistered';
+    id: Scalars['ID'];
+    registration: Registration;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    registrant: Account;
+    expiryDate: Scalars['BigInt'];
+};
+export declare type NameRenewed = RegistrationEvent & {
+    __typename?: 'NameRenewed';
+    id: Scalars['ID'];
+    registration: Registration;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    expiryDate: Scalars['BigInt'];
+};
+export declare type NameTransferred = RegistrationEvent & {
+    __typename?: 'NameTransferred';
+    id: Scalars['ID'];
+    registration: Registration;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    newOwner: Account;
+};
+export declare type WrappedDomain = {
+    __typename?: 'WrappedDomain';
+    id: Scalars['ID'];
+    domain: Domain;
+    expiryDate: Scalars['BigInt'];
+    fuses: Scalars['Int'];
+    owner: Account;
+    name?: Maybe<Scalars['String']>;
+};
+export declare type Account = {
+    __typename?: 'Account';
+    id: Scalars['ID'];
+    domains: Array<Domain>;
+    wrappedDomains?: Maybe<Array<WrappedDomain>>;
+    registrations?: Maybe<Array<Registration>>;
+};
+export declare type Resolver = {
+    __typename?: 'Resolver';
+    id: Scalars['ID'];
+    domain?: Maybe<Domain>;
+    address: Scalars['Bytes'];
+    addr?: Maybe<Account>;
+    contentHash?: Maybe<Scalars['Bytes']>;
+    texts?: Maybe<Array<Scalars['String']>>;
+    coinTypes?: Maybe<Array<Scalars['BigInt']>>;
+    events: Array<ResolverEvent>;
+};
+export declare type ResolverEvent = {
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+};
+export declare type AddrChanged = ResolverEvent & {
+    __typename?: 'AddrChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    addr: Account;
+};
+export declare type MulticoinAddrChanged = ResolverEvent & {
+    __typename?: 'MulticoinAddrChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    coinType: Scalars['BigInt'];
+    addr: Scalars['Bytes'];
+};
+export declare type NameChanged = ResolverEvent & {
+    __typename?: 'NameChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    name: Scalars['String'];
+};
+export declare type AbiChanged = ResolverEvent & {
+    __typename?: 'AbiChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    contentType: Scalars['BigInt'];
+};
+export declare type PubkeyChanged = ResolverEvent & {
+    __typename?: 'PubkeyChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    x: Scalars['Bytes'];
+    y: Scalars['Bytes'];
+};
+export declare type TextChanged = ResolverEvent & {
+    __typename?: 'TextChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    key: Scalars['String'];
+    value?: Maybe<Scalars['String']>;
+};
+export declare type ContenthashChanged = ResolverEvent & {
+    __typename?: 'ContenthashChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    hash: Scalars['Bytes'];
+};
+export declare type InterfaceChanged = ResolverEvent & {
+    __typename?: 'InterfaceChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    interfaceID: Scalars['Bytes'];
+    implementer: Scalars['Bytes'];
+};
+export declare type AuthorisationChanged = ResolverEvent & {
+    __typename?: 'AuthorisationChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    owner: Scalars['Bytes'];
+    target: Scalars['Bytes'];
+    isAuthorized: Scalars['Boolean'];
+};
+export declare type VersionChanged = ResolverEvent & {
+    __typename?: 'VersionChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    version: Scalars['BigInt'];
+};

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

@@ -1,4 +1,4 @@
-import { BigNumber } from '@ethersproject/bignumber/lib/bignumber';
+import { BigNumber } from '@ethersproject/bignumber';
 import { ENSArgs } from '../index';
 export declare type Expiry = string | number | Date | BigNumber;
 export declare const MAX_EXPIRY: BigNumber;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ensdomains/ensjs",
-  "version": "3.0.0-alpha.41",
+  "version": "3.0.0-alpha.43",
   "description": "ENS javascript library for contract interaction",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.mjs",
@@ -68,10 +68,9 @@
     "traverse": "^0.6.6"
   },
   "devDependencies": {
-    "ethers": "^5.7.2",
     "@ensdomains/buffer": "^0.0.13",
-    "@ensdomains/ens-contracts": "^0.0.15",
-    "@ensdomains/ens-test-env": "0.3.6",
+    "@ensdomains/ens-contracts": "^0.0.16",
+    "@ensdomains/ens-test-env": "0.3.7",
     "@ethersproject/abi": "^5.6.4",
     "@ethersproject/abstract-provider": "^5.7.0",
     "@ethersproject/abstract-signer": "^5.7.0",
@@ -98,6 +97,7 @@
     "dotenv": "^16.0.0",
     "esbuild": "^0.15.6",
     "eslint-plugin-jest": "^27.0.1",
+    "ethers": "^5.7.2",
     "ganache": "^7.4.0",
     "glob": "^8.0.3",
     "hardhat": "2.10.2",
@@ -133,7 +133,7 @@
   },
   "scripts": {
     "tenv": "ens-test-env -a",
-    "denv": "pnpm tenv start -ns -nb --extra-time 11368000",
+    "denv": "pnpm tenv start -ns -nb --extra-time 11368000 --verbosity 1",
     "generate-types": "ts-node scripts/runTypechain.ts",
     "generate-abis": "hardhat export-abi",
     "start": "ts-node --files src/index.test.ts",

package/src/contracts/getContractAddress.ts

@@ -20,19 +20,19 @@ const addresses: Record<
     '1': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
     '3': '0xa5627AB7Ae47063B533622C34FEBDb52d3281dF8',
     '4': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
-    '5': '0x9C51161bA2FB02Cc0a403332B607117685f34831',
+    '5': '0xb7A1f9e633fdeaAa2ec44bE00a61a7Db9a733D70',
   },
   Multicall: '0xcA11bde05977b3631167028862bE2a173976CA11',
   NameWrapper: {
     '1': '0x0000000000000000000000000000000000000000',
     '3': '0xF82155e2a43Be0871821E9654Fc8Ae894FB8307C',
     '4': '0x0000000000000000000000000000000000000000',
-    '5': '0x582224b8d4534F4749EFA4f22eF7241E0C56D4B8',
+    '5': '0xEe1F756aCde7E81B2D8cC6aB3c8A1E2cE6db0F39',
   },
   PublicResolver: {
     '1': '0x4976fb03C32e5B8cfe2b6cCB31c09Ba78EBaBa41',
     '3': '0x13F0659Ee6bb7484C884FEeFb7F75C93951ef837',
-    '5': '0xE264d5bb84bA3b8061ADC38D3D76e6674aB91852',
+    '5': '0x2800Ec5BAB9CE9226d19E0ad5BC607e3cfC4347E',
   },
   ENSRegistry: {
     '1': '0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e',
@@ -43,7 +43,7 @@ const addresses: Record<
   ReverseRegistrar: {
     '1': '0x084b1c3C81545d370f3634392De611CaaBFf8148',
     '3': '0x806246b52f8cB61655d3038c58D2f63Aa55d4edE',
-    '5': '0xD5610A08E370051a01fdfe4bB3ddf5270af1aA48',
+    '5': '0x9a879320A9F7ad2BBb02063d67baF5551D6BD8B0',
   },
   UniversalResolver: {
     '1': '0x74E20Bd2A1fE0cdbe45b9A1d89cb7e0a45b36376',

package/src/functions/commitName.test.ts

@@ -31,7 +31,6 @@ describe('commitName', () => {
     expect(popTx).toBeTruthy()
     expect(customData).toHaveProperty('secret')
     expect(customData).toHaveProperty('commitment')
-    expect(customData).toHaveProperty('wrapperExpiry')
 
     const tx = await provider.getSigner().sendTransaction(popTx)
     await tx.wait()
@@ -47,11 +46,9 @@ describe('commitName', () => {
       owner: accounts[1],
       addressOrIndex: accounts[1],
       secret,
-      wrapperExpiry: 100000,
     })
     await tx.wait()
     expect(tx.customData).toBeTruthy()
-    expect(tx.customData!.wrapperExpiry).toBe(100000)
     expect(tx.customData!.secret).toBe(secret)
 
     const controller = await ensInstance.contracts!.getEthRegistrarController()!

package/src/functions/commitName.ts

@@ -22,7 +22,7 @@ export default async function (
     undefined,
     resolverAddress,
   )
-  const { secret, commitment, wrapperExpiry } = makeCommitment({
+  const { secret, commitment } = makeCommitment({
     name,
     resolver,
     ...params,
@@ -33,7 +33,6 @@ export default async function (
     customData: {
       secret,
       commitment,
-      wrapperExpiry,
     },
   }
 }

package/src/functions/createSubname.ts

@@ -1,8 +1,7 @@
-import { BigNumber } from '@ethersproject/bignumber/lib/bignumber'
+import { BigNumber } from '@ethersproject/bignumber'
 import { keccak256 as solidityKeccak256 } from '@ethersproject/solidity'
 import { ENSArgs } from '..'
-import { FuseOptions } from '../utils/fuses'
-import generateFuseInput from '../utils/generateFuseInput'
+import { CombinedFuseInput, encodeFuses } from '../utils/fuses'
 import { namehash } from '../utils/normalise'
 import { Expiry, makeExpiry, wrappedLabelLengthCheck } from '../utils/wrapper'
 
@@ -14,7 +13,7 @@ type BaseArgs = {
 
 type NameWrapperArgs = {
   contract: 'nameWrapper'
-  fuses?: FuseOptions
+  fuses?: CombinedFuseInput
   expiry?: Expiry
 } & BaseArgs
 
@@ -70,8 +69,8 @@ export default async function (
 
       const generatedFuses =
         'fuses' in wrapperArgs && wrapperArgs.fuses
-          ? generateFuseInput(wrapperArgs.fuses)
-          : '0'
+          ? encodeFuses(wrapperArgs.fuses)
+          : 0
 
       return nameWrapper.populateTransaction.setSubnodeRecord(
         parentNodehash,

package/src/functions/getDecryptedName.test.ts

@@ -0,0 +1,49 @@
+import { ENS } from '../index'
+import setup from '../tests/setup'
+
+let ensInstance: ENS
+
+beforeAll(async () => {
+  ;({ ensInstance } = await setup())
+})
+
+describe('getDecryptedName', () => {
+  it('should decrypt a wrapped name with on-chain data', async () => {
+    const result = await ensInstance.getDecryptedName(
+      '[9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb658].wrapped-with-subnames.eth',
+    )
+    expect(result).toBeDefined()
+    expect(result).toBe('test.wrapped-with-subnames.eth')
+  })
+  it('should decrypt a name via namehash lookup', async () => {
+    const result = await ensInstance.getDecryptedName(
+      '[f81b517a242b218999ec8eec0ea6e2ddbef2a367a14e93f4a32a39e260f686ad].eth',
+    )
+    expect(result).toBeDefined()
+    expect(result).toBe('test123.eth')
+  })
+  it('should decrypt a name via labelhash lookup', async () => {
+    const result = await ensInstance.getDecryptedName(
+      '[4d2920c35d976f8478bee89292ba85074d1bbea73f1571363b41a1629e1bac68].with-unknown-subnames.eth',
+    )
+    expect(result).toBeDefined()
+    expect(result).toBe('aaa123.with-unknown-subnames.eth')
+  })
+  it('should partially decrypt a name when allowIncomplete is true', async () => {
+    const result = await ensInstance.getDecryptedName(
+      '[7bffb6e3ebf801bbc438fea5c11d957ba49978bdc8d52b71cba974139d22edea].[6c14e1739568670447af1d5af8a571008f7a582068af18bcd7ac2dbc13bb37c1].eth',
+      true,
+    )
+    expect(result).toBeDefined()
+    expect(result).toBe(
+      '[7bffb6e3ebf801bbc438fea5c11d957ba49978bdc8d52b71cba974139d22edea].with-unknown-subnames.eth',
+    )
+  })
+  it('should not partially decrypt a name when allowIncomplete is false', async () => {
+    const result = await ensInstance.getDecryptedName(
+      '[7bffb6e3ebf801bbc438fea5c11d957ba49978bdc8d52b71cba974139d22edea].[6c14e1739568670447af1d5af8a571008f7a582068af18bcd7ac2dbc13bb37c1].eth',
+      false,
+    )
+    expect(result).toBeUndefined()
+  })
+})

package/src/functions/getDecryptedName.ts

@@ -0,0 +1,119 @@
+import { hexStripZeros } from '@ethersproject/bytes'
+import { ENSArgs } from '../index'
+import { hexDecodeName } from '../utils/hexEncodedName'
+import {
+  checkIsDecrypted,
+  decodeLabelhash,
+  getEncryptedLabelAmount,
+  isEncodedLabelhash,
+} from '../utils/labels'
+import { namehash } from '../utils/normalise'
+
+const raw = async (
+  { contracts }: ENSArgs<'contracts'>,
+  name: string,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  allowIncomplete?: boolean,
+) => {
+  const nameWrapper = await contracts?.getNameWrapper()!
+
+  return {
+    to: nameWrapper.address,
+    data: nameWrapper.interface.encodeFunctionData('names', [namehash(name)]),
+  }
+}
+
+const generateNameQuery = (labels: string[]) => {
+  let query = ''
+
+  for (let i = 0; i < labels.length; i += 1) {
+    const label = labels[i]
+    if (isEncodedLabelhash(label)) {
+      query += `
+        label${i}: domains(where: { labelhash: "${decodeLabelhash(
+        label,
+      ).toLowerCase()}", labelName_not: null }) {
+          labelName
+        }
+      `
+    }
+  }
+
+  return query
+}
+
+const decode = async (
+  { contracts, gqlInstance }: ENSArgs<'contracts' | 'gqlInstance'>,
+  data: string,
+  name: string,
+  allowIncomplete: boolean = false,
+) => {
+  if (data !== null) {
+    const nameWrapper = await contracts?.getNameWrapper()!
+    try {
+      const result = nameWrapper.interface.decodeFunctionResult('names', data)
+      if (hexStripZeros(result['0']) !== '0x') {
+        const decoded = hexDecodeName(result['0'])
+        if (decoded && decoded !== '.') return decoded
+      }
+    } catch (e: any) {
+      console.error('Error decoding name: ', e)
+      return
+    }
+  }
+
+  if (checkIsDecrypted(name)) return name
+  // if the name isn't wrapped, try to fetch the name from an existing Domain entity
+  // also try to fetch the label names from any Domain entities that have a corresponding labelhash
+  const labels = name.split('.')
+  const decryptedNameQuery = gqlInstance.gql`
+        query decodedName($id: String!) {
+          namehashLookup: domains(where: { id: $id }) {
+            name
+          }
+          ${generateNameQuery(labels)}
+        }
+      `
+
+  const decryptedNameResult = await gqlInstance.client.request(
+    decryptedNameQuery,
+    {
+      id: namehash(name),
+    },
+  )
+
+  if (!decryptedNameResult) return
+
+  const namehashLookupResult = decryptedNameResult?.namehashLookup[0]?.name
+  let bestResult: string | undefined = namehashLookupResult
+  if (namehashLookupResult && checkIsDecrypted(namehashLookupResult)) {
+    return namehashLookupResult
+  }
+
+  const { namehashLookup: _, ...labelNames } = decryptedNameResult
+  if (Object.keys(labelNames).length !== 0) {
+    for (const [key, value] of Object.entries<[{ labelName?: string }]>(
+      labelNames,
+    )) {
+      if (value.length && value[0].labelName) {
+        labels[parseInt(key.replace('label', ''))] = value[0].labelName
+      }
+    }
+    const labelLookupResult = labels.join('.')
+    if (
+      !namehashLookupResult ||
+      getEncryptedLabelAmount(namehashLookupResult) >
+        getEncryptedLabelAmount(labelLookupResult)
+    )
+      bestResult = labelLookupResult
+  }
+
+  if (!bestResult || (!allowIncomplete && !checkIsDecrypted(bestResult))) return
+
+  return bestResult
+}
+
+export default {
+  raw,
+  decode,
+}

package/src/functions/getExpiry.ts

@@ -1,4 +1,4 @@
-import { BigNumber } from '@ethersproject/bignumber/lib/bignumber'
+import { BigNumber } from '@ethersproject/bignumber'
 import { keccak256 as solidityKeccak256 } from '@ethersproject/solidity'
 import { ENSArgs } from '..'
 import { namehash } from '../utils/normalise'