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

package/dist/cjs/GqlManager.d.ts

@@ -1,3 +1,6 @@
+export declare const enter: (node: any) => any;
+export declare const requestMiddleware: (visit: any, parse: any) => (request: any) => any;
+export declare const responseMiddleware: (traverse: any) => (response: any) => any;
 export default class GqlManager {
     gql: any;
     client?: any | null;

package/dist/cjs/GqlManager.js

@@ -23,13 +23,73 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.responseMiddleware = exports.requestMiddleware = exports.enter = void 0;
+// @ts-nocheck
+const normalise_1 = require("./utils/normalise");
+const generateSelection = (selection) => ({
+    kind: 'Field',
+    name: {
+        kind: 'Name',
+        value: selection,
+    },
+    arguments: [],
+    directives: [],
+    alias: undefined,
+    selectionSet: undefined,
+});
+const enter = (node) => {
+    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;
+        }
+    }
+};
+exports.enter = enter;
+const requestMiddleware = (visit, parse) => (request) => {
+    const requestBody = JSON.parse(request.body);
+    const rawQuery = requestBody.query;
+    const parsedQuery = parse(rawQuery);
+    const updatedQuery = visit(parsedQuery, { enter: exports.enter });
+    const updatedBody = { ...requestBody, query: updatedQuery.loc.source.body };
+    return {
+        ...request,
+        body: JSON.stringify(updatedBody),
+    };
+};
+exports.requestMiddleware = requestMiddleware;
+const responseMiddleware = (traverse) => (response) => {
+    traverse(response).forEach(function (responseItem) {
+        if (responseItem instanceof Object && responseItem.name) {
+            //Name already in hashed form
+            if (responseItem.name && responseItem.name.includes('[')) {
+                return;
+            }
+            const hashedName = (0, normalise_1.namehash)(responseItem.name);
+            if (responseItem.id !== hashedName) {
+                this.update({ ...responseItem, name: hashedName, invalidName: true });
+            }
+        }
+    });
+    return response;
+};
+exports.responseMiddleware = responseMiddleware;
 class GqlManager {
     gql = () => null;
     client = null;
     setUrl = async (url) => {
         if (url) {
-            const imported = await Promise.resolve().then(() => __importStar(require('graphql-request')));
-            this.client = new imported.GraphQLClient(url);
+            const [imported, traverse, { visit, parse }] = await Promise.all([
+                Promise.resolve().then(() => __importStar(require('graphql-request'))),
+                Promise.resolve().then(() => __importStar(require('traverse'))),
+                Promise.resolve().then(() => __importStar(require('graphql/language'))),
+            ]);
+            this.client = new imported.GraphQLClient(url, {
+                requestMiddleware: (0, exports.requestMiddleware)(visit, parse),
+                responseMiddleware: (0, exports.responseMiddleware)(traverse.default),
+            });
             this.gql = imported.gql;
         }
         else {

package/dist/cjs/functions/getProfile.d.ts

@@ -26,5 +26,8 @@ declare type ProfileOptions = {
     texts?: boolean | string[];
     coinTypes?: boolean | string[];
 };
-export default function ({ contracts, gqlInstance, getName, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, multicallWrapper, }: ENSArgs<'contracts' | 'gqlInstance' | 'getName' | '_getText' | '_getAddr' | '_getContentHash' | 'resolverMulticallWrapper' | 'multicallWrapper'>, nameOrAddress: string, options?: ProfileOptions): Promise<ResolvedProfile | undefined>;
+declare type InputProfileOptions = ProfileOptions & {
+    resolverAddress?: string;
+};
+export default function ({ contracts, gqlInstance, getName, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, multicallWrapper, }: ENSArgs<'contracts' | 'gqlInstance' | 'getName' | '_getText' | '_getAddr' | '_getContentHash' | 'resolverMulticallWrapper' | 'multicallWrapper'>, nameOrAddress: string, options?: InputProfileOptions): Promise<ResolvedProfile | undefined>;
 export {};

package/dist/cjs/functions/getProfile.js

@@ -4,6 +4,7 @@ const address_encoder_1 = require("@ensdomains/address-encoder");
 const ethers_1 = require("ethers");
 const contentHash_1 = require("../utils/contentHash");
 const hexEncodedName_1 = require("../utils/hexEncodedName");
+const normalise_1 = require("../utils/normalise");
 const validation_1 = require("../utils/validation");
 const makeMulticallData = async ({ _getAddr, _getContentHash, _getText, resolverMulticallWrapper, }, name, options) => {
     let calls = [];
@@ -49,13 +50,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((0, hexEncodedName_1.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((0, hexEncodedName_1.hexEncodeName)(name), data);
+        }
     }
     catch {
         useFallbackResolver = true;
@@ -63,12 +70,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 {
@@ -160,10 +173,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 {
@@ -177,12 +190,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 = (0, normalise_1.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 };
@@ -190,7 +230,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];
@@ -207,18 +247,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,
@@ -227,7 +271,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/cjs/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/cjs/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/cjs/functions/setRecord.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const normalise_1 = require("../utils/normalise");
+const recordHelpers_1 = require("../utils/recordHelpers");
+async function default_1({ 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 = (0, normalise_1.namehash)(name);
+    const call = (0, recordHelpers_1.generateSingleRecordCall)(hash, resolver, type)(record);
+    return {
+        to: resolver.address,
+        data: call,
+    };
+}
+exports.default = default_1;

package/dist/cjs/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/cjs/index.js

@@ -90,7 +90,7 @@ class ENS {
             await thisRef.checkInitialProvider();
             // import the module dynamically
             const mod = await Promise.resolve().then(() => __importStar(require(
-            /* 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
@@ -225,6 +225,11 @@ class ENS {
         'contracts',
     ]);
     setRecords = this.generateWriteFunction('setRecords', ['contracts', 'provider', 'getResolver']);
+    setRecord = this.generateWriteFunction('setRecord', [
+        'contracts',
+        'provider',
+        'getResolver',
+    ]);
     setResolver = this.generateWriteFunction('setResolver', ['contracts']);
     transferName = this.generateWriteFunction('transferName', ['contracts']);
     wrapName = this.generateWriteFunction('wrapName', [

package/dist/cjs/utils/labels.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkLocalStorageSize = exports.truncateUndecryptedName = exports.decryptName = exports.checkIsDecrypted = exports.parseName = exports.encodeLabel = exports.checkLabel = exports.saveName = exports.saveLabel = exports.isEncodedLabelhash = exports.encodeLabelhash = exports.decodeLabelhash = exports.keccakFromString = exports.labelhash = void 0;
 const utils_1 = require("ethers/lib/utils");
 const format_1 = require("./format");
+const hasLocalStorage = typeof localStorage !== 'undefined';
 const labelhash = (input) => (0, utils_1.solidityKeccak256)(['string'], [input]);
 exports.labelhash = labelhash;
 const keccakFromString = (input) => (0, exports.labelhash)(input);
@@ -32,12 +33,12 @@ function isEncodedLabelhash(hash) {
 }
 exports.isEncodedLabelhash = isEncodedLabelhash;
 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({
@@ -97,7 +98,7 @@ exports.decryptName = decryptName;
 const truncateUndecryptedName = (name) => (0, format_1.truncateFormat)(name);
 exports.truncateUndecryptedName = truncateUndecryptedName;
 function checkLocalStorageSize() {
-    if (!localStorage)
+    if (!hasLocalStorage)
         return 'Empty (0 KB)';
     let allStrings = '';
     for (const key in window.localStorage) {

package/dist/cjs/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/cjs/utils/normalise.js

@@ -6,17 +6,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.namehash = exports.normalise = void 0;
 const utils_1 = require("ethers/lib/utils");
 const uts46bundle_js_1 = __importDefault(require("idna-uts46-hx/uts46bundle.js"));
+const labels_1 = require("./labels");
 const zeros = new Uint8Array(32);
 zeros.fill(0);
 const normalise = (name) => name ? uts46bundle_js_1.default.toUnicode(name, { useStd3ASCII: true }) : name;
 exports.normalise = normalise;
-const namehash = (inputName) => {
+const namehash = (name) => {
     let result = zeros;
-    const name = (0, exports.normalise)(inputName);
     if (name) {
         const labels = name.split('.');
         for (var i = labels.length - 1; i >= 0; i--) {
-            const labelSha = (0, utils_1.keccak256)((0, utils_1.toUtf8Bytes)(labels[i]));
+            let labelSha;
+            if ((0, labels_1.isEncodedLabelhash)(labels[i])) {
+                labelSha = (0, labels_1.decodeLabelhash)(labels[i]);
+            }
+            else {
+                const normalised = (0, exports.normalise)(labels[i]);
+                labelSha = (0, utils_1.keccak256)((0, utils_1.toUtf8Bytes)(normalised));
+            }
             result = (0, utils_1.keccak256)((0, utils_1.concat)([result, labelSha]));
         }
     }

package/dist/cjs/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/cjs/utils/recordHelpers.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateRecordCallArray = exports.generateSetAddr = void 0;
+exports.generateRecordCallArray = exports.generateSingleRecordCall = exports.generateSetAddr = void 0;
 const address_encoder_1 = require("@ensdomains/address-encoder");
 const contentHash_1 = require("./contentHash");
 const generateSetAddr = (namehash, coinType, address, resolver) => {
@@ -16,28 +16,55 @@ const generateSetAddr = (namehash, coinType, address, resolver) => {
     return resolver?.interface.encodeFunctionData('setAddr(bytes32,uint256,bytes)', [namehash, inputCoinType, encodedAddress]);
 };
 exports.generateSetAddr = generateSetAddr;
+function generateSingleRecordCall(namehash, resolver, type) {
+    if (type === 'contentHash') {
+        return (_r) => {
+            const record = _r;
+            let _contentHash = '';
+            if (record !== _contentHash) {
+                const encoded = (0, contentHash_1.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 (0, exports.generateSetAddr)(namehash, record.key, record.value, resolver);
+            }
+        };
+    }
+}
+exports.generateSingleRecordCall = generateSingleRecordCall;
 const generateRecordCallArray = (namehash, records, resolver) => {
     const calls = [];
     if (records.contentHash) {
-        const contentHash = records.contentHash === '' ? '' : (0, contentHash_1.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 = (0, exports.generateSetAddr)(namehash, key, value, resolver);
-            data && calls.push(data);
-        });
+        records.coinTypes
+            .map(generateSingleRecordCall(namehash, resolver, 'addr'))
+            .forEach((call) => calls.push(call));
     }
     return calls;
 };

package/dist/esm/GqlManager.d.ts

@@ -1,3 +1,6 @@
+export declare const enter: (node: any) => any;
+export declare const requestMiddleware: (visit: any, parse: any) => (request: any) => any;
+export declare const responseMiddleware: (traverse: any) => (response: any) => any;
 export default class GqlManager {
     gql: any;
     client?: any | null;

package/dist/esm/GqlManager.js

@@ -1,11 +1,67 @@
+// @ts-nocheck
+import { namehash } from './utils/normalise';
+const generateSelection = (selection) => ({
+    kind: 'Field',
+    name: {
+        kind: 'Name',
+        value: selection,
+    },
+    arguments: [],
+    directives: [],
+    alias: undefined,
+    selectionSet: undefined,
+});
+export const enter = (node) => {
+    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) => {
+    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) => {
+    traverse(response).forEach(function (responseItem) {
+        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 {
     constructor() {
         this.gql = () => null;
         this.client = null;
         this.setUrl = async (url) => {
             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 {

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

@@ -26,5 +26,8 @@ declare type ProfileOptions = {
     texts?: boolean | string[];
     coinTypes?: boolean | string[];
 };
-export default function ({ contracts, gqlInstance, getName, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, multicallWrapper, }: ENSArgs<'contracts' | 'gqlInstance' | 'getName' | '_getText' | '_getAddr' | '_getContentHash' | 'resolverMulticallWrapper' | 'multicallWrapper'>, nameOrAddress: string, options?: ProfileOptions): Promise<ResolvedProfile | undefined>;
+declare type InputProfileOptions = ProfileOptions & {
+    resolverAddress?: string;
+};
+export default function ({ contracts, gqlInstance, getName, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, multicallWrapper, }: ENSArgs<'contracts' | 'gqlInstance' | 'getName' | '_getText' | '_getAddr' | '_getContentHash' | 'resolverMulticallWrapper' | 'multicallWrapper'>, nameOrAddress: string, options?: InputProfileOptions): Promise<ResolvedProfile | undefined>;
 export {};