@ensdomains/ensjs 2.1.0 → 3.0.0-alpha.3

package/src/functions/makeCommitment.test.ts

@@ -0,0 +1,23 @@
+import { ENS } from '..'
+import { makeCommitment } from '../utils/registerHelpers'
+import setup from '../tests/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/functions/normalise.test.ts

@@ -0,0 +1,22 @@
+import { namehash } from '../utils/normalise'
+
+describe('normalise', () => {
+  it('should namehash an empty string', () => {
+    const hash = namehash('')
+    expect(hash).toEqual(
+      '0x0000000000000000000000000000000000000000000000000000000000000000',
+    )
+  })
+  it('should namehash a TLD', () => {
+    const hash = namehash('eth')
+    expect(hash).toEqual(
+      '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae',
+    )
+  })
+  it('should namehash a 2LD', () => {
+    const hash = namehash('foo.eth')
+    expect(hash).toEqual(
+      '0xde9b09fd7c5f901e23a3f19fecc54828e9c848539801e86591bd9801b019f84f',
+    )
+  })
+})

package/src/functions/setName.test.ts

@@ -0,0 +1,58 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import { hexEncodeName } from '../utils/hexEncodedName'
+import setup from '../tests/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/functions/setName.ts

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

package/src/functions/setRecords.test.ts

@@ -0,0 +1,58 @@
+import { ENS } from '..'
+import { hexEncodeName } from '../utils/hexEncodedName'
+import { namehash } from '../utils/normalise'
+import setup from '../tests/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)', [
+        namehash('parthtejpal.eth'),
+        'foo',
+      ]),
+    )
+    const encodedAddr = await universalResolver.resolve(
+      hexEncodeName('parthtejpal.eth'),
+      publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [
+        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/functions/setRecords.ts

@@ -0,0 +1,38 @@
+import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
+import { generateRecordCallArray, RecordOptions } from '../utils/recordHelpers'
+
+export default async function (
+  {
+    contracts,
+    provider,
+    getResolver,
+  }: ENSArgs<'contracts' | 'provider' | 'getResolver'>,
+  name: string,
+  records: RecordOptions,
+) {
+  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')
+  }
+
+  const address = await provider?.getSigner().getAddress()
+
+  if (!address) {
+    throw new Error('No signer found')
+  }
+
+  const resolver = (
+    await contracts?.getPublicResolver(provider, resolverAddress)
+  )?.connect(provider?.getSigner()!)
+  const hash = namehash(name)
+
+  const calls: string[] = generateRecordCallArray(hash, records, resolver!)
+
+  return resolver?.multicall(calls)
+}

package/src/functions/setResolver.test.ts

@@ -0,0 +1,60 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import { hexEncodeName } from '../utils/hexEncodedName'
+import setup from '../tests/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/functions/setResolver.ts

@@ -0,0 +1,40 @@
+import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
+
+export default async function (
+  { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
+  name: string,
+  contract: 'registry' | 'nameWrapper',
+  resolver?: string,
+  options?: { addressOrIndex?: string | number },
+) {
+  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)!,
+      )
+      return registry.setResolver(namehash(name), resolver)
+    }
+    case 'nameWrapper': {
+      const nameWrapper = (await contracts?.getNameWrapper())!.connect(
+        provider?.getSigner(options?.addressOrIndex)!,
+      )
+      return nameWrapper.setResolver(namehash(name), resolver)
+    }
+    default: {
+      throw new Error(`Unknown contract: ${contract}`)
+    }
+  }
+}

package/src/functions/transferName.test.ts

@@ -0,0 +1,81 @@
+import { ethers, utils } from 'ethers'
+import { ENS } from '..'
+import { namehash } from '../utils/normalise'
+import setup from '../tests/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(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(namehash('test.parthtejpal.eth'))
+    expect(result).toBe(accounts[1])
+  })
+})

package/src/functions/transferName.ts

