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

package/src/functions/getNames.ts

@@ -1,275 +0,0 @@
-import { ENSArgs } from '..'
-import { truncateFormat } from '../utils/format'
-import { decryptName } from '../utils/labels'
-
-export type Name = {
-  id: string
-  labelName: string | null
-  truncatedName?: string
-  labelhash: string
-  isMigrated: boolean
-  name: string
-  parent: {
-    name: string
-  }
-  createdAt?: Date
-  registrationDate?: Date
-  expiryDate?: Date
-  type: 'domain' | 'registration'
-}
-
-type BaseParams = {
-  address: string
-  type: 'registrant' | 'owner' | 'all'
-  page?: number
-  pageSize?: number
-  orderDirection?: 'asc' | 'desc'
-}
-
-type RegistrantParams = {
-  type: 'registrant'
-  orderBy?: 'registrationDate' | 'expiryDate' | 'labelName'
-}
-
-type OwnerParams = {
-  type: 'owner'
-  orderBy?: 'createdAt' | 'labelName'
-}
-
-type AllParams = {
-  type: 'all'
-  orderBy?: 'labelName' | 'creationDate'
-  page?: never
-  pageSize?: never
-}
-
-type Params = BaseParams & (RegistrantParams | OwnerParams | AllParams)
-
-const mapDomain = (domain: any) => {
-  const decrypted = decryptName(domain.name)
-  return {
-    ...domain,
-    name: decrypted,
-    truncatedName: truncateFormat(decrypted),
-    createdAt: new Date(parseInt(domain.createdAt) * 1000),
-    type: 'domain',
-  }
-}
-
-const mapRegistration = (registration: any) => {
-  const decrypted = decryptName(registration.domain.name)
-  return {
-    expiryDate: new Date(parseInt(registration.expiryDate) * 1000),
-    registrationDate: new Date(parseInt(registration.registrationDate) * 1000),
-    ...registration.domain,
-    name: decrypted,
-    truncatedName: truncateFormat(decrypted),
-    type: 'registration',
-  }
-}
-
-const getNames = async (
-  { gqlInstance }: ENSArgs<'gqlInstance'>,
-  {
-    address: _address,
-    type,
-    page,
-    pageSize = 10,
-    orderDirection,
-    orderBy,
-  }: Params,
-) => {
-  const address = _address.toLowerCase()
-  const client = gqlInstance.client!
-  const domainQueryData = `
-    id
-    labelName
-    labelhash
-    name
-    isMigrated
-    parent {
-        name
-    }
-  `
-
-  let queryVars: object = {}
-  let finalQuery: string = ''
-
-  if (type === 'all') {
-    finalQuery = gqlInstance.gql`
-      query getNames(
-        $id: ID!
-        $expiryDate: Int
-      ) {
-        account(id: $id) {
-          registrations(
-            first: 1000
-            where: { expiryDate_gt: $expiryDate }
-          ) {
-            registrationDate
-            expiryDate
-            domain {
-              ${domainQueryData}
-            }
-          }
-          domains(first: 1000) {
-            ${domainQueryData}
-            createdAt
-          }
-        }
-      }
-    `
-    queryVars = {
-      id: address,
-      expiryDate: Math.floor(Date.now() / 1000) - 90 * 24 * 60 * 60,
-    }
-  } else if (type === 'owner') {
-    if (typeof page !== 'number') {
-      finalQuery = gqlInstance.gql`
-        query getNames(
-          $id: ID! 
-          $orderBy: Domain_orderBy 
-          $orderDirection: OrderDirection
-        ) {
-          account(id: $id) {
-            domains(orderBy: $orderBy, orderDirection: $orderDirection) {
-              ${domainQueryData}
-              createdAt
-            }
-          }
-        }
-      `
-      queryVars = {
-        id: address,
-        orderBy,
-        orderDirection,
-      }
-    } else {
-      finalQuery = gqlInstance.gql`
-        query getNames(
-          $id: ID!
-          $first: Int
-          $skip: Int
-          $orderBy: Domain_orderBy
-          $orderDirection: OrderDirection
-        ) {
-          account(id: $id) {
-            domains(
-              first: $first
-              skip: $skip
-              orderBy: $orderBy
-              orderDirection: $orderDirection
-            ) {
-              ${domainQueryData}
-              createdAt
-            }
-          }
-        }
-      `
-
-      queryVars = {
-        id: address,
-        first: pageSize,
-        skip: (page || 0) * pageSize,
-        orderBy,
-        orderDirection,
-      }
-    }
-  } else {
-    if (typeof page !== 'number') {
-      finalQuery = gqlInstance.gql`
-        query getNames(
-          $id: ID!
-          $orderBy: Registration_orderBy
-          $orderDirection: OrderDirection
-          $expiryDate: Int
-        ) {
-          account(id: $id) {
-            registrations(
-              orderBy: $orderBy
-              orderDirection: $orderDirection
-              where: { expiryDate_gt: $expiryDate }
-            ) {
-              registrationDate
-              expiryDate
-              domain {
-                ${domainQueryData}
-              }
-            }
-          }
-        }
-      `
-
-      queryVars = {
-        id: address,
-        orderBy,
-        orderDirection,
-        expiryDate: Math.floor(Date.now() / 1000) - 90 * 24 * 60 * 60,
-      }
-    } else {
-      finalQuery = gqlInstance.gql`
-        query getNames(
-          $id: ID!
-          $first: Int
-          $skip: Int
-          $orderBy: Registration_orderBy
-          $orderDirection: OrderDirection
-          $expiryDate: Int
-        ) {
-          account(id: $id) {
-            registrations(
-              first: $first
-              skip: $skip
-              orderBy: $orderBy
-              orderDirection: $orderDirection
-              where: { expiryDate_gt: $expiryDate }
-            ) {
-              registrationDate
-              expiryDate
-              domain {
-                ${domainQueryData}
-              }
-            }
-          }
-        }
-      `
-
-      queryVars = {
-        id: address,
-        first: pageSize,
-        skip: (page || 0) * pageSize,
-        orderBy: orderBy,
-        orderDirection: orderDirection,
-        expiryDate: Math.floor(Date.now() / 1000) - 90 * 24 * 60 * 60,
-      }
-    }
-  }
-
-  const { account } = await client.request(finalQuery, queryVars)
-  if (type === 'all') {
-    return [
-      ...account.domains.map(mapDomain),
-      ...account.registrations.map(mapRegistration),
-    ].sort((a, b) => {
-      if (orderDirection === 'desc') {
-        if (orderBy === 'labelName') {
-          return b.name.localeCompare(a.name)
-        } else {
-          return b.createdAt.getTime() - a.createdAt.getTime()
-        }
-      } else {
-        if (orderBy === 'labelName') {
-          return a.name.localeCompare(b.name)
-        } else if (orderBy === 'creationDate') {
-          return a.createdAt.getTime() - b.createdAt.getTime()
-        }
-      }
-    }) as Name[]
-  } else if (type === 'owner') {
-    return account.domains.map(mapDomain) as Name[]
-  } else {
-    return account.registrations.map(mapRegistration) as Name[]
-  }
-}
-
-export default getNames

