@ensdomains/ensjs 3.0.0-alpha.1 → 3.0.0-alpha.10

package/README.md

@@ -9,6 +9,8 @@ We also use undeployed contracts under the hood, so this **will not** work on an
 
 Given the current development status, we're actively seeking feedback so feel free to create an issue or PR if you notice something!
 
+If you are looking for documentation for **version 2**, it an be found [here](https://github.com/ensdomains/ensjs#readme).
+
 ## Features
 
 - Dynamically load **everything**

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

@@ -1,4 +1,5 @@
-import { ethers } from 'ethers';
 import { ENSArgs } from '..';
 import { FuseOptions } from '../@types/FuseOptions';
-export default function ({ contracts, provider }: ENSArgs<'contracts' | 'provider'>, name: string, fusesToBurn: FuseOptions): Promise<ethers.ContractTransaction>;
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { fusesToBurn, }: {
+    fusesToBurn: FuseOptions;
+}): Promise<import("ethers").PopulatedTransaction>;

package/dist/cjs/functions/burnFuses.js

@@ -3,16 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const ethers_1 = require("ethers");
 const generateFuseInput_1 = __importDefault(require("../utils/generateFuseInput"));
-async function default_1({ contracts, provider }, name, fusesToBurn) {
-    const signer = provider?.getSigner();
-    if (!signer) {
-        throw new Error('No signer found');
-    }
+const normalise_1 = require("../utils/normalise");
+async function default_1({ contracts, signer }, name, { fusesToBurn, }) {
     const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
-    const namehash = ethers_1.ethers.utils.namehash(name);
+    const hash = (0, normalise_1.namehash)(name);
     const encodedFuses = (0, generateFuseInput_1.default)(fusesToBurn);
-    return nameWrapper.burnFuses(namehash, encodedFuses);
+    return nameWrapper.populateTransaction.burnFuses(hash, encodedFuses);
 }
 exports.default = default_1;

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

@@ -2,18 +2,14 @@ import { ethers } from 'ethers';
 import { ENSArgs } from '..';
 import { FuseOptions } from '../@types/FuseOptions';
 declare type BaseArgs = {
-    name: string;
     owner: string;
     resolverAddress?: string;
     contract: 'registry' | 'nameWrapper';
-    options?: {
-        addressOrIndex?: string | number;
-    };
 };
 declare type NameWrapperArgs = {
     contract: 'nameWrapper';
     fuses?: FuseOptions;
 } & BaseArgs;
 declare type Args = BaseArgs | NameWrapperArgs;
-export default function ({ contracts, provider }: ENSArgs<'contracts' | 'provider'>, { name, owner, resolverAddress, contract, options, ...wrapperArgs }: Args): Promise<ethers.ContractTransaction>;
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { owner, resolverAddress, contract, ...wrapperArgs }: Args): Promise<ethers.PopulatedTransaction>;
 export {};

package/dist/cjs/functions/createSubname.js

@@ -5,11 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
 const generateFuseInput_1 = __importDefault(require("../utils/generateFuseInput"));
