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

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

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

package/dist/cjs/functions/burnFuses.js

@@ -5,11 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const generateFuseInput_1 = __importDefault(require("../utils/generateFuseInput"));
 const normalise_1 = require("../utils/normalise");
-async function default_1({ contracts, provider }, name, fusesToBurn) {
-    const signer = provider?.getSigner();
-    if (!signer) {
-        throw new Error('No signer found');
-    }
+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);

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

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

package/dist/cjs/functions/createSubname.js

@@ -6,11 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
 const generateFuseInput_1 = __importDefault(require("../utils/generateFuseInput"));
 const normalise_1 = require("../utils/normalise");
-async function default_1({ contracts, provider }, { name, owner, resolverAddress, contract, options, ...wrapperArgs }) {
-    const signer = provider?.getSigner(options?.addressOrIndex);
-    if (!signer) {
-        throw new Error('No signer found');
-    }
+async function default_1({ contracts, signer }, name, { owner, resolverAddress, contract, ...wrapperArgs }) {
     const labels = name.split('.');
     if (labels.length === 1) {
         throw new Error('Subnames in ENS.js can only be created for 2LDs, not TLDs');

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

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

package/dist/cjs/functions/deleteSubname.js

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

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;
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { address, resolver, }?: {
+    address?: string;
+    resolver?: string;
 }): Promise<import("ethers").ContractTransaction | undefined>;

package/dist/cjs/functions/setName.js

@@ -1,13 +1,8 @@
 "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);

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

@@ -1,3 +1,6 @@
 import { ENSArgs } from '..';
 import { RecordOptions } from '../utils/recordHelpers';
-export default function ({ contracts, provider, getResolver, }: ENSArgs<'contracts' | 'provider' | 'getResolver'>, name: string, records: RecordOptions): Promise<import("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").ContractTransaction | undefined>;

package/dist/cjs/functions/setRecords.js

@@ -2,19 +2,21 @@
 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, }, 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 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);

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

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

package/dist/cjs/functions/setResolver.js

@@ -1,23 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const normalise_1 = require("../utils/normalise");
-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');
-    }
+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));
+            const registry = (await contracts?.getRegistry()).connect(signer);
             return registry.setResolver((0, normalise_1.namehash)(name), resolver);
         }
         case 'nameWrapper': {
-            const nameWrapper = (await contracts?.getNameWrapper()).connect(provider?.getSigner(options?.addressOrIndex));
+            const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
             return nameWrapper.setResolver((0, normalise_1.namehash)(name), resolver);
         }
         default: {

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;
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { newOwner, contract, }: {
+    newOwner: string;
+    contract: 'registry' | 'nameWrapper' | 'baseRegistrar';
 }): Promise<ethers.ContractTransaction>;

package/dist/cjs/functions/transferName.js

@@ -2,20 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
 const normalise_1 = require("../utils/normalise");
-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');
-    }
+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));
+            const registry = (await contracts?.getRegistry()).connect(signer);
             return registry.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');
@@ -23,7 +18,7 @@ async function default_1({ contracts, provider }, name, newOwner, contract, opti
             return baseRegistrar['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));
+            const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
             return nameWrapper.safeTransferFrom(address, newOwner, (0, normalise_1.namehash)(name), 1, '0x');
         }
         default: {

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;
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { contract, address, }: {
+    contract: 'registry' | 'nameWrapper';
+    address: string;
 }): Promise<ethers.ContractTransaction>;

package/dist/cjs/functions/transferSubname.js

@@ -2,11 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
 const normalise_1 = require("../utils/normalise");
-async function default_1({ contracts, provider }, name, contract, address, options) {
-    const signer = provider?.getSigner(options?.addressOrIndex);
-    if (!signer) {
-        throw new Error('No signer found');
-    }
+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]);

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;
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { newController, newRegistrant, }: {
+    newController: string;
+    newRegistrant?: string;
 }): Promise<import("ethers").ContractTransaction>;

package/dist/cjs/functions/unwrapName.js

@@ -2,12 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
 const normalise_1 = require("../utils/normalise");
-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');
-    }
+async function default_1({ contracts, signer }, name, { newController, newRegistrant, }) {
     const labels = name.split('.');
     const labelhash = ethers_1.utils.solidityKeccak256(['string'], [labels[0]]);
     const parentNodehash = (0, normalise_1.namehash)(labels.slice(1).join('.'));

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;
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { wrappedOwner, fuseOptions, resolverAddress, }: {
+    wrappedOwner: string;
+    fuseOptions?: FuseOptions | string | number;
+    resolverAddress?: string;
 }): Promise<ethers.ContractTransaction>;

package/dist/cjs/functions/wrapName.js

@@ -10,11 +10,11 @@ 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]);
+    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);
 }
-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) {
@@ -22,12 +22,8 @@ async function wrapOther({ contracts }, name, wrappedOwner, decodedFuses, resolv
     }
     return nameWrapper.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 }, 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,4 +1,4 @@
-import { ethers } from 'ethers';
+import { ethers, Signer } from 'ethers';
 import ContractManager from './contracts';
 import { getContractAddress as _getContractAddress } from './contracts/getContractAddress';
 import { SupportedNetworkId } from './contracts/types';
@@ -10,6 +10,7 @@ declare type ENSOptions = {
 export declare type InternalENS = {
     options?: ENSOptions;
     provider?: ethers.providers.Provider;
+    signer: Signer;
     graphURI?: string | null;
 } & ENS;
 export declare type ENSArgs<K extends keyof InternalENS> = {
@@ -17,6 +18,10 @@ 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?: Signer;
+};
 export declare type RawFunction = {
     raw: (...args: any[]) => Promise<{
         to: string;
@@ -77,6 +82,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
@@ -423,49 +436,53 @@ 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;
+    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";
-        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>;
+    })) & 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>;
     getDNSOwner: (dnsName: string) => Promise<any>;
 }
 export {};

