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

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

@@ -1,6 +1,6 @@
 import { ethers } from 'ethers'
 import { ENS } from '..'
-import setup from './setup'
+import setup from '../tests/setup'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']

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

@@ -1,6 +1,6 @@
 import { ENS } from '..'
 import { OwnedName, Registration } from '../functions/getNames'
-import setup from './setup'
+import setup from '../tests/setup'
 
 let ENSInstance: ENS
 

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

@@ -1,6 +1,6 @@
 import { ethers } from 'ethers'
 import { ENS } from '..'
-import setup from './setup'
+import setup from '../tests/setup'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
@@ -10,7 +10,9 @@ let accounts: string[]
 beforeAll(async () => {
   ;({ ENSInstance, revert, provider } = await setup())
   accounts = await provider.listAccounts()
-  const tx = await ENSInstance.wrapName('parthtejpal.eth', accounts[0])
+  const tx = await ENSInstance.wrapName('parthtejpal.eth', {
+    wrappedOwner: accounts[0],
+  })
   await tx.wait()
 })
 

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

@@ -1,5 +1,5 @@
 import { ENS } from '..'
-import setup from './setup'
+import setup from '../tests/setup'
 
 let ENSInstance: ENS
 

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

@@ -1,5 +1,5 @@
 import { ENS } from '..'
-import setup from './setup'
+import setup from '../tests/setup'
 
 let ENSInstance: ENS
 

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

@@ -1,5 +1,5 @@
 import { ENS } from '..'
-import setup from './setup'
+import setup from '../tests/setup'
 
 let ENSInstance: ENS
 

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

@@ -1,5 +1,5 @@
 import { ENS } from '..'
-import setup from './setup'
+import setup from '../tests/setup'
 
 let ENSInstance: ENS
 

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

@@ -1,6 +1,6 @@
 import { ENS } from '..'
 import { makeCommitment } from '../utils/registerHelpers'
-import setup from './setup'
+import setup from '../tests/setup'
 
 let ENSInstance: ENS
 

