@ensdomains/ensjs 3.0.0-alpha.10 → 3.0.0-alpha.11

package/src/functions/getSubnames.test.ts

@@ -11,21 +11,25 @@ const testProperties = (obj: object, ...properties: string[]) =>
   properties.map((property) => expect(obj).toHaveProperty(property))
 
 describe('getSubnames', () => {
-  it('should get the subnames for a name', async () => {
-    const result = await ENSInstance.getSubnames({
-      name: 'jefflau.eth',
-    })
-    expect(result).toBeTruthy()
-    expect(result.length).toBeGreaterThan(0)
-    testProperties(
-      result[0],
-      'id',
-      'labelName',
-      'labelhash',
-      'name',
-      'isMigrated',
-      'owner',
-      'truncatedName',
-    )
-  })
+  it.todo('should get the subnames for a name')
+  // it('should get the subnames for a name', async () => {
+  //   const result = await ENSInstance.getSubnames({
+  //     name: 'with-profile.eth',
+  //   })
+  //   expect(result).toBeTruthy()
+  //   if (result) {
+  //     console.log(result)
+  //     expect(result.length).toBeGreaterThan(0)
+  //     testProperties(
+  //       result[0],
+  //       'id',
+  //       'labelName',
+  //       'labelhash',
+  //       'name',
+  //       'isMigrated',
+  //       'owner',
+  //       'truncatedName',
+  //     )
+  //   }
+  // })
 })

package/src/functions/getSubnames.ts

