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

package/dist/cjs/functions/getSpecificRecord.js

@@ -4,13 +4,14 @@ exports.getAddr = exports._getAddr = exports.getText = exports._getText = export
 const address_encoder_1 = require("@ensdomains/address-encoder");
 const ethers_1 = require("ethers");
 const contentHash_1 = require("../utils/contentHash");
+const normalise_1 = require("../utils/normalise");
 exports._getContentHash = {
     raw: async ({ contracts }, name) => {
         const publicResolver = await contracts?.getPublicResolver();
         return {
             to: '0x0000000000000000000000000000000000000000',
             data: publicResolver.interface.encodeFunctionData('contenthash', [
-                ethers_1.ethers.utils.namehash(name),
+                (0, normalise_1.namehash)(name),
             ]),
         };
     },
@@ -48,7 +49,7 @@ exports._getText = {
         return {
             to: '0x0000000000000000000000000000000000000000',
             data: publicResolver.interface.encodeFunctionData('text', [
-                ethers_1.ethers.utils.namehash(name),
+                (0, normalise_1.namehash)(name),
                 key,
             ]),
         };
@@ -80,10 +81,18 @@ exports._getAddr = {
             coinType = 60;
         }
         const publicResolver = await contracts?.getPublicResolver();
+        if (coinType === 60 || coinType === '60') {
+            return {
+                to: '0x0000000000000000000000000000000000000000',
+                data: publicResolver.interface.encodeFunctionData('addr(bytes32)', [
+                    (0, normalise_1.namehash)(name),
+                ]),
+            };
+        }
         if (bypassFormat) {
             return {
                 to: '0x0000000000000000000000000000000000000000',
-                data: publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [ethers_1.ethers.utils.namehash(name), coinType]),
+                data: publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [(0, normalise_1.namehash)(name), coinType]),
             };
         }
         const formatter = typeof coinType === 'string' && isNaN(parseInt(coinType))
