@ensdomains/ensjs 2.0.1 → 3.0.0-alpha.2

package/src/tests/deleteSubname.test.ts

@@ -0,0 +1,71 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import { namehash } from '../utils/normalise'
+import setup from './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()
+})
+
+describe('deleteSubname', () => {
+  beforeEach(async () => {
+    await revert()
+  })
+  it('should allow deleting 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.deleteSubname(
+      'test.parthtejpal.eth',
+      'registry',
+      { addressOrIndex: 0 },
+    )
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const registry = await ENSInstance.contracts!.getRegistry()!
+    const result = await registry.owner(namehash('test.parthtejpal.eth'))
+    expect(result).toBe('0x0000000000000000000000000000000000000000')
+  })
+  it('should allow deleting 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.deleteSubname(
+      'test.parthtejpal.eth',
+      'nameWrapper',
+      { addressOrIndex: 0 },
+    )
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
+    const result = await nameWrapper.ownerOf(namehash('test.parthtejpal.eth'))
+    expect(result).toBe('0x0000000000000000000000000000000000000000')
+  })
+})

package/src/tests/getExpiry.test.ts

@@ -0,0 +1,37 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import setup from './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()
+})
+
+describe('getExpiry', () => {
+  it('should get the expiry for a name', async () => {
+    const result = await ENSInstance.getExpiry('jefflau.eth')
+    expect(result).toBeTruthy()
+    if (result) {
+      const { expiry, gracePeriod } = result
+      expect(expiry).toBeInstanceOf(Date)
+      expect(gracePeriod).toBe(7776000000)
+    }
+  })
+  it('should throw an error for a non .eth name', async () => {
+    try {
+      await ENSInstance.getExpiry('sub.jefflau.eth')
+      expect(false).toBeTruthy()
+    } catch {
+      expect(true).toBeTruthy()
+    }
+  })
+})

package/src/tests/getFuses.test.ts

@@ -0,0 +1,103 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import setup from './setup'
+
+let ENSInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
+let createSnapshot: Awaited<ReturnType<typeof setup>>['createSnapshot']
+let provider: ethers.providers.JsonRpcProvider
+let accounts: string[]
+let withWrappedSnapshot: any
+
+beforeAll(async () => {
+  ;({ ENSInstance, revert, provider, createSnapshot } = await setup())
+  accounts = await provider.listAccounts()
+  const tx = await ENSInstance.wrapName('parthtejpal.eth', accounts[0])
+  await tx.wait()
+
+  withWrappedSnapshot = await createSnapshot()
+})
+
+afterEach(async () => {
+  await revert(withWrappedSnapshot)
+  withWrappedSnapshot = await createSnapshot()
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+describe('getFuses', () => {
+  it('should return null for an unwrapped name', async () => {
+    const result = await ENSInstance.getFuses('jefflau.eth')
+    expect(result).toBeUndefined()
+  })
+  it('should return with canDoEverything set to true for a name with no fuses burned', async () => {
+    const tx = await ENSInstance.createSubname({
+      contract: 'nameWrapper',
+      name: 'test.parthtejpal.eth',
+      owner: accounts[0],
+      options: { addressOrIndex: 0 },
+    })
+    await tx.wait()
+
+    const result = await ENSInstance.getFuses('test.parthtejpal.eth')
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result.fuseObj.canDoEverything).toBe(true)
+      expect(
+        Object.values(result.fuseObj).reduce(
+          (prev, curr) => (curr ? prev + 1 : prev),
+          0,
+        ),
+      ).toBe(1)
+      expect(result.rawFuses.toHexString()).toBe('0x00')
+    }
+  })
+  it('should return with other correct fuses', async () => {
+    const tx = await ENSInstance.burnFuses('parthtejpal.eth', {
+      cannotUnwrap: true,
+      cannotSetTtl: true,
+      cannotCreateSubdomain: true,
+    })
+    await tx.wait()
+    const result = await ENSInstance.getFuses('parthtejpal.eth')
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result.fuseObj).toMatchObject({
+        cannotUnwrap: true,
+        cannotBurnFuses: false,
+        cannotTransfer: false,
+        cannotSetResolver: false,
+        cannotSetTtl: true,
+        cannotCreateSubdomain: true,
+        parentCannotControl: true,
+        canDoEverything: false,
+      })
+      expect(result.rawFuses.toHexString()).toBe('0x71')
+    }
+  })
+  it('should return correct vulnerability data for an invulnerable node', async () => {
+    const result = await ENSInstance.getFuses('parthtejpal.eth')
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result.vulnerability).toBe('Safe')
+      expect(result.vulnerableNode).toBeNull()
+    }
+  })
+  it('should return correct vulnerability data for a vulnerable node', async () => {
+    const tx = await ENSInstance.createSubname({
+      name: 'test.parthtejpal.eth',
+      owner: accounts[0],
+      contract: 'nameWrapper',
+    })
+    await tx.wait()
+
+    const result = await ENSInstance.getFuses('test.parthtejpal.eth')
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result.vulnerability).toBe('SubdomainReplacementAllowed')
+      expect(result.vulnerableNode).toBe('parthtejpal.eth')
+    }
+  })
+})

