@ensdomains/ensjs 2.1.0 → 3.0.0-alpha.11

package/src/functions/makeCommitment.test.ts

@@ -0,0 +1,23 @@
+import { ENS } from '..'
+import setup from '../tests/setup'
+import { makeCommitment } from '../utils/registerHelpers'
+
+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: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+      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 setup from '../tests/setup'
+import { hexEncodeName } from '../utils/hexEncodedName'
+
+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('test123.eth', { addressOrIndex: 1 })
+    expect(tx).toBeTruthy()
+    await tx?.wait()
+
+    const universalResolver =
+      await ENSInstance.contracts!.getUniversalResolver()!
+    const reverseNode = accounts[1].toLowerCase().substring(2) + '.addr.reverse'
+    const result = await universalResolver.reverse(hexEncodeName(reverseNode))
+    expect(result[0]).toBe('test123.eth')
+  })
+  it("should return a transaction for setting another address' name", async () => {
+    const registry = (await ENSInstance.contracts!.getRegistry()!).connect(
+      provider.getSigner(1),
+    )
+    const setApprovedForAllTx = await registry.setApprovalForAll(
+      accounts[2],
+      true,
+    )
+    await setApprovedForAllTx?.wait()
+
+    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[1].toLowerCase().substring(2) + '.addr.reverse'
+    const result = await universalResolver.reverse(hexEncodeName(reverseNode))
+    expect(result[0]).toBe('test123.eth')
+  })
+})

package/src/functions/setName.ts

