@ensdomains/ensjs 3.0.0-alpha.5 → 3.0.0-alpha.8

package/dist/esm/index.d.ts

@@ -1,7 +1,18 @@
-import { ethers, Signer } from 'ethers';
+import { JsonRpcSigner } from '@ethersproject/providers';
+import { ContractTransaction, ethers, PopulatedTransaction } from 'ethers';
 import ContractManager from './contracts';
 import { getContractAddress as _getContractAddress } from './contracts/getContractAddress';
 import { SupportedNetworkId } from './contracts/types';
+import type burnFuses from './functions/burnFuses';
+import type createSubname from './functions/createSubname';
+import type deleteSubname from './functions/deleteSubname';
+import type setName from './functions/setName';
+import type setRecords from './functions/setRecords';
+import type setResolver from './functions/setResolver';
+import type transferName from './functions/transferName';
+import type transferSubname from './functions/transferSubname';
+import type unwrapName from './functions/unwrapName';
+import type wrapName from './functions/wrapName';
 import GqlManager from './GqlManager';
 declare type ENSOptions = {
     graphURI?: string | null;
@@ -10,7 +21,7 @@ declare type ENSOptions = {
 export declare type InternalENS = {
     options?: ENSOptions;
     provider?: ethers.providers.Provider;
-    signer: Signer;
+    signer: JsonRpcSigner;
     graphURI?: string | null;
 } & ENS;
 export declare type ENSArgs<K extends keyof InternalENS> = {
@@ -20,8 +31,13 @@ declare type OmitFirstArg<F> = F extends (x: any, ...args: infer P) => infer R ?
 declare type OmitFirstTwoArgs<F> = F extends (x: any, y: any, ...args: infer P) => infer R ? (...args: P) => R : never;
 declare type WriteOptions = {
     addressOrIndex?: string | number;
-    signer?: Signer;
+    signer?: JsonRpcSigner;
 };
+declare type OptionalWriteOptions<F> = F extends (x: any, arg_0: infer Z, options?: infer P) => infer R ? (name: Z, options?: P & WriteOptions) => R : F extends (x: any, arg_0: infer Z, options: infer P) => infer R ? (name: Z, options: P & WriteOptions) => R : never;
+interface WriteFunction<F extends (...args: any) => any> extends Function {
+    (...args: Parameters<OptionalWriteOptions<F>>): Promise<ContractTransaction>;
+    populateTransaction: (...args: Parameters<OptionalWriteOptions<F>>) => Promise<PopulatedTransaction>;
+}
 export declare type RawFunction = {
     raw: (...args: any[]) => Promise<{
         to: string;
@@ -117,11 +133,13 @@ export declare class ENS {
         }>;
         decode: ({ multicallWrapper }: ENSArgs<"multicallWrapper">, data: string, ...items: BatchFunctionResult<RawFunction>[]) => Promise<any[] | undefined>;
     }>;
-    getProfile: (nameOrAddress: string, options?: {
+    getProfile: (nameOrAddress: string, options?: ({
         contentHash?: boolean | undefined;
         texts?: boolean | string[] | undefined;
         coinTypes?: boolean | string[] | undefined;
-    } | undefined) => Promise<{
+    } & {
+        resolverAddress?: string | undefined;
+    }) | undefined) => Promise<{
         isMigrated: boolean | null;
         createdAt: string | null;
         address?: string | undefined;
@@ -150,6 +168,7 @@ export declare class ENS {
         contentHash?: boolean | undefined;
         texts?: boolean | string[] | undefined;
         coinTypes?: boolean | string[] | undefined;
+        resolverAddress?: string | undefined;
     } | undefined) => Promise<{
         isMigrated: boolean | null;
         createdAt: string | null;
@@ -436,53 +455,16 @@ export declare class ENS {
         }>;
         decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<any>;
     }>;
-    setName: (name: string, options?: ({
-        address?: string | undefined;
-        resolver?: string | undefined;
-    } & WriteOptions) | undefined) => Promise<ethers.ContractTransaction | undefined>;
-    setRecords: (name: string, options: {
-        records: import("./utils/recordHelpers").RecordOptions;
-        resolverAddress?: string | undefined;
-    } & WriteOptions) => Promise<ethers.ContractTransaction | undefined>;
-    setResolver: (name: string, options: {
-        contract: "nameWrapper" | "registry";
-        resolver?: string | undefined;
-    } & WriteOptions) => Promise<ethers.ContractTransaction>;
-    transferName: (name: string, options: {
-        newOwner: string;
-        contract: "nameWrapper" | "registry" | "baseRegistrar";
-    } & WriteOptions) => Promise<ethers.ContractTransaction>;
-    wrapName: (name: string, options: {
-        wrappedOwner: string;
-        fuseOptions?: string | number | import("./@types/FuseOptions").FuseOptions | undefined;
-        resolverAddress?: string | undefined;
-    } & WriteOptions) => Promise<ethers.ContractTransaction>;
-    unwrapName: (name: string, options: {
-        newController: string;
-        newRegistrant?: string | undefined;
-    } & WriteOptions) => Promise<ethers.ContractTransaction>;
-    burnFuses: (name: string, options: {
-        fusesToBurn: import("./@types/FuseOptions").FuseOptions;
-    } & WriteOptions) => Promise<ethers.ContractTransaction>;
-    createSubname: (name: string, options: ({
-        owner: string;
-        resolverAddress?: string | undefined;
-        contract: "nameWrapper" | "registry";
-    } | ({
-        contract: "nameWrapper";
-        fuses?: import("./@types/FuseOptions").FuseOptions | undefined;
-    } & {
-        owner: string;
-        resolverAddress?: string | undefined;
-        contract: "nameWrapper" | "registry";
-    })) & WriteOptions) => Promise<ethers.ContractTransaction>;
-    deleteSubname: (name: string, options: {
-        contract: "nameWrapper" | "registry";
-    } & WriteOptions) => Promise<ethers.ContractTransaction>;
-    transferSubname: (name: string, options: {
-        contract: "nameWrapper" | "registry";
-        address: string;
-    } & WriteOptions) => Promise<ethers.ContractTransaction>;
+    setName: WriteFunction<typeof setName>;
+    setRecords: WriteFunction<typeof setRecords>;
+    setResolver: WriteFunction<typeof setResolver>;
+    transferName: WriteFunction<typeof transferName>;
+    wrapName: WriteFunction<typeof wrapName>;
+    unwrapName: WriteFunction<typeof unwrapName>;
+    burnFuses: WriteFunction<typeof burnFuses>;
+    createSubname: WriteFunction<typeof createSubname>;
+    deleteSubname: WriteFunction<typeof deleteSubname>;
+    transferSubname: WriteFunction<typeof transferSubname>;
     getDNSOwner: (dnsName: string) => Promise<any>;
 }
 export {};

package/dist/esm/index.js

@@ -2,6 +2,7 @@ import ContractManager from './contracts';
 import { getContractAddress as _getContractAddress } from './contracts/getContractAddress';
 import GqlManager from './GqlManager';
 import singleCall from './utils/singleCall';
+import writeTx from './utils/writeTx';
 const graphURIEndpoints = {
     1: 'https://api.thegraph.com/subgraphs/name/ensdomains/ens',
     3: 'https://api.thegraph.com/subgraphs/name/ensdomains/ensropsten',
@@ -52,29 +53,29 @@ export class ENS {
                 await thisRef.checkInitialProvider();
                 // import the module dynamically
                 const mod = await import(
-                /* webpackMode: "lazy", webpackChunkName: "[request]", webpackPreload: true */
+                /* webpackMode: "lazy", webpackChunkName: "[request]", webpackPreload: true, webpackExclude: /.*\.ts$/ */
                 `./functions/${path}`);
                 // if combine isn't specified, run normally
                 // otherwise, create a function from the raw and decode functions
                 if (subFunc !== 'combine') {
+                    const writeable = subFunc === 'write' || subFunc === 'populateTransaction';
                     // get the function to call
-                    const func = subFunc && subFunc !== 'write'
-                        ? mod[exportName][subFunc]
-                        : mod[exportName];
+                    const func = subFunc && !writeable ? mod[exportName][subFunc] : mod[exportName];
                     // get the dependencies to forward to the function as the first arg
                     let dependenciesToForward = thisRef.forwardDependenciesFromArray(dependencies);
                     // if func is write func, inject signer into dependencies
-                    if (subFunc === 'write') {
+                    if (writeable) {
                         const options = (args[1] || {});
                         const signer = options.signer ||
                             thisRef.provider?.getSigner(options.addressOrIndex);
+                        const populate = subFunc === 'populateTransaction';
                         if (!signer) {
                             throw new Error('No signer specified');
                         }
                         delete options.addressOrIndex;
                         delete options.signer;
                         dependenciesToForward = { ...dependenciesToForward, signer };
-                        return func(dependenciesToForward, args[0], options);
+                        return func(dependenciesToForward, args[0], options).then(writeTx(signer, populate));
                     }
                     // return the function with the dependencies forwarded
                     return func(dependenciesToForward, ...args);
@@ -92,6 +93,9 @@ export class ENS {
                 mainFunc.decode = this.importGenerator(path, dependencies, exportName, 'decode');
                 mainFunc.batch = this.importGenerator(path, dependencies, exportName, 'batch', { raw: mainFunc.raw, decode: mainFunc.decode });
             }
+            else if (subFunc === 'write') {
+                mainFunc.populateTransaction = this.importGenerator(path, dependencies, exportName, 'populateTransaction');
+            }
             return mainFunc;
         };
         /**

package/dist/esm/utils/labels.js

@@ -1,5 +1,6 @@
 import { solidityKeccak256 } from 'ethers/lib/utils';
 import { truncateFormat } from './format';
+const hasLocalStorage = typeof localStorage !== 'undefined';
 export const labelhash = (input) => solidityKeccak256(['string'], [input]);
 export const keccakFromString = (input) => labelhash(input);
 export function decodeLabelhash(hash) {
@@ -24,12 +25,12 @@ export function isEncodedLabelhash(hash) {
     return hash.startsWith('[') && hash.endsWith(']') && hash.length === 66;
 }
 function getLabels() {
-    return localStorage
+    return hasLocalStorage
         ? JSON.parse(localStorage.getItem('ensjs:labels')) || {}
         : {};
 }
 function _saveLabel(hash, label) {
-    if (!localStorage)
+    if (!hasLocalStorage)
         return hash;
     const labels = getLabels();
     localStorage.setItem('ensjs:labels', JSON.stringify({
@@ -81,7 +82,7 @@ export function decryptName(name) {
 }
 export const truncateUndecryptedName = (name) => truncateFormat(name);
 export function checkLocalStorageSize() {
-    if (!localStorage)
+    if (!hasLocalStorage)
         return 'Empty (0 KB)';
     let allStrings = '';
     for (const key in window.localStorage) {

package/dist/esm/utils/normalise.d.ts

@@ -1,2 +1,2 @@
 export declare const normalise: (name: string) => any;
-export declare const namehash: (inputName: string) => string;
+export declare const namehash: (name: string) => string;

package/dist/esm/utils/normalise.js

@@ -1,15 +1,22 @@
 import { concat, hexlify, keccak256, toUtf8Bytes } from 'ethers/lib/utils';
 import uts46 from 'idna-uts46-hx/uts46bundle.js';
+import { decodeLabelhash, isEncodedLabelhash } from './labels';
 const zeros = new Uint8Array(32);
 zeros.fill(0);
 export const normalise = (name) => name ? uts46.toUnicode(name, { useStd3ASCII: true }) : name;
-export const namehash = (inputName) => {
+export const namehash = (name) => {
     let result = zeros;
-    const name = normalise(inputName);
     if (name) {
         const labels = name.split('.');
         for (var i = labels.length - 1; i >= 0; i--) {
-            const labelSha = keccak256(toUtf8Bytes(labels[i]));
+            let labelSha;
+            if (isEncodedLabelhash(labels[i])) {
+                labelSha = decodeLabelhash(labels[i]);
+            }
+            else {
+                const normalised = normalise(labels[i]);
+                labelSha = keccak256(toUtf8Bytes(normalised));
+            }
             result = keccak256(concat([result, labelSha]));
         }
     }

package/dist/esm/utils/writeTx.d.ts

@@ -0,0 +1,4 @@
+import { JsonRpcSigner } from '@ethersproject/providers';
+import type { PopulatedTransaction } from 'ethers';
+declare const _default: (signer: JsonRpcSigner, populate: boolean) => (tx: PopulatedTransaction) => PopulatedTransaction | Promise<import("@ethersproject/abstract-provider").TransactionResponse>;
+export default _default;

package/dist/esm/utils/writeTx.js

@@ -0,0 +1 @@
+export default (signer, populate) => (tx) => populate ? tx : signer.sendTransaction(tx);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ensdomains/ensjs",
-  "version": "3.0.0-alpha.5",
+  "version": "3.0.0-alpha.8",
   "description": "ENS javascript library for contract interaction",
   "main": "./dist/cjs/index.js",
   "types": "./dist/cjs/index.d.ts",
@@ -46,12 +46,13 @@
     "dns-packet": "^5.3.1",
     "ethers": "^5.6.1",
     "graphql": "^16.3.0",
-    "graphql-request": "^4.1.0",
-    "idna-uts46-hx": "3.4.0"
+    "graphql-request": "next",
+    "idna-uts46-hx": "3.4.0",
+    "traverse": "^0.6.6"
   },
   "devDependencies": {
     "@ensdomains/buffer": "^0.0.13",
-    "@ensdomains/ens-test-env": "0.1.2",
+    "@ensdomains/ens-test-env": "0.1.5",
     "@ethersproject/abi": "^5.6.0",
     "@ethersproject/providers": "^5.6.2",
     "@nomiclabs/hardhat-ethers": "^2.0.5",
@@ -61,6 +62,7 @@
     "@typechain/ethers-v5": "^10.0.0",
     "@types/bn.js": "^5.1.0",
     "@types/jest": "^27.4.1",
+    "@types/traverse": "^0.6.32",
     "dotenv": "^16.0.0",
     "ens-contracts": "github:ensdomains/ens-contracts#head=master&commit=3ecc56b14beb4aae8296f8a94f7c0d095e62fd93",
     "hardhat": "^2.9.3",
@@ -81,5 +83,5 @@
   "peerDependencies": {
     "ethers": "*"
   },
-  "stableVersion": "3.0.0-alpha.4"
+  "stableVersion": "3.0.0-alpha.7"
 }

package/src/GqlManager.test.ts

@@ -0,0 +1,170 @@
+import traverse from 'traverse'
+import { visit, parse } from 'graphql'
+
+import { requestMiddleware, responseMiddleware, enter } from './GqlManager'
+import { namehash } from './utils/normalise'
+
+describe('GqlManager', () => {
+  const queryWithoutId = `
+query getNames($id: ID!, $expiryDate: Int) {
+    account(id: $id) {
+      registrations(first: 1000, where: { expiryDate_gt: $expiryDate }) {
+        registrationDate
+        expiryDate
+        domain {
+          labelName
+          labelhash
+          name
+          isMigrated
+          parent {
+            name
+          }
+        }
+      }
+      domains(first: 1000) {
+        labelName
+        labelhash
+        name
+        isMigrated
+        parent {
+          name
+        }
+        createdAt
+      }
+    }
+  }
+`
+
+  const mockRequest = {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({ query: queryWithoutId }),
+  }
+
+  const mockResponse = {
+    data: {
+      account: {
+        registrations: [
+          {
+            registrationDate: '1659245504',
+            expiryDate: '1690781504',
+            domain: {
+              id: '0xb1ccf7f6bb648f39ba48bf80f4a8a4522f474ee7d1edd6ea65f7fa51fe8b1612',
+              labelName: 'randydandy',
+              labelhash:
+                '0x63fd5bfdd0b1eb9f4c33c209b7c3e7dcb87a761d926a65e267f7cb99ee313ddd',
+              name: '0xde2551f43e950a2a4d4e6052f25edc450c48a5338faa27f09d1ee99ca9dc04fd',
+              isMigrated: true,
+              parent: {
+                name: '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae',
+                invalidName: true,
+              },
+              invalidName: true,
+            },
+          },
+          {
+            registrationDate: '1635284756',
+            expiryDate: '1666841708',
+            domain: {
+              id: '0xde2551f43e950a2a4d4e6052f25edc450c48a5338faa27f09d1ee99ca9dc04fd',
+              labelName: 'randydandy',
+              labelhash:
+                '0x6a877a8d92ad83c8d044d0c5b69aa0da3050f4d653dcc149fca952d6439e4105',
+              name: 'randydandy.eth',
+              isMigrated: true,
+              parent: {
+                name: '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae',
+                invalidName: true,
+              },
+            },
+          },
+          {
+            registrationDate: '1659250465',
+            expiryDate: '1690786465',
+            domain: {
+              id: '0xaf119e72f050e5acad6b2d97826a7afb45afe9407376a2ab8240b62173b2d7c2',
+              labelName: 'nullbyte',
+              labelhash:
+                '0xc8985f8323b3dc707003a6ef5b379d9e8a058b6d6bcc2cfb307c61ca36920e27',
+              name: '0xb54c7c79c89d571f1fbf4c67f524e336a04441eeee4d76f156e835da99a46ddb',
+              isMigrated: true,
+              parent: {
+                name: '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae',
+                invalidName: true,
+              },
+              invalidName: true,
+            },
+          },
+        ],
+        domains: [
+          {
+            id: '0xaf119e72f050e5acad6b2d97826a7afb45afe9407376a2ab8240b62173b2d7c2',
+            labelName: 'nullbyte',
+            labelhash:
+              '0xc8985f8323b3dc707003a6ef5b379d9e8a058b6d6bcc2cfb307c61ca36920e27',
+            name: '0xb54c7c79c89d571f1fbf4c67f524e336a04441eeee4d76f156e835da99a46ddb',
+            isMigrated: true,
+            parent: {
+              name: '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae',
+              invalidName: true,
+            },
+            createdAt: '1659250465',
+            invalidName: true,
+          },
+          {
+            id: '0xb1ccf7f6bb648f39ba48bf80f4a8a4522f474ee7d1edd6ea65f7fa51fe8b1612',
+            labelName: 'randydandy',
+            labelhash:
+              '0x63fd5bfdd0b1eb9f4c33c209b7c3e7dcb87a761d926a65e267f7cb99ee313ddd',
+            name: '0xde2551f43e950a2a4d4e6052f25edc450c48a5338faa27f09d1ee99ca9dc04fd',
+            isMigrated: true,
+            parent: {
+              name: '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae',
+              invalidName: true,
+            },
+            createdAt: '1659245504',
+            invalidName: true,
+          },
+          {
+            id: '0xde2551f43e950a2a4d4e6052f25edc450c48a5338faa27f09d1ee99ca9dc04fd',
+            labelName: 'randydandy',
+            labelhash:
+              '0x6a877a8d92ad83c8d044d0c5b69aa0da3050f4d653dcc149fca952d6439e4105',
+            name: 'randydandy.eth',
+            isMigrated: true,
+            parent: {
+              name: '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae',
+              invalidName: true,
+            },
+            createdAt: '1635284756',
+          },
+        ],
+      },
+    },
+    headers: {
+      map: {
+        'content-type': 'application/json',
+      },
+    },
+    status: 200,
+  }
+
+  describe('requestMiddleware', () => {
+    it('should add id to a SelectionSet if name is present and id is not', () => {
+      const result = requestMiddleware(visit, parse)(mockRequest)
+      expect(result.body.includes('id')).toBe(true)
+    })
+  })
+  describe('responseMiddleware', () => {
+    it('should replace name with the namehash when there is an invalid name and id combo', () => {
+      const result = responseMiddleware(traverse)(mockResponse)
+      expect(result.data.account.domains[0].name).toBe(
+        namehash(
+          '0xb54c7c79c89d571f1fbf4c67f524e336a04441eeee4d76f156e835da99a46ddb',
+        ),
+      )
+    })
+  })
+})

package/src/GqlManager.ts

@@ -1,11 +1,76 @@
+// @ts-nocheck
+import { namehash } from './utils/normalise'
+
+const generateSelection = (selection: any) => ({
+  kind: 'Field',
+  name: {
+    kind: 'Name',
+    value: selection,
+  },
+  arguments: [],
+  directives: [],
+  alias: undefined,
+  selectionSet: undefined,
+})
+
+export const enter = (node: any) => {
+  if (node.kind === 'SelectionSet') {
+    const id = node.selections.find((x) => x.name && x.name.value === 'id')
+    const name = node.selections.find((x) => x.name && x.name.value === 'name')
+
+    if (!id && name) {
+      node.selections = [...node.selections, generateSelection('id')]
+      return node
+    }
+  }
+}
+
+export const requestMiddleware = (visit, parse) => (request: any) => {
+  const requestBody = JSON.parse(request.body)
+  const rawQuery = requestBody.query
+  const parsedQuery = parse(rawQuery)
+  const updatedQuery = visit(parsedQuery, { enter })
+  const updatedBody = { ...requestBody, query: updatedQuery.loc.source.body }
+
+  return {
+    ...request,
+    body: JSON.stringify(updatedBody),
+  }
+}
+
+export const responseMiddleware = (traverse) => (response: any) => {
+  traverse(response).forEach(function (responseItem: any) {
+    if (responseItem instanceof Object && responseItem.name) {
+      //Name already in hashed form
+      if (responseItem.name && responseItem.name.includes('[')) {
+        return
+      }
+
+      const hashedName = namehash(responseItem.name)
+      if (responseItem.id !== hashedName) {
+        this.update({ ...responseItem, name: hashedName, invalidName: true })
+      }
+    }
+  })
+  return response
+}
+
 export default class GqlManager {
   public gql: any = () => null
   public client?: any | null = null
 
   public setUrl = async (url: string | null) => {
     if (url) {
-      const imported = await import('graphql-request')
-      this.client = new imported.GraphQLClient(url)
+      const [imported, traverse, { visit, parse }] = await Promise.all([
+        import('graphql-request'),
+        import('traverse'),
+        import('graphql/language'),
+      ])
+
+      this.client = new imported.GraphQLClient(url, {
+        requestMiddleware: requestMiddleware(visit, parse),
+        responseMiddleware: responseMiddleware(traverse.default),
+      })
       this.gql = imported.gql
     } else {
       this.client = null

package/src/functions/burnFuses.ts

@@ -17,5 +17,5 @@ export default async function (
 
   const encodedFuses = generateFuseInput(fusesToBurn)
 
-  return nameWrapper.burnFuses(hash, encodedFuses)
+  return nameWrapper.populateTransaction.burnFuses(hash, encodedFuses)
 }

package/src/functions/createSubname.ts

@@ -44,7 +44,7 @@ export default async function (
     case 'registry': {
       const registry = (await contracts?.getRegistry()!).connect(signer)
 
-      return registry.setSubnodeRecord(
+      return registry.populateTransaction.setSubnodeRecord(
         parentNodehash,
         labelhash,
         owner,
@@ -60,7 +60,7 @@ export default async function (
           ? generateFuseInput(wrapperArgs.fuses)
           : '0'
 
-      return nameWrapper.setSubnodeRecord(
+      return nameWrapper.populateTransaction.setSubnodeRecord(
         parentNodehash,
         label,
         owner,

package/src/functions/deleteSubname.ts

@@ -9,7 +9,7 @@ export default async function (
     contract: 'registry' | 'nameWrapper'
   },
 ) {
-  return transferSubname(name, {
+  return transferSubname.populateTransaction(name, {
     contract,
     address: '0x0000000000000000000000000000000000000000',
   })

package/src/functions/getProfile.test.ts

@@ -2,9 +2,14 @@ import { ENS } from '..'
 import setup from '../tests/setup'
 
 let ENSInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
 
 beforeAll(async () => {
-  ;({ ENSInstance } = await setup())
+  ;({ ENSInstance, revert } = await setup())
+})
+
+afterAll(async () => {
+  await revert()
 })
 
 const checkRecords = (
@@ -88,6 +93,16 @@ describe('getProfile', () => {
       })
       checkRecords(result)
     })
+    it('should return a profile object for a specified resolver', async () => {
+      const result = await ENSInstance.getProfile('saganaki.xyz', {
+        resolverAddress: '0x12299799a50340fb860d276805e78550cbad3de3',
+      })
+      expect(result).toBeDefined()
+      expect(result?.address).toBe('0x157545BfD441453921049998128Ff090c1c11230')
+      expect(result?.resolverAddress).toBe(
+        '0x12299799a50340fb860d276805e78550cbad3de3',
+      )
+    })
     it('should return undefined for an unregistered name', async () => {
       const result = await ENSInstance.getProfile('test123123123cool.eth')
       expect(result).toBeUndefined()