package/src/functions/getOwner.test.ts

@@ -1,73 +0,0 @@
-import { ethers } from 'ethers'
-import { ENS } from '..'
-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()
-  const tx = await ENSInstance.wrapName('parthtejpal.eth', {
-    wrappedOwner: 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/functions/getOwner.ts

@@ -1,202 +0,0 @@
-import { ethers } from 'ethers'
-import { ENSArgs } from '..'
-import { labelhash } from '../utils/labels'
-import { namehash as makeNamehash } from '../utils/normalise'
-
-type Owner = {
-  registrant?: string
-  owner?: string
-  ownershipLevel: 'nameWrapper' | 'registry' | 'registrar'
-}
-
-const singleContractOwnerRaw = async (
-  { contracts }: ENSArgs<'contracts'>,
-  contract: 'nameWrapper' | 'registry' | 'registrar',
-  namehash: string,
-  labels: string[],
-) => {
-  switch (contract) {
-    case 'nameWrapper': {
-      const nameWrapper = await contracts?.getNameWrapper()!
-
-      return {
-        to: nameWrapper.address,
-        data: nameWrapper.interface.encodeFunctionData('ownerOf', [namehash]),
-      }
-    }
-    case 'registry': {
-      const registry = await contracts?.getRegistry()!
-
-      return {
-        to: registry.address,
-        data: registry.interface.encodeFunctionData('owner', [namehash]),
-      }
-    }
-    case 'registrar': {
-      const registrar = await contracts?.getBaseRegistrar()!
-
-      return {
-        to: registrar.address,
-        data: registrar.interface.encodeFunctionData('ownerOf', [
-          labelhash(labels[0]),
-        ]),
-      }
-    }
-  }
-}
-
-const raw = async (
-  { contracts, multicallWrapper }: ENSArgs<'contracts' | 'multicallWrapper'>,
-  name: string,
-  contract?: 'nameWrapper' | 'registry' | 'registrar',
-) => {
-  const namehash = makeNamehash(name)
-  const labels = name.split('.')
-
-  if (contract || labels.length === 1) {
-    return await singleContractOwnerRaw(
-      { contracts },
-      contract || 'registry',
-      namehash,
-      labels,
-    )
-  }
-
-  const registryData = await singleContractOwnerRaw(
-    { contracts },
-    'registry',
-    namehash,
-    labels,
-  )
-  const nameWrapperData = await singleContractOwnerRaw(
-    { contracts },
-    'nameWrapper',
-    namehash,
-    labels,
-  )
-  const registrarData = await singleContractOwnerRaw(
-    { contracts },
-    'registrar',
-    namehash,
-    labels,
-  )
-
-  const data: { to: string; data: string }[] = [registryData, nameWrapperData]
-
-  if (labels.length == 2 && labels[1] === 'eth') {
-    data.push(registrarData)
-  }
-
-  return multicallWrapper.raw(data)
-}
-
-const singleContractOwnerDecode = (data: string) =>
-  ethers.utils.defaultAbiCoder.decode(['address'], data)[0]
-
-const decode = async (
-  { contracts, multicallWrapper }: ENSArgs<'contracts' | 'multicallWrapper'>,
-  data: string,
-  name: string,
-  contract?: 'nameWrapper' | 'registry' | 'registrar',
-): Promise<Owner | undefined> => {
-  if (data === null) return
-  const labels = name.split('.')
-  if (contract || labels.length === 1) {
-    const singleOwner = singleContractOwnerDecode(data)
-    let obj = {
-      ownershipLevel: contract || 'registry',
-    }
-    if (contract === 'registrar') {
-      return {
-        ...obj,
-        registrant: singleOwner as string,
-      }
-    } else {
-      return {
-        ...obj,
-        owner: singleOwner as string,
-      }
-    }
-  }
-  const result = await multicallWrapper.decode(data)
-  if (result === null) return
-  const nameWrapper = await contracts?.getNameWrapper()!
-
-  const decodedData = [result[0][1], result[1][1], result[2]?.[1]].map(
-    (ret) =>
-      ret &&
-      ret !== '0x' &&
-      ethers.utils.defaultAbiCoder.decode(['address'], ret),
-  )
-
-  const registryOwner = (decodedData[0] as ethers.utils.Result)[0]
-  const nameWrapperOwner = (decodedData[1] as ethers.utils.Result)[0]
-  const registrarOwner = (
-    decodedData[2] as ethers.utils.Result | undefined
-  )?.[0]
-
-  // check for only .eth names
-  if (labels[labels.length - 1] === 'eth') {
-    // if the owner on the registrar is the namewrapper, then the namewrapper owner is the owner
-    // there is no "registrant" for wrapped names
-    if (registrarOwner === nameWrapper.address) {
-      return {
-        owner: nameWrapperOwner,
-        ownershipLevel: 'nameWrapper',
-      }
-    }
-    // if there is a registrar owner, then it's not a subdomain but we have also passed the namewrapper clause
-    // this means that it's an unwrapped second-level name
-    // the registrant is the owner of the NFT
-    // the owner is the controller of the records
-    if (registrarOwner) {
-      return {
-        registrant: registrarOwner,
-        owner: registryOwner,
-        ownershipLevel: 'registrar',
-      }
-    }
-    if (
-      labels.length > 2 &&
-      ethers.utils.hexStripZeros(registryOwner) !== '0x'
-    ) {
-      // this means that the subname is wrapped
-      if (registryOwner === nameWrapper.address) {
-        return {
-          owner: nameWrapperOwner,
-          ownershipLevel: 'nameWrapper',
-        }
-      }
-      // unwrapped subnames do not have NFTs associated, so do not have a registrant
-      return {
-        owner: registryOwner,
-        ownershipLevel: 'registry',
-      }
-    }
-    // .eth names with no registrar owner are either unregistered or expired
-    return
-  }
-
-  // non .eth names inherit the owner from the registry
-  // there will only ever be an owner for non .eth names, not a registrant
-  // this is because for unwrapped names, there is no associated NFT
-  // and for wrapped names, owner and registrant are the same thing
-  if (registryOwner == nameWrapper.address) {
-    return {
-      owner: nameWrapperOwner,
-      ownershipLevel: 'nameWrapper',
-    }
-  }
-
-  // for unwrapped non .eth names, the owner is the registry owner
-  if (ethers.utils.hexStripZeros(registryOwner) !== '0x') {
-    return {
-      owner: registryOwner,
-      ownershipLevel: 'registry',
-    }
-  }
-
-  // for anything else, return
-  return
-}
-export default { raw, decode }

package/src/functions/getPrice.ts

@@ -1,71 +0,0 @@
-import { BigNumber, utils } from 'ethers'
-import { ENSArgs } from '..'
-
-const raw = async (
-  { contracts, multicallWrapper }: ENSArgs<'contracts' | 'multicallWrapper'>,
-  name: string,
-  duration: number,
-  legacy?: boolean,
-) => {
-  const controller = await contracts?.getEthRegistrarController()!
-
-  const baseCall = {
-    to: controller.address,
-    data: controller.interface.encodeFunctionData('rentPrice', [
-      name,
-      duration,
-    ]),
-  }
-
-  if (legacy) {
-    return multicallWrapper.raw([
-      baseCall,
-      {
-        to: controller.address,
-        data: controller.interface.encodeFunctionData('rentPrice', [name, 0]),
-      },
-    ])
-  }
-
-  return baseCall
-}
-
-const decode = async (
-  { contracts, multicallWrapper }: ENSArgs<'contracts' | 'multicallWrapper'>,
-  data: string,
-  _name: string,
-  _number: number,
-  legacy?: boolean,
-) => {
-  if (data === null) return
-  const controller = await contracts?.getEthRegistrarController()!
-  try {
-    let base: BigNumber
-    let premium: BigNumber
-    if (legacy) {
-      const result = await multicallWrapper.decode(data)
-      const [price] = utils.defaultAbiCoder.decode(
-        ['uint256'],
-        result[0].returnData,
-      ) as [BigNumber]
-      ;[premium] = utils.defaultAbiCoder.decode(
-        ['uint256'],
-        result[1].returnData,
-      ) as [BigNumber]
-      base = price.sub(premium)
-    } else {
-      ;[base, premium] = controller.interface.decodeFunctionData(
-        'rentPrice',
-        data,
-      ) as [BigNumber, BigNumber]
-    }
-    return {
-      base,
-      premium,
-    }
-  } catch {
-    return
-  }
-}
-
-export default { raw, decode }