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

package/src/functions/transferSubname.test.ts

@@ -1,7 +1,7 @@
 import { ethers } from 'ethers'
 import { ENS } from '..'
-import { namehash } from '../utils/normalise'
 import setup from '../tests/setup'
+import { namehash } from '../utils/normalise'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
@@ -22,20 +22,21 @@ describe('transferSubname', () => {
     await revert()
   })
   it('should allow transferring a subname on the registry', async () => {
-    const createSubnameTx = await ENSInstance.createSubname({
-      contract: 'registry',
-      name: 'test.parthtejpal.eth',
-      owner: accounts[0],
-      options: { addressOrIndex: 0 },
-    })
-    await createSubnameTx.wait()
-
-    const tx = await ENSInstance.transferSubname(
+    const createSubnameTx = await ENSInstance.createSubname(
       'test.parthtejpal.eth',
-      'registry',
-      accounts[1],
-      { addressOrIndex: 0 },
+      {
+        contract: 'registry',
+        owner: accounts[0],
+        addressOrIndex: 0,
+      },
     )
+    await createSubnameTx.wait()
+
+    const tx = await ENSInstance.transferSubname('test.parthtejpal.eth', {
+      contract: 'registry',
+      address: accounts[1],
+      addressOrIndex: 0,
+    })
     expect(tx).toBeTruthy()
     await tx.wait()
 
@@ -44,25 +45,25 @@ describe('transferSubname', () => {
     expect(result).toBe(accounts[1])
   })
   it('should allow transferring a subname on the nameWrapper', async () => {
-    const wrapNameTx = await ENSInstance.wrapName(
-      'parthtejpal.eth',
-      accounts[0],
-    )
-    await wrapNameTx.wait()
-    const createSubnameTx = await ENSInstance.createSubname({
-      contract: 'nameWrapper',
-      name: 'test.parthtejpal.eth',
-      owner: accounts[0],
-      options: { addressOrIndex: 0 },
+    const wrapNameTx = await ENSInstance.wrapName('parthtejpal.eth', {
+      wrappedOwner: accounts[0],
     })
-    await createSubnameTx.wait()
-
-    const tx = await ENSInstance.transferSubname(
+    await wrapNameTx.wait()
+    const createSubnameTx = await ENSInstance.createSubname(
       'test.parthtejpal.eth',
-      'nameWrapper',
-      accounts[1],
-      { addressOrIndex: 0 },
+      {
+        contract: 'nameWrapper',
+        owner: accounts[0],
+        addressOrIndex: 0,
+      },
     )
+    await createSubnameTx.wait()
+
+    const tx = await ENSInstance.transferSubname('test.parthtejpal.eth', {
+      contract: 'nameWrapper',
+      address: accounts[1],
+      addressOrIndex: 0,
+    })
     expect(tx).toBeTruthy()
     await tx.wait()
 

package/src/functions/transferSubname.ts

@@ -3,18 +3,16 @@ import { ENSArgs } from '..'
 import { namehash } from '../utils/normalise'
 
 export default async function (
-  { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
+  { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
   name: string,
-  contract: 'registry' | 'nameWrapper',
-  address: string,
-  options?: { addressOrIndex?: string | number },
+  {
+    contract,
+    address,
+  }: {
+    contract: 'registry' | 'nameWrapper'
+    address: string
+  },
 ) {
-  const signer = provider?.getSigner(options?.addressOrIndex)
-
-  if (!signer) {
-    throw new Error('No signer found')
-  }
-
   const labels = name.split('.')
   const label = labels.shift() as string
   const labelhash = ethers.utils.solidityKeccak256(['string'], [label])
@@ -24,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.test.ts

@@ -1,7 +1,7 @@
 import { ethers, utils } from 'ethers'
 import { ENS } from '..'
-import { namehash } from '../utils/normalise'
 import setup from '../tests/setup'
+import { namehash } from '../utils/normalise'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
@@ -22,17 +22,15 @@ describe('unwrapName', () => {
     await revert()
   })
   it('should return a .eth unwrap name transaction and succeed', async () => {
-    const wrapNameTx = await ENSInstance.wrapName(
-      'parthtejpal.eth',
-      accounts[0],
-    )
+    const wrapNameTx = await ENSInstance.wrapName('parthtejpal.eth', {
+      wrappedOwner: accounts[0],
+    })
     await wrapNameTx.wait()
 
-    const tx = await ENSInstance.unwrapName(
-      'parthtejpal.eth',
-      accounts[0],
-      accounts[0],
-    )
+    const tx = await ENSInstance.unwrapName('parthtejpal.eth', {
+      newController: accounts[0],
+      newRegistrant: accounts[0],
+    })
     expect(tx).toBeTruthy()
     await tx.wait()
 
@@ -43,21 +41,23 @@ describe('unwrapName', () => {
     expect(result).toBe(accounts[0])
   })
   it('should return a regular unwrap name transaction and succeed', async () => {
-    const wrapNameTx = await ENSInstance.wrapName(
-      'parthtejpal.eth',
-      accounts[0],
-    )
-    await wrapNameTx.wait()
-    const createSubnameTx = await ENSInstance.createSubname({
-      contract: 'nameWrapper',
-      name: 'test.parthtejpal.eth',
-      owner: accounts[0],
-      shouldWrap: true,
-      options: { addressOrIndex: 0 },
+    const wrapNameTx = await ENSInstance.wrapName('parthtejpal.eth', {
+      wrappedOwner: accounts[0],
     })
+    await wrapNameTx.wait()
+    const createSubnameTx = await ENSInstance.createSubname(
+      'test.parthtejpal.eth',
+      {
+        contract: 'nameWrapper',
+        owner: accounts[0],
+        addressOrIndex: 0,
+      },
+    )
     await createSubnameTx.wait()
 
-    const tx = await ENSInstance.unwrapName('test.parthtejpal.eth', accounts[0])
+    const tx = await ENSInstance.unwrapName('test.parthtejpal.eth', {
+      newController: accounts[0],
+    })
     expect(tx).toBeTruthy()
     await tx.wait()
 

package/src/functions/unwrapName.ts

@@ -3,20 +3,16 @@ import { ENSArgs } from '..'
 import { namehash } from '../utils/normalise'
 
 export default async function (
-  { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
+  { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
   name: string,
-  newController: string,
-  newRegistrant?: string,
-  options?: { addressOrIndex?: string | number },
+  {
+    newController,
+    newRegistrant,
+  }: {
+    newController: string
+    newRegistrant?: string
+  },
 ) {
-  const signer = provider?.getSigner(options?.addressOrIndex)
-
-  const address = await signer?.getAddress()
-
-  if (!signer || !address) {
-    throw new Error('No signer found')
-  }
-
   const labels = name.split('.')
   const labelhash = utils.solidityKeccak256(['string'], [labels[0]])
   const parentNodehash = namehash(labels.slice(1).join('.'))
@@ -28,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.test.ts

@@ -1,8 +1,8 @@
 import { BigNumber, ethers } from 'ethers'
 import { ENS } from '..'
+import setup from '../tests/setup'
 import { hexEncodeName } from '../utils/hexEncodedName'
 import { namehash } from '../utils/normalise'
-import setup from '../tests/setup'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
@@ -24,7 +24,9 @@ describe('wrapName', () => {
     await revert()
   })
   it('should return a wrap name transaction and succeed', async () => {
-    const tx = await ENSInstance.wrapName('parthtejpal.eth', accounts[0])
+    const tx = await ENSInstance.wrapName('parthtejpal.eth', {
+      wrappedOwner: accounts[0],
+    })
     expect(tx).toBeTruthy()
     await tx.wait()
 
@@ -33,24 +35,25 @@ describe('wrapName', () => {
     expect((result as BigNumber).toHexString()).toBe('0x40')
   })
   it('should allow initial fuses', async () => {
-    const tx = await ENSInstance.wrapName('parthtejpal.eth', accounts[0], {
-      cannotUnwrap: true,
-      cannotSetTtl: true,
+    const tx = await ENSInstance.wrapName('parthtejpal.eth', {
+      wrappedOwner: accounts[0],
+      fuseOptions: {
+        cannotUnwrap: true,
+        cannotSetTtl: true,
+      },
     })
     expect(tx).toBeTruthy()
     await tx.wait()
 
     const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
     const [result] = await nameWrapper.getFuses(namehash('parthtejpal.eth'))
-    expect((result as BigNumber).toHexString()).toBe('0x51')
+    expect((result as BigNumber).toHexString()).toBe('0x40')
   })
   it('should allow an initial resolver address', async () => {
-    const tx = await ENSInstance.wrapName(
-      'parthtejpal.eth',
-      accounts[0],
-      undefined,
-      '0x42D63ae25990889E35F215bC95884039Ba354115',
-    )
+    const tx = await ENSInstance.wrapName('parthtejpal.eth', {
+      wrappedOwner: accounts[0],
+      resolverAddress: '0x42D63ae25990889E35F215bC95884039Ba354115',
+    })
     expect(tx).toBeTruthy()
     await tx.wait()
 

package/src/functions/wrapName.ts

@@ -19,16 +19,13 @@ async function wrapETH(
   const labelhash = ethers.utils.solidityKeccak256(['string'], [labels[0]])
 
   const data = ethers.utils.defaultAbiCoder.encode(
-    ['string', 'address', 'uint96', 'address'],
-    [labels[0], wrappedOwner, decodedFuses, resolverAddress],
+    ['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(
@@ -38,8 +35,9 @@ async function wrapOther(
   decodedFuses: string,
   resolverAddress: string,
   address: string,
+  signer: ethers.Signer,
 ) {
-  const nameWrapper = await contracts?.getNameWrapper()!
+  const nameWrapper = (await contracts?.getNameWrapper()!).connect(signer)
   const registry = await contracts?.getRegistry()!
 
   const hasApproval = await registry.isApprovedForAll(
@@ -53,7 +51,7 @@ async function wrapOther(
     )
   }
 
-  return nameWrapper.wrap(
+  return nameWrapper.populateTransaction.wrap(
     hexEncodeName(name),
     wrappedOwner,
     decodedFuses,
@@ -62,20 +60,19 @@ async function wrapOther(
 }
 
 export default async function (
-  { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
+  { contracts, signer, populate }: ENSArgs<'contracts' | 'signer' | 'populate'>,
   name: string,
-  wrappedOwner: string,
-  fuseOptions?: FuseOptions | string | number,
-  resolverAddress?: string,
-  options?: { addressOrIndex?: string | number },
+  {
+    wrappedOwner,
+    fuseOptions,
+    resolverAddress,
+  }: {
+    wrappedOwner: string
+    fuseOptions?: FuseOptions | string | number
+    resolverAddress?: string
+  },
 ) {
-  const signer = provider?.getSigner(options?.addressOrIndex)
-
-  const address = await signer?.getAddress()
-
-  if (!signer || !address) {
-    throw new Error('No signer found')
-  }
+  const address = await signer.getAddress()
 
   let decodedFuses: string
 
@@ -123,6 +120,7 @@ export default async function (
       decodedFuses,
       resolverAddress,
       address,
+      signer,
     )
   }
 }

package/src/index.ts

@@ -1,4 +1,5 @@
-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'
@@ -11,6 +12,7 @@ import type {
 import type burnFuses from './functions/burnFuses'
 import type createSubname from './functions/createSubname'
 import type deleteSubname from './functions/deleteSubname'
+import type getDNSOwner from './functions/getDNSOwner'
 import type getExpiry from './functions/getExpiry'
 import type getFuses from './functions/getFuses'
 import type {
@@ -41,9 +43,9 @@ 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 type getDNSOwner from './functions/getDNSOwner'
 import GqlManager from './GqlManager'
 import singleCall from './utils/singleCall'
+import writeTx from './utils/writeTx'
 
 type ENSOptions = {
   graphURI?: string | null
@@ -53,6 +55,7 @@ type ENSOptions = {
 export type InternalENS = {
   options?: ENSOptions
   provider?: ethers.providers.Provider
+  signer: JsonRpcSigner
   graphURI?: string | null
 } & ENS
 
@@ -76,6 +79,28 @@ type FirstArg<F> = F extends (x: infer A, ...args: any[]) => any ? A : never
 
 type FunctionDeps<F> = Extract<keyof FirstArg<F>, string>[]
 
+type WriteOptions = {
+  addressOrIndex?: string | number
+  signer?: JsonRpcSigner
+}
+
+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>
+}
+
 const graphURIEndpoints: Record<string, string> = {
   1: 'https://api.thegraph.com/subgraphs/name/ensdomains/ens',
   3: 'https://api.thegraph.com/subgraphs/name/ensdomains/ensropsten',
@@ -172,7 +197,13 @@ export class ENS {
     path: string,
     dependencies: FunctionDeps<F>,
     exportName: string = 'default',
-    subFunc?: 'raw' | 'decode' | 'combine' | 'batch',
+    subFunc?:
+      | 'raw'
+      | 'decode'
+      | 'combine'
+      | 'batch'
+      | 'write'
+      | 'populateTransaction',
     passthrough?: RawFunction,
   ): Function => {
     // if batch is specified, create batch func
@@ -193,11 +224,33 @@ 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 ? 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
-        const dependenciesToForward =
+        let dependenciesToForward =
           thisRef.forwardDependenciesFromArray<F>(dependencies)
+
+        // if func is write func, inject signer into dependencies
+        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).then(
+            writeTx(signer, populate),
+          )
+        }
+
         // return the function with the dependencies forwarded
         return func(dependenciesToForward, ...args)
       } else {
@@ -237,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
@@ -256,6 +316,25 @@ export class ENS {
   ): OmitFirstArg<F> =>
     this.importGenerator<F>(path, dependencies, exportName) as OmitFirstArg<F>
 
+  /**
+   * 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 = <F extends (...args: any) => any>(
+    path: string,
+    dependencies: FunctionDeps<F>,
+    exportName: string = 'default',
+  ): WriteFunction<F> =>
+    this.importGenerator<F>(
+      path,
+      dependencies,
+      exportName,
+      'write',
+    ) as WriteFunction<F>
+
   /**
    * Generates a wrapped function from raw and decode exports
    * @param {string} path - The path of the exported function
@@ -455,55 +534,51 @@ export class ENS {
     'multicallWrapper',
   )
 
-  public setName = this.generateFunction<typeof setName>('setName', [
+  public setName = this.generateWriteFunction<typeof setName>('setName', [
     'contracts',
-    'provider',
   ])
 
-  public setRecords = this.generateFunction<typeof setRecords>('setRecords', [
-    'contracts',
-    'provider',
-    'getResolver',
-  ])
+  public setRecords = this.generateWriteFunction<typeof setRecords>(
+    'setRecords',
+    ['contracts', 'provider', 'getResolver'],
+  )
 
-  public setResolver = this.generateFunction<typeof setResolver>(
+  public setResolver = this.generateWriteFunction<typeof setResolver>(
     'setResolver',
-    ['contracts', 'provider'],
+    ['contracts'],
   )
 
-  public transferName = this.generateFunction<typeof transferName>(
+  public transferName = this.generateWriteFunction<typeof transferName>(
     'transferName',
-    ['contracts', 'provider'],
+    ['contracts'],
   )
 
-  public wrapName = this.generateFunction<typeof wrapName>('wrapName', [
+  public wrapName = this.generateWriteFunction<typeof wrapName>('wrapName', [
     'contracts',
-    'provider',
   ])
 
-  public unwrapName = this.generateFunction<typeof unwrapName>('unwrapName', [
-    'contracts',
-    'provider',
-  ])
+  public unwrapName = this.generateWriteFunction<typeof unwrapName>(
+    'unwrapName',
+    ['contracts'],
+  )
 
-  public burnFuses = this.generateFunction<typeof burnFuses>('burnFuses', [
+  public burnFuses = this.generateWriteFunction<typeof burnFuses>('burnFuses', [
     'contracts',
-    'provider',
   ])
 
-  public createSubname = this.generateFunction<typeof createSubname>(
+  public createSubname = this.generateWriteFunction<typeof createSubname>(
     'createSubname',
-    ['contracts', 'provider'],
+    ['contracts'],
   )
 
-  public deleteSubname = this.generateFunction<typeof deleteSubname>(
+  public deleteSubname = this.generateWriteFunction<typeof deleteSubname>(
     'deleteSubname',
-    ['contracts', 'provider', 'transferSubname'],
+    ['transferSubname'],
   )
 
-  public transferSubname = this.generateFunction<typeof transferSubname>(
+  public transferSubname = this.generateWriteFunction<typeof transferSubname>(
     'transferSubname',
-    ['contracts', 'provider'],
+    ['contracts'],
   )
 
   public getDNSOwner = this.generateFunction<typeof getDNSOwner>(

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')
+    }
+  })
+})