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

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

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

package/dist/cjs/functions/burnFuses.js

@@ -9,6 +9,6 @@ async function default_1({ contracts, signer }, name, { fusesToBurn, }) {
     const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
     const hash = (0, normalise_1.namehash)(name);
     const encodedFuses = (0, generateFuseInput_1.default)(fusesToBurn);
-    return nameWrapper.burnFuses(hash, encodedFuses);
+    return nameWrapper.populateTransaction.burnFuses(hash, encodedFuses);
 }
 exports.default = default_1;

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

@@ -11,5 +11,5 @@ declare type NameWrapperArgs = {
     fuses?: FuseOptions;
 } & BaseArgs;
 declare type Args = BaseArgs | NameWrapperArgs;
-export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { owner, resolverAddress, contract, ...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

@@ -23,14 +23,14 @@ async function default_1({ contracts, signer }, name, { owner, resolverAddress,
     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 ({ transferSubname }: ENSArgs<'transferSubname'>, name: string, { contract, }: {
     contract: 'registry' | 'nameWrapper';
-}): Promise<import("ethers").ContractTransaction>;
+}): Promise<import("ethers").PopulatedTransaction>;

package/dist/cjs/functions/deleteSubname.js

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

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

@@ -2,4 +2,4 @@ import { ENSArgs } from '..';
 export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { address, resolver, }?: {
     address?: string;
     resolver?: string;
-}): Promise<import("ethers").ContractTransaction | undefined>;
+}): Promise<import("ethers").PopulatedTransaction>;

package/dist/cjs/functions/setName.js

@@ -5,8 +5,8 @@ async function default_1({ contracts, signer }, name, { address, resolver, } = {
     const reverseRegistrar = (await contracts?.getReverseRegistrar())?.connect(signer);
     if (address) {
         const publicResolver = await contracts?.getPublicResolver();
-        return reverseRegistrar?.setNameForAddr(address, signerAddress, resolver || publicResolver.address, name);
+        return reverseRegistrar.populateTransaction.setNameForAddr(address, signerAddress, resolver || publicResolver.address, name);
     }
-    return reverseRegistrar?.setName(name);
+    return reverseRegistrar.populateTransaction.setName(name);
 }
 exports.default = default_1;

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

@@ -3,4 +3,4 @@ import { RecordOptions } from '../utils/recordHelpers';
 export default function ({ contracts, provider, getResolver, signer, }: ENSArgs<'contracts' | 'provider' | 'getResolver' | 'signer'>, name: string, { records, resolverAddress, }: {
     records: RecordOptions;
     resolverAddress?: string;
-}): Promise<import("ethers").ContractTransaction | undefined>;
+}): Promise<import("ethers").PopulatedTransaction>;

package/dist/cjs/functions/setRecords.js

@@ -19,6 +19,6 @@ async function default_1({ contracts, provider, getResolver, signer, }, name, {
     const resolver = (await contracts?.getPublicResolver(provider, resolverToUse))?.connect(signer);
     const hash = (0, normalise_1.namehash)(name);
     const calls = (0, recordHelpers_1.generateRecordCallArray)(hash, records, resolver);
-    return resolver?.multicall(calls);
+    return resolver.populateTransaction.multicall(calls);
 }
 exports.default = default_1;

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

@@ -2,4 +2,4 @@ import { ENSArgs } from '..';
 export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { contract, resolver, }: {
     contract: 'registry' | 'nameWrapper';
     resolver?: string;
-}): Promise<import("ethers").ContractTransaction>;
+}): Promise<import("ethers").PopulatedTransaction>;

package/dist/cjs/functions/setResolver.js

@@ -8,11 +8,11 @@ async function default_1({ contracts, signer }, name, { contract, resolver, }) {
     switch (contract) {
         case 'registry': {
             const registry = (await contracts?.getRegistry()).connect(signer);
-            return registry.setResolver((0, normalise_1.namehash)(name), resolver);
+            return registry.populateTransaction.setResolver((0, normalise_1.namehash)(name), resolver);
         }
         case 'nameWrapper': {
             const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
-            return nameWrapper.setResolver((0, normalise_1.namehash)(name), resolver);
+            return nameWrapper.populateTransaction.setResolver((0, normalise_1.namehash)(name), resolver);
         }
         default: {
             throw new Error(`Unknown contract: ${contract}`);

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

@@ -3,4 +3,4 @@ import { ENSArgs } from '..';
 export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { newOwner, contract, }: {
     newOwner: string;
     contract: 'registry' | 'nameWrapper' | 'baseRegistrar';
-}): Promise<ethers.ContractTransaction>;
+}): Promise<ethers.PopulatedTransaction>;

package/dist/cjs/functions/transferName.js

