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

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('.'))

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,8 +19,8 @@ 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)'](
@@ -38,8 +38,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(
@@ -62,20 +63,19 @@ async function wrapOther(
 }
 
 export default async function (
-  { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
+  { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
   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 +123,7 @@ export default async function (
       decodedFuses,
       resolverAddress,
       address,
+      signer,
     )
   }
 }

package/src/index.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'
@@ -11,6 +11,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,7 +42,6 @@ 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'
 
@@ -53,6 +53,7 @@ type ENSOptions = {
 export type InternalENS = {
   options?: ENSOptions
   provider?: ethers.providers.Provider
+  signer: Signer
   graphURI?: string | null
 } & ENS
 
@@ -76,6 +77,21 @@ 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?: Signer
+}
+
+type WriteFunction<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
+
 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 +188,7 @@ export class ENS {
     path: string,
     dependencies: FunctionDeps<F>,
     exportName: string = 'default',
-    subFunc?: 'raw' | 'decode' | 'combine' | 'batch',
+    subFunc?: 'raw' | 'decode' | 'combine' | 'batch' | 'write',
     passthrough?: RawFunction,
   ): Function => {
     // if batch is specified, create batch func
@@ -194,10 +210,29 @@ export 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 =
+        let dependenciesToForward =
           thisRef.forwardDependenciesFromArray<F>(dependencies)
+
+        // if func is write func, inject signer into dependencies
+        if (subFunc === 'write') {
+          const options = (args[1] || {}) as WriteOptions
+          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)
       } else {
@@ -256,6 +291,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>(
+    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 +509,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/signerInjection.test.ts

@@ -0,0 +1,42 @@
+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('Signer Injection', () => {
+  beforeEach(async () => {
+    await revert()
+  })
+  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 })
+    expect(tx).toBeTruthy()
+    if (tx) {
+      await tx.wait()
+      expect(tx.from).toBe(accounts[3])
+    }
+  })
+  it('should return a transaction succesfully for a custom signer index', async () => {
+    const tx = await ENSInstance.setName('fleek.eth', { addressOrIndex: 3 })
+    expect(tx).toBeTruthy()
+    if (tx) {
+      await tx.wait()
+      expect(tx.from).toBe(accounts[3])
+    }
+  })
+})