@@ -21,13 +21,20 @@ type Params = {
   pageSize?: number
   orderDirection?: 'asc' | 'desc'
   orderBy?: 'createdAt' | 'labelName'
-  lastSubnames: Array<any>
+  lastSubnames?: Array<any>
   isLargeQuery?: boolean
 }
 
 const largeQuery = async (
   { gqlInstance }: ENSArgs<'gqlInstance'>,
-  { name, page, pageSize = 10, orderDirection, orderBy, lastSubnames }: Params,
+  {
+    name,
+    page,
+    pageSize = 10,
+    orderDirection,
+    orderBy,
+    lastSubnames = [],
+  }: Params,
 ) => {
   const client = gqlInstance.client
 

package/src/functions/makeCommitment.test.ts

@@ -1,6 +1,6 @@
 import { ENS } from '..'
-import { makeCommitment } from '../utils/registerHelpers'
 import setup from '../tests/setup'
+import { makeCommitment } from '../utils/registerHelpers'
 
 let ENSInstance: ENS
 
@@ -13,7 +13,7 @@ describe('makeCommitment', () => {
     const resolver = await ENSInstance.contracts!.getPublicResolver()!
     const commitment = makeCommitment({
       name: 'test.eth',
-      owner: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      owner: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       duration: 1 * 365 * 24 * 60 * 60,
       resolver: resolver,
     })

package/src/functions/setName.test.ts

@@ -22,38 +22,37 @@ describe('setName', () => {
     await revert()
   })
   it('should return a transaction for a name and set successfully', async () => {
-    const tx = await ENSInstance.setName('fleek.eth')
+    const tx = await ENSInstance.setName('test123.eth', { addressOrIndex: 1 })
     expect(tx).toBeTruthy()
     await tx?.wait()
 
     const universalResolver =
       await ENSInstance.contracts!.getUniversalResolver()!
-    const reverseNode = accounts[0].toLowerCase().substring(2) + '.addr.reverse'
+    const reverseNode = accounts[1].toLowerCase().substring(2) + '.addr.reverse'
     const result = await universalResolver.reverse(hexEncodeName(reverseNode))
-    expect(result[0]).toBe('fleek.eth')
+    expect(result[0]).toBe('test123.eth')
   })
   it("should return a transaction for setting another address' name", async () => {
-    jest.setTimeout(20000)
     const registry = (await ENSInstance.contracts!.getRegistry()!).connect(
-      provider.getSigner(),
+      provider.getSigner(1),
     )
     const setApprovedForAllTx = await registry.setApprovalForAll(
-      accounts[1],
+      accounts[2],
       true,
     )
     await setApprovedForAllTx?.wait()
 
-    const tx = await ENSInstance.setName('fleek.eth', {
-      address: accounts[0],
-      addressOrIndex: 1,
+    const tx = await ENSInstance.setName('test123.eth', {
+      address: accounts[1],
+      addressOrIndex: 2,
     })
     expect(tx).toBeTruthy()
     await tx?.wait()
 
     const universalResolver =
       await ENSInstance.contracts!.getUniversalResolver()!
-    const reverseNode = accounts[0].toLowerCase().substring(2) + '.addr.reverse'
+    const reverseNode = accounts[1].toLowerCase().substring(2) + '.addr.reverse'
     const result = await universalResolver.reverse(hexEncodeName(reverseNode))
-    expect(result[0]).toBe('fleek.eth')
+    expect(result[0]).toBe('test123.eth')
   })
 })

package/src/functions/setRecord.test.ts

@@ -17,9 +17,10 @@ afterAll(async () => {
 
 describe('setRecord', () => {
   it('should allow a text record set', async () => {
-    const tx = await ENSInstance.setRecord('parthtejpal.eth', {
+    const tx = await ENSInstance.setRecord('test123.eth', {
       type: 'text',
       record: { key: 'foo', value: 'bar' },
+      addressOrIndex: 1,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
@@ -28,9 +29,9 @@ describe('setRecord', () => {
       await ENSInstance.contracts!.getUniversalResolver()!
     const publicResolver = await ENSInstance.contracts!.getPublicResolver()!
     const encodedText = await universalResolver.resolve(
-      hexEncodeName('parthtejpal.eth'),
+      hexEncodeName('test123.eth'),
       publicResolver.interface.encodeFunctionData('text', [
-        namehash('parthtejpal.eth'),
+        namehash('test123.eth'),
         'foo',
       ]),
     )
@@ -41,12 +42,13 @@ describe('setRecord', () => {
     expect(resultText).toBe('bar')
   })
   it('should allow an address record set', async () => {
-    const tx = await ENSInstance.setRecord('parthtejpal.eth', {
+    const tx = await ENSInstance.setRecord('test123.eth', {
       type: 'addr',
       record: {
         key: 'ETC',
         value: '0x42D63ae25990889E35F215bC95884039Ba354115',
       },
+      addressOrIndex: 1,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
@@ -55,9 +57,9 @@ describe('setRecord', () => {
       await ENSInstance.contracts!.getUniversalResolver()!
     const publicResolver = await ENSInstance.contracts!.getPublicResolver()!
     const encodedAddr = await universalResolver.resolve(
-      hexEncodeName('parthtejpal.eth'),
+      hexEncodeName('test123.eth'),
       publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [
-        namehash('parthtejpal.eth'),
+        namehash('test123.eth'),
         '61',
       ]),
     )
@@ -70,10 +72,11 @@ describe('setRecord', () => {
     )
   })
   it('should allow a contenthash record set', async () => {
-    const tx = await ENSInstance.setRecord('parthtejpal.eth', {
+    const tx = await ENSInstance.setRecord('test123.eth', {
       type: 'contentHash',
       record:
         'ipns://k51qzi5uqu5dgox2z23r6e99oqency055a6xt92xzmyvpz8mwz5ycjavm0u150',
+      addressOrIndex: 1,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
@@ -82,9 +85,9 @@ describe('setRecord', () => {
       await ENSInstance.contracts!.getUniversalResolver()!
     const publicResolver = await ENSInstance.contracts!.getPublicResolver()!
     const encodedContent = await universalResolver.resolve(
-      hexEncodeName('parthtejpal.eth'),
+      hexEncodeName('test123.eth'),
       publicResolver.interface.encodeFunctionData('contenthash', [
-        namehash('parthtejpal.eth'),
+        namehash('test123.eth'),
       ]),
     )
     const [resultContent] = publicResolver.interface.decodeFunctionResult(

package/src/functions/setRecords.test.ts

@@ -16,13 +16,14 @@ afterAll(async () => {
 
 describe('setRecords', () => {
   it('should return a transaction to the resolver and set successfully', async () => {
-    const tx = await ENSInstance.setRecords('parthtejpal.eth', {
+    const tx = await ENSInstance.setRecords('test123.eth', {
       records: {
         coinTypes: [
           { key: 'ETC', value: '0x42D63ae25990889E35F215bC95884039Ba354115' },
         ],
         texts: [{ key: 'foo', value: 'bar' }],
       },
+      addressOrIndex: 1,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
@@ -31,16 +32,16 @@ describe('setRecords', () => {
       await ENSInstance.contracts!.getUniversalResolver()!
     const publicResolver = await ENSInstance.contracts!.getPublicResolver()!
     const encodedText = await universalResolver.resolve(
-      hexEncodeName('parthtejpal.eth'),
+      hexEncodeName('test123.eth'),
       publicResolver.interface.encodeFunctionData('text', [
-        namehash('parthtejpal.eth'),
+        namehash('test123.eth'),
         'foo',
       ]),
     )
     const encodedAddr = await universalResolver.resolve(
-      hexEncodeName('parthtejpal.eth'),
+      hexEncodeName('test123.eth'),
       publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [
-        namehash('parthtejpal.eth'),
+        namehash('test123.eth'),
         '61',
       ]),
     )

package/src/functions/setResolver.test.ts

@@ -20,9 +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', {
+    const tx = await ENSInstance.setResolver('test123.eth', {
       contract: 'registry',
       resolver: '0xAEfF4f4d8e2cB51854BEa2244B3C5Fb36b41C7fC',
+      addressOrIndex: 1,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
@@ -30,19 +31,15 @@ describe('setResolver', () => {
     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', {
-      wrappedOwner: accounts[0],
-    })
-    await wrapNameTx.wait()
-    const tx = await ENSInstance.setResolver('parthtejpal.eth', {
+    const tx = await ENSInstance.setResolver('wrapped.eth', {
       contract: 'nameWrapper',
       resolver: '0xAEfF4f4d8e2cB51854BEa2244B3C5Fb36b41C7fC',
+      addressOrIndex: 1,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
@@ -50,7 +47,7 @@ describe('setResolver', () => {
     const universalResolver =
       await ENSInstance.contracts!.getUniversalResolver()!
     const [result] = await universalResolver.findResolver(
-      hexEncodeName('parthtejpal.eth'),
+      hexEncodeName('wrapped.eth'),
     )
     expect(result).toBe('0xAEfF4f4d8e2cB51854BEa2244B3C5Fb36b41C7fC')
   })

package/src/functions/transferName.test.ts

@@ -22,58 +22,44 @@ describe('transferName', () => {
     await revert()
   })
   it('should allow a transfer on the registrar', async () => {
-    const tx = await ENSInstance.transferName('parthtejpal.eth', {
+    const tx = await ENSInstance.transferName('test123.eth', {
       contract: 'baseRegistrar',
-      newOwner: accounts[1],
-      addressOrIndex: 0,
+      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', {
-      wrappedOwner: accounts[0],
-    })
-    await wrapNameTx.wait()
-    const tx = await ENSInstance.transferName('parthtejpal.eth', {
-      newOwner: accounts[1],
+    const tx = await ENSInstance.transferName('wrapped.eth', {
+      newOwner: accounts[2],
       contract: 'nameWrapper',
-      addressOrIndex: 0,
+      addressOrIndex: 1,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
 
     const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
-    const result = await nameWrapper.ownerOf(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(
-      'test.parthtejpal.eth',
-      {
-        contract: 'registry',
-        owner: accounts[0],
-        addressOrIndex: accounts[0],
-      },
-    )
-    await createSubnameTx.wait()
-
-    const tx = await ENSInstance.transferName('test.parthtejpal.eth', {
+    const tx = await ENSInstance.transferName('test.with-subnames.eth', {
       newOwner: accounts[1],
       contract: 'registry',
-      addressOrIndex: accounts[0],
+      addressOrIndex: accounts[2],
     })
     expect(tx).toBeTruthy()
     await tx.wait()
 
     const registry = await ENSInstance.contracts!.getRegistry()!
-    const result = await registry.owner(namehash('test.parthtejpal.eth'))
+    const result = await registry.owner(namehash('test.with-subnames.eth'))
     expect(result).toBe(accounts[1])
   })
 })

package/src/functions/transferSubname.test.ts

@@ -22,53 +22,34 @@ describe('transferSubname', () => {
     await revert()
   })
   it('should allow transferring a subname on the registry', async () => {
-    const createSubnameTx = await ENSInstance.createSubname(
-      'test.parthtejpal.eth',
-      {
-        contract: 'registry',
-        owner: accounts[0],
-        addressOrIndex: 0,
-      },
-    )
-    await createSubnameTx.wait()
-
-    const tx = await ENSInstance.transferSubname('test.parthtejpal.eth', {
+    const tx = await ENSInstance.transferSubname('test.with-subnames.eth', {
       contract: 'registry',
-      address: accounts[1],
-      addressOrIndex: 0,
+      owner: accounts[1],
+      addressOrIndex: 1,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
 
     const registry = await ENSInstance.contracts!.getRegistry()!
-    const result = await registry.owner(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', {
-      wrappedOwner: accounts[0],
-    })
-    await wrapNameTx.wait()
-    const createSubnameTx = await ENSInstance.createSubname(
-      'test.parthtejpal.eth',
+    const tx = await ENSInstance.transferSubname(
+      'test.wrapped-with-subnames.eth',
       {
         contract: 'nameWrapper',
-        owner: accounts[0],
-        addressOrIndex: 0,
+        owner: accounts[1],
+        addressOrIndex: 1,
       },
     )
-    await createSubnameTx.wait()
-
-    const tx = await ENSInstance.transferSubname('test.parthtejpal.eth', {
-      contract: 'nameWrapper',
-      address: accounts[1],
-      addressOrIndex: 0,
-    })
     expect(tx).toBeTruthy()
     await tx.wait()
 
     const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
-    const result = await nameWrapper.ownerOf(namehash('test.parthtejpal.eth'))
+    const result = await nameWrapper.ownerOf(
+      namehash('test.wrapped-with-subnames.eth'),
+    )
     expect(result).toBe(accounts[1])
   })
 })

package/src/functions/transferSubname.ts

@@ -1,17 +1,29 @@
 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, signer }: ENSArgs<'contracts' | 'signer'>,
-  name: string,
   {
-    contract,
-    address,
-  }: {
-    contract: 'registry' | 'nameWrapper'
-    address: string
-  },
+    contracts,
+    signer,
+    getExpiry,
+  }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>,
+  name: string,
+  { contract, owner, resolverAddress, ...wrapperArgs }: Args,
 ) {
   const labels = name.split('.')
   const label = labels.shift() as string
@@ -25,17 +37,23 @@ export default async function (
       return registry.populateTransaction.setSubnodeOwner(
         parentNodehash,
         labelhash,
-        address,
+        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.populateTransaction.setSubnodeOwner(
         parentNodehash,
         label,
-        address,
+        owner,
         '0',
+        expiry,
       )
     }
     default: {

package/src/functions/unwrapName.test.ts

@@ -22,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', {
-      wrappedOwner: accounts[0],
-    })
-    await wrapNameTx.wait()
-
-    const tx = await ENSInstance.unwrapName('parthtejpal.eth', {
-      newController: accounts[0],
-      newRegistrant: 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', {
-      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', {
-      newController: accounts[0],
+    const tx = await ENSInstance.unwrapName('test.wrapped-with-subnames.eth', {
+      newController: accounts[1],
+      addressOrIndex: 2,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
 
     const registry = await ENSInstance.contracts!.getRegistry()!
-    const result = await registry.owner(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])
   })
 })