@ensdomains/ensjs 2.1.0 → 3.0.0-alpha.1

package/src/tests/getProfile.test.ts

@@ -0,0 +1,102 @@
+import { ENS } from '..'
+import setup from './setup'
+
+let ENSInstance: ENS
+
+beforeAll(async () => {
+  ;({ ENSInstance } = await setup())
+})
+
+const checkRecords = (
+  result: Record<string, any> | null,
+  textLength = 3,
+  coinTypeLength = 5,
+) => {
+  expect(result).toBeTruthy()
+  if (result) {
+    expect(result.records?.texts).toHaveLength(textLength)
+    expect(result.records?.coinTypes).toHaveLength(coinTypeLength)
+    expect(result.resolverAddress).toBe(
+      '0x42D63ae25990889E35F215bC95884039Ba354115',
+    )
+  }
+}
+
+describe('getProfile', () => {
+  describe('with an address', () => {
+    it('should return a profile object with no other args', async () => {
+      const result = await ENSInstance.getProfile(
+        '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      )
+      expect((result as any).name).toBe('jefflau.eth')
+      expect((result as any).address).toBeUndefined()
+      checkRecords(result)
+    })
+    it('should return a profile object with specified records', async () => {
+      const result = await ENSInstance.getProfile(
+        '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+        { texts: ['description', 'url'], coinTypes: ['ETC', '0'] },
+      )
+      expect((result as any).name).toBe('jefflau.eth')
+      expect((result as any).address).toBeUndefined()
+      checkRecords(result, 2, 3)
+    })
+    it('should return a profile object with all of each specified record type', async () => {
+      const result = await ENSInstance.getProfile(
+        '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+        { texts: true, coinTypes: true },
+      )
+      checkRecords(result)
+    })
+    it('should return null for an address without a name', async () => {
+      const result = await ENSInstance.getProfile(
+        '0x8e8db5ccef88cca9d624701db544989c996e3216',
+      )
+      expect(result).toBeUndefined()
+    })
+  })
+  describe('with a name', () => {
+    it('should return a profile object with no other args', async () => {
+      const result = await ENSInstance.getProfile('jefflau.eth')
+      expect((result as any).address).toBe(
+        '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      )
+      checkRecords(result)
+    })
+    it('should return a profile object with specified records', async () => {
+      const result = await ENSInstance.getProfile('jefflau.eth', {
+        texts: ['description', 'url'],
+        coinTypes: ['ETC', '0'],
+      })
+      expect((result as any).address).toBe(
+        '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      )
+      checkRecords(result, 2, 3)
+    })
+    it('should return a profile object with all of each specified record type', async () => {
+      const result = await ENSInstance.getProfile('jefflau.eth', {
+        texts: true,
+        coinTypes: true,
+      })
+      checkRecords(result)
+    })
+    it('should return null for an unregistered name', async () => {
+      const result = await ENSInstance.getProfile('test123123123cool.eth')
+      expect(result).toBeUndefined()
+    })
+  })
+  describe('with an unmigrated name', () => {
+    beforeAll(async () => {
+      ;({ ENSInstance } = await setup(true))
+      jest.setTimeout(20000)
+    })
+    it('should return an object with isMigrated false and a message', async () => {
+      const result = await ENSInstance.getProfile('jefflau.test')
+      expect(result).toBeTruthy()
+      if (result) {
+        expect(result.isMigrated).toBe(false)
+        expect(result.message).toBe("Records fetch didn't complete")
+      }
+    })
+  })
+})

package/src/tests/getResolver.test.ts

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

@@ -0,0 +1,76 @@
+import { ENS } from '..'
+import setup from './setup'
+
+let ENSInstance: ENS
+
+beforeAll(async () => {
+  ;({ ENSInstance } = await setup())
+})
+
+describe('getSpecificRecord', () => {
+  describe('getContentHash', () => {
+    it('should return null for a non-existent name', async () => {
+      const result = await ENSInstance.getContentHash('test123123cool.eth')
+      expect(result).toBeUndefined()
+    })
+    it('should return null for a name with no contenthash record', async () => {
+      const result = await ENSInstance.getContentHash('jefflau.eth')
+      expect(result).toBeUndefined()
+    })
+    it('should return the contenthash for a name with the record set', async () => {
+      const result = await ENSInstance.getContentHash('matoken.eth')
+      expect(result).toMatchObject({
+        protocolType: 'ipfs',
+        decoded: 'bafybeico3uuyj3vphxpvbowchdwjlrlrh62awxscrnii7w7flu5z6fk77y',
+        error: undefined,
+      })
+    })
+  })
+
+  describe('getText', () => {
+    it('should return a record from a key', async () => {
+      const result = await ENSInstance.getText('jefflau.eth', 'description')
+      expect(result).toBe('Hello2')
+    })
+
+    it('should return null for a non-existent key', async () => {
+      const result = await ENSInstance.getText(
+        'jefflau.eth',
+        'thiskeydoesntexist',
+      )
+      expect(result).toBeUndefined()
+    })
+  })
+
+  describe('getAddr', () => {
+    it('should return the ETH addr record if no coinType is provided', async () => {
+      const result = await ENSInstance.getAddr('jefflau.eth')
+      expect(result).toBe('0x866B3c4994e1416B7C738B9818b31dC246b95eEE')
+    })
+    it('should return the correct address based on a coin ID input as a number', async () => {
+      const result = await ENSInstance.getAddr('jefflau.eth', 61)
+      expect((result as any).addr).toBe(
+        '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      )
+      expect((result as any).coin).toBe('ETC')
+    })
+    it('should return the correct address based on a coin ID input as a string', async () => {
+      const result = await ENSInstance.getAddr('jefflau.eth', '61')
+      expect((result as any).addr).toBe(
+        '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      )
+      expect((result as any).coin).toBe('ETC')
+    })
+    it('should return the correct address based on a coin name', async () => {
+      const result = await ENSInstance.getAddr('jefflau.eth', 'ETC')
+      expect((result as any).addr).toBe(
+        '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      )
+      expect((result as any).coin).toBe('ETC')
+    })
+    it('should return null for a non-existent coin', async () => {
+      const result = await ENSInstance.getAddr('jefflau.eth', 'BNB')
+      expect(result).toBeUndefined()
+    })
+  })
+})

package/src/tests/getSubnames.test.ts

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

@@ -0,0 +1,23 @@
+import { ENS } from '..'
+import { makeCommitment } from '../utils/registerHelpers'
+import setup from './setup'
+
+let ENSInstance: ENS
+
+beforeAll(async () => {
+  ;({ ENSInstance } = await setup())
+})
+
+describe('makeCommitment', () => {
+  it('should create a valid commitment', async () => {
+    const resolver = await ENSInstance.contracts!.getPublicResolver()!
+    const commitment = makeCommitment({
+      name: 'test.eth',
+      owner: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      duration: 1 * 365 * 24 * 60 * 60,
+      resolver: resolver,
+    })
+    expect(commitment).toHaveProperty('secret')
+    expect(commitment).toHaveProperty('commitment')
+  })
+})

package/src/tests/setName.test.ts

@@ -0,0 +1,58 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import { hexEncodeName } from '../utils/hexEncodedName'
+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('setName', () => {
+  beforeEach(async () => {
+    await revert()
+  })
+  it('should return a transaction for a name and set successfully', async () => {
+    const tx = await ENSInstance.setName('fleek.eth')
+    expect(tx).toBeTruthy()
+    await tx?.wait()
+
+    const universalResolver =
+      await ENSInstance.contracts!.getUniversalResolver()!
+    const reverseNode = accounts[0].toLowerCase().substring(2) + '.addr.reverse'
+    const result = await universalResolver.reverse(hexEncodeName(reverseNode))
+    expect(result[0]).toBe('fleek.eth')
+  })
+  it("should return a transaction for setting another address' name", async () => {
+    jest.setTimeout(20000)
+    const registry = (await ENSInstance.contracts!.getRegistry()!).connect(
+      provider.getSigner(),
+    )
+    const setApprovedForAllTx = await registry.setApprovalForAll(
+      accounts[1],
+      true,
+    )
+    await setApprovedForAllTx?.wait()
+
+    const tx = await ENSInstance.setName('fleek.eth', accounts[0], undefined, {
+      addressOrIndex: 1,
+    })
+    expect(tx).toBeTruthy()
+    await tx?.wait()
+
+    const universalResolver =
+      await ENSInstance.contracts!.getUniversalResolver()!
+    const reverseNode = accounts[0].toLowerCase().substring(2) + '.addr.reverse'
+    const result = await universalResolver.reverse(hexEncodeName(reverseNode))
+    expect(result[0]).toBe('fleek.eth')
+  })
+})

package/src/tests/setRecords.test.ts

@@ -0,0 +1,58 @@
+import { utils } from 'ethers'
+import { ENS } from '..'
+import { hexEncodeName } from '../utils/hexEncodedName'
+import setup from './setup'
+
+let ENSInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
+
+beforeAll(async () => {
+  ;({ ENSInstance, revert } = await setup())
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+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' }],
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const universalResolver =
+      await ENSInstance.contracts!.getUniversalResolver()!
+    const publicResolver = await ENSInstance.contracts!.getPublicResolver()!
+    const encodedText = await universalResolver.resolve(
+      hexEncodeName('parthtejpal.eth'),
+      publicResolver.interface.encodeFunctionData('text(bytes32,string)', [
+        utils.namehash('parthtejpal.eth'),
+        'foo',
+      ]),
+    )
+    const encodedAddr = await universalResolver.resolve(
+      hexEncodeName('parthtejpal.eth'),
+      publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [
+        utils.namehash('parthtejpal.eth'),
+        '61',
+      ]),
+    )
+    const [resultText] = publicResolver.interface.decodeFunctionResult(
+      'text(bytes32,string)',
+      encodedText[0],
+    )
+    const [resultAddr] = publicResolver.interface.decodeFunctionResult(
+      'addr(bytes32,uint256)',
+      encodedAddr[0],
+    )
+    expect(resultText).toBe('bar')
+    expect(resultAddr).toBe(
+      '0x42D63ae25990889E35F215bC95884039Ba354115'.toLowerCase(),
+    )
+  })
+})

package/src/tests/setResolver.test.ts

@@ -0,0 +1,60 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import { hexEncodeName } from '../utils/hexEncodedName'
+import setup from './setup'
+
+let ENSInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
+let provider: ethers.providers.JsonRpcProvider
+
+beforeAll(async () => {
+  ;({ ENSInstance, revert, provider } = await setup())
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+describe('setResolver', () => {
+  beforeEach(async () => {
+    await revert()
+  })
+  it('should return a transaction to the registry and set successfully', async () => {
+    const tx = await ENSInstance.setResolver(
+      'parthtejpal.eth',
+      'registry',
+      '0xAEfF4f4d8e2cB51854BEa2244B3C5Fb36b41C7fC',
+    )
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const universalResolver =
+      await ENSInstance.contracts!.getUniversalResolver()!
+    const [result] = await universalResolver.findResolver(
+      hexEncodeName('parthtejpal.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',
+    )
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const universalResolver =
+      await ENSInstance.contracts!.getUniversalResolver()!
+    const [result] = await universalResolver.findResolver(
+      hexEncodeName('parthtejpal.eth'),
+    )
+    expect(result).toBe('0xAEfF4f4d8e2cB51854BEa2244B3C5Fb36b41C7fC')
+  })
+})

package/src/tests/setup.ts

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

package/src/tests/transferName.test.ts

@@ -0,0 +1,80 @@
+import { ethers, utils } 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('transferName', () => {
+  beforeEach(async () => {
+    await revert()
+  })
+  it('should allow a transfer on the registrar', async () => {
+    const tx = await ENSInstance.transferName(
+      'parthtejpal.eth',
+      accounts[1],
+      'baseRegistrar',
+      { addressOrIndex: 0 },
+    )
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const baseRegistrar = await ENSInstance.contracts!.getBaseRegistrar()!
+    const result = await baseRegistrar.ownerOf(
+      utils.solidityKeccak256(['string'], ['parthtejpal']),
+    )
+    expect(result).toBe(accounts[1])
+  })
+  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 },
+    )
+    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])
+  })
+  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(
+      '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'))
+    expect(result).toBe(accounts[1])
+  })
+})

package/src/tests/transferSubname.test.ts

@@ -0,0 +1,74 @@
+import { ethers, utils } 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('transferSubname', () => {
+  beforeEach(async () => {
+    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(
+      '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'))
+    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 },
+    )
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
+    const result = await nameWrapper.ownerOf(
+      utils.namehash('test.parthtejpal.eth'),
+    )
+    expect(result).toBe(accounts[1])
+  })
+})