@ensdomains/ensjs 3.0.0-alpha.8 → 3.0.0-beta.1

package/src/functions/public/getAddressRecord.ts

@@ -0,0 +1,66 @@
+import type { Hex } from 'viem'
+import type { ClientWithEns } from '../../contracts/consts.js'
+import type {
+  GenericPassthrough,
+  Prettify,
+  SimpleTransactionRequest,
+} from '../../types.js'
+import {
+  generateFunction,
+  type GeneratedFunction,
+} from '../../utils/generateFunction.js'
+import _getAddr, {
+  type InternalGetAddrParameters,
+  type InternalGetAddrReturnType,
+} from './_getAddr.js'
+import universalWrapper from './universalWrapper.js'
+
+export type GetAddressRecordParameters = Prettify<InternalGetAddrParameters>
+
+export type GetAddressRecordReturnType = Prettify<InternalGetAddrReturnType>
+
+const encode = (
+  client: ClientWithEns,
+  { name, coin }: GetAddressRecordParameters,
+): SimpleTransactionRequest => {
+  const prData = _getAddr.encode(client, { name, coin })
+  return universalWrapper.encode(client, { name, data: prData.data })
+}
+
+const decode = async (
+  client: ClientWithEns,
+  data: Hex,
+  passthrough: GenericPassthrough,
+  args: GetAddressRecordParameters,
+): Promise<GetAddressRecordReturnType> => {
+  const urData = await universalWrapper.decode(client, data, passthrough)
+  return _getAddr.decode(client, urData.data, args)
+}
+
+type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
+
+/**
+ * Gets an address record for a name and specified coin
+ * @param client - {@link ClientWithEns}
+ * @param parameters - {@link GetAddressRecordParameters}
+ * @returns Coin value object, or `null` if not found. {@link GetAddressRecordReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { addEnsContracts, getAddressRecord } from '@ensdomains/ensjs'
+ *
+ * const client = createPublicClient({
+ *   chain: addEnsContracts(mainnet),
+ *   transport: http(),
+ * })
+ * const result = await getAddressRecord(client, { name: 'ens.eth', coin: 'ETH' })
+ * // { id: 60, name: 'ETH , value: '0xFe89cc7aBB2C4183683ab71653C4cdc9B02D44b7' }
+ */
+const getAddressRecord = generateFunction({ encode, decode }) as ((
+  client: ClientWithEns,
+  { name, coin, bypassFormat }: GetAddressRecordParameters,
+) => Promise<GetAddressRecordReturnType>) &
+  BatchableFunctionObject
+
+export default getAddressRecord

package/src/functions/public/getAvailable.test.ts

@@ -0,0 +1,17 @@
+import { publicClient } from '../../tests/addTestContracts.js'
+import getAvailable from './getAvailable.js'
+
+describe('getAvailable', () => {
+  it('should return false for a name that is unavailable', async () => {
+    const result = await getAvailable(publicClient, { name: 'test123.eth' })
+    expect(typeof result).toBe('boolean')
+    expect(result).toBe(false)
+  })
+  it('should return true for a name that is available', async () => {
+    const result = await getAvailable(publicClient, {
+      name: 'available-name.eth',
+    })
+    expect(typeof result).toBe('boolean')
+    expect(result).toBe(true)
+  })
+})

package/src/functions/public/getAvailable.ts