package/src/{tests → functions}/setName.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']
@@ -43,7 +43,8 @@ describe('setName', () => {
     )
     await setApprovedForAllTx?.wait()
 
-    const tx = await ENSInstance.setName('fleek.eth', accounts[0], undefined, {
+    const tx = await ENSInstance.setName('fleek.eth', {
+      address: accounts[0],
       addressOrIndex: 1,
     })
     expect(tx).toBeTruthy()

package/src/functions/setName.ts

@@ -1,22 +1,20 @@
 import { ENSArgs } from '..'
 
 export default async function (
-  { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
+  { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
   name: string,
-  address?: string,
-  resolver?: string,
-  options?: { addressOrIndex?: string | number },
+  {
+    address,
+    resolver,
+  }: {
+    address?: string
+    resolver?: string
+  } = {},
 ) {
-  const signerAddress = await provider
-    ?.getSigner(options?.addressOrIndex)
-    .getAddress()
-
-  if (!signerAddress) {
-    throw new Error('No signer found')
-  }
+  const signerAddress = await signer.getAddress()
 
   const reverseRegistrar = (await contracts?.getReverseRegistrar())?.connect(
-    provider?.getSigner()!,
+    signer,
   )
 
   if (address) {

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

@@ -1,7 +1,7 @@
 import { ENS } from '..'
+import setup from '../tests/setup'
 import { hexEncodeName } from '../utils/hexEncodedName'
 import { namehash } from '../utils/normalise'
-import setup from './setup'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
@@ -17,10 +17,12 @@ afterAll(async () => {
 describe('setRecords', () => {
   it('should return a transaction to the resolver and set successfully', async () => {
     const tx = await ENSInstance.setRecords('parthtejpal.eth', {
-      coinTypes: [
-        { key: 'ETC', value: '0x42D63ae25990889E35F215bC95884039Ba354115' },
-      ],
-      texts: [{ key: 'foo', value: 'bar' }],
+      records: {
+        coinTypes: [
+          { key: 'ETC', value: '0x42D63ae25990889E35F215bC95884039Ba354115' },
+        ],
+        texts: [{ key: 'foo', value: 'bar' }],
+      },
     })
     expect(tx).toBeTruthy()
     await tx.wait()

package/src/functions/setRecords.ts

@@ -7,29 +7,35 @@ export default async function (
     contracts,
     provider,
     getResolver,
-  }: ENSArgs<'contracts' | 'provider' | 'getResolver'>,
+    signer,
+  }: ENSArgs<'contracts' | 'provider' | 'getResolver' | 'signer'>,
   name: string,
-  records: RecordOptions,
+  {
+    records,
+    resolverAddress,
+  }: {
+    records: RecordOptions
+    resolverAddress?: string
+  },
 ) {
   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: string
+  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()!)
+    await contracts?.getPublicResolver(provider, resolverToUse)
+  )?.connect(signer)
   const hash = namehash(name)
 
   const calls: string[] = generateRecordCallArray(hash, records, resolver!)

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,11 +20,10 @@ 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('parthtejpal.eth', {
+      contract: 'registry',
+      resolver: '0xAEfF4f4d8e2cB51854BEa2244B3C5Fb36b41C7fC',
+    })
     expect(tx).toBeTruthy()
     await tx.wait()
 
@@ -37,16 +36,14 @@ describe('setResolver', () => {
   })
   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],
-    )
+    const wrapNameTx = await ENSInstance.wrapName('parthtejpal.eth', {
+      wrappedOwner: accounts[0],
+    })
     await wrapNameTx.wait()
-    const tx = await ENSInstance.setResolver(
-      'parthtejpal.eth',
-      'nameWrapper',
-      '0xAEfF4f4d8e2cB51854BEa2244B3C5Fb36b41C7fC',
-    )
+    const tx = await ENSInstance.setResolver('parthtejpal.eth', {
+      contract: 'nameWrapper',
+      resolver: '0xAEfF4f4d8e2cB51854BEa2244B3C5Fb36b41C7fC',
+    })
     expect(tx).toBeTruthy()
     await tx.wait()
 

package/src/functions/setResolver.ts

@@ -2,35 +2,27 @@ 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)!,
-      )
+      const registry = (await contracts?.getRegistry())!.connect(signer)
       return registry.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.setResolver(namehash(name), resolver)
     }
     default: {

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

@@ -1,7 +1,7 @@
 import { ethers, utils } from 'ethers'
 import { ENS } from '..'
+import setup from '../tests/setup'
 import { namehash } from '../utils/normalise'
-import setup from './setup'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
@@ -22,12 +22,11 @@ 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('parthtejpal.eth', {
+      contract: 'baseRegistrar',
+      newOwner: accounts[1],
+      addressOrIndex: 0,
+    })
     expect(tx).toBeTruthy()
     await tx.wait()
 
@@ -38,17 +37,15 @@ describe('transferName', () => {
     expect(result).toBe(accounts[1])
   })
   it('should allow a transfer on the namewrapper', 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.transferName(
-      'parthtejpal.eth',
-      accounts[1],
-      'nameWrapper',
-      { addressOrIndex: 0 },
-    )
+    const tx = await ENSInstance.transferName('parthtejpal.eth', {
+      newOwner: accounts[1],
+      contract: 'nameWrapper',
+      addressOrIndex: 0,
+    })
     expect(tx).toBeTruthy()
     await tx.wait()
 
@@ -57,20 +54,21 @@ describe('transferName', () => {
     expect(result).toBe(accounts[1])
   })
   it('should allow a transfer on the registry', async () => {
-    const createSubnameTx = await ENSInstance.createSubname({
-      name: 'test.parthtejpal.eth',
-      contract: 'registry',
-      owner: accounts[0],
-      options: { addressOrIndex: accounts[0] },
-    })
-    await createSubnameTx.wait()
-
-    const tx = await ENSInstance.transferName(
+    const createSubnameTx = await ENSInstance.createSubname(
       'test.parthtejpal.eth',
-      accounts[1],
-      'registry',
-      { addressOrIndex: accounts[0] },
+      {
+        contract: 'registry',
+        owner: accounts[0],
+        addressOrIndex: accounts[0],
+      },
     )
+    await createSubnameTx.wait()
+
+    const tx = await ENSInstance.transferName('test.parthtejpal.eth', {
+      newOwner: accounts[1],
+      contract: 'registry',
+      addressOrIndex: accounts[0],
+    })
     expect(tx).toBeTruthy()
     await tx.wait()
 

package/src/functions/transferName.ts

@@ -3,30 +3,26 @@ 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)!,
-      )
+      const registry = (await contracts?.getRegistry())!.connect(signer)
       return registry.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') {
@@ -39,9 +35,7 @@ export default async function (
       )
     }
     case 'nameWrapper': {
-      const nameWrapper = (await contracts?.getNameWrapper())!.connect(
-        provider?.getSigner(options?.addressOrIndex)!,
-      )
+      const nameWrapper = (await contracts?.getNameWrapper())!.connect(signer)
       return nameWrapper.safeTransferFrom(
         address,
         newOwner,

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

@@ -1,7 +1,7 @@
 import { ethers } from 'ethers'
 import { ENS } from '..'
+import setup from '../tests/setup'
 import { namehash } from '../utils/normalise'
-import setup from './setup'
 
 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])

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

@@ -1,7 +1,7 @@
 import { ethers, utils } from 'ethers'
 import { ENS } from '..'
+import setup from '../tests/setup'
 import { namehash } from '../utils/normalise'
-import setup from './setup'
 
 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('.'))