package/src/tests/getHistory.test.ts

@@ -0,0 +1,101 @@
+import { ENS } from '..'
+import setup from './setup'
+
+let ENSInstance: ENS
+
+beforeAll(async () => {
+  ;({ ENSInstance } = await setup())
+  jest.setTimeout(20000)
+})
+
+describe('getHistory', () => {
+  let textEventsWithValue: any[]
+
+  it('should return null for a non-existent name', async () => {
+    const result = await ENSInstance.getHistory('test123123cool.eth')
+    expect(result).toBeUndefined()
+  })
+  it('should return the history of a name', async () => {
+    const result = await ENSInstance.getHistory('jefflau.eth')
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result).toHaveProperty('domain')
+      expect(result).toHaveProperty('resolver')
+      expect(result).toHaveProperty('registration')
+    }
+  })
+  describe('getHistoryWithDetail', () => {
+    it('should return null for a non-existent name', async () => {
+      const result = await ENSInstance.getHistoryWithDetail(
+        'test123123cool.eth',
+      )
+      expect(result).toBeUndefined()
+    })
+    it('should return the history of a name with TextChanged event detail', async () => {
+      const result = await ENSInstance.getHistoryWithDetail('jefflau.eth')
+      expect(result).toBeTruthy()
+      if (result) {
+        const textEvents = result.resolver.filter(
+          (x) => x.type === 'TextChanged',
+        )
+        textEvents.forEach((event) =>
+          expect(event.data).toHaveProperty('value'),
+        )
+        textEventsWithValue = textEvents
+      }
+    })
+  })
+  describe('getHistoryDetailForTransactionHash', () => {
+    it('should throw an error for an invalid transaction hash', async () => {
+      try {
+        await ENSInstance.getHistoryDetailForTransactionHash('0x234')
+        expect(false).toBeTruthy()
+      } catch (error) {
+        expect((error as any).message).toContain('invalid hash')
+      }
+    })
+    it('should return null for a transaction hash with no text events', async () => {
+      const result = await ENSInstance.getHistoryDetailForTransactionHash(
+        '0x0fd7b555e3076ef38dbbe2e40deefe44c9a0530d43f6b3f60dbed4ba49d229b7',
+      )
+      expect(result).toBeUndefined()
+    })
+    it('should return single item for a given transaction hash with one event', async () => {
+      const eventToUse = textEventsWithValue[0]
+      const result = (await ENSInstance.getHistoryDetailForTransactionHash(
+        eventToUse.transactionHash,
+      )) as { key: any; value: any }[]
+      expect(result).toHaveLength(1)
+      if (result) {
+        expect(result[0]).toMatchObject(eventToUse.data)
+      }
+    })
+    it('should return multiple items for a given transaction hash with multiple events', async () => {
+      const hash =
+        '0x002b7cc3c85168d885a38226a28fac349d13cbaff7f3db4fa3af31f22b863079'
+      const dataArr = [
+        { key: 'description', value: 'Not so super description' },
+        { key: 'url', value: 'facebook.com' },
+      ]
+      const result = (await ENSInstance.getHistoryDetailForTransactionHash(
+        hash,
+      )) as { key: any; value: any }[]
+      expect(result).toHaveLength(dataArr.length)
+      if (result) {
+        result.forEach((item, index) =>
+          expect(item).toMatchObject(dataArr[index]),
+        )
+      }
+    })
+    it('should return a single item when an index is specified for a hash', async () => {
+      const hash =
+        '0x002b7cc3c85168d885a38226a28fac349d13cbaff7f3db4fa3af31f22b863079'
+      const data = { key: 'url', value: 'facebook.com' }
+      const result = (await ENSInstance.getHistoryDetailForTransactionHash(
+        hash,
+        1,
+      )) as { key: any; value: any }
+      expect(result).toMatchObject(data)
+    })
+  })
+})

