@ensdomains/ensjs 3.0.0-alpha.6 → 3.0.0-alpha.60

package/src/functions/getSubnames.ts

@@ -1,43 +1,88 @@
 import { ENSArgs } from '..'
 import { truncateFormat } from '../utils/format'
+import { AllCurrentFuses, checkPCCBurned, decodeFuses } from '../utils/fuses'
 import { decryptName } from '../utils/labels'
 import { namehash } from '../utils/normalise'
+import { Domain } from '../utils/subgraph-types'
 
-type Subname = {
+type BaseSubname = {
   id: string
   labelName: string | null
   truncatedName?: string
   labelhash: string
   isMigrated: boolean
   name: string
-  owner: {
-    id: string
-  }
+  owner: string | undefined
+}
+
+type UnwrappedSubname = BaseSubname & {
+  fuses?: never
+  expiryDate?: never
+  pccExpired?: never
+  type: 'domain'
+}
+
+type WrappedSubname = BaseSubname & {
+  fuses: AllCurrentFuses
+  expiryDate: Date
+  pccExpired: boolean
+  type: 'wrappedDomain'
 }
 
+type Subname = WrappedSubname | UnwrappedSubname
+
 type Params = {
   name: string
   page?: number
   pageSize?: number
   orderDirection?: 'asc' | 'desc'
   orderBy?: 'createdAt' | 'labelName'
-  lastSubnames: Array<any>
-  isLargeQuery?: boolean
+  lastSubnames?: Array<any>
+  search?: string
 }
 
 const largeQuery = async (
   { gqlInstance }: ENSArgs<'gqlInstance'>,
-  { name, page, pageSize = 10, orderDirection, orderBy, lastSubnames }: Params,
+  {
+    name,
+    pageSize = 10,
+    orderDirection,
+    orderBy,
+    lastSubnames = [],
+    search = '',
+  }: Params,
 ) => {
-  const client = gqlInstance.client
+  const { client } = gqlInstance
 
-  let finalQuery = gqlInstance.gql`
+  const lastSubname = lastSubnames?.[lastSubnames.length - 1]
+  const lastCreatedAt = lastSubname?.createdAt
+  const lastLabelName = lastSubname?.labelName
+
+  let whereFilter = ''
+  if (orderBy === 'createdAt' && lastCreatedAt) {
+    whereFilter +=
+      orderDirection === 'asc'
+        ? 'createdAt_gt: $lastCreatedAt'
+        : 'createdAt_lt: $lastCreatedAt'
+  } else if (orderBy === 'labelName' && lastLabelName) {
+    whereFilter +=
+      orderDirection === 'asc'
+        ? 'labelName_gt: $lastLabelName'
+        : 'labelName_lt: $lastLabelName'
+  }
+  if (search) {
+    whereFilter += ' labelName_contains: $search'
+  }
+
+  const finalQuery = gqlInstance.gql`
     query getSubnames(
       $id: ID! 
       $first: Int
       $lastCreatedAt: BigInt
+      $lastLabelName: String
       $orderBy: Domain_orderBy 
       $orderDirection: OrderDirection
+      $search: String
     ) {
       domain(
         id: $id
@@ -47,7 +92,9 @@ const largeQuery = async (
           first: $first
           orderBy: $orderBy
           orderDirection: $orderDirection
-          where: { createdAt_lt: $lastCreatedAt }
+          where: { 
+            ${whereFilter}
+          }
         ) {
           id
           labelName
@@ -59,120 +106,67 @@ const largeQuery = async (
           owner {
             id
           }
+          wrappedDomain {
+            fuses
+            expiryDate
+            owner {
+              id
+            }
+          }
         }
       }
     }
   `
-  let queryVars = {
+
+  const queryVars = {
     id: namehash(name),
     first: pageSize,
-    lastCreatedAt: lastSubnames[lastSubnames.length - 1]?.createdAt,
+    lastCreatedAt,
+    lastLabelName,
     orderBy,
     orderDirection,
+    search: search?.toLowerCase(),
   }
-  const { domain } = await client.request(finalQuery, queryVars)
-  const subdomains = domain.subdomains.map((subname: any) => {
-    const decrypted = decryptName(subname.name)
-    return {
-      ...subname,
-      name: decrypted,
-      truncatedName: truncateFormat(decrypted),
-    }
-  })
+  const response = await client.request(finalQuery, queryVars)
+  const domain = response?.domain
+  const subdomains = domain.subdomains.map(
+    ({ wrappedDomain, ...subname }: Domain) => {
+      const decrypted = decryptName(subname.name!)
 
-  return {
-    subnames: subdomains,
-    subnameCount: domain.subdomainCount,
-  }
-}
+      const obj = {
+        ...subname,
+        labelName: subname.labelName || null,
+        labelhash: subname.labelhash || '',
+        name: decrypted,
+        truncatedName: truncateFormat(decrypted),
+        owner: subname.owner.id,
+        type: 'domain',
+      } as Subname
 
-const smallQuery = async (
-  { gqlInstance }: ENSArgs<'gqlInstance'>,
-  { name, page, pageSize = 10, orderDirection, orderBy }: Params,
-) => {
-  const client = gqlInstance.client
-  const subdomainsGql = `
-  id
-  labelName
-  labelhash
-  isMigrated
-  name
-  subdomainCount
-  createdAt
-  owner {
-    id
-  }
-`
-  let queryVars = {}
-  let finalQuery = ''
-  if (typeof page !== 'number') {
-    finalQuery = gqlInstance.gql`
-    query getSubnames(
-      $id: ID! 
-      $orderBy: Domain_orderBy 
-      $orderDirection: OrderDirection
-    ) {
-      domain(
-        id: $id
-      ) {
-        subdomains(
-          orderBy: $orderBy
-          orderDirection: $orderDirection
-        ) {
-          ${subdomainsGql}
-        }
+      if (wrappedDomain) {
+        obj.type = 'wrappedDomain'
+        const expiryDateAsDate =
+          wrappedDomain.expiryDate && wrappedDomain.expiryDate !== '0'
+            ? new Date(parseInt(wrappedDomain.expiryDate) * 1000)
+            : undefined
+        // if a user's local time is out of sync with the blockchain, this could potentially
+        // be incorrect. the likelihood of that happening though is very low, and devs
+        // shouldn't be relying on this value for anything critical anyway.
+        const hasExpired = expiryDateAsDate && expiryDateAsDate < new Date()
+        obj.expiryDate = expiryDateAsDate
+        obj.fuses = decodeFuses(hasExpired ? 0 : wrappedDomain.fuses)
+        obj.pccExpired = hasExpired
+          ? checkPCCBurned(wrappedDomain.fuses)
+          : false
+        obj.owner = obj.pccExpired ? undefined : wrappedDomain.owner.id
       }
-    }
-  `
-    queryVars = {
-      id: namehash(name),
-      orderBy,
-      orderDirection,
-    }
-  } else {
-    finalQuery = gqlInstance.gql`
-    query getSubnames(
-      $id: ID! 
-      $first: Int
-      $skip: Int
-      $orderBy: Domain_orderBy 
-      $orderDirection: OrderDirection
-    ) {
-      domain(
-        id: $id
-      ) {
-        subdomainCount
-        subdomains(
-          first: $first
-          skip: $skip
-          orderBy: $orderBy
-          orderDirection: $orderDirection
-        ) {
-          ${subdomainsGql}
-        }
-      }
-    }
-  `
-    queryVars = {
-      id: namehash(name),
-      first: pageSize,
-      skip: (page || 0) * pageSize,
-      orderBy,
-      orderDirection,
-    }
-  }
-  const { domain } = await client.request(finalQuery, queryVars)
-  const subdomains = domain.subdomains.map((subname: any) => {
-    const decrypted = decryptName(subname.name)
-    return {
-      ...subname,
-      name: decrypted,
-      truncatedName: truncateFormat(decrypted),
-    }
-  })
+
+      return obj
+    },
+  )
 
   return {
-    subnames: subdomains,
+    subnames: subdomains as Subname[],
     subnameCount: domain.subdomainCount,
   }
 }
@@ -181,10 +175,7 @@ const getSubnames = (
   injected: ENSArgs<'gqlInstance'>,
   functionArgs: Params,
 ): Promise<{ subnames: Subname[]; subnameCount: number }> => {
-  if (functionArgs.isLargeQuery) {
-    return largeQuery(injected, functionArgs)
-  }
-  return smallQuery(injected, functionArgs)
+  return largeQuery(injected, functionArgs)
 }
 
 export default getSubnames

package/src/functions/getWrapperData.test.ts

@@ -0,0 +1,90 @@
+import { ENS } from '../index'
+import setup from '../tests/setup'
+
+let ensInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
+let createSnapshot: Awaited<ReturnType<typeof setup>>['createSnapshot']
+let withWrappedSnapshot: any
+
+beforeAll(async () => {
+  ;({ ensInstance, revert, createSnapshot } = await setup())
+
+  withWrappedSnapshot = await createSnapshot()
+})
+
+afterEach(async () => {
+  await revert(withWrappedSnapshot)
+  withWrappedSnapshot = await createSnapshot()
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+describe('getWrapperData', () => {
+  it('should return default data for an unwrapped name', async () => {
+    const result = await ensInstance.getWrapperData('with-profile.eth')
+    expect(result?.expiryDate).toBeUndefined()
+    expect(result?.rawFuses).toEqual(0)
+    expect(result?.child.CAN_DO_EVERYTHING).toBeTruthy()
+  })
+  it('should return with CAN_DO_EVERYTHING set to true for a name with no fuses burned', async () => {
+    const result = await ensInstance.getWrapperData(
+      'test.wrapped-with-subnames.eth',
+    )
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result.child.CAN_DO_EVERYTHING).toBe(true)
+      expect(result.rawFuses).toBe(0)
+    }
+  })
+  it('should return with other correct fuses', async () => {
+    const tx = await ensInstance.setFuses('wrapped.eth', {
+      named: [
+        'CANNOT_UNWRAP',
+        'CANNOT_CREATE_SUBDOMAIN',
+        'CANNOT_SET_TTL',
+        'CANNOT_APPROVE',
+      ],
+      addressOrIndex: 1,
+    })
+    await tx.wait()
+
+    const result = await ensInstance.getWrapperData('wrapped.eth')
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result.child.CAN_DO_EVERYTHING).toBe(false)
+      expect(result.child.CANNOT_UNWRAP).toBe(true)
+      expect(result.child.CANNOT_CREATE_SUBDOMAIN).toBe(true)
+      expect(result.child.CANNOT_SET_TTL).toBe(true)
+      expect(result.child.CANNOT_APPROVE).toBe(true)
+      expect(result.parent.IS_DOT_ETH).toBe(true)
+    }
+  })
+  it('should return correct expiry', async () => {
+    const result = await ensInstance.getWrapperData('wrapped.eth')
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result.expiryDate).toBeInstanceOf(Date)
+      expect(Number.isNaN(result.expiryDate?.getTime())).toBe(false)
+    }
+  })
+  it('should return correct expiry for large expiry', async () => {
+    const result = await ensInstance.getWrapperData('wrapped-big-duration.eth')
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result.expiryDate).toBeInstanceOf(Date)
+      expect(result.expiryDate!.getFullYear()).toBe(275760)
+      expect(Number.isNaN(result.expiryDate?.getTime())).toBe(false)
+    }
+  })
+  it('should return correct max expiry for expiry larger than maximum for date', async () => {
+    const result = await ensInstance.getWrapperData('wrapped-max-duration.eth')
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result.expiryDate).toBeInstanceOf(Date)
+      expect(result.expiryDate!.getFullYear()).toBe(275760)
+      expect(Number.isNaN(result.expiryDate?.getTime())).toBe(false)
+    }
+  })
+})

package/src/functions/getWrapperData.ts

@@ -0,0 +1,51 @@
+import { BigNumber } from '@ethersproject/bignumber'
+import { ENSArgs } from '../index'
+import { MAX_DATE_INT } from '../utils/consts'
+import { decodeFuses } from '../utils/fuses'
+import { namehash } from '../utils/normalise'
+
+const raw = async ({ contracts }: ENSArgs<'contracts'>, name: string) => {
+  const nameWrapper = await contracts?.getNameWrapper()!
+  return {
+    to: nameWrapper.address,
+    data: nameWrapper.interface.encodeFunctionData('getData', [namehash(name)]),
+  }
+}
+
+const decode = async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
+  const nameWrapper = await contracts?.getNameWrapper()!
+  try {
+    const [owner, fuses, expiry] = nameWrapper.interface.decodeFunctionResult(
+      'getData',
+      data,
+    ) as [string, number, BigNumber]
+
+    const fuseObj = decodeFuses(fuses)
+
+    let expiryDate: Date | undefined
+
+    if (expiry.gt(0)) {
+      const msBigNumber = expiry.mul(1000)
+      if (msBigNumber.gte(MAX_DATE_INT)) {
+        expiryDate = new Date(MAX_DATE_INT)
+      } else {
+        expiryDate = new Date(msBigNumber.toNumber())
+      }
+    }
+
+    return {
+      ...fuseObj,
+      expiryDate,
+      rawFuses: fuses,
+      owner,
+    }
+  } catch (e) {
+    console.error('Error decoding wrapper data: ', e)
+    return
+  }
+}
+
+export default {
+  raw,
+  decode,
+}

package/src/functions/importDNSSECName.ts

@@ -0,0 +1,54 @@
+import { Oracle as NewOracle } from '@ensdomains/dnssecoraclejs'
+import packet from 'dns-packet'
+import type { ENSArgs } from '..'
+import { EMPTY_ADDRESS } from '../utils/consts'
+
+export const DNS_OVER_HTTP_ENDPOINT = 'https://1.1.1.1/dns-query'
+
+export type ImportDNSSECNameProps = {
+  address: string
+  proverResult: any
+}
+
+export default async function (
+  { contracts, provider }: ENSArgs<'contracts' | 'signer' | 'provider'>,
+  name: string,
+  { address, proverResult }: ImportDNSSECNameProps,
+) {
+  const dnsRegistrarContract = await contracts?.getDNSRegistrar()
+  const resolverContract = await contracts?.getPublicResolver()
+  const registrarOracle = await dnsRegistrarContract?.oracle()
+
+  if (!registrarOracle) {
+    throw new Error('No oracle found')
+  }
+
+  const oracle = new NewOracle(registrarOracle, provider!)
+  const proofData = await oracle.getProofData(proverResult)
+  const encodedName = `0x${packet.name.encode(name).toString('hex')}`
+  const data = proofData.rrsets.map((x) =>
+    Object.values(x),
+  ) as unknown as Array<{
+    rrset: string
+    sig: string
+  }>
+  const { proof } = proofData
+
+  if (address === EMPTY_ADDRESS) {
+    return dnsRegistrarContract?.populateTransaction.proveAndClaim(
+      encodedName,
+      data,
+      proof,
+    )
+  }
+
+  if (address) {
+    return dnsRegistrarContract?.populateTransaction.proveAndClaimWithResolver(
+      encodedName,
+      data,
+      proof,
+      resolverContract!.address,
+      address,
+    )
+  }
+}

package/src/functions/initialGetters.ts

@@ -6,6 +6,6 @@ export { default as getNames } from './getNames'
 export { default as getOwner } from './getOwner'
 export { default as getPrice } from './getPrice'
 export { default as getProfile } from './getProfile'
-export { default as getRecords } from './getRecords'
 export * from './getSpecificRecord'
 export { default as getSubnames } from './getSubnames'
+export { default as supportsTLD } from './supportsTLD'

package/src/functions/makeCommitment.test.ts

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

package/src/functions/registerName.test.ts

@@ -0,0 +1,59 @@
+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()
+  await provider.send('anvil_removeBlockTimestampInterval', [])
+})
+
+describe('registerName', () => {
+  beforeEach(async () => {
+    await revert()
+  })
+  it('should return a registration transaction and succeed', async () => {
+    const controller = await ensInstance.contracts!.getEthRegistrarController()!
+
+    const name = 'cool-swag.eth'
+    const duration = 31536000
+    const { customData, ...commitPopTx } =
+      await ensInstance.commitName.populateTransaction(name, {
+        duration,
+        owner: accounts[1],
+        addressOrIndex: accounts[1],
+      })
+    const commitTx = await provider.getSigner().sendTransaction(commitPopTx)
+    await commitTx.wait()
+
+    await provider.send('evm_increaseTime', [60])
+    await provider.send('evm_mine', [])
+
+    const { secret } = customData!
+
+    const [price] = await controller.rentPrice(name, duration)
+
+    const tx = await ensInstance.registerName(name, {
+      secret,
+      duration,
+      owner: accounts[1],
+      addressOrIndex: accounts[1],
+      value: price,
+    })
+    await tx.wait()
+
+    const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+    const owner = await nameWrapper.ownerOf(namehash(name))
+    expect(owner).toBe(accounts[1])
+  })
+})

package/src/functions/registerName.ts

@@ -0,0 +1,38 @@
+import { BigNumber } from '@ethersproject/bignumber'
+import { ENSArgs } from '..'
+import {
+  BaseRegistrationParams,
+  makeRegistrationData,
+} from '../utils/registerHelpers'
+import { wrappedLabelLengthCheck } from '../utils/wrapper'
+
+type Params = BaseRegistrationParams & {
+  value: BigNumber
+}
+
+export default async function (
+  { contracts }: ENSArgs<'contracts'>,
+  name: string,
+  { resolverAddress, value, ...params }: Params,
+) {
+  const labels = name.split('.')
+  if (labels.length !== 2 || labels[1] !== 'eth')
+    throw new Error('Currently only .eth TLD registrations are supported')
+
+  wrappedLabelLengthCheck(labels[0])
+
+  const controller = await contracts!.getEthRegistrarController()
+  const _resolver = await contracts!.getPublicResolver(
+    undefined,
+    resolverAddress,
+  )
+  const generatedParams = makeRegistrationData({
+    name,
+    resolver: _resolver,
+    ...params,
+  })
+
+  return controller.populateTransaction.register(...generatedParams, {
+    value,
+  })
+}

package/src/functions/renewNames.test.ts

@@ -0,0 +1,64 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import setup from '../tests/setup'
+import { labelhash } from '../utils/labels'
+
+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('renewNames', () => {
+  beforeEach(async () => {
+    await revert()
+  })
+  it('should return a renew transaction and succeed', async () => {
+    const name = 'to-be-renewed.eth'
+    const label = name.split('.')[0]
+    const duration = 31536000
+    const baseRegistrar = await ensInstance.contracts!.getBaseRegistrar()!
+    const oldExpiry = await baseRegistrar.nameExpires(labelhash(label))
+
+    const controller = await ensInstance.contracts!.getEthRegistrarController()!
+    const [price] = await controller.rentPrice(label, duration)
+
+    const tx = await ensInstance.renewNames(name, {
+      value: price.mul(2),
+      duration,
+      addressOrIndex: accounts[0],
+    })
+    await tx.wait()
+
+    const newExpiry = await baseRegistrar.nameExpires(labelhash(label))
+    expect(newExpiry.toNumber()).toBe(oldExpiry.add(31536000).toNumber())
+  })
+
+  it('should return a renew transaction and succeed', async () => {
+    const names = ['to-be-renewed.eth', 'test123.eth']
+    const label = names[0].split('.')[0]
+    const duration = 31536000
+    const baseRegistrar = await ensInstance.contracts!.getBaseRegistrar()!
+    const oldExpiry = await baseRegistrar.nameExpires(labelhash(label))
+    const bulkRenewal = await ensInstance.contracts!.getBulkRenewal()!
+    const price = await bulkRenewal.rentPrice(names, duration)
+
+    const tx = await ensInstance.renewNames(names, {
+      value: price.mul(4),
+      duration,
+      addressOrIndex: accounts[1],
+    })
+    await tx.wait()
+
+    const newExpiry = await baseRegistrar.nameExpires(labelhash(label))
+    expect(newExpiry.toNumber()).toBe(oldExpiry.add(31536000).toNumber())
+  })
+})