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

package/dist/esm/utils/registerHelpers.js

@@ -7,37 +7,63 @@ export const randomSecret = () => {
     const bytes = Buffer.allocUnsafe(32);
     return '0x' + crypto.getRandomValues(bytes).toString('hex');
 };
-export const makeCommitment = ({ name, owner, duration, resolver, records, reverseRecord, fuses, }) => {
+export const makeCommitmentData = ({ name, owner, duration, resolver, records, reverseRecord, fuses, wrapperExpiry, secret, }) => {
     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) => {
+    const commitmentData = makeCommitmentData(params);
+    commitmentData[0] = params.name.split('.')[0];
+    const secret = commitmentData.splice(5, 1)[0];
+    commitmentData.splice(3, 0, secret);
+    return commitmentData;
+};
+export const makeCommitment = ({ secret = randomSecret(), ...inputParams }) => {
+    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, }) => {
-    return utils.solidityKeccak256([
+export const _makeCommitment = (params) => {
+    return utils.keccak256(utils.defaultAbiCoder.encode([
         'bytes32',
         'address',
         'uint256',
-        'bytes32',
         'address',
         'bytes[]',
+        'bytes32',
         'bool',
-        'uint96',
-    ], [labelhash, owner, duration, secret, resolver, data, reverseRecord, fuses]);
+        'uint32',
+        'uint64',
+    ], params));
 };

package/dist/esm/utils/writeTx.d.ts

@@ -1,4 +1,21 @@
 import { JsonRpcSigner } from '@ethersproject/providers';
 import type { PopulatedTransaction } from 'ethers';
-declare const _default: (signer: JsonRpcSigner, populate: boolean) => (tx: PopulatedTransaction) => PopulatedTransaction | Promise<import("@ethersproject/abstract-provider").TransactionResponse>;
+declare type CustomData = Record<string, any>;
+declare const _default: (signer: JsonRpcSigner, populate: boolean) => ({ customData, ...tx }: PopulatedTransaction) => {
+    to?: string | undefined;
+    from?: string | undefined;
+    nonce?: number | undefined;
+    gasLimit?: import("ethers").BigNumber | undefined;
+    gasPrice?: import("ethers").BigNumber | undefined;
+    data?: string | undefined;
+    value?: import("ethers").BigNumber | undefined;
+    chainId?: number | undefined;
+    type?: number | undefined;
+    accessList?: import("ethers/lib/utils").AccessList | undefined;
+    maxFeePerGas?: import("ethers").BigNumber | undefined;
+    maxPriorityFeePerGas?: import("ethers").BigNumber | undefined;
+    ccipReadEnabled?: boolean | undefined;
+} | Promise<import("@ethersproject/providers").TransactionResponse | (import("@ethersproject/providers").TransactionResponse & {
+    customData: CustomData;
+})>;
 export default _default;

package/dist/esm/utils/writeTx.js

@@ -1 +1,4 @@
-export default (signer, populate) => (tx) => populate ? tx : signer.sendTransaction(tx);
+const withCustomData = (tx, customData) => customData ? { ...tx, customData } : tx;
+export default (signer, populate) => ({ customData, ...tx }) => populate
+    ? withCustomData(tx, customData)
+    : signer.sendTransaction(tx).then((r) => withCustomData(r, customData));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ensdomains/ensjs",
-  "version": "3.0.0-alpha.12",
+  "version": "3.0.0-alpha.13",
   "description": "ENS javascript library for contract interaction",
   "main": "./dist/cjs/index.js",
   "types": "./dist/cjs/index.d.ts",
@@ -22,26 +22,8 @@
   "repository": "git@github.com:ensdomains/ensjs-v3.git",
   "author": "TateB <yo@taytems.xyz>",
   "license": "MIT",
-  "scripts": {
-    "env": "yarn ens-test-env",
-    "generate-types": "ts-node scripts/runTypechain.ts",
-    "generate-abis": "hardhat export-abi",
-    "start": "ts-node --files src/index.test.ts",
-    "test": "jest --run-in-band",
-    "test:watch": "jest --watch --run-in-band",
-    "test:specific": "ts-node --files ",
-    "clean": "rm -rf ./dist ./README.md ./LICENSE",
-    "build:esm": "tsc --project tsconfig.esm.json",
-    "build:cjs": "tsc --project tsconfig.cjs.json",
-    "build": "yarn clean && yarn build:esm && yarn build:cjs",
-    "prepublish": "yarn build && cp ../../{README.md,LICENSE} ./",
-    "remove-stableVersion": "ex -c '%s/,\\n\\s\\+\"stableVersion\".*\"//g' -cwq ./package.json",
-    "version:create": "yarn remove-stableVersion && yarn version",
-    "enode": "ganache --wallet.mnemonic=\"test test test test test test test test test test test junk\" --chain.chainId 1337 --chain.networkId 1337 --chain.time 1659500634000"
-  },
-  "packageManager": "yarn@3.2.0",
   "dependencies": {
-    "@ensdomains/address-encoder": "^0.2.16",
+    "@ensdomains/address-encoder": "0.2.16",
     "@ensdomains/content-hash": "^2.5.7",
     "dns-packet": "^5.3.1",
     "ethers": "^5.6.1",
@@ -53,7 +35,7 @@
   "devDependencies": {
     "@ensdomains/buffer": "^0.0.13",
     "@ensdomains/ens-contracts": "^0.0.12",
-    "@ensdomains/ens-test-env": "0.1.5",
+    "@ensdomains/ens-test-env": "0.2.2",
     "@ethersproject/abi": "^5.6.0",
     "@ethersproject/providers": "^5.6.2",
     "@nomiclabs/hardhat-ethers": "npm:hardhat-deploy-ethers",
@@ -85,5 +67,20 @@
   "peerDependencies": {
     "ethers": "*"
   },
-  "stableVersion": "3.0.0-alpha.11"
+  "scripts": {
+    "tenv": "ens-test-env -a",
+    "generate-types": "ts-node scripts/runTypechain.ts",
+    "generate-abis": "hardhat export-abi",
+    "start": "ts-node --files src/index.test.ts",
+    "test": "jest --run-in-band",
+    "test:watch": "jest --watch --run-in-band",
+    "test:specific": "ts-node --files ",
+    "clean": "rm -rf ./dist ./README.md ./LICENSE",
+    "build:esm": "tsc --project tsconfig.esm.json",
+    "build:cjs": "tsc --project tsconfig.cjs.json",
+    "build": "pnpm clean && pnpm build:esm && pnpm build:cjs",
+    "prepublish": "pnpm build && cp ../../README.md ../../LICENSE ./",
+    "enode": "ganache --wallet.mnemonic=\"test test test test test test test test test test test junk\" --chain.chainId 1337 --chain.networkId 1337 --chain.time 1659500634000",
+    "ver": "pnpm version --no-workspaces-update"
+  }
 }

package/src/functions/commitName.test.ts

@@ -0,0 +1,61 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import setup from '../tests/setup'
+import { randomSecret } from '../utils/registerHelpers'
+
+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('commitName', () => {
+  beforeEach(async () => {
+    await revert()
+  })
+  it('should return a populated commit transaction with extra data and succeed', async () => {
+    const { customData, ...popTx } =
+      await ENSInstance.commitName.populateTransaction('commitment.eth', {
+        duration: 31536000,
+        owner: accounts[1],
+        addressOrIndex: accounts[1],
+      })
+    expect(popTx).toBeTruthy()
+    expect(customData).toHaveProperty('secret')
+    expect(customData).toHaveProperty('commitment')
+    expect(customData).toHaveProperty('wrapperExpiry')
+
+    const tx = await provider.getSigner().sendTransaction(popTx)
+    await tx.wait()
+
+    const controller = await ENSInstance.contracts!.getEthRegistrarController()!
+    const commitment = await controller.commitments(customData!.commitment)
+    expect(commitment).toBeTruthy()
+  })
+  it('should return a customised commmit transaction and succeed', async () => {
+    const secret = randomSecret()
+    const tx = await ENSInstance.commitName('commitment.eth', {
+      duration: 31536000,
+      owner: accounts[1],
+      addressOrIndex: accounts[1],
+      secret,
+      wrapperExpiry: 100000,
+    })
+    await tx.wait()
+    expect(tx.customData).toBeTruthy()
+    expect(tx.customData!.wrapperExpiry).toBe(100000)
+    expect(tx.customData!.secret).toBe(secret)
+
+    const controller = await ENSInstance.contracts!.getEthRegistrarController()!
+    const commitment = await controller.commitments(tx.customData!.commitment)
+    expect(commitment).toBeTruthy()
+  })
+})

package/src/functions/commitName.ts

@@ -0,0 +1,36 @@
+import { ENSArgs } from '..'
+import { CommitmentParams, makeCommitment } from '../utils/registerHelpers'
+
+type Params = Omit<CommitmentParams, 'resolver' | 'name'> & {
+  resolverAddress?: string
+}
+
+export default async function (
+  { contracts }: ENSArgs<'contracts'>,
+  name: string,
+  { resolverAddress, ...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 { secret, commitment, wrapperExpiry } = makeCommitment({
+    name,
+    resolver,
+    ...params,
+  })
+
+  return {
+    ...(await controller.populateTransaction.commit(commitment)),
+    customData: {
+      secret,
+      commitment,
+      wrapperExpiry,
+    },
+  }
+}

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'
@@ -92,7 +95,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>
@@ -499,6 +506,11 @@ export class ENS {
     'getPrice',
   )
 
+  public getDNSOwner = this.generateFunction<typeof getDNSOwner>(
+    'getDNSOwner',
+    [],
+  )
+
   public universalWrapper = this.generateRawFunction<typeof universalWrapper>(
     'initialGetters',
     ['contracts'],
@@ -569,8 +581,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',
+  ])
 }