package/src/tests/getName.test.ts

@@ -0,0 +1,47 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import setup from './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()
+})
+
+describe('getName', () => {
+  it('should get a primary name from an address', async () => {
+    const result = await ENSInstance.getName(
+      '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+    )
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result.name).toBe('jefflau.eth')
+      expect(result.match).toBeTruthy()
+    }
+  })
+  it('should return null for an address with no primary name', async () => {
+    const result = await ENSInstance.getName(
+      '0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0',
+    )
+    expect(result).toBeUndefined()
+  })
+  it('should return with a false match for a name with no forward resolution', async () => {
+    const tx = await ENSInstance.setName('jefflau.eth')
+    await tx?.wait()
+
+    const result = await ENSInstance.getName(accounts[0])
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result.name).toBe('jefflau.eth')
+      expect(result.match).toBeFalsy()
+    }
+  })
+})

package/src/tests/getNames.test.ts

@@ -0,0 +1,247 @@
+import { ENS } from '..'
+import { OwnedName, Registration } from '../functions/getNames'
+import setup from './setup'
+
+let ENSInstance: ENS
+
+beforeAll(async () => {
+  ;({ ENSInstance } = await setup())
+})
+
+const testProperties = (obj: object, ...properties: string[]) =>
+  properties.map((property) => expect(obj).toHaveProperty(property))
+
+const testNotProperties = (obj: object, ...properties: string[]) =>
+  properties.map((property) => expect(obj).not.toHaveProperty(property))
+
+describe('getNames', () => {
+  let totalRegistrations: number = 0
+  let totalOwnedNames: number = 0
+  it('should get the registrations for an address', async () => {
+    const result = await ENSInstance.getNames({
+      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      type: 'registrant',
+    })
+    totalRegistrations = result.length
+    expect(result).toBeTruthy()
+    testProperties(
+      result[0],
+      'expiryDate',
+      'registrationDate',
+      'id',
+      'labelName',
+      'labelhash',
+      'name',
+      'isMigrated',
+      'parent',
+      'truncatedName',
+    )
+  })
+  it('should get the owned names for an address', async () => {
+    const result = await ENSInstance.getNames({
+      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      type: 'owner',
+    })
+    totalOwnedNames = result.length
+    expect(result).toBeTruthy()
+    testProperties(
+      result[0],
+      'id',
+      'labelName',
+      'labelhash',
+      'name',
+      'isMigrated',
+      'parent',
+      'truncatedName',
+    )
+    testNotProperties(result[0], 'expiryDate', 'registrationDate')
+  })
+  it('should get the registrations for an address with pagination', async () => {
+    const pageOne = await ENSInstance.getNames({
+      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      type: 'registrant',
+      page: 0,
+    })
+    expect(pageOne).toHaveLength(10)
+    const pageTwo = await ENSInstance.getNames({
+      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      type: 'registrant',
+      page: 1,
+    })
+    expect(pageTwo).toHaveLength(totalRegistrations % 10)
+  })
+  it('should get the owned names for an address with pagination', async () => {
+    const pageOne = await ENSInstance.getNames({
+      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      type: 'owner',
+      page: 0,
+    })
+    expect(pageOne).toHaveLength(10)
+    const pageTwo = await ENSInstance.getNames({
+      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      type: 'owner',
+      page: 1,
+    })
+    expect(pageTwo).toHaveLength(10)
+    const pageThree = await ENSInstance.getNames({
+      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      type: 'owner',
+      page: 2,
+    })
+    expect(pageThree).toHaveLength(10)
+    const pageFour = await ENSInstance.getNames({
+      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      type: 'owner',
+      page: 3,
+    })
+    expect(pageFour).toHaveLength(totalOwnedNames % 10)
+  })
+  describe('orderBy', () => {
+    describe('registrations', () => {
+      it('descending registrationDate', async () => {
+        const registrationDateOrderedDesc = (await ENSInstance.getNames({
+          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          type: 'registrant',
+          orderBy: 'registrationDate',
+          orderDirection: 'desc',
+        })) as Registration[]
+        registrationDateOrderedDesc.reduce((prev, curr) => {
+          expect(prev.registrationDate.getTime()).toBeGreaterThanOrEqual(
+            curr.registrationDate.getTime(),
+          )
+          return curr
+        })
+      })
+      it('ascending registrationDate', async () => {
+        const registrationDateOrderedAsc = (await ENSInstance.getNames({
+          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          type: 'registrant',
+          orderBy: 'registrationDate',
+          orderDirection: 'asc',
+        })) as Registration[]
+        registrationDateOrderedAsc.reduce((prev, curr) => {
+          expect(prev.registrationDate.getTime()).toBeLessThanOrEqual(
+            curr.registrationDate.getTime(),
+          )
+          return curr
+        })
+      })
+      it('descending expiryDate', async () => {
+        const expiryDateOrderedDesc = (await ENSInstance.getNames({
+          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          type: 'registrant',
+          orderBy: 'expiryDate',
+          orderDirection: 'desc',
+        })) as Registration[]
+        expiryDateOrderedDesc.reduce((prev, curr) => {
+          expect(prev.expiryDate.getTime()).toBeGreaterThanOrEqual(
+            curr.expiryDate.getTime(),
+          )
+          return curr
+        })
+      })
+      it('ascending expiryDate', async () => {
+        const expiryDateOrderedAsc = (await ENSInstance.getNames({
+          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          type: 'registrant',
+          orderBy: 'expiryDate',
+          orderDirection: 'asc',
+        })) as Registration[]
+        expiryDateOrderedAsc.reduce((prev, curr) => {
+          expect(prev.expiryDate.getTime()).toBeLessThanOrEqual(
+            curr.expiryDate.getTime(),
+          )
+          return curr
+        })
+      })
+      it('descending labelName', async () => {
+        const labelNameOrderedDesc = (await ENSInstance.getNames({
+          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          type: 'registrant',
+          orderBy: 'labelName',
+          orderDirection: 'desc',
+        })) as Registration[]
+        labelNameOrderedDesc.reduce((prev, curr) => {
+          expect((prev.labelName || '') > (curr.labelName || '')).toBeTruthy()
+          return curr
+        })
+      })
+      it('ascending labelName', async () => {
+        const labelNameOrderedAsc = (await ENSInstance.getNames({
+          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          type: 'registrant',
+          orderBy: 'labelName',
+          orderDirection: 'asc',
+        })) as Registration[]
+        labelNameOrderedAsc.reduce((prev, curr) => {
+          expect((prev.labelName || '') < (curr.labelName || '')).toBeTruthy()
+          return curr
+        })
+      })
+    })
+    describe('owned names', () => {
+      it('descending createdAt', async () => {
+        const createdAtOrderedDesc = (await ENSInstance.getNames({
+          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          type: 'owner',
+          orderBy: 'createdAt',
+          orderDirection: 'desc',
+        })) as OwnedName[]
+        createdAtOrderedDesc.reduce((prev, curr) => {
+          expect(prev.createdAt.getTime()).toBeGreaterThanOrEqual(
+            curr.createdAt.getTime(),
+          )
+          return curr
+        })
+      })
+      it('ascending createdAt', async () => {
+        const createdAtOrderedAsc = (await ENSInstance.getNames({
+          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          type: 'owner',
+          orderBy: 'createdAt',
+          orderDirection: 'asc',
+        })) as OwnedName[]
+        createdAtOrderedAsc.reduce((prev, curr) => {
+          expect(prev.createdAt.getTime()).toBeLessThanOrEqual(
+            curr.createdAt.getTime(),
+          )
+          return curr
+        })
+      })
+      it('descending labelName', async () => {
+        const labelNameOrderedDesc = (await ENSInstance.getNames({
+          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          type: 'owner',
+          orderBy: 'labelName',
+          orderDirection: 'desc',
+        })) as Registration[]
+        labelNameOrderedDesc.reduce((prev, curr) => {
+          if (
+            (!prev.labelName && !curr.labelName) ||
+            (!prev.labelName && curr.labelName)
+          )
+            return curr
+          expect((prev.labelName || '') > (curr.labelName || '')).toBeTruthy()
+          return curr
+        })
+      })
+      it('ascending labelName', async () => {
+        const labelNameOrderedAsc = (await ENSInstance.getNames({
+          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          type: 'owner',
+          orderBy: 'labelName',
+          orderDirection: 'asc',
+        })) as Registration[]
+        labelNameOrderedAsc.reduce((prev, curr) => {
+          if (
+            (!prev.labelName && !curr.labelName) ||
+            (prev.labelName && !curr.labelName)
+          )
+            return curr
+          expect((prev.labelName || '') < (curr.labelName || '')).toBeTruthy()
+          return curr
+        })
+      })
+    })
+  })
+})

