@ensdomains/ensjs 3.0.0-alpha.3 → 3.0.0-alpha.30

package/src/functions/getSubnames.ts

@@ -21,23 +21,52 @@ type Params = {
   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
+
+  const lastSubname = lastSubnames?.[lastSubnames.length - 1]
+  const lastCreatedAt = lastSubname?.createdAt
+  const lastLabelName = lastSubname?.labelName
 
-  let finalQuery = gqlInstance.gql`
+  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 +76,9 @@ const largeQuery = async (
           first: $first
           orderBy: $orderBy
           orderDirection: $orderDirection
-          where: { createdAt_lt: $lastCreatedAt }
+          where: { 
+            ${whereFilter}
+          }
         ) {
           id
           labelName
@@ -63,107 +94,20 @@ const largeQuery = async (
       }
     }
   `
-  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),
-    }
-  })
 
-  return {
-    subnames: subdomains,
-    subnameCount: domain.subdomainCount,
-  }
-}
-
-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}
-        }
-      }
-    }
-  `
-    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,
@@ -181,10 +125,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,98 @@
+import { BigNumber } from 'ethers'
+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
+
+const unwrappedNameDefault = {
+  expiryDate: new Date(0).toString(),
+  fuseObj: {
+    CANNOT_BURN_FUSES: false,
+    CANNOT_CREATE_SUBDOMAIN: false,
+    CANNOT_SET_RESOLVER: false,
+    CANNOT_SET_TTL: false,
+    CANNOT_TRANSFER: false,
+    CANNOT_UNWRAP: false,
+    PARENT_CANNOT_CONTROL: false,
+    CAN_DO_EVERYTHING: true,
+  },
+  owner: '0x0000000000000000000000000000000000000000',
+  rawFuses: BigNumber.from(0),
+}
+
+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: result?.expiryDate.toString() }).toEqual(
+      unwrappedNameDefault,
+    )
+  })
+  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.fuseObj.CAN_DO_EVERYTHING).toBe(true)
+      expect(
+        Object.values(result.fuseObj).reduce(
+          (prev, curr) => (curr ? prev + 1 : prev),
+          0,
+        ),
+      ).toBe(1)
+      expect(result.rawFuses.toHexString()).toBe('0x00')
+    }
+  })
+  it('should return with other correct fuses', async () => {
+    const tx = await ensInstance.burnFuses('wrapped.eth', {
+      namedFusesToBurn: [
+        'CANNOT_UNWRAP',
+        'CANNOT_CREATE_SUBDOMAIN',
+        'CANNOT_SET_TTL',
+      ],
+      addressOrIndex: 1,
+    })
+    await tx.wait()
+
+    const result = await ensInstance.getWrapperData('wrapped.eth')
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result.fuseObj).toMatchObject({
+        CANNOT_UNWRAP: true,
+        CANNOT_BURN_FUSES: false,
+        CANNOT_TRANSFER: false,
+        CANNOT_SET_RESOLVER: false,
+        CANNOT_SET_TTL: true,
+        CANNOT_CREATE_SUBDOMAIN: true,
+        PARENT_CANNOT_CONTROL: true,
+        CAN_DO_EVERYTHING: false,
+      })
+      expect(result.rawFuses.toHexString()).toBe('0x71')
+    }
+  })
+  it('should return correct expiry', async () => {
+    const result = await ensInstance.getWrapperData('wrapped.eth')
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result.expiryDate).toBeInstanceOf(Date)
+    }
+  })
+})

package/src/functions/getWrapperData.ts

@@ -0,0 +1,42 @@
+import { BigNumber } from 'ethers'
+import { ENSArgs } from '../index'
+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,
+    )
+
+    const fuses = BigNumber.from(_fuses)
+    const fuseObj = decodeFuses(fuses)
+
+    const expiryDate = new Date(expiry * 1000)
+
+    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/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 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, wrapperExpiry } = customData!
+
+    const controller = await ensInstance.contracts!.getEthRegistrarController()!
+    const [price] = await controller.rentPrice(name, duration)
+
+    const tx = await ensInstance.registerName(name, {
+      secret,
+      wrapperExpiry,
+      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 'ethers'
+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())
+  })
+})

package/src/functions/renewNames.ts

@@ -0,0 +1,60 @@
+import { BigNumber, BigNumberish } from 'ethers'
+import { ENSArgs } from '..'
+import { FuseProps, validateFuses } from '../utils/fuses'
+import { MAX_INT_64 } from '../utils/registerHelpers'
+
+type BaseProps = {
+  duration: number
+  value: BigNumber
+}
+
+export async function renewNameWithData(
+  { contracts }: ENSArgs<'contracts'>,
+  name: string,
+  {
+    duration,
+    value,
+    fuses,
+    wrapperExpiry = MAX_INT_64,
+  }: BaseProps & {
+    fuses?: FuseProps
+    wrapperExpiry?: BigNumberish
+  },
+) {
+  const labels = name.split('.')
+  if (labels.length !== 2 || labels[1] !== 'eth') {
+    throw new Error('Currently only .eth TLD renewals are supported')
+  }
+
+  const encodedFuses = fuses ? validateFuses(fuses) : 0
+  const controller = await contracts!.getEthRegistrarController()
+  return controller.populateTransaction.renewWithFuses(
+    labels[0],
+    duration,
+    encodedFuses,
+    wrapperExpiry,
+    { value },
+  )
+}
+
+export default async function (
+  { contracts }: ENSArgs<'contracts'>,
+  nameOrNames: string | string[],
+  { duration, value }: BaseProps,
+) {
+  const names = Array.isArray(nameOrNames) ? nameOrNames : [nameOrNames]
+  const labels = names.map((name) => {
+    const label = name.split('.')
+    if (label.length !== 2 || label[1] !== 'eth') {
+      throw new Error('Currently only .eth TLD renewals are supported')
+    }
+    return label[0]
+  })
+
+  if (labels.length === 1) {
+    const controller = await contracts!.getEthRegistrarController()
+    return controller.populateTransaction.renew(labels[0], duration, { value })
+  }
+  const bulkRenewal = await contracts!.getBulkRenewal()
+  return bulkRenewal.populateTransaction.renewAll(labels, duration, { value })
+}