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

package/src/{tests → functions}/setResolver.test.ts

@@ -1,7 +1,7 @@
 import { ethers } from 'ethers'
 import { ENS } from '..'
+import setup from '../tests/setup'
 import { hexEncodeName } from '../utils/hexEncodedName'
-import setup from './setup'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
@@ -20,40 +20,34 @@ describe('setResolver', () => {
     await revert()
   })
   it('should return a transaction to the registry and set successfully', async () => {
-    const tx = await ENSInstance.setResolver(
-      'parthtejpal.eth',
-      'registry',
-      '0xAEfF4f4d8e2cB51854BEa2244B3C5Fb36b41C7fC',
-    )
+    const tx = await ENSInstance.setResolver('test123.eth', {
+      contract: 'registry',
+      resolver: '0xAEfF4f4d8e2cB51854BEa2244B3C5Fb36b41C7fC',
+      addressOrIndex: 1,
+    })
     expect(tx).toBeTruthy()
     await tx.wait()
 
     const universalResolver =
       await ENSInstance.contracts!.getUniversalResolver()!
     const [result] = await universalResolver.findResolver(
-      hexEncodeName('parthtejpal.eth'),
+      hexEncodeName('test123.eth'),
     )
     expect(result).toBe('0xAEfF4f4d8e2cB51854BEa2244B3C5Fb36b41C7fC')
   })
   it('should return a transaction to the namewrapper and set successfully', async () => {
-    const accounts = await provider.listAccounts()
-    const wrapNameTx = await ENSInstance.wrapName(
-      'parthtejpal.eth',
-      accounts[0],
-    )
-    await wrapNameTx.wait()
-    const tx = await ENSInstance.setResolver(
-      'parthtejpal.eth',
-      'nameWrapper',
-      '0xAEfF4f4d8e2cB51854BEa2244B3C5Fb36b41C7fC',
-    )
+    const tx = await ENSInstance.setResolver('wrapped.eth', {
+      contract: 'nameWrapper',
+      resolver: '0xAEfF4f4d8e2cB51854BEa2244B3C5Fb36b41C7fC',
+      addressOrIndex: 1,
+    })
     expect(tx).toBeTruthy()
     await tx.wait()
 
     const universalResolver =
       await ENSInstance.contracts!.getUniversalResolver()!
     const [result] = await universalResolver.findResolver(
-      hexEncodeName('parthtejpal.eth'),
+      hexEncodeName('wrapped.eth'),
     )
     expect(result).toBe('0xAEfF4f4d8e2cB51854BEa2244B3C5Fb36b41C7fC')
   })

package/src/functions/setResolver.ts

@@ -1,37 +1,32 @@
-import { ethers } from 'ethers'
 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',
