@ensdomains/ensjs 3.0.0-alpha.9 → 3.0.0-beta.1

package/src/functions/normalise.test.ts

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

@@ -1,59 +0,0 @@
-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('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', {
-      address: accounts[0],
-      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

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

@@ -1,100 +0,0 @@
-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('parthtejpal.eth', {
-      type: 'text',
-      record: { 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', [
-        namehash('parthtejpal.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('parthtejpal.eth', {
-      type: 'addr',
-      record: {
-        key: 'ETC',
-        value: '0x42D63ae25990889E35F215bC95884039Ba354115',
-      },
-    })
-    expect(tx).toBeTruthy()
-    await tx.wait()
-
-    const universalResolver =
-      await ENSInstance.contracts!.getUniversalResolver()!
-    const publicResolver = await ENSInstance.contracts!.getPublicResolver()!
-    const encodedAddr = await universalResolver.resolve(
-      hexEncodeName('parthtejpal.eth'),
-      publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [
-        namehash('parthtejpal.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('parthtejpal.eth', {
-      type: 'contentHash',
-      record:
-        'ipns://k51qzi5uqu5dgox2z23r6e99oqency055a6xt92xzmyvpz8mwz5ycjavm0u150',
-    })
-    expect(tx).toBeTruthy()
-    await tx.wait()
-
-    const universalResolver =
-      await ENSInstance.contracts!.getUniversalResolver()!
-    const publicResolver = await ENSInstance.contracts!.getPublicResolver()!
-    const encodedContent = await universalResolver.resolve(
-      hexEncodeName('parthtejpal.eth'),
-      publicResolver.interface.encodeFunctionData('contenthash', [
-        namehash('parthtejpal.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

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

@@ -1,60 +0,0 @@
-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('parthtejpal.eth', {
-      records: {
-        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', [
-        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',
-      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

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

@@ -1,57 +0,0 @@
-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('parthtejpal.eth', {
-      contract: 'registry',
-      resolver: '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', {
-      wrappedOwner: accounts[0],
-    })
-    await wrapNameTx.wait()
-    const tx = await ENSInstance.setResolver('parthtejpal.eth', {
-      contract: 'nameWrapper',
-      resolver: '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

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

@@ -1,79 +0,0 @@
-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('parthtejpal.eth', {
-      contract: 'baseRegistrar',
-      newOwner: accounts[1],
-      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', {
-      wrappedOwner: accounts[0],
-    })
-    await wrapNameTx.wait()
-    const tx = await ENSInstance.transferName('parthtejpal.eth', {
-      newOwner: accounts[1],
-      contract: '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(
-      'test.parthtejpal.eth',
-      {
-        contract: 'registry',
-        owner: accounts[0],
-        addressOrIndex: accounts[0],
-      },
-    )
-    await createSubnameTx.wait()
-
-    const tx = await ENSInstance.transferName('test.parthtejpal.eth', {
-      newOwner: accounts[1],
-      contract: '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

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

@@ -1,74 +0,0 @@
-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 createSubnameTx = await ENSInstance.createSubname(
-      'test.parthtejpal.eth',
-      {
-        contract: 'registry',
-        owner: accounts[0],
-        addressOrIndex: 0,
-      },
-    )
-    await createSubnameTx.wait()
-
-    const tx = await ENSInstance.transferSubname('test.parthtejpal.eth', {
-      contract: 'registry',
-      address: 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', {
-      wrappedOwner: accounts[0],
-    })
-    await wrapNameTx.wait()
-    const createSubnameTx = await ENSInstance.createSubname(
-      'test.parthtejpal.eth',
-      {
-        contract: 'nameWrapper',
-        owner: accounts[0],
-        addressOrIndex: 0,
-      },
-    )
-    await createSubnameTx.wait()
-
-    const tx = await ENSInstance.transferSubname('test.parthtejpal.eth', {
-      contract: 'nameWrapper',
-      address: 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])
-  })
-})