@@ -94,7 +103,7 @@ exports._getAddr = {
         }
         return {
             to: '0x0000000000000000000000000000000000000000',
-            data: publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [ethers_1.ethers.utils.namehash(name), formatter.coinType]),
+            data: publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [(0, normalise_1.namehash)(name), formatter.coinType]),
         };
     },
     decode: async ({ contracts }, data, _name, coinType) => {
@@ -107,7 +116,15 @@ exports._getAddr = {
         const formatter = typeof coinType === 'string' && isNaN(parseInt(coinType))
             ? address_encoder_1.formatsByName[coinType]
             : address_encoder_1.formatsByCoinType[typeof coinType === 'number' ? coinType : parseInt(coinType)];
-        const [response] = publicResolver.interface.decodeFunctionResult('addr(bytes32,uint256)', data);
+        let response;
+        if (coinType === 60 || coinType === '60') {
+            ;
+            [response] = publicResolver.interface.decodeFunctionResult('addr(bytes32)', data);
+        }
+        else {
+            ;
+            [response] = publicResolver.interface.decodeFunctionResult('addr(bytes32,uint256)', data);
+        }
         if (!response)
             return;
         if (ethers_1.ethers.utils.hexStripZeros(response) === '0x') {

package/dist/cjs/functions/getSubnames.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("ethers/lib/utils");
 const format_1 = require("../utils/format");
 const labels_1 = require("../utils/labels");
+const normalise_1 = require("../utils/normalise");
 const largeQuery = async ({ gqlInstance }, { name, page, pageSize = 10, orderDirection, orderBy, lastSubnames }) => {
     const client = gqlInstance.client;
     let finalQuery = gqlInstance.gql `
@@ -38,7 +38,7 @@ const largeQuery = async ({ gqlInstance }, { name, page, pageSize = 10, orderDir
     }
   `;
     let queryVars = {
-        id: (0, utils_1.namehash)(name),
+        id: (0, normalise_1.namehash)(name),
         first: pageSize,
         lastCreatedAt: lastSubnames[lastSubnames.length - 1]?.createdAt,
         orderBy,
@@ -55,7 +55,7 @@ const largeQuery = async ({ gqlInstance }, { name, page, pageSize = 10, orderDir
     });
     return {
         subnames: subdomains,
-        subnameCount: domain.subdomainCount
+        subnameCount: domain.subdomainCount,
     };
 };
 const smallQuery = async ({ gqlInstance }, { name, page, pageSize = 10, orderDirection, orderBy }) => {
@@ -94,7 +94,7 @@ const smallQuery = async ({ gqlInstance }, { name, page, pageSize = 10, orderDir
     }
   `;
         queryVars = {
-            id: (0, utils_1.namehash)(name),
+            id: (0, normalise_1.namehash)(name),
             orderBy,
             orderDirection,
         };
@@ -124,7 +124,7 @@ const smallQuery = async ({ gqlInstance }, { name, page, pageSize = 10, orderDir
     }
   `;
         queryVars = {
-            id: (0, utils_1.namehash)(name),
+            id: (0, normalise_1.namehash)(name),
             first: pageSize,
             skip: (page || 0) * pageSize,
             orderBy,
@@ -142,7 +142,7 @@ const smallQuery = async ({ gqlInstance }, { name, page, pageSize = 10, orderDir
     });
     return {
         subnames: subdomains,
-        subnameCount: domain.subdomainCount
+        subnameCount: domain.subdomainCount,
     };
 };
 const getSubnames = (injected, functionArgs) => {

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

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

package/dist/cjs/functions/setName.js

@@ -1,17 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-async function default_1({ contracts, provider }, name, address, resolver, options) {
-    const signerAddress = await provider
-        ?.getSigner(options?.addressOrIndex)
-        .getAddress();
-    if (!signerAddress) {
-        throw new Error('No signer found');
-    }
-    const reverseRegistrar = (await contracts?.getReverseRegistrar())?.connect(provider?.getSigner());
+async function default_1({ contracts, signer }, name, { address, resolver, } = {}) {
+    const signerAddress = await signer.getAddress();
+    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/setRecord.d.ts

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

package/dist/cjs/functions/setRecord.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const normalise_1 = require("../utils/normalise");
+const recordHelpers_1 = require("../utils/recordHelpers");
+async function default_1({ contracts, provider, getResolver, signer, }, name, { record, type, resolverAddress, }) {
+    if (!name.includes('.')) {
+        throw new Error('Input is not an ENS name');
+    }
+    let resolverToUse;
+    if (resolverAddress) {
+        resolverToUse = resolverAddress;
+    }
+    else {
+        resolverToUse = await getResolver(name);
+    }
+    if (!resolverToUse) {
+        throw new Error('No resolver found for input address');
+    }
+    const resolver = (await contracts?.getPublicResolver(provider, resolverToUse))?.connect(signer);
+    const hash = (0, normalise_1.namehash)(name);
+    const call = (0, recordHelpers_1.generateSingleRecordCall)(hash, resolver, type)(record);
+    return {
+        to: resolver.address,
+        data: call,
+    };
+}
+exports.default = default_1;

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

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

package/dist/cjs/functions/setRecords.js

@@ -1,22 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const ethers_1 = require("ethers");
+const normalise_1 = require("../utils/normalise");
 const recordHelpers_1 = require("../utils/recordHelpers");
-async function default_1({ contracts, provider, getResolver, }, name, records) {
+async function default_1({ contracts, provider, getResolver, signer, }, name, { records, resolverAddress, }) {
     if (!name.includes('.')) {
         throw new Error('Input is not an ENS name');
     }
-    const resolverAddress = await getResolver(name);
-    if (!resolverAddress) {
-        throw new Error('No resolver found for input address');
+    let resolverToUse;
+    if (resolverAddress) {
+        resolverToUse = resolverAddress;
+    }
+    else {
+        resolverToUse = await getResolver(name);
     }
-    const address = await provider?.getSigner().getAddress();
-    if (!address) {
-        throw new Error('No signer found');
+    if (!resolverToUse) {
+        throw new Error('No resolver found for input address');
     }
-    const resolver = (await contracts?.getPublicResolver(provider, resolverAddress))?.connect(provider?.getSigner());
-    const namehash = ethers_1.ethers.utils.namehash(name);
-    const calls = (0, recordHelpers_1.generateRecordCallArray)(namehash, records, resolver);
-    return resolver?.multicall(calls);
+    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.populateTransaction.multicall(calls);
 }
 exports.default = default_1;

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

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

package/dist/cjs/functions/setResolver.js

@@ -1,24 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const ethers_1 = require("ethers");
-async function default_1({ contracts, provider }, name, contract, resolver, options) {
-    const address = await provider
-        ?.getSigner(options?.addressOrIndex)
-        .getAddress();
-    if (!address) {
-        throw new Error('No signer found');
-    }
+const normalise_1 = require("../utils/normalise");
+async function default_1({ contracts, signer }, name, { contract, resolver, }) {
     if (!resolver) {
         resolver = (await contracts?.getPublicResolver()).address;
     }
     switch (contract) {
         case 'registry': {
-            const registry = (await contracts?.getRegistry()).connect(provider?.getSigner(options?.addressOrIndex));
-            return registry.setResolver(ethers_1.ethers.utils.namehash(name), resolver);
+            const registry = (await contracts?.getRegistry()).connect(signer);
+            return registry.populateTransaction.setResolver((0, normalise_1.namehash)(name), resolver);
         }
         case 'nameWrapper': {
-            const nameWrapper = (await contracts?.getNameWrapper()).connect(provider?.getSigner(options?.addressOrIndex));
-            return nameWrapper.setResolver(ethers_1.ethers.utils.namehash(name), resolver);
+            const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
+            return nameWrapper.populateTransaction.setResolver((0, normalise_1.namehash)(name), resolver);
         }
         default: {
             throw new Error(`Unknown contract: ${contract}`);

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

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

package/dist/cjs/functions/transferName.js

@@ -1,29 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
-async function default_1({ contracts, provider }, name, newOwner, contract, options) {
-    const address = await provider
-        ?.getSigner(options?.addressOrIndex)
-        .getAddress();
-    if (!address) {
-        throw new Error('No signer found');
-    }
+const normalise_1 = require("../utils/normalise");
+async function default_1({ contracts, signer }, name, { newOwner, contract, }) {
+    const address = await signer.getAddress();
     switch (contract) {
         case 'registry': {
-            const registry = (await contracts?.getRegistry()).connect(provider?.getSigner(options?.addressOrIndex));
-            return registry.setOwner(ethers_1.ethers.utils.namehash(name), newOwner);
+            const registry = (await contracts?.getRegistry()).connect(signer);
+            return registry.populateTransaction.setOwner((0, normalise_1.namehash)(name), newOwner);
         }
         case 'baseRegistrar': {
-            const baseRegistrar = (await contracts?.getBaseRegistrar()).connect(provider?.getSigner(options?.addressOrIndex));
+            const baseRegistrar = (await contracts?.getBaseRegistrar()).connect(signer);
             const labels = name.split('.');
             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(provider?.getSigner(options?.addressOrIndex));
-            return nameWrapper.safeTransferFrom(address, newOwner, ethers_1.ethers.utils.namehash(name), 1, '0x');
+            const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
+            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

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

package/dist/cjs/functions/transferSubname.js

@@ -1,23 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
-async function default_1({ contracts, provider }, name, contract, address, options) {
-    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, { contract, address, }) {
     const labels = name.split('.');
     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.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

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

package/dist/cjs/functions/unwrapName.js

@@ -1,27 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
-async function default_1({ contracts, provider }, name, newController, newRegistrant, options) {
-    const signer = provider?.getSigner(options?.addressOrIndex);
-    const address = await signer?.getAddress();
-    if (!signer || !address) {
-        throw new Error('No signer found');
-    }
+const normalise_1 = require("../utils/normalise");
+async function default_1({ contracts, signer }, name, { newController, newRegistrant, }) {
     const labels = name.split('.');
     const labelhash = ethers_1.utils.solidityKeccak256(['string'], [labels[0]]);
-    const parentNodehash = ethers_1.utils.namehash(labels.slice(1).join('.'));
+    const parentNodehash = (0, normalise_1.namehash)(labels.slice(1).join('.'));
     const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
     if (labels.length === 2 && labels[1] === 'eth') {
         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,6 +1,8 @@
 import { ethers } from 'ethers';
 import { ENSArgs } from '..';
 import type { FuseOptions } from '../@types/FuseOptions';
-export default function ({ contracts, provider }: ENSArgs<'contracts' | 'provider'>, name: string, wrappedOwner: string, fuseOptions?: FuseOptions | string | number, resolverAddress?: string, options?: {
-    addressOrIndex?: string | number;
-}): Promise<ethers.ContractTransaction>;
+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.PopulatedTransaction>;

package/dist/cjs/functions/wrapName.js

@@ -10,24 +10,20 @@ async function wrapETH({ contracts }, labels, wrappedOwner, decodedFuses, resolv
     const nameWrapper = await contracts?.getNameWrapper();
     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', 'uint96', 'address'], [labels[0], wrappedOwner, decodedFuses, resolverAddress]);
-    return baseRegistrar['safeTransferFrom(address,address,uint256,bytes)'](address, nameWrapper.address, labelhash, data);
+    const data = ethers_1.ethers.utils.defaultAbiCoder.encode(['string', 'address', 'uint32', 'uint64', 'address'], [labels[0], wrappedOwner, '0x0', decodedFuses, resolverAddress]);
+    return baseRegistrar.populateTransaction['safeTransferFrom(address,address,uint256,bytes)'](address, nameWrapper.address, labelhash, data);
 }
-async function wrapOther({ contracts }, name, wrappedOwner, decodedFuses, resolverAddress, address) {
-    const nameWrapper = await contracts?.getNameWrapper();
+async function wrapOther({ contracts }, name, wrappedOwner, decodedFuses, resolverAddress, address, signer) {
+    const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
     const registry = await contracts?.getRegistry();
     const hasApproval = await registry.isApprovedForAll(address, nameWrapper.address);
     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, provider }, name, wrappedOwner, fuseOptions, resolverAddress, options) {
-    const signer = provider?.getSigner(options?.addressOrIndex);
-    const address = await signer?.getAddress();
-    if (!signer || !address) {
-        throw new Error('No signer found');
-    }
+async function default_1({ contracts, signer, populate }, name, { wrappedOwner, fuseOptions, resolverAddress, }) {
+    const address = await signer.getAddress();
     let decodedFuses;
     switch (typeof fuseOptions) {
         case 'object': {
@@ -58,7 +54,7 @@ async function default_1({ contracts, provider }, name, wrappedOwner, fuseOption
         return wrapETH({ contracts }, labels, wrappedOwner, decodedFuses, resolverAddress, signer, address);
     }
     else {
-        return wrapOther({ contracts }, name, wrappedOwner, decodedFuses, resolverAddress, address);
+        return wrapOther({ contracts }, name, wrappedOwner, decodedFuses, resolverAddress, address, signer);
     }
 }
 exports.default = default_1;

package/dist/cjs/index.d.ts

@@ -1,7 +1,19 @@
-import { ethers } 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 setRecord from './functions/setRecord';
+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,6 +22,7 @@ declare type ENSOptions = {
 export declare type InternalENS = {
     options?: ENSOptions;
     provider?: ethers.providers.Provider;
+    signer: JsonRpcSigner;
     graphURI?: string | null;
 } & ENS;
 export declare type ENSArgs<K extends keyof InternalENS> = {
@@ -17,6 +30,15 @@ export declare type ENSArgs<K extends keyof InternalENS> = {
 };
 declare type OmitFirstArg<F> = F extends (x: any, ...args: infer P) => infer R ? (...args: P) => R : never;
 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?: 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;
@@ -77,6 +99,14 @@ export declare class ENS {
      * @returns {OmitFirstArg} - The generated wrapped function
      */
     private generateFunction;
+    /**
+     * Generates a write wrapped function
+     * @param {string} path - The path of the exported function
+     * @param {FunctionDeps} dependencies - An array of ENS properties
+     * @param {string} exportName - The export name of the target function
+     * @returns {OmitFirstArg} - The generated wrapped function
+     */
+    private generateWriteFunction;
     /**
      * Generates a wrapped function from raw and decode exports
      * @param {string} path - The path of the exported function
@@ -104,11 +134,13 @@ export declare class ENS {
         }>;
         decode: ({ multicallWrapper }: ENSArgs<"multicallWrapper">, data: string, ...items: BatchFunctionResult<RawFunction>[]) => Promise<any[] | undefined>;
     }>;
-    getProfile: (nameOrAddress: string, options?: {
+    getProfile: (nameOrAddress: string, options?: ({
         contentHash?: boolean | undefined;
         texts?: boolean | string[] | undefined;
         coinTypes?: boolean | string[] | undefined;
-    } | undefined) => Promise<{
+    } & {
+        resolverAddress?: string | undefined;
+    }) | undefined) => Promise<{
         isMigrated: boolean | null;
         createdAt: string | null;
         address?: string | undefined;
@@ -137,6 +169,7 @@ export declare class ENS {
         contentHash?: boolean | undefined;
         texts?: boolean | string[] | undefined;
         coinTypes?: boolean | string[] | undefined;
+        resolverAddress?: string | undefined;
     } | undefined) => Promise<{
         isMigrated: boolean | null;
         createdAt: string | null;
@@ -423,48 +456,17 @@ export declare class ENS {
         }>;
         decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<any>;
     }>;
-    setName: (name: string, address?: string | undefined, resolver?: string | undefined, options?: {
-        addressOrIndex?: string | number | undefined;
-    } | undefined) => Promise<ethers.ContractTransaction | undefined>;
-    setRecords: (name: string, records: import("./utils/recordHelpers").RecordOptions) => Promise<ethers.ContractTransaction | undefined>;
-    setResolver: (name: string, contract: "nameWrapper" | "registry", resolver?: string | undefined, options?: {
-        addressOrIndex?: string | number | undefined;
-    } | undefined) => Promise<ethers.ContractTransaction>;
-    transferName: (name: string, newOwner: string, contract: "nameWrapper" | "registry" | "baseRegistrar", options?: {
-        addressOrIndex?: string | number | undefined;
-    } | undefined) => Promise<ethers.ContractTransaction>;
-    wrapName: (name: string, wrappedOwner: string, fuseOptions?: string | number | import("./@types/FuseOptions").FuseOptions | undefined, resolverAddress?: string | undefined, options?: {
-        addressOrIndex?: string | number | undefined;
-    } | undefined) => Promise<ethers.ContractTransaction>;
-    unwrapName: (name: string, newController: string, newRegistrant?: string | undefined, options?: {
-        addressOrIndex?: string | number | undefined;
-    } | undefined) => Promise<ethers.ContractTransaction>;
-    burnFuses: (name: string, fusesToBurn: import("./@types/FuseOptions").FuseOptions) => Promise<ethers.ContractTransaction>;
-    createSubname: (args_0: {
-        name: string;
-        owner: string;
-        resolverAddress?: string | undefined;
-        contract: "nameWrapper" | "registry";
-        options?: {
-            addressOrIndex?: string | number | undefined;
-        } | undefined;
-    } | ({
-        contract: "nameWrapper";
-        fuses?: import("./@types/FuseOptions").FuseOptions | undefined;
-    } & {
-        name: string;
-        owner: string;
-        resolverAddress?: string | undefined;
-        contract: "nameWrapper" | "registry";
-        options?: {
-            addressOrIndex?: string | number | undefined;
-        } | undefined;
-    })) => Promise<ethers.ContractTransaction>;
-    deleteSubname: (name: string, contract: "nameWrapper" | "registry", options?: {
-        addressOrIndex?: string | number | undefined;
-    } | undefined) => Promise<ethers.ContractTransaction>;
-    transferSubname: (name: string, contract: "nameWrapper" | "registry", address: string, options?: {
-        addressOrIndex?: string | number | undefined;
-    } | undefined) => Promise<ethers.ContractTransaction>;
+    setName: WriteFunction<typeof setName>;
+    setRecords: WriteFunction<typeof setRecords>;
+    setRecord: WriteFunction<typeof setRecord>;
+    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 {};