@@ -0,0 +1,57 @@
+import { ethers } from 'ethers'
+import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
+
+export default async function (
+  { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
+  name: string,
+  newOwner: string,
+  contract: 'registry' | 'nameWrapper' | 'baseRegistrar',
+  options?: { addressOrIndex?: string | number },
+) {
+  const address = await provider
+    ?.getSigner(options?.addressOrIndex)
+    .getAddress()
+
+  if (!address) {
+    throw new Error('No signer found')
+  }
+
+  switch (contract) {
+    case 'registry': {
+      const registry = (await contracts?.getRegistry())!.connect(
+        provider?.getSigner(options?.addressOrIndex)!,
+      )
+      return registry.setOwner(namehash(name), newOwner)
+    }
+    case 'baseRegistrar': {
+      const baseRegistrar = (await contracts?.getBaseRegistrar())!.connect(
+        provider?.getSigner(options?.addressOrIndex)!,
+      )
+      const labels = name.split('.')
+      if (labels.length > 2 || labels[labels.length - 1] !== 'eth') {
+        throw new Error('Invalid name for baseRegistrar')
+      }
+      return baseRegistrar['safeTransferFrom(address,address,uint256)'](
+        address,
+        newOwner,
+        ethers.utils.solidityKeccak256(['string'], [labels[0]]),
+      )
+    }
+    case 'nameWrapper': {
+      const nameWrapper = (await contracts?.getNameWrapper())!.connect(
+        provider?.getSigner(options?.addressOrIndex)!,
+      )
+      return nameWrapper.safeTransferFrom(
+        address,
+        newOwner,
+        namehash(name),
+        1,
+        '0x',
+      )
+    }
+    default: {
+      throw new Error(`Unknown contract: ${contract}`)
+    }
+  }
+}

package/src/functions/transferSubname.test.ts

@@ -0,0 +1,73 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import { namehash } from '../utils/normalise'
+import setup from '../tests/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(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(namehash('test.parthtejpal.eth'))
+    expect(result).toBe(accounts[1])
+  })
+})

package/src/functions/transferSubname.ts

@@ -0,0 +1,38 @@
+import { ethers } from 'ethers'
+import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
+
+export default async function (
+  { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
+  name: string,
+  contract: 'registry' | 'nameWrapper',
+  address: string,
+  options?: { addressOrIndex?: string | number },
+) {
+  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])
+  const parentNodehash = namehash(labels.join('.'))
+
+  switch (contract) {
+    case 'registry': {
+      const registry = (await contracts?.getRegistry()!).connect(signer)
+
+      return registry.setSubnodeOwner(parentNodehash, labelhash, address)
+    }
+    case 'nameWrapper': {
+      const nameWrapper = (await contracts?.getNameWrapper()!).connect(signer)
+
+      return nameWrapper.setSubnodeOwner(parentNodehash, label, address, '0')
+    }
+    default: {
+      throw new Error(`Unknown contract: ${contract}`)
+    }
+  }
+}

package/src/functions/unwrapName.test.ts

@@ -0,0 +1,68 @@
+import { ethers, utils } from 'ethers'
+import { ENS } from '..'
+import { namehash } from '../utils/normalise'
+import setup from '../tests/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('unwrapName', () => {
+  beforeEach(async () => {
+    await revert()
+  })
+  it('should return a .eth unwrap name transaction and succeed', async () => {
+    const wrapNameTx = await ENSInstance.wrapName(
+      'parthtejpal.eth',
+      accounts[0],
+    )
+    await wrapNameTx.wait()
+
+    const tx = await ENSInstance.unwrapName(
+      'parthtejpal.eth',
+      accounts[0],
+      accounts[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[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 },
+    })
+    await createSubnameTx.wait()
+
+    const tx = await ENSInstance.unwrapName('test.parthtejpal.eth', accounts[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(accounts[0])
+  })
+})