@@ -0,0 +1,32 @@
+import { ENSArgs } from '..'
+
+export default async function (
+  { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
+  name: string,
+  {
+    address,
+    resolver,
+  }: {
+    address?: string
+    resolver?: string
+  } = {},
+) {
+  const signerAddress = await signer.getAddress()
+
+  const reverseRegistrar = (await contracts?.getReverseRegistrar())?.connect(
+    signer,
+  )!
+
+  if (address) {
+    const publicResolver = await contracts?.getPublicResolver()!
+
+    return reverseRegistrar.populateTransaction.setNameForAddr(
+      address,
+      signerAddress,
+      resolver || publicResolver.address,
+      name,
+    )
+  }
+
+  return reverseRegistrar.populateTransaction.setName(name)
+}

package/src/functions/setRecord.test.ts

@@ -0,0 +1,103 @@
+import { ENS } from '..'
+import setup from '../tests/setup'
+import { decodeContenthash } from '../utils/contentHash'
+import { hexEncodeName } from '../utils/hexEncodedName'
+import { namehash } from '../utils/normalise'
+
+let ENSInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
+
+beforeAll(async () => {
+  ;({ ENSInstance, revert } = await setup())
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+describe('setRecord', () => {
+  it('should allow a text record set', async () => {
+    const tx = await ENSInstance.setRecord('test123.eth', {
+      type: 'text',
+      record: { key: 'foo', value: 'bar' },
+      addressOrIndex: 1,
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const universalResolver =
+      await ENSInstance.contracts!.getUniversalResolver()!
+    const publicResolver = await ENSInstance.contracts!.getPublicResolver()!
+    const encodedText = await universalResolver.resolve(
+      hexEncodeName('test123.eth'),
+      publicResolver.interface.encodeFunctionData('text', [
+        namehash('test123.eth'),
+        'foo',
+      ]),
+    )
+    const [resultText] = publicResolver.interface.decodeFunctionResult(
+      'text',
+      encodedText[0],
+    )
+    expect(resultText).toBe('bar')
+  })
+  it('should allow an address record set', async () => {
+    const tx = await ENSInstance.setRecord('test123.eth', {
+      type: 'addr',
+      record: {
+        key: 'ETC',
+        value: '0x42D63ae25990889E35F215bC95884039Ba354115',
+      },
+      addressOrIndex: 1,
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const universalResolver =
+      await ENSInstance.contracts!.getUniversalResolver()!
+    const publicResolver = await ENSInstance.contracts!.getPublicResolver()!
+    const encodedAddr = await universalResolver.resolve(
+      hexEncodeName('test123.eth'),
+      publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [
+        namehash('test123.eth'),
+        '61',
+      ]),
+    )
+    const [resultAddr] = publicResolver.interface.decodeFunctionResult(
+      'addr(bytes32,uint256)',
+      encodedAddr[0],
+    )
+    expect(resultAddr).toBe(
+      '0x42D63ae25990889E35F215bC95884039Ba354115'.toLowerCase(),
+    )
+  })
+  it('should allow a contenthash record set', async () => {
+    const tx = await ENSInstance.setRecord('test123.eth', {
+      type: 'contentHash',
+      record:
+        'ipns://k51qzi5uqu5dgox2z23r6e99oqency055a6xt92xzmyvpz8mwz5ycjavm0u150',
+      addressOrIndex: 1,
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const universalResolver =
+      await ENSInstance.contracts!.getUniversalResolver()!
+    const publicResolver = await ENSInstance.contracts!.getPublicResolver()!
+    const encodedContent = await universalResolver.resolve(
+      hexEncodeName('test123.eth'),
+      publicResolver.interface.encodeFunctionData('contenthash', [
+        namehash('test123.eth'),
+      ]),
+    )
+    const [resultContent] = publicResolver.interface.decodeFunctionResult(
+      'contenthash',
+      encodedContent[0],
+    )
+    const content = decodeContenthash(resultContent)
+    expect(content.decoded).toBe(
+      'k51qzi5uqu5dgox2z23r6e99oqency055a6xt92xzmyvpz8mwz5ycjavm0u150',
+    )
+    expect(content.protocolType).toBe('ipns')
+  })
+})

package/src/functions/setRecord.ts

@@ -0,0 +1,63 @@
+import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
+import {
+  generateSingleRecordCall,
+  RecordInput,
+  RecordTypes,
+} from '../utils/recordHelpers'
+
+type BaseInput = {
+  resolverAddress?: string
+}
+
+type ContentHashInput = {
+  record: RecordInput<'contentHash'>
+  type: 'contentHash'
+}
+
+type AddrOrTextInput = {
+  record: RecordInput<'addr' | 'text'>
+  type: 'addr' | 'text'
+}
+
+export default async function <T extends RecordTypes>(
+  {
+    contracts,
+    provider,
+    getResolver,
+    signer,
+  }: ENSArgs<'contracts' | 'provider' | 'getResolver' | 'signer'>,
+  name: string,
+  {
+    record,
+    type,
+    resolverAddress,
+  }: BaseInput & (ContentHashInput | AddrOrTextInput),
+) {
+  if (!name.includes('.')) {
+    throw new Error('Input is not an ENS name')
+  }
+
+  let resolverToUse: string
+  if (resolverAddress) {
+    resolverToUse = resolverAddress
+  } else {
+    resolverToUse = await getResolver(name)
+  }
+
+  if (!resolverToUse) {
+    throw new Error('No resolver found for input address')
+  }
+
+  const resolver = (
+    await contracts?.getPublicResolver(provider, resolverToUse)
+  )?.connect(signer)!
+  const hash = namehash(name)
+
+  const call = generateSingleRecordCall(hash, resolver, type)(record)
+
+  return {
+    to: resolver.address,
+    data: call,
+  }
+}

package/src/functions/setRecords.test.ts

@@ -0,0 +1,61 @@
+import { ENS } from '..'
+import setup from '../tests/setup'
+import { hexEncodeName } from '../utils/hexEncodedName'
+import { namehash } from '../utils/normalise'
+
+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('test123.eth', {
+      records: {
+        coinTypes: [
+          { key: 'ETC', value: '0x42D63ae25990889E35F215bC95884039Ba354115' },
+        ],
+        texts: [{ key: 'foo', value: 'bar' }],
+      },
+      addressOrIndex: 1,
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const universalResolver =
+      await ENSInstance.contracts!.getUniversalResolver()!
+    const publicResolver = await ENSInstance.contracts!.getPublicResolver()!
+    const encodedText = await universalResolver.resolve(
+      hexEncodeName('test123.eth'),
+      publicResolver.interface.encodeFunctionData('text', [
+        namehash('test123.eth'),
+        'foo',
+      ]),
+    )
+    const encodedAddr = await universalResolver.resolve(
+      hexEncodeName('test123.eth'),
+      publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [
+        namehash('test123.eth'),
+        '61',
+      ]),
+    )
+    const [resultText] = publicResolver.interface.decodeFunctionResult(
+      'text',
+      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,44 @@
+import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
+import { generateRecordCallArray, RecordOptions } from '../utils/recordHelpers'
+
+export default async function (
+  {
+    contracts,
+    provider,
+    getResolver,
+    signer,
+  }: ENSArgs<'contracts' | 'provider' | 'getResolver' | 'signer'>,
+  name: string,
+  {
+    records,
+    resolverAddress,
+  }: {
+    records: RecordOptions
+    resolverAddress?: string
+  },
+) {
+  if (!name.includes('.')) {
+    throw new Error('Input is not an ENS name')
+  }
+
+  let resolverToUse: string
+  if (resolverAddress) {
+    resolverToUse = resolverAddress
+  } else {
+    resolverToUse = await getResolver(name)
+  }
+
+  if (!resolverToUse) {
+    throw new Error('No resolver found for input address')
+  }
+
+  const resolver = (
+    await contracts?.getPublicResolver(provider, resolverToUse)
+  )?.connect(signer)!
+  const hash = namehash(name)
+
+  const calls: string[] = generateRecordCallArray(hash, records, resolver!)
+
+  return resolver.populateTransaction.multicall(calls)
+}

package/src/functions/setResolver.test.ts

@@ -0,0 +1,54 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import setup from '../tests/setup'
+import { hexEncodeName } from '../utils/hexEncodedName'
+
+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('test123.eth', {
+      contract: 'registry',
+      resolver: '0xAEfF4f4d8e2cB51854BEa2244B3C5Fb36b41C7fC',
+      addressOrIndex: 1,
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const universalResolver =
+      await ENSInstance.contracts!.getUniversalResolver()!
+    const [result] = await universalResolver.findResolver(
+      hexEncodeName('test123.eth'),
+    )
+    expect(result).toBe('0xAEfF4f4d8e2cB51854BEa2244B3C5Fb36b41C7fC')
+  })
+  it('should return a transaction to the namewrapper and set successfully', async () => {
+    const tx = await ENSInstance.setResolver('wrapped.eth', {
+      contract: 'nameWrapper',
+      resolver: '0xAEfF4f4d8e2cB51854BEa2244B3C5Fb36b41C7fC',
+      addressOrIndex: 1,
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const universalResolver =
+      await ENSInstance.contracts!.getUniversalResolver()!
+    const [result] = await universalResolver.findResolver(
+      hexEncodeName('wrapped.eth'),
+    )
+    expect(result).toBe('0xAEfF4f4d8e2cB51854BEa2244B3C5Fb36b41C7fC')
+  })
+})

package/src/functions/setResolver.ts

@@ -0,0 +1,35 @@
+import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
+
+export default async function (
+  { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
+  name: string,
+  {
+    contract,
+    resolver,
+  }: {
+    contract: 'registry' | 'nameWrapper'
+    resolver?: string
+  },
+) {
+  if (!resolver) {
+    resolver = (await contracts?.getPublicResolver()!).address
+  }
+
+  switch (contract) {
+    case 'registry': {
+      const registry = (await contracts?.getRegistry())!.connect(signer)
+      return registry.populateTransaction.setResolver(namehash(name), resolver)
+    }
+    case 'nameWrapper': {
+      const nameWrapper = (await contracts?.getNameWrapper())!.connect(signer)
+      return nameWrapper.populateTransaction.setResolver(
+        namehash(name),
+        resolver,
+      )
+    }
+    default: {
+      throw new Error(`Unknown contract: ${contract}`)
+    }
+  }
+}

package/src/functions/transferName.test.ts

@@ -0,0 +1,65 @@
+import { ethers, utils } from 'ethers'
+import { ENS } from '..'
+import setup from '../tests/setup'
+import { namehash } from '../utils/normalise'
+
+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('test123.eth', {
+      contract: 'baseRegistrar',
+      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'], ['test123']),
+    )
+    expect(result).toBe(accounts[2])
+  })
+  it('should allow a transfer on the namewrapper', async () => {
+    const tx = await ENSInstance.transferName('wrapped.eth', {
+      newOwner: accounts[2],
+      contract: 'nameWrapper',
+      addressOrIndex: 1,
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
+    const result = await nameWrapper.ownerOf(namehash('wrapped.eth'))
+    expect(result).toBe(accounts[2])
+  })
+  it('should allow a transfer on the registry', async () => {
+    const tx = await ENSInstance.transferName('test.with-subnames.eth', {
+      newOwner: accounts[1],
+      contract: 'registry',
+      addressOrIndex: accounts[2],
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const registry = await ENSInstance.contracts!.getRegistry()!
+    const result = await registry.owner(namehash('test.with-subnames.eth'))
+    expect(result).toBe(accounts[1])
+  })
+})

package/src/functions/transferName.ts

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

package/src/functions/transferSubname.test.ts

@@ -0,0 +1,55 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import setup from '../tests/setup'
+import { namehash } from '../utils/normalise'
+
+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 tx = await ENSInstance.transferSubname('test.with-subnames.eth', {
+      contract: 'registry',
+      owner: accounts[1],
+      addressOrIndex: 1,
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const registry = await ENSInstance.contracts!.getRegistry()!
+    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 tx = await ENSInstance.transferSubname(
+      'test.wrapped-with-subnames.eth',
+      {
+        contract: 'nameWrapper',
+        owner: accounts[1],
+        addressOrIndex: 1,
+      },
+    )
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
+    const result = await nameWrapper.ownerOf(
+      namehash('test.wrapped-with-subnames.eth'),
+    )
+    expect(result).toBe(accounts[1])
+  })
+})