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

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

@@ -4,6 +4,7 @@ import type commitName from './commitName';
 import type createSubname from './createSubname';
 import type deleteSubname from './deleteSubname';
 import type getAvailable from './getAvailable';
+import type getDecryptedName from './getDecryptedName';
 import type getDNSOwner from './getDNSOwner';
 import type getExpiry from './getExpiry';
 import type { getHistory } from './getHistory';
@@ -43,6 +44,7 @@ declare type Function = {
     createSubname: typeof createSubname;
     deleteSubname: typeof deleteSubname;
     getAvailable: typeof getAvailable;
+    getDecryptedName: typeof getDecryptedName;
     getDNSOwner: typeof getDNSOwner;
     getExpiry: typeof getExpiry;
     getHistory: typeof getHistory;

package/dist/types/index.d.ts

@@ -133,10 +133,16 @@ export declare class ENS {
     withProvider: (provider: JsonRpcProvider) => ENS;
     batch: GeneratedBatchFunction<{
         raw: ({ multicallWrapper }: ENSArgs<"multicallWrapper">, ...items: BatchFunctionResult<RawFunction>[]) => Promise<{
+            passthrough: {
+                to: string;
+                data: string;
+            }[];
             to: string;
             data: string;
         }>;
-        decode: ({ multicallWrapper }: ENSArgs<"multicallWrapper">, data: string, ...items: BatchFunctionResult<RawFunction>[]) => Promise<any[] | undefined>;
+        decode: ({ multicallWrapper }: ENSArgs<"multicallWrapper">, data: string, passthrough: import("@ethersproject/abstract-provider").TransactionRequest & {
+            passthrough?: any;
+        }[], ...items: BatchFunctionResult<RawFunction>[]) => Promise<any[] | undefined>;
     }>;
     getProfile: (nameOrAddress: string, options?: ({
         contentHash?: boolean | undefined;
@@ -154,6 +160,7 @@ export declare class ENS {
         createdAt: string | null;
         address?: string | undefined;
         name?: string | null | undefined;
+        decryptedName?: string | null | undefined;
         match?: boolean | undefined;
         message?: string | undefined;
         records?: {
@@ -185,6 +192,7 @@ export declare class ENS {
         createdAt: string | null;
         address?: string | undefined;
         name?: string | null | undefined;
+        decryptedName?: string | null | undefined;
         match?: boolean | undefined;
         message?: string | undefined;
         records?: {
@@ -304,6 +312,22 @@ export declare class ENS {
             id: string;
             data: object;
         }[];
+    } | {
+        domain: {
+            type: "Transfer" | "NewOwner" | "NewResolver" | "NewTTL" | "ExpiryExtended" | "FusesSet" | "NameUnwrapped" | "NameWrapped" | "WrappedTransfer";
+            blockNumber: number;
+            transactionHash: string;
+            id: string;
+            data: object;
+        }[];
+        resolver: {
+            type: "AddrChanged" | "ContenthashChanged" | "InterfaceChanged" | "NameChanged" | "PubkeyChanged" | "TextChanged" | "VersionChanged" | "MulticoinAddrChanged" | "AbiChanged" | "AuthorisationChanged";
+            blockNumber: number;
+            transactionHash: string;
+            id: string;
+            data: object;
+        }[];
+        registration?: undefined;
     } | undefined>;
     getContentHash: GeneratedRawFunction<{
         raw: ({ contracts, universalWrapper }: ENSArgs<"contracts" | "universalWrapper">, name: string) => Promise<{
@@ -490,6 +514,13 @@ export declare class ENS {
         }>;
         decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<boolean | undefined>;
     }>;
+    getDecryptedName: GeneratedRawFunction<{
+        raw: ({ contracts }: ENSArgs<"contracts">, name: string, allowIncomplete?: boolean | undefined) => Promise<{
+            to: string;
+            data: string;
+        }>;
+        decode: ({ contracts, gqlInstance }: ENSArgs<"contracts" | "gqlInstance">, data: string, name: string, allowIncomplete?: boolean) => Promise<any>;
+    }>;
     universalWrapper: GeneratedRawFunction<{
         raw: ({ contracts }: ENSArgs<"contracts">, name: string, data: string) => Promise<{
             to: string;

package/dist/types/static.d.ts

@@ -1,4 +1,4 @@
-import type { StaticJsonRpcProvider } from '@ethersproject/providers/lib/url-json-rpc-provider';
+import type { StaticJsonRpcProvider } from '@ethersproject/providers';
 import { gql, GraphQLClient } from 'graphql-request';
 import { ENS, FunctionSubtype } from './index';
 import type Factories from './contracts/factories';

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

@@ -30,6 +30,7 @@ export declare const userSettableFuseEnum: {
 };
 export declare const fullFuseEnum: {
     CAN_DO_EVERYTHING: number;
+    IS_DOT_ETH: 131072;
     PARENT_CANNOT_CONTROL: number;
     CAN_EXTEND_EXPIRY: number;
     CANNOT_UNWRAP: 1;

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

@@ -1 +1,2 @@
 export declare const hexEncodeName: (name: string) => string;
+export declare const hexDecodeName: (hex: string) => string;

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

@@ -5,10 +5,11 @@ export declare function encodeLabelhash(hash: string): string;
 export declare function isEncodedLabelhash(hash: string): boolean;
 export declare function saveLabel(label: string): string;
 export declare function saveName(name: string): void;
-export declare function checkLabel(hash: string): string | undefined;
+export declare function checkLabel(hash: string): string;
 export declare function encodeLabel(label: any): any;
 export declare function parseName(name: string): string;
 export declare function checkIsDecrypted(string: string | string[]): boolean;
 export declare function decryptName(name: string): string;
 export declare const truncateUndecryptedName: (name: string) => string;
 export declare function checkLocalStorageSize(): string;
+export declare const getEncryptedLabelAmount: (name: string) => number;

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

@@ -3,6 +3,7 @@ declare const _default: (provider: Provider, ensData: any, func: {
     raw: (...args: any[]) => Promise<{
         to: string;
         data: string;
+        passthrough?: any;
     }>;
     decode: (...args: any[]) => Promise<any>;
 }, ...data: any[]) => Promise<any>;

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

@@ -5,4 +5,5 @@ declare type InputType = {
     info?: 'short' | 'supported' | 'unsupported';
 };
 export declare const parseInputType: (input: string) => InputType;
+export declare const checkIsDotEth: (labels: string[]) => boolean;
 export {};

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.42",
+  "version": "3.0.0-alpha.44",
   "description": "ENS javascript library for contract interaction",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.mjs",
@@ -69,7 +69,7 @@
   },
   "devDependencies": {
     "@ensdomains/buffer": "^0.0.13",
-    "@ensdomains/ens-contracts": "^0.0.16",
+    "@ensdomains/ens-contracts": "^0.0.17",
     "@ensdomains/ens-test-env": "0.3.7",
     "@ethersproject/abi": "^5.6.4",
     "@ethersproject/abstract-provider": "^5.7.0",

package/src/contracts/getContractAddress.ts

@@ -20,19 +20,19 @@ const addresses: Record<
     '1': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
     '3': '0xa5627AB7Ae47063B533622C34FEBDb52d3281dF8',
     '4': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
-    '5': '0xb7A1f9e633fdeaAa2ec44bE00a61a7Db9a733D70',
+    '5': '0x603A4F2e7615d0099244496883062bA2eFBbeaf0',
   },
   Multicall: '0xcA11bde05977b3631167028862bE2a173976CA11',
   NameWrapper: {
     '1': '0x0000000000000000000000000000000000000000',
     '3': '0xF82155e2a43Be0871821E9654Fc8Ae894FB8307C',
     '4': '0x0000000000000000000000000000000000000000',
-    '5': '0xEe1F756aCde7E81B2D8cC6aB3c8A1E2cE6db0F39',
+    '5': '0x060f1546642E67c485D56248201feA2f9AB1803C',
   },
   PublicResolver: {
     '1': '0x4976fb03C32e5B8cfe2b6cCB31c09Ba78EBaBa41',
     '3': '0x13F0659Ee6bb7484C884FEeFb7F75C93951ef837',
-    '5': '0x2800Ec5BAB9CE9226d19E0ad5BC607e3cfC4347E',
+    '5': '0x19c2d5D0f035563344dBB7bE5fD09c8dad62b001',
   },
   ENSRegistry: {
     '1': '0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e',

package/src/functions/batch.ts

@@ -1,3 +1,4 @@
+import { TransactionRequest } from '@ethersproject/abstract-provider'
 import { BatchFunctionResult, ENSArgs, RawFunction } from '..'
 
 const raw = async (
@@ -12,21 +13,30 @@ const raw = async (
       return rawRef(...args)
     }),
   )
-  return multicallWrapper.raw(rawDataArr)
+  const response = await multicallWrapper.raw(rawDataArr)
+  return { ...response, passthrough: rawDataArr }
 }
 
 const decode = async (
   { multicallWrapper }: ENSArgs<'multicallWrapper'>,
   data: string,
+  passthrough: TransactionRequest & { passthrough?: any }[],
   ...items: BatchFunctionResult<RawFunction>[]
 ): Promise<any[] | undefined> => {
-  const response = await multicallWrapper.decode(data)
+  const response = await multicallWrapper.decode(data, passthrough)
   if (!response) return
 
   return Promise.all(
-    response.map((ret: any, i: number) =>
-      items[i].decode(ret.returnData, ...items[i].args),
-    ),
+    response.map((ret: any, i: number) => {
+      if (passthrough[i].passthrough) {
+        return items[i].decode(
+          ret.returnData,
+          passthrough[i].passthrough,
+          ...items[i].args,
+        )
+      }
+      return items[i].decode(ret.returnData, ...items[i].args)
+    }),
   )
 }
 

package/src/functions/ccip.test.ts

@@ -0,0 +1,62 @@
+import dotenv from 'dotenv'
+import { ENS } from '..'
+import setup from '../tests/setup'
+
+dotenv.config()
+
+let ensInstance: ENS
+
+beforeAll(async () => {
+  ;({ ensInstance } = await setup(true))
+})
+
+jest.setTimeout(20000)
+
+describe('CCIP', () => {
+  describe('getProfile', () => {
+    it('should return a profile from a ccip-read name', async () => {
+      const result = await ensInstance.getProfile('1.offchainexample.eth', {
+        fallback: {
+          texts: ['email', 'description'],
+          contentHash: true,
+          coinTypes: ['LTC', '60'],
+        },
+      })
+      expect(result).toBeTruthy()
+      if (result) {
+        expect(result.address).toBe(
+          '0x41563129cDbbD0c5D3e1c86cf9563926b243834d',
+        )
+      }
+    })
+  })
+  describe('batch', () => {
+    it('allows batch ccip', async () => {
+      const result = await ensInstance.batch(
+        ensInstance.getAddr.batch('1.offchainexample.eth'),
+        ensInstance.getAddr.batch('1.offchainexample.eth', 'LTC'),
+        ensInstance.getText.batch('1.offchainexample.eth', 'email'),
+      )
+      expect(result).toBeTruthy()
+      if (result) {
+        expect(result[0]).toBe('0x41563129cDbbD0c5D3e1c86cf9563926b243834d')
+        expect(result[1]).toStrictEqual({
+          coin: 'LTC',
+          addr: 'MQMcJhpWHYVeQArcZR3sBgyPZxxRtnH441',
+        })
+        expect(result[2]).toBe('nick@ens.domains')
+      }
+    })
+    it('allows nested batch ccip', async () => {
+      const result = await ensInstance.batch(
+        ensInstance.batch.batch(
+          ensInstance.getAddr.batch('1.offchainexample.eth'),
+        ),
+      )
+      expect(result).toBeTruthy()
+      if (result) {
+        expect(result[0]![0]).toBe('0x41563129cDbbD0c5D3e1c86cf9563926b243834d')
+      }
+    })
+  })
+})

package/src/functions/createSubname.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 { CombinedFuseInput, encodeFuses } from '../utils/fuses'

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,7 +1,8 @@
-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'
+import { checkIsDotEth } from '../utils/validation'
 
 type ContractOption = 'registrar' | 'nameWrapper'
 
@@ -56,7 +57,7 @@ const getContractToUse = (
   labels: string[],
 ) => {
   if (contract) return contract
-  if (labels.length === 2 && labels[1] === 'eth') {
+  if (checkIsDotEth(labels)) {
     return 'registrar'
   }
   return 'nameWrapper'

package/src/functions/getHistory.test.ts

@@ -35,4 +35,15 @@ describe('getHistory', () => {
       expect(result).toHaveProperty('registration')
     }
   })
+  it('should return the history of a subname', async () => {
+    const result = await ensInstance.getHistory(
+      'test.wrapped-with-subnames.eth',
+    )
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result).toHaveProperty('domain')
+      expect(result).toHaveProperty('resolver')
+      expect(result).not.toHaveProperty('registration')
+    }
+  })
 })

package/src/functions/getHistory.ts

@@ -2,7 +2,6 @@ import { formatsByCoinType } from '@ensdomains/address-encoder'
 import { hexStripZeros } from '@ethersproject/bytes'
 import { ENSArgs } from '..'
 import { decodeContenthash } from '../utils/contentHash'
-import { labelhash } from '../utils/labels'
 import { namehash } from '../utils/normalise'
 import {
   AbiChanged,
@@ -28,6 +27,7 @@ import {
   VersionChanged,
   WrappedTransfer,
 } from '../utils/subgraph-types'
+import { checkIsDotEth } from '../utils/validation'
 
 type DomainEvent =
   | 'NewOwner'
@@ -154,7 +154,7 @@ export async function getHistory(
 ) {
   const { client } = gqlInstance
   const query = gqlInstance.gql`
-      query getHistory($namehash: String!, $labelhash: String!) {
+      query getHistory($namehash: String!) {
         domain(id: $namehash) {
           events {
             id
@@ -275,14 +275,12 @@ export async function getHistory(
       }
       `
 
-  const label = name.split('.')[0]
-
   const nameHash = namehash(name)
-  const labelHash = labelhash(label)
+  const labels = name.split('.')
+  const is2ldEth = checkIsDotEth(labels)
 
   const response = await client.request(query, {
     namehash: nameHash,
-    labelhash: labelHash,
   })
   const domain = response?.domain
 
@@ -290,12 +288,10 @@ export async function getHistory(
 
   const {
     events: domainEvents,
-    registration: { events: registrationEvents },
     resolver: { events: resolverEvents },
   } = domain
 
   const domainHistory = mapEvents(domainEvents, 'Domain')
-  const registrationHistory = mapEvents(registrationEvents, 'Registration')
   const resolverHistory = mapEvents(
     // remove duplicate events for ETH cointype
     resolverEvents.filter(
@@ -304,9 +300,20 @@ export async function getHistory(
     'Resolver',
   )
 
+  if (is2ldEth) {
+    const {
+      registration: { events: registrationEvents },
+    } = domain
+    const registrationHistory = mapEvents(registrationEvents, 'Registration')
+    return {
+      domain: domainHistory,
+      registration: registrationHistory,
+      resolver: resolverHistory,
+    }
+  }
+
   return {
     domain: domainHistory,
-    registration: registrationHistory,
     resolver: resolverHistory,
   }
 }

package/src/functions/getNames.test.ts

@@ -29,7 +29,7 @@ const letterItems = [
 ]
 
 const domainLetterItems = [
-  '[',
+  ...Array(3).fill('['),
   'x',
   'w',
   't',

package/src/functions/getOwner.ts

@@ -1,9 +1,10 @@
-import { defaultAbiCoder } from '@ethersproject/abi/lib/abi-coder'
-import type { Result } from '@ethersproject/abi/lib/coders/abstract-coder'
+import type { Result } from '@ethersproject/abi'
+import { defaultAbiCoder } from '@ethersproject/abi'
 import { hexStripZeros } from '@ethersproject/bytes'
 import { ENSArgs } from '..'
 import { labelhash } from '../utils/labels'
 import { namehash as makeNamehash } from '../utils/normalise'
+import { checkIsDotEth } from '../utils/validation'
 
 type Owner = {
   registrant?: string
@@ -87,7 +88,7 @@ const raw = async (
 
   const data: { to: string; data: string }[] = [registryData, nameWrapperData]
 
-  if (labels.length === 2 && labels[1] === 'eth') {
+  if (checkIsDotEth(labels)) {
     data.push(registrarData)
   }
 

package/src/functions/getPrice.ts

@@ -1,5 +1,5 @@
-import { defaultAbiCoder } from '@ethersproject/abi/lib/abi-coder'
-import { BigNumber } from '@ethersproject/bignumber/lib/bignumber'
+import { defaultAbiCoder } from '@ethersproject/abi'
+import { BigNumber } from '@ethersproject/bignumber'
 import { ENSArgs } from '..'
 
 const raw = async (

package/src/functions/getProfile.test.ts

@@ -119,6 +119,13 @@ describe('getProfile', () => {
         deploymentAddresses.LegacyPublicResolver,
       )
     })
+    it('should return the decoded name for a name with encoded labels', async () => {
+      const result = await ensInstance.getProfile(
+        '[9dd2c369a187b4e6b9c402f030e50743e619301ea62aa4c0737d4ef7e10a3d49].with-subnames.eth',
+      )
+      expect(result).toBeDefined()
+      expect(result?.decryptedName).toBe('xyz.with-subnames.eth')
+    })
     it('should return undefined for an unregistered name', async () => {
       const result = await ensInstance.getProfile('test123123123cool.eth')
       expect(result).toBeUndefined()