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

package/src/tests/getFuses.test.ts

@@ -1,103 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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/getNames.test.ts

@@ -1,247 +0,0 @@
-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

@@ -1,71 +0,0 @@
-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')
-  // })
-})

package/src/tests/getResolver.test.ts

@@ -1,19 +0,0 @@
-import { ENS } from '..'
-import setup from './setup'
-
-let ENSInstance: ENS
-
-beforeAll(async () => {
-  ;({ ENSInstance } = await setup())
-})
-
-describe('getResolver', () => {
-  it('should find the resolver for a name with a resolver', async () => {
-    const result = await ENSInstance.getResolver('jefflau.eth')
-    expect(result).toBe('0x42D63ae25990889E35F215bC95884039Ba354115')
-  })
-  it('should return .eth resolver for an unregistered name', async () => {
-    const result = await ENSInstance.getResolver('test123123cool.eth')
-    expect(result).toBe('0x3E8Dc215A6E404A7Ba811DE5Da3ff2A809AE94E2')
-  })
-})

package/src/tests/getSubnames.test.ts

@@ -1,31 +0,0 @@
-import { ENS } from '..'
-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))
-
-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',
-    )
-  })
-})

package/src/tests/setup.ts

@@ -1,53 +0,0 @@
-import { ethers } from 'ethers'
-import { ENS } from '../'
-import { ContractName, SupportedNetworkId } from '../contracts/types'
-
-const addresses = {
-  BaseRegistrarImplementation: '0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85',
-  Multicall: '0xcA11bde05977b3631167028862bE2a173976CA11',
-  NameWrapper: '0xD7D9C568Bc4C2343ab286096e1F851D33eEf49Af',
-  PublicResolver: '0x3bAa5F3ea7bFCC8948c4140f233d72c11eBF0bdB',
-  ENSRegistryWithFallback: '0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e',
-  ReverseRegistrar: '0x4696E2f7D9f4CA187155ff50D93C00172181ddd5',
-  UniversalResolver: '0xAbCd01ddDa102B0C32e8C5a371D7480dFA559DC3',
-}
-
-const createENS = (graphURI: string) =>
-  new ENS({
-    graphURI,
-    getContractAddress:
-      (_: SupportedNetworkId) => (contractName: ContractName) =>
-        addresses[contractName],
-  })
-
-export default async (useReal?: boolean) => {
-  const graphURI = useReal
-    ? 'https://api.thegraph.com/subgraphs/name/ensdomains/ensropsten'
-    : 'http://localhost:8000/subgraphs/name/graphprotocol/ens'
-
-  const provider = new ethers.providers.JsonRpcProvider(
-    'http://localhost:8545',
-    'ropsten',
-  )
-
-  let ENSInstance = createENS(graphURI)
-  await ENSInstance.setProvider(provider)
-
-  let snapshot = await provider.send('evm_snapshot', [])
-
-  const revert = async (customSnapshot?: any) => {
-    const snapshotToUse = customSnapshot || snapshot
-    await provider.send('evm_revert', [snapshotToUse])
-    if (parseInt(snapshot, 16) >= parseInt(snapshotToUse, 16)) {
-      snapshot = await provider.send('evm_snapshot', [])
-    }
-
-    ENSInstance = createENS(graphURI)
-    await ENSInstance.setProvider(provider)
-    return
-  }
-
-  const createSnapshot = async () => await provider.send('evm_snapshot', [])
-
-  return { ENSInstance, revert, createSnapshot, provider }
-}