@ensdomains/ensjs 4.0.1 → 4.0.2-alpha.5

package/src/functions/subgraph/getSubnames.ts

@@ -2,10 +2,14 @@
 import { gql } from 'graphql-request'
 import type { ClientWithEns } from '../../contracts/consts.js'
 import { InvalidOrderByError } from '../../errors/subgraph.js'
-import { EMPTY_ADDRESS, GRACE_PERIOD_SECONDS } from '../../utils/consts.js'
+import { EMPTY_ADDRESS } from '../../utils/consts.js'
 import { namehash } from '../../utils/normalise.js'
 import { createSubgraphClient } from './client.js'
-import type { DomainFilter } from './filters.js'
+import {
+  getExpiryDateOrderFilter,
+  type DomainFilter,
+  getCreatedAtOrderFilter,
+} from './filters.js'
 import {
   domainDetailsWithoutParentFragment,
   registrationDetailsFragment,
@@ -44,46 +48,21 @@ type SubgraphResult = {
 }
 
 const getOrderByFilter = ({
-  name,
   orderBy,
   orderDirection,
   previousPage,
 }: Required<
-  Pick<
-    GetSubnamesParameters,
-    'name' | 'orderBy' | 'orderDirection' | 'previousPage'
-  >
+  Pick<GetSubnamesParameters, 'orderBy' | 'orderDirection' | 'previousPage'>
 >): DomainFilter => {
   const lastDomain = previousPage[previousPage.length - 1]
   const operator = orderDirection === 'asc' ? 'gt' : 'lt'
 
   switch (orderBy) {
     case 'expiryDate': {
-      let lastExpiryDate = lastDomain.expiryDate?.value
-        ? lastDomain.expiryDate.value / 1000
-        : 0
-      if (name === 'eth' && lastExpiryDate) {
-        lastExpiryDate += GRACE_PERIOD_SECONDS
-      }
-
-      if (orderDirection === 'asc' && lastExpiryDate === 0) {
-        return {
-          and: [{ expiryDate: null }, { [`id_${operator}`]: lastDomain.id }],
-        }
-      }
-      if (orderDirection === 'desc' && lastExpiryDate !== 0) {
-        return {
-          [`expiryDate_${operator}`]: `${lastExpiryDate}`,
-        }
-      }
-      return {
-        or: [
-          {
-            [`expiryDate_${operator}`]: `${lastExpiryDate}`,
-          },
-          { expiryDate: null },
-        ],
-      }
+      return getExpiryDateOrderFilter({
+        lastDomain,
+        orderDirection,
+      })
     }
     case 'name': {
       return {
@@ -96,9 +75,7 @@ const getOrderByFilter = ({
       }
     }
     case 'createdAt': {
-      return {
-        [`createdAt_${operator}`]: `${lastDomain.createdAt.value / 1000}`,
-      }
+      return getCreatedAtOrderFilter({ lastDomain, orderDirection })
     }
     default:
       throw new InvalidOrderByError({
@@ -146,7 +123,6 @@ const getSubnames = async (
   if (previousPage?.length) {
     whereFilters.push(
       getOrderByFilter({
-        name,
         orderBy,
         orderDirection,
         previousPage,

package/utils/legacyNameGenerator.cjs

@@ -0,0 +1,73 @@
+/* eslint-disable import/no-extraneous-dependencies */
+const { namehash, labelhash } = require('viem')
+
+const makeNameGenerator = async (hre, optionalNonceManager) => {
+  const { getNamedAccounts } = hre
+  const allNamedAccts = await getNamedAccounts()
+  const controller = await ethers.getContract('LegacyETHRegistrarController')
+  const publicResolver = await ethers.getContract('LegacyPublicResolver')
+  const registry = await ethers.getContract('ENSRegistry')
+  const nonceManager = optionalNonceManager ?? { getNonce: () => undefined}
+
+  return {
+    commit: async ({ label, namedOwner, namedAddr }) => {
+      const secret =
+        '0x0000000000000000000000000000000000000000000000000000000000000000'
+      const registrant = allNamedAccts[namedOwner]
+      const resolver = publicResolver.address
+      const addr = allNamedAccts[namedAddr]
+
+      const commitment = await controller.makeCommitmentWithConfig(
+        label,
+        registrant,
+        secret,
+        resolver,
+        addr,
+      )
+
+      const _controller = controller.connect(await ethers.getSigner(registrant))
+      return _controller.commit(commitment, {nonce: nonceManager.getNonce(namedOwner)})
+    },
+    register: async ({ label, namedOwner, namedAddr, duration = 31536000 }) => {
+      const secret =
+        '0x0000000000000000000000000000000000000000000000000000000000000000'
+      const registrant = allNamedAccts[namedOwner]
+      const resolver = publicResolver.address
+      const addr = allNamedAccts[namedAddr]
+      const price = await controller.rentPrice(label, duration)
+      const _controller = controller.connect(await ethers.getSigner(registrant))
+      return _controller.registerWithConfig(
+        label,
+        registrant,
+        duration,
+        secret,
+        resolver,
+        addr,
+        {
+          value: price,
+          nonce: nonceManager.getNonce(namedOwner),
+        },
+      )
+    },
+    subname: async ({ label, namedOwner, subnameLabel, namedSubnameOwner }) => {
+      console.log(`Setting subnames for ${label}.eth...`)
+      const resolver = publicResolver.address
+      const registrant = allNamedAccts[namedOwner]
+      const owner = allNamedAccts[namedSubnameOwner]
+      const _registry = registry.connect(await ethers.getSigner(registrant))
+      return _registry.setSubnodeRecord(
+        namehash(`${label}.eth`),
+        labelhash(subnameLabel),
+        owner,
+        resolver,
+        '0',
+      )
+    },
+    setSubnameRecords: async () => {},
+    configure: async () => {},
+  }
+}
+
+module.exports = {
+  makeNameGenerator,
+}

package/utils/nonceManager.cjs

@@ -0,0 +1,26 @@
+ /* eslint-disable import/no-extraneous-dependencies */
+ const { hexToNumber, numberToHex} = require('viem')
+ 
+ const makeNonceManager = async (href) => {
+  const { getNamedAccounts, network } = href
+  const names = ['owner', 'owner2', 'owner3', 'owner4']
+  const allNamedAccts = await getNamedAccounts()
+  const startingNonces = await Promise.all(names.map((name) => network.provider.send('eth_getTransactionCount', [allNamedAccts[name], "latest"]).then(hexToNumber)))
+  const nonceMap = Object.fromEntries(names.map((name, i) => [name, startingNonces[i]]))
+
+  console.log('Nonce manager initialized', nonceMap)
+  
+  return {
+    getNonce: (name) => {
+      const nonce = nonceMap[name]
+      nonceMap[name]++
+      return nonce
+    }
+  }
+
+
+}
+
+module.exports = {
+  makeNonceManager
+}

package/utils/wrappedNameGenerator.cjs

@@ -0,0 +1,101 @@
+/* eslint-disable import/no-extraneous-dependencies */
+
+const { BigNumber } = require('ethers')
+const { namehash } = require('viem/ens')
+
+const makeNameGenerator = async (hre, optionalNonceManager) => {
+  const { getNamedAccounts } = hre
+  const allNamedAccts = await getNamedAccounts()
+  const controller = await ethers.getContract('ETHRegistrarController')
+  const publicResolver = await ethers.getContract('PublicResolver')
+  const nameWrapper = await ethers.getContract('NameWrapper')
+  const nonceManager = optionalNonceManager ?? { getNonce: () => undefined }
+
+  return {
+    commit: async ({
+      label,
+      namedOwner,
+      data = [],
+      reverseRecord = false,
+      fuses = 0,
+      duration = 31536000,
+    }) => {
+      const secret =
+        '0x0000000000000000000000000000000000000000000000000000000000000000'
+      const owner = allNamedAccts[namedOwner]
+      const resolver = publicResolver.address
+      const commitment = await controller.makeCommitment(
+        label,
+        owner,
+        duration,
+        secret,
+        resolver,
+        data,
+        reverseRecord,
+        fuses,
+      )
+
+      const _controller = controller.connect(await ethers.getSigner(owner))
+      return _controller.commit(commitment, {
+        nonce: nonceManager.getNonce(namedOwner),
+      })
+    },
+    register: async ({
+      label,
+      namedOwner,
+      data = [],
+      reverseRecord = false,
+      fuses = 0,
+      duration = 31536000,
+    }) => {
+      const secret =
+        '0x0000000000000000000000000000000000000000000000000000000000000000'
+      const owner = allNamedAccts[namedOwner]
+      const resolver = publicResolver.address
+      const [price] = await controller.rentPrice(label, duration)
+      
+      const priceWithBuffer = BigNumber.from(price).mul(105).div(100)
+      const _controller = controller.connect(await ethers.getSigner(owner))
+      return _controller.register(
+        label,
+        owner,
+        duration,
+        secret,
+        resolver,
+        data,
+        reverseRecord,
+        fuses,
+        {
+          value: priceWithBuffer,
+          nonce: nonceManager.getNonce(namedOwner),
+        },
+      )
+    },
+    subname: async ({
+      label,
+      namedOwner,
+      subnameLabel,
+      namedSubnameOwner,
+      subnameFuses = 0,
+      subnameExpiry = BigNumber.from(2).pow(64).sub(1),
+    }) => {
+      const resolver = publicResolver.address
+      const owner = allNamedAccts[namedOwner]
+      const subnameOwner = allNamedAccts[namedSubnameOwner]
+      const _nameWrapper = nameWrapper.connect(await ethers.getSigner(owner))
+      return _nameWrapper.setSubnodeRecord(
+        namehash(`${label}.eth`),
+        subnameLabel,
+        subnameOwner,
+        resolver,
+        '0',
+        subnameFuses,
+        subnameExpiry,
+      )
+    },
+  }
+}
+
+module.exports = {
+  makeNameGenerator,
+}