-async function default_1({ contracts, provider }, { name, owner, resolverAddress, contract, options, ...wrapperArgs }) {
-    const signer = provider?.getSigner(options?.addressOrIndex);
-    if (!signer) {
-        throw new Error('No signer found');
-    }
+const normalise_1 = require("../utils/normalise");
+async function default_1({ contracts, signer }, name, { owner, resolverAddress, contract, ...wrapperArgs }) {
     const labels = name.split('.');
     if (labels.length === 1) {
         throw new Error('Subnames in ENS.js can only be created for 2LDs, not TLDs');
@@ -22,18 +19,18 @@ async function default_1({ contracts, provider }, { name, owner, resolverAddress
     }
     const label = labels.shift();
     const labelhash = ethers_1.ethers.utils.solidityKeccak256(['string'], [label]);
-    const parentNodehash = ethers_1.ethers.utils.namehash(labels.join('.'));
+    const parentNodehash = (0, normalise_1.namehash)(labels.join('.'));
     switch (contract) {
         case 'registry': {
             const registry = (await contracts?.getRegistry()).connect(signer);
-            return registry.setSubnodeRecord(parentNodehash, labelhash, owner, resolverAddress, 0);
+            return registry.populateTransaction.setSubnodeRecord(parentNodehash, labelhash, owner, resolverAddress, 0);
         }
         case 'nameWrapper': {
             const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
             const generatedFuses = 'fuses' in wrapperArgs && wrapperArgs.fuses
                 ? (0, generateFuseInput_1.default)(wrapperArgs.fuses)
                 : '0';
-            return nameWrapper.setSubnodeRecord(parentNodehash, label, owner, resolverAddress, 0, generatedFuses);
+            return nameWrapper.populateTransaction.setSubnodeRecord(parentNodehash, label, owner, resolverAddress, 0, generatedFuses);
         }
         default: {
             throw new Error(`Unknown contract: ${contract}`);

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

@@ -1,4 +1,4 @@
 import { ENSArgs } from '..';
-export default function ({ contracts, provider, transferSubname, }: ENSArgs<'contracts' | 'provider' | 'transferSubname'>, name: string, contract: 'registry' | 'nameWrapper', options?: {
-    addressOrIndex?: string | number;
-}): Promise<import("ethers").ContractTransaction>;
+export default function ({ transferSubname }: ENSArgs<'transferSubname'>, name: string, { contract, }: {
+    contract: 'registry' | 'nameWrapper';
+}): Promise<import("ethers").PopulatedTransaction>;

package/dist/cjs/functions/deleteSubname.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-async function default_1({ contracts, provider, transferSubname, }, name, contract, options) {
-    return transferSubname(name, contract, '0x0000000000000000000000000000000000000000', options);
+async function default_1({ transferSubname }, name, { contract, }) {
+    return transferSubname.populateTransaction(name, {
+        contract,
+        address: '0x0000000000000000000000000000000000000000',
+    });
 }
 exports.default = default_1;

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

@@ -0,0 +1,7 @@
+import * as packet from 'dns-packet';
+export declare function encodeURLParams(p: {
+    [key: string]: string;
+}): string;
+export declare const getDNS: (q: packet.Packet) => Promise<packet.Packet>;
+export declare const dnsQuery: (qtype: string, qname: string) => Promise<packet.Packet>;
+export default function (_: any, dnsName: string): Promise<any>;

package/dist/cjs/functions/getDNSOwner.js

@@ -0,0 +1,81 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dnsQuery = exports.getDNS = exports.encodeURLParams = void 0;
+const packet = __importStar(require("dns-packet"));
+function encodeURLParams(p) {
+    return Object.entries(p)
+        .map((kv) => kv.map(encodeURIComponent).join('='))
+        .join('&');
+}
+exports.encodeURLParams = encodeURLParams;
+const getDNS = async (q) => {
+    const response = await global.fetch(`https://cloudflare-dns.com/dns-query?${encodeURLParams({
+        ct: 'application/dns-udpwireformat',
+        dns: packet.encode(q)?.toString('base64'),
+        ts: Date.now().toString(),
+    })}`);
+    const arrayBuffer = await response.arrayBuffer();
+    // @ts-ignore:next-line
+    const fromArrayBuffer = Buffer.from(arrayBuffer);
+    return packet.decode(fromArrayBuffer);
+};
+exports.getDNS = getDNS;
+const dnsQuery = async (qtype, qname) => {
+    const query = {
+        type: 'query',
+        id: 1,
+        flags: packet.RECURSION_DESIRED,
+        questions: [
+            {
+                type: qtype,
+                class: 'IN',
+                name: qname,
+            },
+        ],
+        additionals: [
+            {
+                type: 'OPT',
+                class: 'IN',
+                name: '.',
+                udpPayloadSize: 4096,
+                flags: packet.DNSSEC_OK,
+            },
+        ],
+        answers: [],
+    };
+    const response = await (0, exports.getDNS)(query);
+    if (response.rcode !== 'NOERROR') {
+        throw new Error(`DNS query failed: ${response.rcode}`);
+    }
+    return response;
+};
+exports.dnsQuery = dnsQuery;
+async function default_1(_, dnsName) {
+    const result = await (0, exports.dnsQuery)('TXT', `_ens.${dnsName}`);
+    const address = result?.answers?.[0]?.data?.[0]?.toString()?.split('=')?.[1];
+    return address;
+}
+exports.default = default_1;

package/dist/cjs/functions/getFuses.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
 const fuses_1 = require("../utils/fuses");
+const normalise_1 = require("../utils/normalise");
 const NameSafety = [
     'Safe',
     'RegistrantNotWrapped',
@@ -14,7 +15,7 @@ const raw = async ({ contracts }, name) => {
     return {
         to: nameWrapper.address,
         data: nameWrapper.interface.encodeFunctionData('getFuses', [
-            ethers_1.ethers.utils.namehash(name),
+            (0, normalise_1.namehash)(name),
         ]),
     };
 };
@@ -38,7 +39,7 @@ const decode = async ({ contracts }, data, name) => {
         if (ethers_1.utils.hexStripZeros(vulnerableNode) !== '0x') {
             name.split('.').forEach((label, index, arr) => {
                 const node = arr.slice(index).join('.');
-                const nodehash = ethers_1.utils.namehash(node);
+                const nodehash = (0, normalise_1.namehash)(node);
                 if (nodehash === vulnerableNode) {
                     returnVulnerableNode = node;
                 }

package/dist/cjs/functions/getOwner.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
 const labels_1 = require("../utils/labels");
+const normalise_1 = require("../utils/normalise");
 const singleContractOwnerRaw = async ({ contracts }, contract, namehash, labels) => {
     switch (contract) {
         case 'nameWrapper': {
@@ -30,10 +31,10 @@ const singleContractOwnerRaw = async ({ contracts }, contract, namehash, labels)
     }
 };
 const raw = async ({ contracts, multicallWrapper }, name, contract) => {
-    const namehash = ethers_1.ethers.utils.namehash(name);
+    const namehash = (0, normalise_1.namehash)(name);
     const labels = name.split('.');
-    if (contract) {
-        return await singleContractOwnerRaw({ contracts }, contract, namehash, labels);
+    if (contract || labels.length === 1) {
+        return await singleContractOwnerRaw({ contracts }, contract || 'registry', namehash, labels);
     }
     const registryData = await singleContractOwnerRaw({ contracts }, 'registry', namehash, labels);
     const nameWrapperData = await singleContractOwnerRaw({ contracts }, 'nameWrapper', namehash, labels);
@@ -48,10 +49,11 @@ const singleContractOwnerDecode = (data) => ethers_1.ethers.utils.defaultAbiCode
 const decode = async ({ contracts, multicallWrapper }, data, name, contract) => {
     if (data === null)
         return;
-    if (contract) {
+    const labels = name.split('.');
+    if (contract || labels.length === 1) {
         const singleOwner = singleContractOwnerDecode(data);
         let obj = {
-            ownershipLevel: contract,
+            ownershipLevel: contract || 'registry',
         };
         if (contract === 'registrar') {
             return {
@@ -76,7 +78,6 @@ const decode = async ({ contracts, multicallWrapper }, data, name, contract) =>
     const registryOwner = decodedData[0][0];
     const nameWrapperOwner = decodedData[1][0];
     const registrarOwner = decodedData[2]?.[0];
-    const labels = name.split('.');
     // check for only .eth names
     if (labels[labels.length - 1] === 'eth') {
         // if the owner on the registrar is the namewrapper, then the namewrapper owner is the owner

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, }: ENSArgs<'contracts' | 'gqlInstance' | 'getName' | '_getText' | '_getAddr' | '_getContentHash' | 'resolverMulticallWrapper'>, 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 = [];
@@ -42,23 +43,51 @@ const makeMulticallData = async ({ _getAddr, _getContentHash, _getText, resolver
     const prRawData = await resolverMulticallWrapper.raw(calls.map((x) => x.data));
     return { data: prRawData.data, calls };
 };
-const makeHashIndexes = (data, name) => [...data.matchAll(ethers_1.ethers.utils.namehash(name).substring(2))].map((x) => x.index / 2 - 1);
-const getDataForName = async ({ contracts, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, }, name, options) => {
+const fetchWithoutResolverMulticall = async ({ multicallWrapper }, calls, resolverAddress) => {
+    const callsWithResolver = calls.map((call) => ({
+        to: resolverAddress,
+        data: call.data.data,
+    }));
+    return (await multicallWrapper(callsWithResolver)).map((x) => x[1]);
+};
+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 resolver;
+    let resolvedData;
+    let useFallbackResolver = false;
     try {
-        resolver = 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 {
-        return;
+        useFallbackResolver = true;
+    }
+    let resolverAddress;
+    let recordData;
+    if (useFallbackResolver) {
+        resolverAddress = specificResolver || fallbackResolver;
+        recordData = await fetchWithoutResolverMulticall({ multicallWrapper }, calls, resolverAddress);
+    }
+    else {
+        resolverAddress = specificResolver || resolvedData['1'];
+        if (specificResolver) {
+            recordData = resolvedData;
+        }
+        else {
+            ;
+            [recordData] = await resolverMulticallWrapper.decode(resolvedData['0']);
+        }
     }
-    const [recordData] = await resolverMulticallWrapper.decode(resolver['0']);
     const matchAddress = recordData[calls.findIndex((x) => x.key === '60')];
     return {
         address: matchAddress && (await _getAddr.decode(matchAddress)),
         records: await formatRecords({ _getAddr, _getContentHash, _getText }, recordData, calls, options),
-        resolverAddress: resolver['1'],
+        resolverAddress,
     };
 };
 const formatRecords = async ({ _getText, _getAddr, _getContentHash, }, data, calls, options) => {
@@ -68,7 +97,7 @@ const formatRecords = async ({ _getText, _getAddr, _getContentHash, }, data, cal
             key: calls[i].key,
             type: calls[i].type,
         };
-        if (itemRet.type === 'addr' || itemRet.type === 'contenthash') {
+        if (itemRet.type === 'contenthash') {
             decodedFromAbi = ethers_1.ethers.utils.defaultAbiCoder.decode(['bytes'], item)[0];
             if (ethers_1.ethers.utils.hexStripZeros(decodedFromAbi) === '0x') {
                 return;
@@ -144,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 {
@@ -157,18 +186,52 @@ const graphFetch = async ({ gqlInstance }, name, wantedRecords) => {
           addr {
             id
           }
+          address
+        }
+      }
+    }
+  `;
+    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 (!wantedRecords)
+    if (!resolverResponse)
         return { isMigrated, createdAt };
+    if (!wantedRecords)
+        return {
+            isMigrated,
+            createdAt,
+            graphResolverAddress: resolverResponse.address || resolverAddress,
+        };
     Object.keys(wantedRecords).forEach((key) => {
         const data = wantedRecords[key];
         if (typeof data === 'boolean' && data) {
@@ -180,28 +243,40 @@ const graphFetch = async ({ gqlInstance }, name, wantedRecords) => {
             }
         }
     });
-    return { ...returnedRecords, isMigrated, createdAt };
+    return {
+        ...returnedRecords,
+        isMigrated,
+        createdAt,
+        graphResolverAddress: resolverResponse.address || resolverAddress,
+    };
 };
-const getProfileFromName = async ({ contracts, gqlInstance, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, }, name, options) => {
-    const usingOptions = !options || options?.texts === true || options?.coinTypes === true
-        ? options || { contentHash: true, texts: true, coinTypes: true }
+const getProfileFromName = async ({ contracts, gqlInstance, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, multicallWrapper, }, name, options) => {
+    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, ...wantedRecords } = graphResult;
+    const { isMigrated, createdAt, graphResolverAddress, ...wantedRecords } = graphResult;
+    if (!graphResolverAddress && !options?.resolverAddress)
+        return { isMigrated, createdAt, message: "Name doesn't have a resolver" };
     const result = await getDataForName({
         contracts,
         _getAddr,
         _getContentHash,
         _getText,
         resolverMulticallWrapper,
-    }, name, usingOptions ? wantedRecords : options);
+        multicallWrapper,
+    }, name, usingOptions ? wantedRecords : options, graphResolverAddress, options?.resolverAddress);
     if (!result)
         return { isMigrated, createdAt, message: "Records fetch didn't complete" };
     return { ...result, isMigrated, createdAt, message: undefined };
 };
-const getProfileFromAddress = async ({ contracts, gqlInstance, getName, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, }, address, options) => {
+const getProfileFromAddress = async ({ contracts, gqlInstance, getName, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, multicallWrapper, }, address, options) => {
     let name;
     try {
         name = await getName(address);
@@ -220,6 +295,7 @@ const getProfileFromAddress = async ({ contracts, gqlInstance, getName, _getAddr
         _getContentHash,
         _getText,
         resolverMulticallWrapper,
+        multicallWrapper,
     }, name.name, options);
     if (!result || result.message)
         return;
@@ -230,7 +306,7 @@ const getProfileFromAddress = async ({ contracts, gqlInstance, getName, _getAddr
         message: undefined,
     };
 };
-async function default_1({ contracts, gqlInstance, getName, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, }, nameOrAddress, options) {
+async function default_1({ contracts, gqlInstance, getName, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, multicallWrapper, }, nameOrAddress, options) {
     if (options && options.coinTypes && typeof options.coinTypes !== 'boolean') {
         options.coinTypes = options.coinTypes.map((coin) => {
             if (!isNaN(parseInt(coin))) {
@@ -254,6 +330,7 @@ async function default_1({ contracts, gqlInstance, getName, _getAddr, _getConten
             _getContentHash,
             _getText,
             resolverMulticallWrapper,
+            multicallWrapper,
         }, nameOrAddress, options);
     }
     return getProfileFromName({
@@ -263,6 +340,7 @@ async function default_1({ contracts, gqlInstance, getName, _getAddr, _getConten
         _getContentHash,
         _getText,
         resolverMulticallWrapper,
+        multicallWrapper,
     }, nameOrAddress, options);
 }
 exports.default = default_1;

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;