@ensdomains/ensjs 3.0.0-alpha.12 → 3.0.0-alpha.15

package/src/functions/getFuses.test.ts

@@ -1,4 +1,4 @@
-import { ethers } from 'ethers'
+import { BigNumber, ethers } from 'ethers'
 import { ENS } from '..'
 import setup from '../tests/setup'
 
@@ -9,6 +9,22 @@ let provider: ethers.providers.JsonRpcProvider
 let accounts: string[]
 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,
+    canDoEverything: true,
+  },
+  owner: '0x0000000000000000000000000000000000000000',
+  rawFuses: BigNumber.from(0),
+}
+
 beforeAll(async () => {
   ;({ ENSInstance, revert, provider, createSnapshot } = await setup())
   accounts = await provider.listAccounts()
@@ -26,9 +42,11 @@ afterAll(async () => {
 })
 
 describe('getFuses', () => {
-  it('should return null for an unwrapped name', async () => {
+  it('should return default data for an unwrapped name', async () => {
     const result = await ENSInstance.getFuses('with-profile.eth')
-    expect(result).toBeUndefined()
+    expect({ ...result, expiryDate: result?.expiryDate.toString() }).toEqual(
+      unwrappedNameDefault,
+    )
   })
   it('should return with canDoEverything set to true for a name with no fuses burned', async () => {
     const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
@@ -47,11 +65,11 @@ describe('getFuses', () => {
   })
   it('should return with other correct fuses', async () => {
     const tx = await ENSInstance.burnFuses('wrapped.eth', {
-      fusesToBurn: {
-        cannotUnwrap: true,
-        cannotSetTtl: true,
-        cannotCreateSubdomain: true,
-      },
+      namedFusesToBurn: [
+        'CANNOT_UNWRAP',
+        'CANNOT_CREATE_SUBDOMAIN',
+        'CANNOT_SET_TTL',
+      ],
       addressOrIndex: 1,
     })
     await tx.wait()
@@ -60,13 +78,13 @@ describe('getFuses', () => {
     expect(result).toBeTruthy()
     if (result) {
       expect(result.fuseObj).toMatchObject({
-        cannotUnwrap: true,
-        cannotBurnFuses: false,
-        cannotTransfer: false,
-        cannotSetResolver: false,
-        cannotSetTtl: true,
-        cannotCreateSubdomain: true,
-        parentCannotControl: true,
+        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,
         canDoEverything: false,
       })
       expect(result.rawFuses.toHexString()).toBe('0x71')

package/src/functions/getFuses.ts

@@ -1,48 +1,34 @@
 import { BigNumber } from 'ethers'
 import { ENSArgs } from '..'
-import { testable as fuseEnums } from '../utils/fuses'
+import { fuseEnum } from '../utils/fuses'
 import { namehash } from '../utils/normalise'
 
-const NameSafety = [
-  'Safe',
-  'RegistrantNotWrapped',
-  'ControllerNotWrapped',
-  'SubdomainReplacementAllowed',
-  'Expired',
-]
-
 const raw = async ({ contracts }: ENSArgs<'contracts'>, name: string) => {
   const nameWrapper = await contracts?.getNameWrapper()!
   return {
     to: nameWrapper.address,
-    data: nameWrapper.interface.encodeFunctionData('getFuses', [
-      namehash(name),
-    ]),
+    data: nameWrapper.interface.encodeFunctionData('getData', [namehash(name)]),
   }
 }
 
 const decode = async (
   { contracts }: ENSArgs<'contracts'>,
   data: string,
-  name: string,
 ) => {
   const nameWrapper = await contracts?.getNameWrapper()!
   try {
-    const [_fuses, expiry] = nameWrapper.interface.decodeFunctionResult(
-      'getFuses',
-      data,
-    )
+    const {
+      owner,
+      fuses: _fuses,
+      expiry,
+    } = nameWrapper.interface.decodeFunctionResult('getData', data)
 
     const fuses = BigNumber.from(_fuses)
 
     const fuseObj = Object.fromEntries(
-      Object.keys(fuseEnums).map((fuseEnum) => [
-        fuseEnum
-          .toLowerCase()
-          .replace(/([-_][a-z])/g, (group: string) =>
-            group.toUpperCase().replace('-', '').replace('_', ''),
-          ),
-        fuses.and(fuseEnums[fuseEnum as keyof typeof fuseEnums]).gt(0),
+      Object.keys(fuseEnum).map((fuse) => [
+        fuse,
+        fuses.and(fuseEnum[fuse as keyof typeof fuseEnum]).gt(0),
       ]),
     )
 
@@ -58,8 +44,10 @@ const decode = async (
       fuseObj,
       expiryDate,
       rawFuses: fuses,
+      owner,
     }
-  } catch {
+  } catch (e) {
+    console.error('Error decoding fuses data: ', e)
     return
   }
 }

package/src/functions/getProfile.ts

@@ -362,7 +362,7 @@ const graphFetch = async (
     ;({ domain } = await client.request(query, { id }))
     resolverResponse = domain?.resolver
   } else {
-    const resolverId = `${resolverAddress}-${id}`
+    const resolverId = `${resolverAddress.toLowerCase()}-${id}`
     ;({ resolver: resolverResponse, domain } = await client.request(
       customResolverQuery,
       { id, resolverId },

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 {
+  CommitmentParams,
+  makeRegistrationData,
+} from '../utils/registerHelpers'
+
+type Params = Omit<CommitmentParams, 'name' | 'resolver'> & {
+  resolverAddress?: string
+  secret: string
+  wrapperExpiry: number
+  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')
+
+  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/renewName.test.ts

@@ -0,0 +1,44 @@
+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('registerName', () => {
+  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.renewName(name, {
+      value: price.mul(2),
+      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/renewName.ts

@@ -0,0 +1,22 @@
+import type { BigNumber } from 'ethers'
+import { ENSArgs } from '..'
+
+export default async function (
+  { contracts }: ENSArgs<'contracts'>,
+  name: string,
+  {
+    duration,
+    value,
+  }: {
+    duration: number
+    value: BigNumber
+  },
+) {
+  const labels = name.split('.')
+  if (labels.length !== 2 || labels[1] !== 'eth')
+    throw new Error('Currently only .eth TLD renewals are supported')
+
+  const controller = await contracts!.getEthRegistrarController()
+
+  return controller.populateTransaction.renew(labels[0], duration, { value })
+}

package/src/index.ts

@@ -10,6 +10,7 @@ import type {
   universalWrapper,
 } from './functions/batchWrappers'
 import type burnFuses from './functions/burnFuses'
+import type commitName from './functions/commitName'
 import type createSubname from './functions/createSubname'
 import type deleteSubname from './functions/deleteSubname'
 import type getDNSOwner from './functions/getDNSOwner'
@@ -32,6 +33,8 @@ import type {
   _getText,
 } from './functions/getSpecificRecord'
 import type getSubnames from './functions/getSubnames'
+import registerName from './functions/registerName'
+import renewName from './functions/renewName'
 import type setName from './functions/setName'
 import type setRecord from './functions/setRecord'
 import type setRecords from './functions/setRecords'
@@ -43,6 +46,7 @@ import type wrapName from './functions/wrapName'
 import GqlManager from './GqlManager'
 import singleCall from './utils/singleCall'
 import writeTx from './utils/writeTx'
+import fuseEnum from './utils/fuses'
 
 type ENSOptions = {
   graphURI?: string | null
@@ -92,7 +96,11 @@ type OptionalWriteOptions<F> = F extends (
   : never
 
 interface WriteFunction<F extends (...args: any) => any> extends Function {
-  (...args: Parameters<OptionalWriteOptions<F>>): Promise<ContractTransaction>
+  (...args: Parameters<OptionalWriteOptions<F>>): Promise<
+    ContractTransaction & {
+      customData?: Record<string, any>
+    }
+  >
   populateTransaction: (
     ...args: Parameters<OptionalWriteOptions<F>>
   ) => Promise<PopulatedTransaction>
@@ -150,6 +158,7 @@ export class ENS {
   contracts?: ContractManager
   getContractAddress = _getContractAddress
   gqlInstance = new GqlManager()
+  fuses = fuseEnum
 
   constructor(options?: ENSOptions) {
     this.options = options
@@ -499,6 +508,11 @@ export class ENS {
     'getPrice',
   )
 
+  public getDNSOwner = this.generateFunction<typeof getDNSOwner>(
+    'getDNSOwner',
+    [],
+  )
+
   public universalWrapper = this.generateRawFunction<typeof universalWrapper>(
     'initialGetters',
     ['contracts'],
@@ -569,8 +583,17 @@ export class ENS {
     ['contracts', 'getExpiry'],
   )
 
-  public getDNSOwner = this.generateFunction<typeof getDNSOwner>(
-    'getDNSOwner',
-    [],
+  public commitName = this.generateWriteFunction<typeof commitName>(
+    'commitName',
+    ['contracts'],
+  )
+
+  public registerName = this.generateWriteFunction<typeof registerName>(
+    'registerName',
+    ['contracts'],
   )
+
+  public renewName = this.generateWriteFunction<typeof renewName>('renewName', [
+    'contracts',
+  ])
 }

package/src/utils/fuses.ts

@@ -7,7 +7,7 @@ const CANNOT_CREATE_SUBDOMAIN = 32
 const PARENT_CANNOT_CONTROL = 64
 const CAN_DO_EVERYTHING = 0
 
-export const testable = {
+export const fuseEnum = {
   CANNOT_UNWRAP,
   CANNOT_BURN_FUSES,
   CANNOT_TRANSFER,
@@ -15,9 +15,17 @@ export const testable = {
   CANNOT_SET_TTL,
   CANNOT_CREATE_SUBDOMAIN,
   PARENT_CANNOT_CONTROL,
-}
+} as const
+
+export const unnamedFuses = [
+  128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144,
+  524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, 67108864,
+  134217728, 268435456, 536870912, 1073741824, 2147483648, 4294967296,
+] as const
 
-export default {
-  ...testable,
+const fullFuseEnum = {
+  ...fuseEnum,
   CAN_DO_EVERYTHING,
 }
+
+export default fullFuseEnum

package/src/utils/registerHelpers.ts

@@ -6,12 +6,56 @@ import { labelhash } from './labels'
 import { namehash } from './normalise'
 import { generateRecordCallArray, RecordOptions } from './recordHelpers'
 
+export type RegistrationParams = {
+  name: string
+  owner: string
+  duration: number
+  secret: string
+  resolver: PublicResolver
+  records?: RecordOptions
+  reverseRecord?: boolean
+  fuses?: FuseOptions
+  wrapperExpiry: number
+}
+
+export type CommitmentParams = Omit<
+  RegistrationParams,
+  'secret' | 'wrapperExpiry'
+> & {
+  secret?: string
+  wrapperExpiry?: number
+}
+
+export type RegistrationTuple = [
+  name: string,
+  owner: string,
+  duration: number,
+  secret: string,
+  resolver: string,
+  data: string[],
+  reverseRecord: boolean,
+  fuses: string,
+  wrapperExpiry: number,
+]
+
+export type CommitmentTuple = [
+  labelhash: string,
+  owner: string,
+  duration: number,
+  resolver: string,
+  data: string[],
+  secret: string,
+  reverseRecord: boolean,
+  fuses: string,
+  wrapperExpiry: number,
+]
+
 export const randomSecret = () => {
   const bytes = Buffer.allocUnsafe(32)
   return '0x' + crypto.getRandomValues(bytes).toString('hex')
 }
 
-export const makeCommitment = ({
+export const makeCommitmentData = ({
   name,
   owner,
   duration,
@@ -19,69 +63,83 @@ export const makeCommitment = ({
   records,
   reverseRecord,
   fuses,
-}: {
-  name: string
-  owner: string
-  duration: number
-  resolver: PublicResolver
-  records?: RecordOptions
-  reverseRecord?: boolean
-  fuses?: FuseOptions
-}) => {
+  wrapperExpiry,
+  secret,
+}: CommitmentParams & {
+  secret: string
+}): CommitmentTuple => {
   const label = labelhash(name.split('.')[0])
   const hash = namehash(name)
   const resolverAddress = resolver.address
-  const data = records ? generateRecordCallArray(hash, records, resolver) : []
-  const secret = randomSecret()
   const fuseData = fuses ? generateFuseInput(fuses) : '0'
 
-  const commitment = _makeCommitment({
-    labelhash: label,
+  if (reverseRecord) {
+    if (!records) {
+      records = { coinTypes: [{ key: 'ETH', value: owner }] }
+    } else if (!records.coinTypes?.find((c) => c.key === 'ETH')) {
+      if (!records.coinTypes) records.coinTypes = []
+      records.coinTypes.push({ key: 'ETH', value: owner })
+    }
+  }
+
+  const data = records ? generateRecordCallArray(hash, records, resolver) : []
+
+  return [
+    label,
     owner,
     duration,
-    secret,
-    resolver: resolverAddress,
+    resolverAddress,
     data,
-    reverseRecord: !!reverseRecord,
-    fuses: fuseData,
+    secret,
+    !!reverseRecord,
+    fuseData,
+    wrapperExpiry || Math.floor(Date.now() / 1000) + duration,
+  ]
+}
+
+export const makeRegistrationData = (
+  params: RegistrationParams,
+): RegistrationTuple => {
+  const commitmentData = makeCommitmentData(params)
+  commitmentData[0] = params.name.split('.')[0]
+  const secret = commitmentData.splice(5, 1)[0]
+  commitmentData.splice(3, 0, secret)
+  return commitmentData as unknown as RegistrationTuple
+}
+
+export const makeCommitment = ({
+  secret = randomSecret(),
+  ...inputParams
+}: CommitmentParams) => {
+  const generatedParams = makeCommitmentData({
+    ...inputParams,
+    secret,
   })
 
+  const commitment = _makeCommitment(generatedParams)
+
   return {
     secret,
     commitment,
+    wrapperExpiry: generatedParams[8],
   }
 }
 
-export const _makeCommitment = ({
-  labelhash,
-  owner,
-  duration,
-  secret,
-  resolver,
-  data,
-  reverseRecord,
-  fuses,
-}: {
-  labelhash: string
-  owner: string
-  duration: number
-  secret: string
-  resolver: string
-  data: string[]
-  reverseRecord: boolean
-  fuses: string
-}) => {
-  return utils.solidityKeccak256(
-    [
-      'bytes32',
-      'address',
-      'uint256',
-      'bytes32',
-      'address',
-      'bytes[]',
-      'bool',
-      'uint96',
-    ],
-    [labelhash, owner, duration, secret, resolver, data, reverseRecord, fuses],
+export const _makeCommitment = (params: CommitmentTuple) => {
+  return utils.keccak256(
+    utils.defaultAbiCoder.encode(
+      [
+        'bytes32',
+        'address',
+        'uint256',
+        'address',
+        'bytes[]',
+        'bytes32',
+        'bool',
+        'uint32',
+        'uint64',
+      ],
+      params,
+    ),
   )
 }

package/src/utils/writeTx.ts

@@ -1,6 +1,16 @@
 import { JsonRpcSigner } from '@ethersproject/providers'
 import type { PopulatedTransaction } from 'ethers'
 
+type CustomData = Record<string, any>
+
+const withCustomData = <T extends object>(
+  tx: T,
+  customData: CustomData | undefined,
+): (T & { customData: CustomData }) | T =>
+  customData ? { ...tx, customData } : tx
+
 export default (signer: JsonRpcSigner, populate: boolean) =>
-  (tx: PopulatedTransaction) =>
-    populate ? tx : signer.sendTransaction(tx)
+  ({ customData, ...tx }: PopulatedTransaction) =>
+    populate
+      ? withCustomData(tx, customData)
+      : signer.sendTransaction(tx).then((r) => withCustomData(r, customData))

package/src/tests/populateTransaction.test.ts

@@ -1,40 +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()
-})
-
-afterAll(async () => {
-  await revert()
-})
-
-jest.setTimeout(20000)
-
-describe('populateTransaction', () => {
-  beforeEach(async () => {
-    await revert()
-  })
-  it('should return a transaction successfully', async () => {
-    const tx = await ENSInstance.setName('fleek.eth')
-    expect(tx).toBeTruthy()
-    if (tx) {
-      await tx.wait()
-      expect(tx.hash).toBeTruthy()
-    }
-  })
-  it('should return a populated transaction successfully', async () => {
-    const tx = await ENSInstance.setName.populateTransaction('fleek.eth')
-    expect(tx).toBeTruthy()
-    if (tx) {
-      expect(tx).not.toHaveProperty('hash')
-    }
-  })
-})