package/dist/cjs/index.js

@@ -95,9 +95,24 @@ class ENS {
             // otherwise, create a function from the raw and decode functions
             if (subFunc !== 'combine') {
                 // get the function to call
-                const func = subFunc ? mod[exportName][subFunc] : mod[exportName];
+                const func = subFunc && subFunc !== 'write'
+                    ? mod[exportName][subFunc]
+                    : mod[exportName];
                 // get the dependencies to forward to the function as the first arg
-                const dependenciesToForward = thisRef.forwardDependenciesFromArray(dependencies);
+                let dependenciesToForward = thisRef.forwardDependenciesFromArray(dependencies);
+                // if func is write func, inject signer into dependencies
+                if (subFunc === 'write') {
+                    const options = (args[1] || {});
+                    const signer = options.signer ||
+                        thisRef.provider?.getSigner(options.addressOrIndex);
+                    if (!signer) {
+                        throw new Error('No signer specified');
+                    }
+                    delete options.addressOrIndex;
+                    delete options.signer;
+                    dependenciesToForward = { ...dependenciesToForward, signer };
+                    return func(dependenciesToForward, args[0], options);
+                }
                 // return the function with the dependencies forwarded
                 return func(dependenciesToForward, ...args);
             }
@@ -124,6 +139,14 @@ class ENS {
      * @returns {OmitFirstArg} - The generated wrapped function
      */
     generateFunction = (path, dependencies, exportName = 'default') => this.importGenerator(path, dependencies, exportName);
+    /**
+     * 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
+     */
+    generateWriteFunction = (path, dependencies, exportName = 'default') => this.importGenerator(path, dependencies, exportName, 'write');
     /**
      * Generates a wrapped function from raw and decode exports
      * @param {string} path - The path of the exported function
@@ -194,32 +217,22 @@ class ENS {
     universalWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'universalWrapper');
     resolverMulticallWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'resolverMulticallWrapper');
     multicallWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'multicallWrapper');
-    setName = this.generateFunction('setName', [
-        'contracts',
-        'provider',
-    ]);
-    setRecords = this.generateFunction('setRecords', [
-        'contracts',
-        'provider',
-        'getResolver',
-    ]);
-    setResolver = this.generateFunction('setResolver', ['contracts', 'provider']);
-    transferName = this.generateFunction('transferName', ['contracts', 'provider']);
-    wrapName = this.generateFunction('wrapName', [
+    setName = this.generateWriteFunction('setName', [
         'contracts',
-        'provider',
     ]);
-    unwrapName = this.generateFunction('unwrapName', [
+    setRecords = this.generateWriteFunction('setRecords', ['contracts', 'provider', 'getResolver']);
+    setResolver = this.generateWriteFunction('setResolver', ['contracts']);
+    transferName = this.generateWriteFunction('transferName', ['contracts']);
+    wrapName = this.generateWriteFunction('wrapName', [
         'contracts',
-        'provider',
     ]);
-    burnFuses = this.generateFunction('burnFuses', [
+    unwrapName = this.generateWriteFunction('unwrapName', ['contracts']);
+    burnFuses = this.generateWriteFunction('burnFuses', [
         'contracts',
-        'provider',
     ]);
-    createSubname = this.generateFunction('createSubname', ['contracts', 'provider']);
-    deleteSubname = this.generateFunction('deleteSubname', ['contracts', 'provider', 'transferSubname']);
-    transferSubname = this.generateFunction('transferSubname', ['contracts', 'provider']);
+    createSubname = this.generateWriteFunction('createSubname', ['contracts']);
+    deleteSubname = this.generateWriteFunction('deleteSubname', ['transferSubname']);
+    transferSubname = this.generateWriteFunction('transferSubname', ['contracts']);
     getDNSOwner = this.generateFunction('getDNSOwner', []);
 }
 exports.ENS = ENS;

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

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

package/dist/esm/functions/burnFuses.js

@@ -1,10 +1,6 @@
 import generateFuseInput from '../utils/generateFuseInput';
 import { namehash } from '../utils/normalise';
-export default async function ({ contracts, provider }, name, fusesToBurn) {
-    const signer = provider?.getSigner();
-    if (!signer) {
-        throw new Error('No signer found');
-    }
+export default async function ({ contracts, signer }, name, { fusesToBurn, }) {
     const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
     const hash = namehash(name);
     const encodedFuses = generateFuseInput(fusesToBurn);

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

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

package/dist/esm/functions/createSubname.js

@@ -1,11 +1,7 @@
 import { ethers } from 'ethers';
 import generateFuseInput from '../utils/generateFuseInput';
 import { namehash } from '../utils/normalise';
-export default async function ({ contracts, provider }, { name, owner, resolverAddress, contract, options, ...wrapperArgs }) {
-    const signer = provider?.getSigner(options?.addressOrIndex);
-    if (!signer) {
-        throw new Error('No signer found');
-    }
+export default async function ({ contracts, signer }, name, { owner, resolverAddress, contract, ...wrapperArgs }) {
     const labels = name.split('.');
     if (labels.length === 1) {
         throw new Error('Subnames in ENS.js can only be created for 2LDs, not TLDs');

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

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

package/dist/esm/functions/deleteSubname.js

@@ -1,3 +1,6 @@
-export default async function ({ contracts, provider, transferSubname, }, name, contract, options) {
-    return transferSubname(name, contract, '0x0000000000000000000000000000000000000000', options);
+export default async function ({ transferSubname }, name, { contract, }) {
+    return transferSubname(name, {
+        contract,
+        address: '0x0000000000000000000000000000000000000000',
+    });
 }