@@ -0,0 +1,91 @@
+import {
+  BaseError,
+  decodeFunctionResult,
+  encodeFunctionData,
+  labelhash,
+  type Hex,
+} from 'viem'
+import { baseRegistrarAvailableSnippet } from '../../contracts/baseRegistrar.js'
+import type { ClientWithEns } from '../../contracts/consts.js'
+import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
+import { UnsupportedNameTypeError } from '../../errors/general.js'
+import type { SimpleTransactionRequest } from '../../types.js'
+import {
+  generateFunction,
+  type GeneratedFunction,
+} from '../../utils/generateFunction.js'
+import { getNameType } from '../../utils/getNameType.js'
+
+export type GetAvailableParameters = {
+  /** Name to check availability for, only compatible for eth 2ld */
+  name: string
+}
+
+export type GetAvailableReturnType = boolean
+
+const encode = (
+  client: ClientWithEns,
+  { name }: GetAvailableParameters,
+): SimpleTransactionRequest => {
+  const labels = name.split('.')
+  const nameType = getNameType(name)
+  if (nameType !== 'eth-2ld')
+    throw new UnsupportedNameTypeError({
+      nameType,
+      supportedNameTypes: ['eth-2ld'],
+      details: 'Currently only eth-2ld names can be checked for availability',
+    })
+
+  return {
+    to: getChainContractAddress({
+      client,
+      contract: 'ensBaseRegistrarImplementation',
+    }),
+    data: encodeFunctionData({
+      abi: baseRegistrarAvailableSnippet,
+      functionName: 'available',
+      args: [BigInt(labelhash(labels[0]))],
+    }),
+  }
+}
+
+const decode = async (
+  _client: ClientWithEns,
+  data: Hex | BaseError,
+): Promise<GetAvailableReturnType> => {
+  if (typeof data === 'object') throw data
+  const result = decodeFunctionResult({
+    abi: baseRegistrarAvailableSnippet,
+    functionName: 'available',
+    data,
+  })
+  return result
+}
+
+type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
+
+/**
+ * Gets the availability of a name to register
+ * @param client - {@link ClientWithEns}
+ * @param parameters - {@link GetAvailableParameters}
+ * @returns Availability as boolean. {@link GetAvailableReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { addEnsContracts, getAvailable } from '@ensdomains/ensjs'
+ *
+ * const client = createPublicClient({
+ *   chain: addEnsContracts(mainnet),
+ *   transport: http(),
+ * })
+ * const result = await getAvailable(client, { name: 'ens.eth' })
+ * // false
+ */
+const getAvailable = generateFunction({ encode, decode }) as ((
+  client: ClientWithEns,
+  { name }: GetAvailableParameters,
+) => Promise<GetAvailableReturnType>) &
+  BatchableFunctionObject
+
+export default getAvailable

package/src/functions/public/getContentHashRecord.test.ts