package/src/tests/getOwner.test.ts

@@ -0,0 +1,71 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import setup from './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()
+  const tx = await ENSInstance.wrapName('parthtejpal.eth', accounts[0])
+  await tx.wait()
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+describe('getOwner', () => {
+  it('should return null for an unregistered name', async () => {
+    const result = await ENSInstance.getOwner('test123123cool.eth')
+    expect(result).toBeUndefined()
+  })
+  it('should return the owner, registrant, and ownership level for a registered name', async () => {
+    const result = await ENSInstance.getOwner('jefflau.eth')
+    expect(result).toMatchObject({
+      owner: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      registrant: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      ownershipLevel: 'registrar',
+    })
+  })
+  it('should return nameWrapper as the ownership level for a wrapped name', async () => {
+    const result = await ENSInstance.getOwner('parthtejpal.eth')
+    expect(result?.ownershipLevel).toBe('nameWrapper')
+  })
+  it('should return the owner at a specific level if specified', async () => {
+    const result = await ENSInstance.getOwner('parthtejpal.eth', 'registrar')
+    const nameWrapperAddress = (await ENSInstance.contracts!.getNameWrapper())
+      .address
+    expect(result?.ownershipLevel).toBe('registrar')
+    expect(result?.registrant).toBe(nameWrapperAddress)
+  })
+  it('should return the owner of a TLD on the registry', async () => {
+    const result = await ENSInstance.getOwner('eth')
+    const baseRegistrarAddress = (
+      await ENSInstance.contracts!.getBaseRegistrar()
+    ).address
+    expect(result?.ownershipLevel).toBe('registry')
+    expect(result?.owner?.toLowerCase()).toBe(
+      baseRegistrarAddress.toLowerCase(),
+    )
+  })
+  // it('should return registry as the ownership level for an unwrapped subname', async () => {
+  //   const result0 = await ENSInstance.getOwner('fleek.eth')
+  //   console.log(result0?.owner, accounts[2])
+
+  //   const tx = await ENSInstance.createSubname({
+  //     name: 'test.fleek.eth',
+  //     contract: 'registry',
+  //     owner: accounts[0],
+  //     options: { addressOrIndex: accounts[1] },
+  //   })
+
+  //   await tx.wait()
+
+  //   const result = await ENSInstance.getOwner('test.fleek.eth')
+  //   expect(result?.ownershipLevel).toBe('registry')
+  // })
+})