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

package/dist/cjs/index.js

@@ -31,6 +31,7 @@ const contracts_1 = __importDefault(require("./contracts"));
 const getContractAddress_1 = require("./contracts/getContractAddress");
 const GqlManager_1 = __importDefault(require("./GqlManager"));
 const singleCall_1 = __importDefault(require("./utils/singleCall"));
+const writeTx_1 = __importDefault(require("./utils/writeTx"));
 const graphURIEndpoints = {
     1: 'https://api.thegraph.com/subgraphs/name/ensdomains/ens',
     3: 'https://api.thegraph.com/subgraphs/name/ensdomains/ensropsten',
@@ -89,29 +90,29 @@ 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
             if (subFunc !== 'combine') {
+                const writeable = subFunc === 'write' || subFunc === 'populateTransaction';
                 // get the function to call
-                const func = subFunc && subFunc !== 'write'
-                    ? mod[exportName][subFunc]
-                    : mod[exportName];
+                const func = subFunc && !writeable ? mod[exportName][subFunc] : mod[exportName];
                 // get the dependencies to forward to the function as the first arg
                 let dependenciesToForward = thisRef.forwardDependenciesFromArray(dependencies);
                 // if func is write func, inject signer into dependencies
-                if (subFunc === 'write') {
+                if (writeable) {
                     const options = (args[1] || {});
                     const signer = options.signer ||
                         thisRef.provider?.getSigner(options.addressOrIndex);
+                    const populate = subFunc === 'populateTransaction';
                     if (!signer) {
                         throw new Error('No signer specified');
                     }
                     delete options.addressOrIndex;
                     delete options.signer;
                     dependenciesToForward = { ...dependenciesToForward, signer };
-                    return func(dependenciesToForward, args[0], options);
+                    return func(dependenciesToForward, args[0], options).then((0, writeTx_1.default)(signer, populate));
                 }
                 // return the function with the dependencies forwarded
                 return func(dependenciesToForward, ...args);
@@ -129,6 +130,9 @@ class ENS {
             mainFunc.decode = this.importGenerator(path, dependencies, exportName, 'decode');
             mainFunc.batch = this.importGenerator(path, dependencies, exportName, 'batch', { raw: mainFunc.raw, decode: mainFunc.decode });
         }
+        else if (subFunc === 'write') {
+            mainFunc.populateTransaction = this.importGenerator(path, dependencies, exportName, 'populateTransaction');
+        }
         return mainFunc;
     };
     /**

package/dist/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/writeTx.d.ts

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

package/dist/cjs/utils/writeTx.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (signer, populate) => (tx) => populate ? tx : signer.sendTransaction(tx);

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/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/esm/functions/burnFuses.js

@@ -4,5 +4,5 @@ export default async function ({ contracts, signer }, name, { fusesToBurn, }) {
     const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
     const hash = namehash(name);
     const encodedFuses = generateFuseInput(fusesToBurn);
-    return nameWrapper.burnFuses(hash, encodedFuses);
+    return nameWrapper.populateTransaction.burnFuses(hash, encodedFuses);
 }

package/dist/esm/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/esm/functions/createSubname.js

@@ -18,14 +18,14 @@ export default async function ({ contracts, signer }, name, { owner, resolverAdd
     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
                 ? generateFuseInput(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/esm/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/esm/functions/deleteSubname.js

@@ -1,5 +1,5 @@
 export default async function ({ transferSubname }, name, { contract, }) {
-    return transferSubname(name, {
+    return transferSubname.populateTransaction(name, {
         contract,
         address: '0x0000000000000000000000000000000000000000',
     });

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 {};

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/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/esm/functions/setName.js

@@ -3,7 +3,7 @@ export default async function ({ 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);
 }

package/dist/esm/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/esm/functions/setRecords.js

@@ -17,5 +17,5 @@ export default async function ({ contracts, provider, getResolver, signer, }, na
     const resolver = (await contracts?.getPublicResolver(provider, resolverToUse))?.connect(signer);
     const hash = namehash(name);
     const calls = generateRecordCallArray(hash, records, resolver);
-    return resolver?.multicall(calls);
+    return resolver.populateTransaction.multicall(calls);
 }

package/dist/esm/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/esm/functions/setResolver.js

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

package/dist/esm/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/esm/functions/transferName.js

@@ -5,7 +5,7 @@ export default async function ({ contracts, signer }, name, { newOwner, contract
     switch (contract) {
         case 'registry': {
             const registry = (await contracts?.getRegistry()).connect(signer);
-            return registry.setOwner(namehash(name), newOwner);
+            return registry.populateTransaction.setOwner(namehash(name), newOwner);
         }
         case 'baseRegistrar': {
             const baseRegistrar = (await contracts?.getBaseRegistrar()).connect(signer);
@@ -13,11 +13,11 @@ export default async function ({ 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.utils.solidityKeccak256(['string'], [labels[0]]));
+            return baseRegistrar.populateTransaction['safeTransferFrom(address,address,uint256)'](address, newOwner, ethers.utils.solidityKeccak256(['string'], [labels[0]]));
         }
         case 'nameWrapper': {
             const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
-            return nameWrapper.safeTransferFrom(address, newOwner, namehash(name), 1, '0x');
+            return nameWrapper.populateTransaction.safeTransferFrom(address, newOwner, namehash(name), 1, '0x');
         }
         default: {
             throw new Error(`Unknown contract: ${contract}`);

package/dist/esm/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/esm/functions/transferSubname.js

@@ -8,11 +8,11 @@ export default async function ({ 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/esm/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/esm/functions/unwrapName.js

@@ -9,12 +9,12 @@ export default async function ({ contracts, signer }, name, { newController, new
         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);
     }
 }

package/dist/esm/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/esm/functions/wrapName.js

@@ -6,7 +6,7 @@ async function wrapETH({ contracts }, labels, wrappedOwner, decodedFuses, resolv
     const baseRegistrar = (await contracts?.getBaseRegistrar()).connect(signer);
     const labelhash = ethers.utils.solidityKeccak256(['string'], [labels[0]]);
     const data = 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);
@@ -15,9 +15,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(hexEncodeName(name), wrappedOwner, decodedFuses, resolverAddress);
+    return nameWrapper.populateTransaction.wrap(hexEncodeName(name), wrappedOwner, decodedFuses, resolverAddress);
 }
-export default async function ({ contracts, signer }, name, { wrappedOwner, fuseOptions, resolverAddress, }) {
+export default async function ({ contracts, signer, populate }, name, { wrappedOwner, fuseOptions, resolverAddress, }) {
     const address = await signer.getAddress();
     let decodedFuses;
     switch (typeof fuseOptions) {