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

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')
-    }
-  })
-})

package/src/tests/setup.ts

@@ -1,57 +0,0 @@
-import { config } from 'dotenv'
-import { ethers } from 'ethers'
-import { resolve } from 'path'
-import { ENS } from '../'
-import { ContractName, SupportedNetworkId } from '../contracts/types'
-
-config({
-  path: resolve(__dirname, '../../.env.local'),
-  override: true,
-})
-
-const deploymentAddresses = JSON.parse(
-  process.env.DEPLOYMENT_ADDRESSES!,
-) as Record<ContractName | 'ENSRegistry', string>
-
-const createENS = (graphURI: string) =>
-  new ENS({
-    graphURI,
-    getContractAddress: (_: SupportedNetworkId) => (contractName) =>
-      deploymentAddresses[
-        contractName === 'ENSRegistryWithFallback'
-          ? 'ENSRegistry'
-          : contractName
-      ],
-  })
-
-export default async (useReal?: boolean) => {
-  const graphURI = useReal
-    ? 'https://api.thegraph.com/subgraphs/name/ensdomains/ensropsten'
-    : 'http://localhost:8000/subgraphs/name/graphprotocol/ens'
-
-  const provider = new ethers.providers.JsonRpcProvider(
-    'http://localhost:8545',
-    1337,
-  )
-
-  let ENSInstance = createENS(graphURI)
-  await ENSInstance.setProvider(provider)
-
-  let snapshot = await provider.send('evm_snapshot', [])
-
-  const revert = async (customSnapshot?: any) => {
-    const snapshotToUse = customSnapshot || snapshot
-    await provider.send('evm_revert', [snapshotToUse])
-    if (parseInt(snapshot, 16) >= parseInt(snapshotToUse, 16)) {
-      snapshot = await provider.send('evm_snapshot', [])
-    }
-
-    ENSInstance = createENS(graphURI)
-    await ENSInstance.setProvider(provider)
-    return
-  }
-
-  const createSnapshot = async () => await provider.send('evm_snapshot', [])
-
-  return { ENSInstance, revert, createSnapshot, provider }
-}

package/src/tests/signerInjection.test.ts

@@ -1,46 +0,0 @@
-import { ContractTransaction, 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('Signer Injection', () => {
-  beforeEach(async () => {
-    await revert()
-  })
-  it('should return a transaction successfully for a custom signer', async () => {
-    const signer = provider.getSigner(accounts[3])
-    const tx = await ENSInstance.setName('fleek.eth', {
-      signer,
-    })
-    expect(tx).toBeTruthy()
-    if (tx) {
-      await tx.wait()
-      expect(tx.from).toBe(accounts[3])
-    }
-  })
-  it('should return a transaction succesfully for a custom signer index', async () => {
-    const tx = (await ENSInstance.setName('fleek.eth', {
-      addressOrIndex: 3,
-    })) as ContractTransaction
-    expect(tx).toBeTruthy()
-    if (tx) {
-      await tx.wait()
-      expect(tx.from).toBe(accounts[3])
-    }
-  })
-})

package/src/tests/withProvider.test.ts

@@ -1,28 +0,0 @@
-import { ethers } from 'ethers'
-import { ENS } from '..'
-import setup from '../tests/setup'
-
-let ENSInstance: ENS
-let providerFake: ethers.providers.JsonRpcProvider
-
-beforeAll(async () => {
-  ;({ ENSInstance } = await setup())
-  providerFake = new ethers.providers.JsonRpcProvider(
-    'http://localhost:34023',
-    'ropsten',
-  )
-})
-
-describe('withProvider', () => {
-  it('should be able to use a new provider', async () => {
-    const addr = await ENSInstance.getAddr('with-profile.eth')
-    expect(addr).toBeTruthy()
-
-    try {
-      await ENSInstance.withProvider(providerFake).getOwner('with-profile.eth')
-      expect(false).toBeTruthy()
-    } catch {
-      expect(true).toBeTruthy()
-    }
-  })
-})