-  resolver?: string,
-  options?: { addressOrIndex?: string | number },
+  {
+    contract,
+    resolver,
+  }: {
+    contract: 'registry' | 'nameWrapper'
+    resolver?: string
+  },
 ) {
-  const address = await provider
-    ?.getSigner(options?.addressOrIndex)
-    .getAddress()
-
-  if (!address) {
-    throw new Error('No signer found')
-  }
-
   if (!resolver) {
     resolver = (await contracts?.getPublicResolver()!).address
   }
 
   switch (contract) {
     case 'registry': {
-      const registry = (await contracts?.getRegistry())!.connect(
-        provider?.getSigner(options?.addressOrIndex)!,
-      )
-      return registry.setResolver(ethers.utils.namehash(name), resolver)
+      const registry = (await contracts?.getRegistry())!.connect(signer)
+      return registry.populateTransaction.setResolver(namehash(name), resolver)
     }
     case 'nameWrapper': {
-      const nameWrapper = (await contracts?.getNameWrapper())!.connect(
-        provider?.getSigner(options?.addressOrIndex)!,
+      const nameWrapper = (await contracts?.getNameWrapper())!.connect(signer)
+      return nameWrapper.populateTransaction.setResolver(
+        namehash(name),
+        resolver,
       )
-      return nameWrapper.setResolver(ethers.utils.namehash(name), resolver)
     }
     default: {
       throw new Error(`Unknown contract: ${contract}`)

package/src/{tests → functions}/transferName.test.ts

@@ -1,6 +1,7 @@
 import { ethers, utils } from 'ethers'
 import { ENS } from '..'
-import setup from './setup'
+import setup from '../tests/setup'
+import { namehash } from '../utils/normalise'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
@@ -21,60 +22,44 @@ describe('transferName', () => {
     await revert()
   })
   it('should allow a transfer on the registrar', async () => {
-    const tx = await ENSInstance.transferName(
-      'parthtejpal.eth',
-      accounts[1],
-      'baseRegistrar',
-      { addressOrIndex: 0 },
-    )
+    const tx = await ENSInstance.transferName('test123.eth', {
+      contract: 'baseRegistrar',
+      newOwner: accounts[2],
+      addressOrIndex: 1,
+    })
     expect(tx).toBeTruthy()
     await tx.wait()
 
     const baseRegistrar = await ENSInstance.contracts!.getBaseRegistrar()!
     const result = await baseRegistrar.ownerOf(
-      utils.solidityKeccak256(['string'], ['parthtejpal']),
+      utils.solidityKeccak256(['string'], ['test123']),
     )
-    expect(result).toBe(accounts[1])
+    expect(result).toBe(accounts[2])
   })
   it('should allow a transfer on the namewrapper', async () => {
-    const wrapNameTx = await ENSInstance.wrapName(
-      'parthtejpal.eth',
-      accounts[0],
-    )
-    await wrapNameTx.wait()
-    const tx = await ENSInstance.transferName(
-      'parthtejpal.eth',
-      accounts[1],
-      'nameWrapper',
-      { addressOrIndex: 0 },
-    )
+    const tx = await ENSInstance.transferName('wrapped.eth', {
+      newOwner: accounts[2],
+      contract: 'nameWrapper',
+      addressOrIndex: 1,
+    })
     expect(tx).toBeTruthy()
     await tx.wait()
 
     const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
-    const result = await nameWrapper.ownerOf(utils.namehash('parthtejpal.eth'))
-    expect(result).toBe(accounts[1])
+    const result = await nameWrapper.ownerOf(namehash('wrapped.eth'))
+    expect(result).toBe(accounts[2])
   })
   it('should allow a transfer on the registry', async () => {
-    const createSubnameTx = await ENSInstance.createSubname({
-      name: 'test.parthtejpal.eth',
+    const tx = await ENSInstance.transferName('test.with-subnames.eth', {
+      newOwner: accounts[1],
       contract: 'registry',
-      owner: accounts[0],
-      options: { addressOrIndex: accounts[0] },
+      addressOrIndex: accounts[2],
     })
-    await createSubnameTx.wait()
-
-    const tx = await ENSInstance.transferName(
-      'test.parthtejpal.eth',
-      accounts[1],
-      'registry',
-      { addressOrIndex: accounts[0] },
-    )
     expect(tx).toBeTruthy()
     await tx.wait()
 
     const registry = await ENSInstance.contracts!.getRegistry()!
-    const result = await registry.owner(utils.namehash('test.parthtejpal.eth'))
+    const result = await registry.owner(namehash('test.with-subnames.eth'))
     expect(result).toBe(accounts[1])
   })
 })

package/src/functions/transferName.ts

@@ -1,50 +1,47 @@
 import { ethers } from 'ethers'
 import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
 
 export default async function (
-  { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
+  { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
   name: string,
-  newOwner: string,
-  contract: 'registry' | 'nameWrapper' | 'baseRegistrar',
-  options?: { addressOrIndex?: string | number },
+  {
+    newOwner,
+    contract,
+  }: {
+    newOwner: string
+    contract: 'registry' | 'nameWrapper' | 'baseRegistrar'
+  },
 ) {
-  const address = await provider
-    ?.getSigner(options?.addressOrIndex)
-    .getAddress()
-
-  if (!address) {
-    throw new Error('No signer found')
-  }
+  const address = await signer.getAddress()
 
   switch (contract) {
     case 'registry': {
-      const registry = (await contracts?.getRegistry())!.connect(
-        provider?.getSigner(options?.addressOrIndex)!,
-      )
-      return registry.setOwner(ethers.utils.namehash(name), newOwner)
+      const registry = (await contracts?.getRegistry())!.connect(signer)
+      return registry.populateTransaction.setOwner(namehash(name), newOwner)
     }
     case 'baseRegistrar': {
       const baseRegistrar = (await contracts?.getBaseRegistrar())!.connect(
-        provider?.getSigner(options?.addressOrIndex)!,
+        signer,
       )
       const labels = name.split('.')
       if (labels.length > 2 || labels[labels.length - 1] !== 'eth') {
         throw new Error('Invalid name for baseRegistrar')
       }
-      return baseRegistrar['safeTransferFrom(address,address,uint256)'](
+      return baseRegistrar.populateTransaction[
+        'safeTransferFrom(address,address,uint256)'
+      ](
         address,
         newOwner,
         ethers.utils.solidityKeccak256(['string'], [labels[0]]),
       )
     }
     case 'nameWrapper': {
-      const nameWrapper = (await contracts?.getNameWrapper())!.connect(
-        provider?.getSigner(options?.addressOrIndex)!,
-      )
-      return nameWrapper.safeTransferFrom(
+      const nameWrapper = (await contracts?.getNameWrapper())!.connect(signer)
+      return nameWrapper.populateTransaction.safeTransferFrom(
         address,
         newOwner,
-        ethers.utils.namehash(name),
+        namehash(name),
         1,
         '0x',
       )

package/src/{tests → functions}/transferSubname.test.ts

@@ -1,6 +1,7 @@
-import { ethers, utils } from 'ethers'
+import { ethers } from 'ethers'
 import { ENS } from '..'
-import setup from './setup'
+import setup from '../tests/setup'
+import { namehash } from '../utils/normalise'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
@@ -21,53 +22,33 @@ describe('transferSubname', () => {
     await revert()
   })
   it('should allow transferring a subname on the registry', async () => {
-    const createSubnameTx = await ENSInstance.createSubname({
+    const tx = await ENSInstance.transferSubname('test.with-subnames.eth', {
       contract: 'registry',
-      name: 'test.parthtejpal.eth',
-      owner: accounts[0],
-      options: { addressOrIndex: 0 },
+      owner: accounts[1],
+      addressOrIndex: 1,
     })
-    await createSubnameTx.wait()
-
-    const tx = await ENSInstance.transferSubname(
-      'test.parthtejpal.eth',
-      'registry',
-      accounts[1],
-      { addressOrIndex: 0 },
-    )
     expect(tx).toBeTruthy()
     await tx.wait()
 
     const registry = await ENSInstance.contracts!.getRegistry()!
-    const result = await registry.owner(utils.namehash('test.parthtejpal.eth'))
+    const result = await registry.owner(namehash('test.with-subnames.eth'))
     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 },
-    })
-    await createSubnameTx.wait()
-
     const tx = await ENSInstance.transferSubname(
-      'test.parthtejpal.eth',
-      'nameWrapper',
-      accounts[1],
-      { addressOrIndex: 0 },
+      'test.wrapped-with-subnames.eth',
+      {
+        contract: 'nameWrapper',
+        owner: accounts[1],
+        addressOrIndex: 1,
+      },
     )
     expect(tx).toBeTruthy()
     await tx.wait()
 
     const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
     const result = await nameWrapper.ownerOf(
-      utils.namehash('test.parthtejpal.eth'),
+      namehash('test.wrapped-with-subnames.eth'),
     )
     expect(result).toBe(accounts[1])
   })

package/src/functions/transferSubname.ts

@@ -1,34 +1,60 @@
 import { ethers } from 'ethers'
 import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
+import { Expiry, makeExpiry } from '../utils/wrapperExpiry'
+
+type BaseArgs = {
+  owner: string
+  resolverAddress?: string
+  contract: 'registry' | 'nameWrapper'
+}
+
+type NameWrapperArgs = {
+  contract: 'nameWrapper'
+  expiry?: Expiry
+} & BaseArgs
+
+type Args = BaseArgs | NameWrapperArgs
 
 export default async function (
-  { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
+  {
+    contracts,
+    signer,
+    getExpiry,
+  }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>,
   name: string,
-  contract: 'registry' | 'nameWrapper',
-  address: string,
-  options?: { addressOrIndex?: string | number },
+  { contract, owner, resolverAddress, ...wrapperArgs }: Args,
 ) {
-  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])
-  const parentNodehash = ethers.utils.namehash(labels.join('.'))
+  const parentNodehash = namehash(labels.join('.'))
 
   switch (contract) {
     case 'registry': {
       const registry = (await contracts?.getRegistry()!).connect(signer)
 
-      return registry.setSubnodeOwner(parentNodehash, labelhash, address)
+      return registry.populateTransaction.setSubnodeOwner(
+        parentNodehash,
+        labelhash,
+        owner,
+      )
     }
     case 'nameWrapper': {
       const nameWrapper = (await contracts?.getNameWrapper()!).connect(signer)
+      const expiry = await makeExpiry(
+        { getExpiry },
+        labels.join('.'),
+        'expiry' in wrapperArgs ? wrapperArgs.expiry : undefined,
+      )
 
-      return nameWrapper.setSubnodeOwner(parentNodehash, label, address, '0')
+      return nameWrapper.populateTransaction.setSubnodeOwner(
+        parentNodehash,
+        label,
+        owner,
+        '0',
+        expiry,
+      )
     }
     default: {
       throw new Error(`Unknown contract: ${contract}`)

package/src/{tests → functions}/unwrapName.test.ts

@@ -1,6 +1,7 @@
 import { ethers, utils } from 'ethers'
 import { ENS } from '..'
-import setup from './setup'
+import setup from '../tests/setup'
+import { namehash } from '../utils/normalise'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
@@ -21,47 +22,32 @@ describe('unwrapName', () => {
     await revert()
   })
   it('should return a .eth unwrap name transaction and succeed', async () => {
-    const wrapNameTx = await ENSInstance.wrapName(
-      'parthtejpal.eth',
-      accounts[0],
-    )
-    await wrapNameTx.wait()
-
-    const tx = await ENSInstance.unwrapName(
-      'parthtejpal.eth',
-      accounts[0],
-      accounts[0],
-    )
+    const tx = await ENSInstance.unwrapName('wrapped.eth', {
+      newController: accounts[1],
+      newRegistrant: accounts[1],
+      addressOrIndex: 1,
+    })
     expect(tx).toBeTruthy()
     await tx.wait()
 
     const baseRegistrar = await ENSInstance.contracts!.getBaseRegistrar()!
     const result = await baseRegistrar.ownerOf(
-      utils.solidityKeccak256(['string'], ['parthtejpal']),
+      utils.solidityKeccak256(['string'], ['wrapped']),
     )
-    expect(result).toBe(accounts[0])
+    expect(result).toBe(accounts[1])
   })
   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 tx = await ENSInstance.unwrapName('test.wrapped-with-subnames.eth', {
+      newController: accounts[1],
+      addressOrIndex: 2,
     })
-    await createSubnameTx.wait()
-
-    const tx = await ENSInstance.unwrapName('test.parthtejpal.eth', accounts[0])
     expect(tx).toBeTruthy()
     await tx.wait()
 
     const registry = await ENSInstance.contracts!.getRegistry()!
-    const result = await registry.owner(utils.namehash('test.parthtejpal.eth'))
-    expect(result).toBe(accounts[0])
+    const result = await registry.owner(
+      namehash('test.wrapped-with-subnames.eth'),
+    )
+    expect(result).toBe(accounts[1])
   })
 })

package/src/functions/unwrapName.ts

@@ -1,24 +1,21 @@
 import { utils } from 'ethers'
 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 = utils.namehash(labels.slice(1).join('.'))
+  const parentNodehash = namehash(labels.slice(1).join('.'))
 
   const nameWrapper = (await contracts?.getNameWrapper()!).connect(signer)
 
@@ -27,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,
+    )
   }
 }