@@ -0,0 +1,28 @@
+import { publicClient } from '../../tests/addTestContracts.js'
+import getContentHashRecord from './getContentHashRecord.js'
+
+describe('getContentHashRecord', () => {
+  it('should return null for a non-existent name', async () => {
+    const result = await getContentHashRecord(publicClient, {
+      name: 'test123123cool.eth',
+    })
+    expect(result).toBeNull()
+  })
+  it('should return null for a name with no contenthash record', async () => {
+    const result = await getContentHashRecord(publicClient, {
+      name: 'with-profile.eth',
+    })
+    expect(result).toBeNull()
+  })
+  it('should return the contenthash for a name with the record set', async () => {
+    const result = await getContentHashRecord(publicClient, {
+      name: 'with-contenthash.eth',
+    })
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "decoded": "bafybeico3uuyj3vphxpvbowchdwjlrlrh62awxscrnii7w7flu5z6fk77y",
+        "protocolType": "ipfs",
+      }
+    `)
+  })
+})

package/src/functions/public/getContentHashRecord.ts

@@ -0,0 +1,67 @@
+import type { BaseError, Hex } from 'viem'
+import type { ClientWithEns } from '../../contracts/consts.js'
+import type {
+  GenericPassthrough,
+  Prettify,
+  TransactionRequestWithPassthrough,
+} from '../../types.js'
+import {
+  generateFunction,
+  type GeneratedFunction,
+} from '../../utils/generateFunction.js'
+import _getContentHash, {
+  type InternalGetContentHashParameters,
+  type InternalGetContentHashReturnType,
+} from './_getContentHash.js'
+import universalWrapper from './universalWrapper.js'
+
+export type GetContentHashRecordParameters =
+  Prettify<InternalGetContentHashParameters>
+
+export type GetContentHashRecordReturnType =
+  Prettify<InternalGetContentHashReturnType>
+
+const encode = (
+  client: ClientWithEns,
+  { name }: GetContentHashRecordParameters,
+): TransactionRequestWithPassthrough => {
+  const prData = _getContentHash.encode(client, { name })
+  return universalWrapper.encode(client, { name, data: prData.data })
+}
+
+const decode = async (
+  client: ClientWithEns,
+  data: Hex | BaseError,
+  passthrough: GenericPassthrough,
+): Promise<GetContentHashRecordReturnType> => {
+  const urData = await universalWrapper.decode(client, data, passthrough)
+  return _getContentHash.decode(client, urData.data)
+}
+
+type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
+
+/**
+ * Gets the content hash record for a name
+ * @param client - {@link ClientWithEns}
+ * @param parameters - {@link GetContentHashRecordParameters}
+ * @returns Content hash object, or `null` if not found. {@link GetContentHashRecordReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { addEnsContracts, getContentHashRecord } from '@ensdomains/ensjs'
+ *
+ * const client = createPublicClient({
+ *   chain: addEnsContracts(mainnet),
+ *   transport: http(),
+ * })
+ * const result = await getContentHashRecord(client, { name: 'ens.eth' })
+ * // { protocolType: 'ipfs', decoded: 'k51qzi5uqu5djdczd6zw0grmo23j2vkj9uzvujencg15s5rlkq0ss4ivll8wqw' }
+ */
+const getContentHashRecord = generateFunction({ encode, decode }) as ((
+  client: ClientWithEns,
+  { name }: GetContentHashRecordParameters,
+) => Promise<GetContentHashRecordReturnType>) &
+  BatchableFunctionObject
+
+export default getContentHashRecord

package/src/functions/public/getExpiry.test.ts

@@ -0,0 +1,48 @@
+import { publicClient } from '../../tests/addTestContracts.js'
+import getExpiry from './getExpiry.js'
+
+describe('getExpiry', () => {
+  it('should get the expiry for a .eth name with no other args', async () => {
+    const result = await getExpiry(publicClient, { name: 'with-profile.eth' })
+    expect(result).toBeTruthy()
+    if (result) {
+      const { expiry, gracePeriod, status } = result
+      expect(expiry.date).toBeInstanceOf(Date)
+      expect(typeof expiry.value).toBe('bigint')
+      expect(gracePeriod).toBe(7776000)
+      expect(status).toBe('active')
+    }
+  })
+  it('should get the expiry for a wrapped name', async () => {
+    const result = await getExpiry(publicClient, {
+      name: 'wrapped.eth',
+      contract: 'nameWrapper',
+    })
+
+    expect(result).toBeTruthy()
+    if (result) {
+      const { expiry, gracePeriod, status } = result
+      expect(expiry.date).toBeInstanceOf(Date)
+      expect(typeof expiry.value).toBe('bigint')
+      expect(gracePeriod).toBe(0)
+      expect(status).toBe('active')
+    }
+  })
+  it('should return null for a non .eth name if not wrapped', async () => {
+    const result = await getExpiry(publicClient, {
+      name: 'sub.with-profile.eth',
+    })
+    expect(result).toBeNull()
+  })
+  it('should throw an error for a non .eth name if registrar is specified', async () => {
+    try {
+      await getExpiry(publicClient, {
+        name: 'sub.with-profile.eth',
+        contract: 'registrar',
+      })
+      expect(false).toBeTruthy()
+    } catch {
+      expect(true).toBeTruthy()
+    }
+  })
+})

package/src/functions/public/getExpiry.ts

@@ -0,0 +1,199 @@
+import {
+  BaseError,
+  decodeFunctionResult,
+  encodeFunctionData,
+  labelhash,
+  type Hex,
+} from 'viem'
+import {
+  baseRegistrarGracePeriodSnippet,
+  baseRegistrarNameExpiresSnippet,
+} from '../../contracts/baseRegistrar.js'
+import type { ClientWithEns } from '../../contracts/consts.js'
+import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
+import { multicallGetCurrentBlockTimestampSnippet } from '../../contracts/multicall.js'
+import { nameWrapperGetDataSnippet } from '../../contracts/nameWrapper.js'
+import type {
+  DateWithValue,
+  Prettify,
+  SimpleTransactionRequest,
+} from '../../types.js'
+import {
+  generateFunction,
+  type GeneratedFunction,
+} from '../../utils/generateFunction.js'
+import { makeSafeSecondsDate } from '../../utils/makeSafeSecondsDate.js'
+import { namehash } from '../../utils/normalise.js'
+import { checkIsDotEth } from '../../utils/validation.js'
+import multicallWrapper from './multicallWrapper.js'
+
+type ContractOption = 'registrar' | 'nameWrapper'
+type ExpiryStatus = 'active' | 'expired' | 'gracePeriod'
+
+export type GetExpiryParameters = Prettify<{
+  /** Name to get expiry for */
+  name: string
+  /** Optional specific contract to use to get expiry */
+  contract?: ContractOption
+}>
+
+export type GetExpiryReturnType = Prettify<{
+  /** Expiry value */
+  expiry: DateWithValue<bigint>
+  /** Grace period value (in seconds) */
+  gracePeriod: number
+  /** Status of name */
+  status: ExpiryStatus
+} | null>
+
+const getContractToUse = (
+  contract: ContractOption | undefined,
+  labels: string[],
+) => {
+  if (contract) return contract
+  if (checkIsDotEth(labels)) {
+    return 'registrar'
+  }
+  return 'nameWrapper'
+}
+
+const encode = (
+  client: ClientWithEns,
+  { name, contract }: GetExpiryParameters,
+): SimpleTransactionRequest => {
+  const labels = name.split('.')
+
+  const contractToUse = getContractToUse(contract, labels)
+
+  const calls: SimpleTransactionRequest[] = [
+    {
+      to: getChainContractAddress({ client, contract: 'multicall3' }),
+      data: encodeFunctionData({
+        abi: multicallGetCurrentBlockTimestampSnippet,
+        functionName: 'getCurrentBlockTimestamp',
+      }),
+    },
+  ]
+
+  if (contractToUse === 'nameWrapper') {
+    calls.push({
+      to: getChainContractAddress({ client, contract: 'ensNameWrapper' }),
+      data: encodeFunctionData({
+        abi: nameWrapperGetDataSnippet,
+        functionName: 'getData',
+        args: [BigInt(namehash(labels.join('.')))],
+      }),
+    })
+  } else {
+    const baseRegistrarImplementationAddress = getChainContractAddress({
+      client,
+      contract: 'ensBaseRegistrarImplementation',
+    })
+    calls.push({
+      to: baseRegistrarImplementationAddress,
+      data: encodeFunctionData({
+        abi: baseRegistrarNameExpiresSnippet,
+        functionName: 'nameExpires',
+        args: [BigInt(labelhash(labels[0]))],
+      }),
+    })
+    calls.push({
+      to: baseRegistrarImplementationAddress,
+      data: encodeFunctionData({
+        abi: baseRegistrarGracePeriodSnippet,
+        functionName: 'GRACE_PERIOD',
+      }),
+    })
+  }
+
+  return multicallWrapper.encode(client, { transactions: calls })
+}
+
+const decode = async (
+  client: ClientWithEns,
+  data: Hex | BaseError,
+  { name, contract }: GetExpiryParameters,
+): Promise<GetExpiryReturnType> => {
+  if (typeof data === 'object') throw data
+  const labels = name.split('.')
+  const result = await multicallWrapper.decode(client, data, [])
+
+  const blockTimestamp = decodeFunctionResult({
+    abi: multicallGetCurrentBlockTimestampSnippet,
+    functionName: 'getCurrentBlockTimestamp',
+    data: result[0].returnData,
+  })
+
+  const contractToUse = getContractToUse(contract, labels)
+
+  let expiry: bigint
+  let gracePeriod: bigint = 0n
+
+  if (contractToUse === 'nameWrapper') {
+    ;[, , expiry] = decodeFunctionResult({
+      abi: nameWrapperGetDataSnippet,
+      functionName: 'getData',
+      data: result[1].returnData,
+    })
+  } else {
+    expiry = decodeFunctionResult({
+      abi: baseRegistrarNameExpiresSnippet,
+      functionName: 'nameExpires',
+      data: result[1].returnData,
+    })
+    gracePeriod = decodeFunctionResult({
+      abi: baseRegistrarGracePeriodSnippet,
+      functionName: 'GRACE_PERIOD',
+      data: result[2].returnData,
+    })
+  }
+
+  if (expiry === 0n) {
+    return null
+  }
+
+  let status: ExpiryStatus = 'active'
+
+  if (blockTimestamp > expiry + gracePeriod) {
+    status = 'expired'
+  } else if (blockTimestamp > expiry) {
+    status = 'gracePeriod'
+  }
+
+  return {
+    expiry: {
+      date: makeSafeSecondsDate(expiry),
+      value: expiry,
+    },
+    gracePeriod: Number(gracePeriod),
+    status,
+  }
+}
+
+type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
+
+/**
+ * Gets the expiry for a name
+ * @param client - {@link ClientWithEns}
+ * @param parameters - {@link GetExpiryParameters}
+ * @returns Expiry object, or `null` if no expiry. {@link GetExpiryReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { addEnsContracts, getExpiry } from '@ensdomains/ensjs'
+ *
+ * const client = createPublicClient({
+ *   chain: addEnsContracts(mainnet),
+ *   transport: http(),
+ * })
+ * const result = await getExpiry(client, { name: 'ens.eth' })
+ * // { expiry: { date: Date, value: 1913933217n }, gracePeriod: 7776000, status: 'active' }
+ */
+const getExpiry = generateFunction({ encode, decode }) as ((
+  client: ClientWithEns,
+  { name, contract }: GetExpiryParameters,
+) => Promise<GetExpiryReturnType>) &
+  BatchableFunctionObject
+
+export default getExpiry

package/src/functions/public/getName.test.ts

@@ -0,0 +1,66 @@
+import type { Address, Hex } from 'viem'
+import {
+  deploymentAddresses,
+  publicClient,
+  testClient,
+  waitForTransaction,
+  walletClient,
+} from '../../tests/addTestContracts.js'
+import setPrimaryName from '../wallet/setPrimaryName.js'
+import getName from './getName.js'
+
+let snapshot: Hex
+let accounts: Address[]
+
+beforeAll(async () => {
+  accounts = await walletClient.getAddresses()
+})
+
+beforeEach(async () => {
+  snapshot = await testClient.snapshot()
+})
+
+afterEach(async () => {
+  await testClient.revert({ id: snapshot })
+})
+
+describe('getName', () => {
+  it('should get a primary name from an address', async () => {
+    const result = await getName(publicClient, {
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+    })
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "match": true,
+        "name": "with-profile.eth",
+        "resolverAddress": "${deploymentAddresses.LegacyPublicResolver}",
+        "reverseResolverAddress": "${deploymentAddresses.PublicResolver}",
+      }
+    `)
+  })
+  it('should return null for an address with no primary name', async () => {
+    const result = await getName(publicClient, {
+      address: '0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0',
+    })
+    expect(result).toBeNull()
+  })
+  it('should return with a false match for a name with no forward resolution', async () => {
+    const tx = await setPrimaryName(walletClient, {
+      name: 'with-profile.eth',
+      account: accounts[0],
+    })
+    await waitForTransaction(tx)
+
+    const result = await getName(publicClient, {
+      address: accounts[0],
+    })
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "match": false,
+        "name": "with-profile.eth",
+        "resolverAddress": "${deploymentAddresses.LegacyPublicResolver}",
+        "reverseResolverAddress": "${deploymentAddresses.PublicResolver}",
+      }
+    `)
+  })
+})