@ensdomains/ensjs 3.0.0-alpha.6 → 3.0.0-alpha.9

package/dist/esm/functions/getProfile.js

@@ -2,6 +2,7 @@ import { formatsByName } from '@ensdomains/address-encoder';
 import { ethers } from 'ethers';
 import { decodeContenthash } from '../utils/contentHash';
 import { hexEncodeName } from '../utils/hexEncodedName';
+import { namehash } from '../utils/normalise';
 import { parseInputType } from '../utils/validation';
 const makeMulticallData = async ({ _getAddr, _getContentHash, _getText, resolverMulticallWrapper, }, name, options) => {
     let calls = [];
@@ -47,13 +48,19 @@ const fetchWithoutResolverMulticall = async ({ multicallWrapper }, calls, resolv
     }));
     return (await multicallWrapper(callsWithResolver)).map((x) => x[1]);
 };
-const getDataForName = async ({ contracts, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, multicallWrapper, }, name, options, fallbackResolver) => {
+const getDataForName = async ({ contracts, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, multicallWrapper, }, name, options, fallbackResolver, specificResolver) => {
     const universalResolver = await contracts?.getUniversalResolver();
     const { data, calls } = await makeMulticallData({ _getAddr, _getContentHash, _getText, resolverMulticallWrapper }, name, options);
     let resolvedData;
     let useFallbackResolver = false;
     try {
-        resolvedData = await universalResolver?.resolve(hexEncodeName(name), data);
+        if (specificResolver) {
+            const publicResolver = await contracts?.getPublicResolver(undefined, specificResolver);
+            resolvedData = await publicResolver?.callStatic.multicall(calls.map((x) => x.data));
+        }
+        else {
+            resolvedData = await universalResolver?.resolve(hexEncodeName(name), data);
+        }
     }
     catch {
         useFallbackResolver = true;
@@ -61,12 +68,18 @@ const getDataForName = async ({ contracts, _getAddr, _getContentHash, _getText,
     let resolverAddress;
     let recordData;
     if (useFallbackResolver) {
-        resolverAddress = fallbackResolver;
+        resolverAddress = specificResolver || fallbackResolver;
         recordData = await fetchWithoutResolverMulticall({ multicallWrapper }, calls, resolverAddress);
     }
     else {
-        resolverAddress = resolvedData['1'];
-        [recordData] = await resolverMulticallWrapper.decode(resolvedData['0']);
+        resolverAddress = specificResolver || resolvedData['1'];
+        if (specificResolver) {
+            recordData = resolvedData;
+        }
+        else {
+            ;
+            [recordData] = await resolverMulticallWrapper.decode(resolvedData['0']);
+        }
     }
     const matchAddress = recordData[calls.findIndex((x) => x.key === '60')];
     return {
@@ -158,10 +171,10 @@ const formatRecords = async ({ _getText, _getAddr, _getContentHash, }, data, cal
     }
     return returnedResponse;
 };
-const graphFetch = async ({ gqlInstance }, name, wantedRecords) => {
+const graphFetch = async ({ gqlInstance }, name, wantedRecords, resolverAddress) => {
     const query = gqlInstance.gql `
-    query getRecords($name: String!) {
-      domains(where: { name: $name }) {
+    query getRecords($id: String!) {
+      domain(id: $id) {
         isMigrated
         createdAt
         resolver {
@@ -175,12 +188,39 @@ const graphFetch = async ({ gqlInstance }, name, wantedRecords) => {
         }
       }
     }
+  `;
+    const customResolverQuery = gqlInstance.gql `
+    query getRecordsWithCustomResolver($id: String!, $resolverId: String!) {
+      domain(id: $id) {
+        isMigrated
+        createdAt
+      }
+      resolver(id: $resolverId) {
+        texts
+        coinTypes
+        contentHash
+        addr {
+          id
+        }
+      }
+    }
   `;
     const client = gqlInstance.client;
-    const { domains } = await client.request(query, { name });
-    if (!domains || domains.length === 0)
+    const id = namehash(name);
+    let domain;
+    let resolverResponse;
+    if (!resolverAddress) {
+        ;
+        ({ domain } = await client.request(query, { id }));
+        resolverResponse = domain?.resolver;
+    }
+    else {
+        const resolverId = `${resolverAddress}-${id}`;
+        ({ resolver: resolverResponse, domain } = await client.request(customResolverQuery, { id, resolverId }));
+    }
+    if (!domain)
         return;
-    const [{ resolver: resolverResponse, isMigrated, createdAt }] = domains;
+    const { isMigrated, createdAt } = domain;
     let returnedRecords = {};
     if (!resolverResponse)
         return { isMigrated, createdAt };
@@ -188,7 +228,7 @@ const graphFetch = async ({ gqlInstance }, name, wantedRecords) => {
         return {
             isMigrated,
             createdAt,
-            graphResolverAddress: resolverResponse.address,
+            graphResolverAddress: resolverResponse.address || resolverAddress,
         };
     Object.keys(wantedRecords).forEach((key) => {
         const data = wantedRecords[key];
@@ -205,18 +245,22 @@ const graphFetch = async ({ gqlInstance }, name, wantedRecords) => {
         ...returnedRecords,
         isMigrated,
         createdAt,
-        graphResolverAddress: resolverResponse.address,
+        graphResolverAddress: resolverResponse.address || resolverAddress,
     };
 };
 const getProfileFromName = async ({ contracts, gqlInstance, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, multicallWrapper, }, name, options) => {
-    const usingOptions = !options || options?.texts === true || options?.coinTypes === true
-        ? options || { contentHash: true, texts: true, coinTypes: true }
+    const { resolverAddress, ..._options } = options || {};
+    const optsLength = Object.keys(_options).length;
+    const usingOptions = !optsLength || _options?.texts === true || _options?.coinTypes === true
+        ? optsLength
+            ? _options
+            : { contentHash: true, texts: true, coinTypes: true }
         : undefined;
-    const graphResult = await graphFetch({ gqlInstance }, name, usingOptions);
+    const graphResult = await graphFetch({ gqlInstance }, name, usingOptions, resolverAddress);
     if (!graphResult)
         return;
     const { isMigrated, createdAt, graphResolverAddress, ...wantedRecords } = graphResult;
-    if (!graphResolverAddress)
+    if (!graphResolverAddress && !options?.resolverAddress)
         return { isMigrated, createdAt, message: "Name doesn't have a resolver" };
     const result = await getDataForName({
         contracts,
@@ -225,7 +269,7 @@ const getProfileFromName = async ({ contracts, gqlInstance, _getAddr, _getConten
         _getText,
         resolverMulticallWrapper,
         multicallWrapper,
-    }, name, usingOptions ? wantedRecords : options, graphResolverAddress);
+    }, name, usingOptions ? wantedRecords : options, graphResolverAddress, options?.resolverAddress);
     if (!result)
         return { isMigrated, createdAt, message: "Records fetch didn't complete" };
     return { ...result, isMigrated, createdAt, message: undefined };

package/dist/esm/functions/getRecords.d.ts

@@ -3,6 +3,7 @@ declare type ProfileOptions = {
     contentHash?: boolean;
     texts?: boolean | string[];
     coinTypes?: boolean | string[];
+    resolverAddress?: string;
 };
 export default function ({ getProfile }: ENSArgs<'getProfile'>, name: string, options?: ProfileOptions): Promise<{
     isMigrated: boolean | null;

package/dist/esm/functions/setRecord.d.ts

@@ -0,0 +1,18 @@
+import { ENSArgs } from '..';
+import { RecordInput, RecordTypes } from '../utils/recordHelpers';
+declare type BaseInput = {
+    resolverAddress?: string;
+};
+declare type ContentHashInput = {
+    record: RecordInput<'contentHash'>;
+    type: 'contentHash';
+};
+declare type AddrOrTextInput = {
+    record: RecordInput<'addr' | 'text'>;
+    type: 'addr' | 'text';
+};
+export default function <T extends RecordTypes>({ contracts, provider, getResolver, signer, }: ENSArgs<'contracts' | 'provider' | 'getResolver' | 'signer'>, name: string, { record, type, resolverAddress, }: BaseInput & (ContentHashInput | AddrOrTextInput)): Promise<{
+    to: string;
+    data: string;
+}>;
+export {};

package/dist/esm/functions/setRecord.js

@@ -0,0 +1,24 @@
+import { namehash } from '../utils/normalise';
+import { generateSingleRecordCall, } from '../utils/recordHelpers';
+export default async function ({ contracts, provider, getResolver, signer, }, name, { record, type, resolverAddress, }) {
+    if (!name.includes('.')) {
+        throw new Error('Input is not an ENS name');
+    }
+    let resolverToUse;
+    if (resolverAddress) {
+        resolverToUse = resolverAddress;
+    }
+    else {
+        resolverToUse = await getResolver(name);
+    }
+    if (!resolverToUse) {
+        throw new Error('No resolver found for input address');
+    }
+    const resolver = (await contracts?.getPublicResolver(provider, resolverToUse))?.connect(signer);
+    const hash = namehash(name);
+    const call = generateSingleRecordCall(hash, resolver, type)(record);
+    return {
+        to: resolver.address,
+        data: call,
+    };
+}

package/dist/esm/index.d.ts

@@ -7,6 +7,7 @@ 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 setRecord from './functions/setRecord';
 import type setRecords from './functions/setRecords';
 import type setResolver from './functions/setResolver';
 import type transferName from './functions/transferName';
@@ -133,11 +134,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;
@@ -166,6 +169,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;
@@ -454,6 +458,7 @@ export declare class ENS {
     }>;
     setName: WriteFunction<typeof setName>;
     setRecords: WriteFunction<typeof setRecords>;
+    setRecord: WriteFunction<typeof setRecord>;
     setResolver: WriteFunction<typeof setResolver>;
     transferName: WriteFunction<typeof transferName>;
     wrapName: WriteFunction<typeof wrapName>;

package/dist/esm/index.js

@@ -53,7 +53,7 @@ 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
@@ -188,6 +188,11 @@ export class ENS {
             'contracts',
         ]);
         this.setRecords = this.generateWriteFunction('setRecords', ['contracts', 'provider', 'getResolver']);
+        this.setRecord = this.generateWriteFunction('setRecord', [
+            'contracts',
+            'provider',
+            'getResolver',
+        ]);
         this.setResolver = this.generateWriteFunction('setResolver', ['contracts']);
         this.transferName = this.generateWriteFunction('transferName', ['contracts']);
         this.wrapName = this.generateWriteFunction('wrapName', [

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/recordHelpers.d.ts

@@ -9,5 +9,8 @@ export declare type RecordOptions = {
     coinTypes?: RecordItem[];
 };
 export declare const generateSetAddr: (namehash: string, coinType: string, address: string, resolver: PublicResolver) => string;
+export declare type RecordTypes = 'contentHash' | 'text' | 'addr';
+export declare type RecordInput<T extends RecordTypes> = T extends 'contentHash' ? string : RecordItem;
+export declare function generateSingleRecordCall<T extends RecordTypes>(namehash: string, resolver: PublicResolver, type: T): (record: RecordInput<T>) => string;
 export declare const generateRecordCallArray: (namehash: string, records: RecordOptions, resolver: PublicResolver) => string[];
 export {};

package/dist/esm/utils/recordHelpers.js

@@ -12,28 +12,54 @@ export const generateSetAddr = (namehash, coinType, address, resolver) => {
     const encodedAddress = coinTypeInstance.decoder(address);
     return resolver?.interface.encodeFunctionData('setAddr(bytes32,uint256,bytes)', [namehash, inputCoinType, encodedAddress]);
 };
+export function generateSingleRecordCall(namehash, resolver, type) {
+    if (type === 'contentHash') {
+        return (_r) => {
+            const record = _r;
+            let _contentHash = '';
+            if (record !== _contentHash) {
+                const encoded = encodeContenthash(record);
+                if (encoded.error)
+                    throw new Error(encoded.error);
+                _contentHash = encoded.encoded;
+            }
+            return resolver.interface.encodeFunctionData('setContenthash', [
+                namehash,
+                _contentHash,
+            ]);
+        };
+    }
+    else {
+        return (_r) => {
+            const record = _r;
+            if (type === 'text') {
+                return resolver.interface.encodeFunctionData('setText', [
+                    namehash,
+                    record.key,
+                    record.value,
+                ]);
+            }
+            else {
+                return generateSetAddr(namehash, record.key, record.value, resolver);
+            }
+        };
+    }
+}
 export const generateRecordCallArray = (namehash, records, resolver) => {
     const calls = [];
     if (records.contentHash) {
-        const contentHash = records.contentHash === '' ? '' : encodeContenthash(records.contentHash);
-        const data = resolver?.interface.encodeFunctionData('setContenthash', [namehash, contentHash]);
+        const data = generateSingleRecordCall(namehash, resolver, 'contentHash')(records.contentHash);
         data && calls.push(data);
     }
     if (records.texts && records.texts.length > 0) {
-        records.texts.forEach(({ key, value }) => {
-            const data = resolver?.interface.encodeFunctionData('setText', [
-                namehash,
-                key,
-                value,
-            ]);
-            data && calls.push(data);
-        });
+        records.texts
+            .map(generateSingleRecordCall(namehash, resolver, 'text'))
+            .forEach((call) => calls.push(call));
     }
     if (records.coinTypes && records.coinTypes.length > 0) {
-        records.coinTypes.forEach(({ key, value }) => {
-            const data = generateSetAddr(namehash, key, value, resolver);
-            data && calls.push(data);
-        });
+        records.coinTypes
+            .map(generateSingleRecordCall(namehash, resolver, 'addr'))
+            .forEach((call) => calls.push(call));
     }
     return calls;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ensdomains/ensjs",
-  "version": "3.0.0-alpha.6",
+  "version": "3.0.0-alpha.9",
   "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.4",
+    "@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.5"
+  "stableVersion": "3.0.0-alpha.8"
 }

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',
+        ),
+      )
+    })
+  })
+})