@@ -7,7 +7,7 @@ async function default_1({ contracts, signer }, name, { newOwner, contract, }) {
     switch (contract) {
         case 'registry': {
             const registry = (await contracts?.getRegistry()).connect(signer);
-            return registry.setOwner((0, normalise_1.namehash)(name), newOwner);
+            return registry.populateTransaction.setOwner((0, normalise_1.namehash)(name), newOwner);
         }
         case 'baseRegistrar': {
             const baseRegistrar = (await contracts?.getBaseRegistrar()).connect(signer);
@@ -15,11 +15,11 @@ async function default_1({ contracts, signer }, name, { newOwner, contract, }) {
             if (labels.length > 2 || labels[labels.length - 1] !== 'eth') {
                 throw new Error('Invalid name for baseRegistrar');
             }
-            return baseRegistrar['safeTransferFrom(address,address,uint256)'](address, newOwner, ethers_1.ethers.utils.solidityKeccak256(['string'], [labels[0]]));
+            return baseRegistrar.populateTransaction['safeTransferFrom(address,address,uint256)'](address, newOwner, ethers_1.ethers.utils.solidityKeccak256(['string'], [labels[0]]));
         }
         case 'nameWrapper': {
             const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
-            return nameWrapper.safeTransferFrom(address, newOwner, (0, normalise_1.namehash)(name), 1, '0x');
+            return nameWrapper.populateTransaction.safeTransferFrom(address, newOwner, (0, normalise_1.namehash)(name), 1, '0x');
         }
         default: {
             throw new Error(`Unknown contract: ${contract}`);

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

@@ -3,4 +3,4 @@ import { ENSArgs } from '..';
 export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { contract, address, }: {
     contract: 'registry' | 'nameWrapper';
     address: string;
-}): Promise<ethers.ContractTransaction>;
+}): Promise<ethers.PopulatedTransaction>;

package/dist/cjs/functions/transferSubname.js

@@ -10,11 +10,11 @@ async function default_1({ contracts, signer }, name, { contract, address, }) {
     switch (contract) {
         case 'registry': {
             const registry = (await contracts?.getRegistry()).connect(signer);
-            return registry.setSubnodeOwner(parentNodehash, labelhash, address);
+            return registry.populateTransaction.setSubnodeOwner(parentNodehash, labelhash, address);
         }
         case 'nameWrapper': {
             const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
-            return nameWrapper.setSubnodeOwner(parentNodehash, label, address, '0');
+            return nameWrapper.populateTransaction.setSubnodeOwner(parentNodehash, label, address, '0');
         }
         default: {
             throw new Error(`Unknown contract: ${contract}`);

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

@@ -2,4 +2,4 @@ import { ENSArgs } from '..';
 export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { newController, newRegistrant, }: {
     newController: string;
     newRegistrant?: string;
-}): Promise<import("ethers").ContractTransaction>;
+}): Promise<import("ethers").PopulatedTransaction>;

package/dist/cjs/functions/unwrapName.js

@@ -11,13 +11,13 @@ async function default_1({ contracts, signer }, name, { newController, newRegist
         if (!newRegistrant) {
             throw new Error('newRegistrant must be specified for .eth names');
         }
-        return nameWrapper.unwrapETH2LD(labelhash, newRegistrant, newController);
+        return nameWrapper.populateTransaction.unwrapETH2LD(labelhash, newRegistrant, newController);
     }
     else {
         if (newRegistrant) {
             throw new Error('newRegistrant can only be specified for .eth names');
         }
-        return nameWrapper.unwrap(parentNodehash, labelhash, newController);
+        return nameWrapper.populateTransaction.unwrap(parentNodehash, labelhash, newController);
     }
 }
 exports.default = default_1;

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

@@ -1,8 +1,8 @@
 import { ethers } from 'ethers';
 import { ENSArgs } from '..';
 import type { FuseOptions } from '../@types/FuseOptions';
-export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { wrappedOwner, fuseOptions, resolverAddress, }: {
+export default function ({ contracts, signer, populate }: ENSArgs<'contracts' | 'signer' | 'populate'>, name: string, { wrappedOwner, fuseOptions, resolverAddress, }: {
     wrappedOwner: string;
     fuseOptions?: FuseOptions | string | number;
     resolverAddress?: string;
-}): Promise<ethers.ContractTransaction>;
+}): Promise<ethers.PopulatedTransaction>;

package/dist/cjs/functions/wrapName.js

@@ -11,7 +11,7 @@ async function wrapETH({ contracts }, labels, wrappedOwner, decodedFuses, resolv
     const baseRegistrar = (await contracts?.getBaseRegistrar()).connect(signer);
     const labelhash = ethers_1.ethers.utils.solidityKeccak256(['string'], [labels[0]]);
     const data = ethers_1.ethers.utils.defaultAbiCoder.encode(['string', 'address', 'uint32', 'uint64', 'address'], [labels[0], wrappedOwner, '0x0', decodedFuses, resolverAddress]);
-    return baseRegistrar['safeTransferFrom(address,address,uint256,bytes)'](address, nameWrapper.address, labelhash, data);
+    return baseRegistrar.populateTransaction['safeTransferFrom(address,address,uint256,bytes)'](address, nameWrapper.address, labelhash, data);
 }
 async function wrapOther({ contracts }, name, wrappedOwner, decodedFuses, resolverAddress, address, signer) {
     const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
@@ -20,9 +20,9 @@ async function wrapOther({ contracts }, name, wrappedOwner, decodedFuses, resolv
     if (!hasApproval) {
         throw new Error('NameWrapper must have approval to wrap a name from this address.');
     }
-    return nameWrapper.wrap((0, hexEncodedName_1.hexEncodeName)(name), wrappedOwner, decodedFuses, resolverAddress);
+    return nameWrapper.populateTransaction.wrap((0, hexEncodedName_1.hexEncodeName)(name), wrappedOwner, decodedFuses, resolverAddress);
 }
-async function default_1({ contracts, signer }, name, { wrappedOwner, fuseOptions, resolverAddress, }) {
+async function default_1({ contracts, signer, populate }, name, { wrappedOwner, fuseOptions, resolverAddress, }) {
     const address = await signer.getAddress();
     let decodedFuses;
     switch (typeof fuseOptions) {

package/dist/cjs/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 {};