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

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) {

package/dist/esm/index.d.ts

@@ -1,7 +1,18 @@
-import { ethers, Signer } from 'ethers';
+import { JsonRpcSigner } from '@ethersproject/providers';
+import { ContractTransaction, ethers, PopulatedTransaction } from 'ethers';
 import ContractManager from './contracts';
 import { getContractAddress as _getContractAddress } from './contracts/getContractAddress';
 import { SupportedNetworkId } from './contracts/types';
+import type burnFuses from './functions/burnFuses';
+import type createSubname from './functions/createSubname';
+import type deleteSubname from './functions/deleteSubname';
+import type setName from './functions/setName';
+import type setRecords from './functions/setRecords';
+import type setResolver from './functions/setResolver';
+import type transferName from './functions/transferName';
+import type transferSubname from './functions/transferSubname';
+import type unwrapName from './functions/unwrapName';
+import type wrapName from './functions/wrapName';
 import GqlManager from './GqlManager';
 declare type ENSOptions = {
     graphURI?: string | null;
@@ -10,7 +21,7 @@ declare type ENSOptions = {
 export declare type InternalENS = {
     options?: ENSOptions;
     provider?: ethers.providers.Provider;
-    signer: Signer;
+    signer: JsonRpcSigner;
     graphURI?: string | null;
 } & ENS;
 export declare type ENSArgs<K extends keyof InternalENS> = {
@@ -20,8 +31,13 @@ declare type OmitFirstArg<F> = F extends (x: any, ...args: infer P) => infer R ?
 declare type OmitFirstTwoArgs<F> = F extends (x: any, y: any, ...args: infer P) => infer R ? (...args: P) => R : never;
 declare type WriteOptions = {
     addressOrIndex?: string | number;
-    signer?: Signer;
+    signer?: JsonRpcSigner;
 };
+declare type OptionalWriteOptions<F> = F extends (x: any, arg_0: infer Z, options?: infer P) => infer R ? (name: Z, options?: P & WriteOptions) => R : F extends (x: any, arg_0: infer Z, options: infer P) => infer R ? (name: Z, options: P & WriteOptions) => R : never;
+interface WriteFunction<F extends (...args: any) => any> extends Function {
+    (...args: Parameters<OptionalWriteOptions<F>>): Promise<ContractTransaction>;
+    populateTransaction: (...args: Parameters<OptionalWriteOptions<F>>) => Promise<PopulatedTransaction>;
+}
 export declare type RawFunction = {
     raw: (...args: any[]) => Promise<{
         to: string;
@@ -436,53 +452,16 @@ export declare class ENS {
         }>;
         decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<any>;
     }>;
-    setName: (name: string, options?: ({
-        address?: string | undefined;
-        resolver?: string | undefined;
-    } & WriteOptions) | undefined) => Promise<ethers.ContractTransaction | undefined>;
-    setRecords: (name: string, options: {
-        records: import("./utils/recordHelpers").RecordOptions;
-        resolverAddress?: string | undefined;
-    } & WriteOptions) => Promise<ethers.ContractTransaction | undefined>;
-    setResolver: (name: string, options: {
-        contract: "nameWrapper" | "registry";
-        resolver?: string | undefined;
-    } & WriteOptions) => Promise<ethers.ContractTransaction>;
-    transferName: (name: string, options: {
-        newOwner: string;
-        contract: "nameWrapper" | "registry" | "baseRegistrar";
-    } & WriteOptions) => Promise<ethers.ContractTransaction>;
-    wrapName: (name: string, options: {
-        wrappedOwner: string;
-        fuseOptions?: string | number | import("./@types/FuseOptions").FuseOptions | undefined;
-        resolverAddress?: string | undefined;
-    } & WriteOptions) => Promise<ethers.ContractTransaction>;
-    unwrapName: (name: string, options: {
-        newController: string;
-        newRegistrant?: string | undefined;
-    } & WriteOptions) => Promise<ethers.ContractTransaction>;
-    burnFuses: (name: string, options: {
-        fusesToBurn: import("./@types/FuseOptions").FuseOptions;
-    } & WriteOptions) => Promise<ethers.ContractTransaction>;
-    createSubname: (name: string, options: ({
-        owner: string;
-        resolverAddress?: string | undefined;
-        contract: "nameWrapper" | "registry";
-    } | ({
-        contract: "nameWrapper";
-        fuses?: import("./@types/FuseOptions").FuseOptions | undefined;
-    } & {
-        owner: string;
-        resolverAddress?: string | undefined;
-        contract: "nameWrapper" | "registry";
-    })) & WriteOptions) => Promise<ethers.ContractTransaction>;
-    deleteSubname: (name: string, options: {
-        contract: "nameWrapper" | "registry";
-    } & WriteOptions) => Promise<ethers.ContractTransaction>;
-    transferSubname: (name: string, options: {
-        contract: "nameWrapper" | "registry";
-        address: string;
-    } & WriteOptions) => Promise<ethers.ContractTransaction>;
+    setName: WriteFunction<typeof setName>;
+    setRecords: WriteFunction<typeof setRecords>;
+    setResolver: WriteFunction<typeof setResolver>;
+    transferName: WriteFunction<typeof transferName>;
+    wrapName: WriteFunction<typeof wrapName>;
+    unwrapName: WriteFunction<typeof unwrapName>;
+    burnFuses: WriteFunction<typeof burnFuses>;
+    createSubname: WriteFunction<typeof createSubname>;
+    deleteSubname: WriteFunction<typeof deleteSubname>;
+    transferSubname: WriteFunction<typeof transferSubname>;
     getDNSOwner: (dnsName: string) => Promise<any>;
 }
 export {};

package/dist/esm/index.js

@@ -2,6 +2,7 @@ import ContractManager from './contracts';
 import { getContractAddress as _getContractAddress } from './contracts/getContractAddress';
 import GqlManager from './GqlManager';
 import singleCall from './utils/singleCall';
+import writeTx from './utils/writeTx';
 const graphURIEndpoints = {
     1: 'https://api.thegraph.com/subgraphs/name/ensdomains/ens',
     3: 'https://api.thegraph.com/subgraphs/name/ensdomains/ensropsten',
@@ -57,24 +58,24 @@ export class ENS {
                 // 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(writeTx(signer, populate));
                     }
                     // return the function with the dependencies forwarded
                     return func(dependenciesToForward, ...args);
@@ -92,6 +93,9 @@ export 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/esm/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/esm/utils/writeTx.js

@@ -0,0 +1 @@
+export default (signer, populate) => (tx) => populate ? tx : signer.sendTransaction(tx);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ensdomains/ensjs",
-  "version": "3.0.0-alpha.5",
+  "version": "3.0.0-alpha.6",
   "description": "ENS javascript library for contract interaction",
   "main": "./dist/cjs/index.js",
   "types": "./dist/cjs/index.d.ts",
@@ -51,7 +51,7 @@
   },
   "devDependencies": {
     "@ensdomains/buffer": "^0.0.13",
-    "@ensdomains/ens-test-env": "0.1.2",
+    "@ensdomains/ens-test-env": "0.1.4",
     "@ethersproject/abi": "^5.6.0",
     "@ethersproject/providers": "^5.6.2",
     "@nomiclabs/hardhat-ethers": "^2.0.5",
@@ -81,5 +81,5 @@
   "peerDependencies": {
     "ethers": "*"
   },
-  "stableVersion": "3.0.0-alpha.4"
+  "stableVersion": "3.0.0-alpha.5"
 }

package/src/functions/burnFuses.ts

@@ -17,5 +17,5 @@ export default async function (
 
   const encodedFuses = generateFuseInput(fusesToBurn)
 
-  return nameWrapper.burnFuses(hash, encodedFuses)
+  return nameWrapper.populateTransaction.burnFuses(hash, encodedFuses)
 }

package/src/functions/createSubname.ts

@@ -44,7 +44,7 @@ export default async function (
     case 'registry': {
       const registry = (await contracts?.getRegistry()!).connect(signer)
 
-      return registry.setSubnodeRecord(
+      return registry.populateTransaction.setSubnodeRecord(
         parentNodehash,
         labelhash,
         owner,
@@ -60,7 +60,7 @@ export default async function (
           ? generateFuseInput(wrapperArgs.fuses)
           : '0'
 
-      return nameWrapper.setSubnodeRecord(
+      return nameWrapper.populateTransaction.setSubnodeRecord(
         parentNodehash,
         label,
         owner,

package/src/functions/deleteSubname.ts

@@ -9,7 +9,7 @@ export default async function (
     contract: 'registry' | 'nameWrapper'
   },
 ) {
-  return transferSubname(name, {
+  return transferSubname.populateTransaction(name, {
     contract,
     address: '0x0000000000000000000000000000000000000000',
   })

package/src/functions/setName.ts

@@ -15,18 +15,18 @@ export default async function (
 
   const reverseRegistrar = (await contracts?.getReverseRegistrar())?.connect(
     signer,
-  )
+  )!
 
   if (address) {
-    const publicResolver = await contracts?.getPublicResolver()
+    const publicResolver = await contracts?.getPublicResolver()!
 
-    return reverseRegistrar?.setNameForAddr(
+    return reverseRegistrar.populateTransaction.setNameForAddr(
       address,
       signerAddress,
-      resolver || publicResolver!.address,
+      resolver || publicResolver.address,
       name,
     )
   }
 
-  return reverseRegistrar?.setName(name)
+  return reverseRegistrar.populateTransaction.setName(name)
 }

package/src/functions/setRecords.ts

@@ -35,10 +35,10 @@ export default async function (
 
   const resolver = (
     await contracts?.getPublicResolver(provider, resolverToUse)
-  )?.connect(signer)
+  )?.connect(signer)!
   const hash = namehash(name)
 
   const calls: string[] = generateRecordCallArray(hash, records, resolver!)
 
-  return resolver?.multicall(calls)
+  return resolver.populateTransaction.multicall(calls)
 }

package/src/functions/setResolver.ts

@@ -19,11 +19,14 @@ export default async function (
   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/src/functions/transferName.ts

@@ -18,7 +18,7 @@ export default async function (
   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(
@@ -28,7 +28,9 @@ export default async function (
       if (labels.length > 2 || labels[labels.length - 1] !== 'eth') {
         throw new Error('Invalid name for baseRegistrar')
       }
-      return baseRegistrar['safeTransferFrom(address,address,uint256)'](
+      return baseRegistrar.populateTransaction[
+        'safeTransferFrom(address,address,uint256)'
+      ](
         address,
         newOwner,
         ethers.utils.solidityKeccak256(['string'], [labels[0]]),
@@ -36,7 +38,7 @@ export default async function (
     }
     case 'nameWrapper': {
       const nameWrapper = (await contracts?.getNameWrapper())!.connect(signer)
-      return nameWrapper.safeTransferFrom(
+      return nameWrapper.populateTransaction.safeTransferFrom(
         address,
         newOwner,
         namehash(name),

package/src/functions/transferSubname.ts

@@ -22,12 +22,21 @@ export default async function (
     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/src/functions/unwrapName.ts

@@ -24,12 +24,20 @@ export default async function (
       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/src/functions/wrapName.ts

@@ -23,12 +23,9 @@ async function wrapETH(
     [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(
@@ -54,7 +51,7 @@ async function wrapOther(
     )
   }
 
-  return nameWrapper.wrap(
+  return nameWrapper.populateTransaction.wrap(
     hexEncodeName(name),
     wrappedOwner,
     decodedFuses,
@@ -63,7 +60,7 @@ async function wrapOther(
 }
 
 export default async function (
-  { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
+  { contracts, signer, populate }: ENSArgs<'contracts' | 'signer' | 'populate'>,
   name: string,
   {
     wrappedOwner,

package/src/index.ts

@@ -1,4 +1,5 @@
-import { ethers, Signer } from 'ethers'
+import { JsonRpcSigner } from '@ethersproject/providers'
+import { ContractTransaction, ethers, PopulatedTransaction } from 'ethers'
 import ContractManager from './contracts'
 import { getContractAddress as _getContractAddress } from './contracts/getContractAddress'
 import { SupportedNetworkId } from './contracts/types'
@@ -44,6 +45,7 @@ import type unwrapName from './functions/unwrapName'
 import type wrapName from './functions/wrapName'
 import GqlManager from './GqlManager'
 import singleCall from './utils/singleCall'
+import writeTx from './utils/writeTx'
 
 type ENSOptions = {
   graphURI?: string | null
@@ -53,7 +55,7 @@ type ENSOptions = {
 export type InternalENS = {
   options?: ENSOptions
   provider?: ethers.providers.Provider
-  signer: Signer
+  signer: JsonRpcSigner
   graphURI?: string | null
 } & ENS
 
@@ -79,10 +81,10 @@ type FunctionDeps<F> = Extract<keyof FirstArg<F>, string>[]
 
 type WriteOptions = {
   addressOrIndex?: string | number
-  signer?: Signer
+  signer?: JsonRpcSigner
 }
 
-type WriteFunction<F> = F extends (
+type OptionalWriteOptions<F> = F extends (
   x: any,
   arg_0: infer Z,
   options?: infer P,
@@ -92,6 +94,13 @@ type WriteFunction<F> = F extends (
   ? (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>
+}
+
 const graphURIEndpoints: Record<string, string> = {
   1: 'https://api.thegraph.com/subgraphs/name/ensdomains/ens',
   3: 'https://api.thegraph.com/subgraphs/name/ensdomains/ensropsten',
@@ -188,7 +197,13 @@ export class ENS {
     path: string,
     dependencies: FunctionDeps<F>,
     exportName: string = 'default',
-    subFunc?: 'raw' | 'decode' | 'combine' | 'batch' | 'write',
+    subFunc?:
+      | 'raw'
+      | 'decode'
+      | 'combine'
+      | 'batch'
+      | 'write'
+      | 'populateTransaction',
     passthrough?: RawFunction,
   ): Function => {
     // if batch is specified, create batch func
@@ -209,28 +224,31 @@ export class ENS {
       // 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]
+          subFunc && !writeable ? mod[exportName][subFunc] : mod[exportName]
         // get the dependencies to forward to the function as the first arg
         let dependenciesToForward =
           thisRef.forwardDependenciesFromArray<F>(dependencies)
 
         // if func is write func, inject signer into dependencies
-        if (subFunc === 'write') {
+        if (writeable) {
           const options = (args[1] || {}) as WriteOptions
           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(
+            writeTx(signer, populate),
+          )
         }
 
         // return the function with the dependencies forwarded
@@ -272,6 +290,13 @@ export class ENS {
         'batch',
         { raw: mainFunc.raw as any, decode: mainFunc.decode as any },
       )
+    } else if (subFunc === 'write') {
+      mainFunc.populateTransaction = this.importGenerator<F>(
+        path,
+        dependencies,
+        exportName,
+        'populateTransaction',
+      )
     }
 
     return mainFunc as Function
@@ -298,7 +323,7 @@ export class ENS {
    * @param {string} exportName - The export name of the target function
    * @returns {OmitFirstArg} - The generated wrapped function
    */
-  private generateWriteFunction = <F>(
+  private generateWriteFunction = <F extends (...args: any) => any>(
     path: string,
     dependencies: FunctionDeps<F>,
     exportName: string = 'default',

package/src/tests/populateTransaction.test.ts

@@ -0,0 +1,40 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import setup from '../tests/setup'
+
+let ENSInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
+let provider: ethers.providers.JsonRpcProvider
+let accounts: string[]
+
+beforeAll(async () => {
+  ;({ ENSInstance, revert, provider } = await setup())
+  accounts = await provider.listAccounts()
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+jest.setTimeout(20000)
+
+describe('populateTransaction', () => {
+  beforeEach(async () => {
+    await revert()
+  })
+  it('should return a transaction successfully', async () => {
+    const tx = await ENSInstance.setName('fleek.eth')
+    expect(tx).toBeTruthy()
+    if (tx) {
+      await tx.wait()
+      expect(tx.hash).toBeTruthy()
+    }
+  })
+  it('should return a populated transaction successfully', async () => {
+    const tx = await ENSInstance.setName.populateTransaction('fleek.eth')
+    expect(tx).toBeTruthy()
+    if (tx) {
+      expect(tx).not.toHaveProperty('hash')
+    }
+  })
+})

package/src/tests/signerInjection.test.ts

@@ -1,4 +1,4 @@
-import { ethers } from 'ethers'
+import { ContractTransaction, ethers } from 'ethers'
 import { ENS } from '..'
 import setup from '../tests/setup'
 
@@ -24,7 +24,9 @@ describe('Signer Injection', () => {
   })
   it('should return a transaction successfully for a custom signer', async () => {
     const signer = provider.getSigner(accounts[3])
-    const tx = await ENSInstance.setName('fleek.eth', { signer })
+    const tx = await ENSInstance.setName('fleek.eth', {
+      signer,
+    })
     expect(tx).toBeTruthy()
     if (tx) {
       await tx.wait()
@@ -32,7 +34,9 @@ describe('Signer Injection', () => {
     }
   })
   it('should return a transaction succesfully for a custom signer index', async () => {
-    const tx = await ENSInstance.setName('fleek.eth', { addressOrIndex: 3 })
+    const tx = (await ENSInstance.setName('fleek.eth', {
+      addressOrIndex: 3,
+    })) as ContractTransaction
     expect(tx).toBeTruthy()
     if (tx) {
       await tx.wait()

package/src/utils/writeTx.ts

@@ -0,0 +1,6 @@
+import { JsonRpcSigner } from '@ethersproject/providers'
+import type { PopulatedTransaction } from 'ethers'
+
+export default (signer: JsonRpcSigner, populate: boolean) =>
+  (tx: PopulatedTransaction) =>
+    populate ? tx : signer.sendTransaction(tx)