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

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

@@ -0,0 +1,79 @@
+import { publicClient } from '../../tests/addTestContracts.js'
+import getWrapperData from './getWrapperData.js'
+
+describe('getWrapperData', () => {
+  it('should return null for an unwrapped name', async () => {
+    const result = await getWrapperData(publicClient, {
+      name: 'with-profile.eth',
+    })
+    expect(result).toBeNull()
+  })
+  it('should return with CAN_DO_EVERYTHING set to true for a name with no fuses burned', async () => {
+    const result = await getWrapperData(publicClient, {
+      name: 'test.wrapped-with-subnames.eth',
+    })
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result.fuses.child.CAN_DO_EVERYTHING).toBe(true)
+      expect(result.fuses.value).toBe(0)
+    }
+  })
+  // it('should return with other correct fuses', async () => {
+  //   const tx = await ensInstance.setFuses('wrapped.eth', {
+  //     named: [
+  //       'CANNOT_UNWRAP',
+  //       'CANNOT_CREATE_SUBDOMAIN',
+  //       'CANNOT_SET_TTL',
+  //       'CANNOT_APPROVE',
+  //     ],
+  //     addressOrIndex: 1,
+  //   })
+  //   await tx.wait()
+
+  //   const result = await ensInstance.getWrapperData('wrapped.eth')
+  //   expect(result).toBeTruthy()
+  //   if (result) {
+  //     expect(result.child.CAN_DO_EVERYTHING).toBe(false)
+  //     expect(result.child.CANNOT_UNWRAP).toBe(true)
+  //     expect(result.child.CANNOT_CREATE_SUBDOMAIN).toBe(true)
+  //     expect(result.child.CANNOT_SET_TTL).toBe(true)
+  //     expect(result.child.CANNOT_APPROVE).toBe(true)
+  //     expect(result.parent.IS_DOT_ETH).toBe(true)
+  //   }
+  // })
+  it('should return correct expiry', async () => {
+    const result = await getWrapperData(publicClient, {
+      name: 'wrapped.eth',
+    })
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result.expiry!.date).toBeInstanceOf(Date)
+      expect(typeof result.expiry!.value).toBe('bigint')
+      expect(Number.isNaN(result.expiry!.date.getTime())).toBe(false)
+    }
+  })
+  it('should return correct expiry for large expiry', async () => {
+    const result = await getWrapperData(publicClient, {
+      name: 'wrapped-big-duration.eth',
+    })
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result.expiry!.date).toBeInstanceOf(Date)
+      expect(typeof result.expiry!.value).toBe('bigint')
+      expect(result.expiry!.date.getFullYear()).toBe(275760)
+      expect(Number.isNaN(result.expiry!.date.getTime())).toBe(false)
+    }
+  })
+  it('should return correct max expiry for expiry larger than maximum for date', async () => {
+    const result = await getWrapperData(publicClient, {
+      name: 'wrapped-max-duration.eth',
+    })
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result.expiry!.date).toBeInstanceOf(Date)
+      expect(typeof result.expiry!.value).toBe('bigint')
+      expect(result.expiry!.date.getFullYear()).toBe(275760)
+      expect(Number.isNaN(result.expiry!.date.getTime())).toBe(false)
+    }
+  })
+})

package/src/functions/public/getWrapperData.ts

@@ -0,0 +1,128 @@
+import {
+  BaseError,
+  decodeFunctionResult,
+  encodeFunctionData,
+  getContractError,
+  type Address,
+  type Hex,
+} from 'viem'
+import type { ClientWithEns } from '../../contracts/consts.js'
+import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
+import { nameWrapperGetDataSnippet } from '../../contracts/nameWrapper.js'
+import type {
+  DateWithValue,
+  GenericPassthrough,
+  Prettify,
+  TransactionRequestWithPassthrough,
+} from '../../types.js'
+import { EMPTY_ADDRESS } from '../../utils/consts.js'
+import { decodeFuses } from '../../utils/fuses.js'
+import {
+  generateFunction,
+  type GeneratedFunction,
+} from '../../utils/generateFunction.js'
+import { makeSafeSecondsDate } from '../../utils/makeSafeSecondsDate.js'
+import { namehash } from '../../utils/normalise.js'
+
+export type GetWrapperDataParameters = {
+  /** Name to get wrapper data for */
+  name: string
+}
+
+export type GetWrapperDataReturnType = Prettify<{
+  /** Fuse object */
+  fuses: ReturnType<typeof decodeFuses> & {
+    value: number
+  }
+  /** Expiry of the name */
+  expiry: DateWithValue<bigint> | null
+  /** Owner of the name */
+  owner: Address
+} | null>
+
+const encode = (
+  client: ClientWithEns,
+  { name }: GetWrapperDataParameters,
+): TransactionRequestWithPassthrough => {
+  const address = getChainContractAddress({
+    client,
+    contract: 'ensNameWrapper',
+  })
+  const args = [BigInt(namehash(name))] as const
+  return {
+    to: address,
+    data: encodeFunctionData({
+      abi: nameWrapperGetDataSnippet,
+      functionName: 'getData',
+      args,
+    }),
+    passthrough: { address, args },
+  }
+}
+
+const decode = async (
+  _client: ClientWithEns,
+  data: Hex | BaseError,
+  passthrough: GenericPassthrough,
+): Promise<GetWrapperDataReturnType> => {
+  if (typeof data === 'object')
+    throw getContractError(data, {
+      abi: nameWrapperGetDataSnippet,
+      functionName: 'getData',
+      args: passthrough.args,
+      address: passthrough.address,
+    })
+  const [owner, fuses, expiry] = decodeFunctionResult({
+    abi: nameWrapperGetDataSnippet,
+    functionName: 'getData',
+    data,
+  })
+
+  if (owner === EMPTY_ADDRESS) {
+    return null
+  }
+
+  const fuseObj = decodeFuses(fuses)
+  const expiryDate = expiry > 0 ? makeSafeSecondsDate(expiry) : null
+
+  return {
+    fuses: {
+      ...fuseObj,
+      value: fuses,
+    },
+    expiry: expiryDate
+      ? {
+          date: expiryDate,
+          value: expiry,
+        }
+      : null,
+    owner,
+  }
+}
+
+type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
+
+/**
+ * Gets the wrapper data for a name.
+ * @param client - {@link ClientWithEns}
+ * @param parameters - {@link GetWrapperDataParameters}
+ * @returns Wrapper data object, or null if name is not wrapped. {@link GetWrapperDataReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { addEnsContracts, getWrapperData } from '@ensdomains/ensjs'
+ *
+ * const client = createPublicClient({
+ *   chain: addEnsContracts(mainnet),
+ *   transport: http(),
+ * })
+ * const result = await getWrapperData(client, { name: 'ilikelasagna.eth' })
+ */
+const getWrapperData = generateFunction({ encode, decode }) as ((
+  client: ClientWithEns,
+  { name }: GetWrapperDataParameters,
+) => Promise<GetWrapperDataReturnType>) &
+  BatchableFunctionObject
+
+export default getWrapperData

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

@@ -0,0 +1,19 @@
+import { publicClient } from '../../tests/addTestContracts.js'
+import getWrapperName from './getWrapperName.js'
+
+describe('getWrapperName()', () => {
+  it('should return name for existing name', async () => {
+    const result = await getWrapperName(publicClient, {
+      // wrapped.eth
+      name: '[4ca938ec1b323ca71c4fb47a712abb68cce1cabf39ea4d6789e42fbc1f95459b].eth',
+    })
+    expect(result).toBe('wrapped.eth')
+  })
+  it('should return null for non-existent name', async () => {
+    const result = await getWrapperName(publicClient, {
+      // test123.eth
+      name: '[f81b517a242b218999ec8eec0ea6e2ddbef2a367a14e93f4a32a39e260f686ad].eth',
+    })
+    expect(result).toBeNull()
+  })
+})

package/src/functions/public/getWrapperName.ts

@@ -0,0 +1,97 @@
+import {
+  BaseError,
+  decodeFunctionResult,
+  encodeFunctionData,
+  getContractError,
+  hexToBytes,
+  type Hex,
+} from 'viem'
+import type { ClientWithEns } from '../../contracts/consts.js'
+import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
+import { nameWrapperNamesSnippet } from '../../contracts/nameWrapper.js'
+import type {
+  GenericPassthrough,
+  TransactionRequestWithPassthrough,
+} from '../../types.js'
+import {
+  generateFunction,
+  type GeneratedFunction,
+} from '../../utils/generateFunction.js'
+import { bytesToPacket } from '../../utils/hexEncodedName.js'
+import { namehash } from '../../utils/normalise.js'
+
+export type GetWrapperNameParameters = {
+  /** Name with unknown labels, e.g. "[4ca938ec1b323ca71c4fb47a712abb68cce1cabf39ea4d6789e42fbc1f95459b].eth" */
+  name: string
+}
+
+export type GetWrapperNameReturnType = string | null
+
+const encode = (
+  client: ClientWithEns,
+  { name }: GetWrapperNameParameters,
+): TransactionRequestWithPassthrough => {
+  const address = getChainContractAddress({
+    client,
+    contract: 'ensNameWrapper',
+  })
+  const args = [namehash(name)] as const
+  return {
+    to: address,
+    data: encodeFunctionData({
+      abi: nameWrapperNamesSnippet,
+      functionName: 'names',
+      args,
+    }),
+    passthrough: { address, args },
+  }
+}
+
+const decode = async (
+  _client: ClientWithEns,
+  data: Hex | BaseError,
+  passthrough: GenericPassthrough,
+): Promise<GetWrapperNameReturnType> => {
+  if (typeof data === 'object')
+    throw getContractError(data, {
+      abi: nameWrapperNamesSnippet,
+      functionName: 'names',
+      args: passthrough.args,
+      address: passthrough.address,
+    })
+  const result = decodeFunctionResult({
+    abi: nameWrapperNamesSnippet,
+    functionName: 'names',
+    data,
+  })
+  if (!result || result === '0x' || BigInt(result) === 0n) return null
+  return bytesToPacket(hexToBytes(result))
+}
+
+type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
+
+/**
+ * Gets the full name for a name with unknown labels from the NameWrapper.
+ * @param client - {@link ClientWithEns}
+ * @param parameters - {@link GetWrapperNameParameters}
+ * @returns Full name, or null if name was not found. {@link GetWrapperNameReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { addEnsContracts, getWrapperName } from '@ensdomains/ensjs'
+ *
+ * const client = createPublicClient({
+ *   chain: addEnsContracts(mainnet),
+ *   transport: http(),
+ * })
+ * const result = await getWrapperName(client, { name: '[4ca938ec1b323ca71c4fb47a712abb68cce1cabf39ea4d6789e42fbc1f95459b].eth' })
+ * // wrapped.eth
+ */
+const getWrapperName = generateFunction({ encode, decode }) as ((
+  client: ClientWithEns,
+  { name }: GetWrapperNameParameters,
+) => Promise<GetWrapperNameReturnType>) &
+  BatchableFunctionObject
+
+export default getWrapperName

package/src/functions/public/multicallWrapper.ts

@@ -0,0 +1,88 @@
+import {
+  BaseError,
+  decodeFunctionResult,
+  encodeFunctionData,
+  getContractError,
+  offchainLookup,
+  type Hex,
+} from 'viem'
+import type { ClientWithEns } from '../../contracts/consts.js'
+import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
+import { multicallTryAggregateSnippet } from '../../contracts/multicall.js'
+import type {
+  SimpleTransactionRequest,
+  TransactionRequestWithPassthrough,
+} from '../../types.js'
+import { generateFunction } from '../../utils/generateFunction.js'
+
+export type MulticallWrapperParameters = {
+  transactions: SimpleTransactionRequest[]
+  requireSuccess?: boolean
+}
+
+export type MulticallWrapperReturnType = {
+  success: boolean
+  returnData: Hex
+}[]
+
+const encode = (
+  client: ClientWithEns,
+  { transactions, requireSuccess = false }: MulticallWrapperParameters,
+): SimpleTransactionRequest => {
+  return {
+    to: getChainContractAddress({ client, contract: 'multicall3' }),
+    data: encodeFunctionData({
+      abi: multicallTryAggregateSnippet,
+      functionName: 'tryAggregate',
+      args: [
+        requireSuccess,
+        transactions.map((tx) => ({ target: tx.to!, callData: tx.data! })),
+      ],
+    }),
+  }
+}
+
+const decode = async (
+  client: ClientWithEns,
+  data: Hex | BaseError,
+  transactions: TransactionRequestWithPassthrough[],
+): Promise<MulticallWrapperReturnType> => {
+  if (typeof data === 'object') {
+    throw getContractError(data, {
+      abi: multicallTryAggregateSnippet,
+      functionName: 'tryAggregate',
+      args: [],
+    })
+  }
+  const result = decodeFunctionResult({
+    abi: multicallTryAggregateSnippet,
+    functionName: 'tryAggregate',
+    data,
+  })
+  const ccipChecked = await Promise.all(
+    result.map(async ({ success, returnData }, i) => {
+      let newObj: { success: boolean; returnData: Hex } = {
+        success,
+        returnData,
+      }
+      // OffchainLookup(address,string[],bytes,bytes4,bytes)
+      if (!success && returnData.startsWith('0x556f1830')) {
+        try {
+          const newData = await offchainLookup(client, {
+            to: transactions[i].to!,
+            data: returnData,
+          })
+          if (newData) {
+            newObj = { success: true, returnData: newData }
+          }
+        } catch {}
+      }
+      return newObj
+    }),
+  )
+  return ccipChecked
+}
+
+const multicallWrapper = generateFunction({ encode, decode })
+
+export default multicallWrapper

package/src/functions/public/universalWrapper.ts

@@ -0,0 +1,108 @@
+import {
+  BaseError,
+  decodeErrorResult,
+  decodeFunctionResult,
+  encodeFunctionData,
+  getContractError,
+  labelhash,
+  toBytes,
+  toHex,
+  type Address,
+  type Hex,
+} from 'viem'
+import type { ClientWithEns } from '../../contracts/consts.js'
+import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
+import { universalResolverResolveSnippet } from '../../contracts/universalResolver.js'
+import type {
+  GenericPassthrough,
+  TransactionRequestWithPassthrough,
+} from '../../types.js'
+import { EMPTY_ADDRESS } from '../../utils/consts.js'
+import { generateFunction } from '../../utils/generateFunction.js'
+import { getRevertErrorData } from '../../utils/getRevertErrorData.js'
+import { packetToBytes } from '../../utils/hexEncodedName.js'
+import { encodeLabelhash } from '../../utils/labels.js'
+
+export type UniversalWrapperParameters = {
+  name: string
+  data: Hex
+}
+
+export type UniversalWrapperReturnType = {
+  data: Hex
+  resolver: Address
+}
+
+const encode = (
+  client: ClientWithEns,
+  { name, data }: UniversalWrapperParameters,
+): TransactionRequestWithPassthrough => {
+  const nameWithSizedLabels = name
+    .split('.')
+    .map((label) => {
+      const labelLength = toBytes(label).byteLength
+      if (labelLength > 255) {
+        return encodeLabelhash(labelhash(label))
+      }
+      return label
+    })
+    .join('.')
+  const to = getChainContractAddress({
+    client,
+    contract: 'ensUniversalResolver',
+  })
+  const args = [toHex(packetToBytes(nameWithSizedLabels)), data] as const
+  return {
+    to: getChainContractAddress({ client, contract: 'ensUniversalResolver' }),
+    data: encodeFunctionData({
+      abi: universalResolverResolveSnippet,
+      functionName: 'resolve',
+      args,
+    }),
+    passthrough: {
+      args,
+      address: to,
+    },
+  }
+}
+
+const decode = async (
+  _client: ClientWithEns,
+  data: Hex | BaseError,
+  passthrough: GenericPassthrough,
+): Promise<UniversalWrapperReturnType> => {
+  if (typeof data === 'object') {
+    const errorData = getRevertErrorData(data)
+    if (errorData) {
+      const decodedError = decodeErrorResult({
+        abi: universalResolverResolveSnippet,
+        data: errorData,
+      })
+      if (
+        decodedError.errorName === 'ResolverNotFound' ||
+        decodedError.errorName === 'ResolverWildcardNotSupported'
+      )
+        return {
+          data: '0x',
+          resolver: EMPTY_ADDRESS,
+        }
+    }
+    throw getContractError(data, {
+      abi: universalResolverResolveSnippet,
+      functionName: 'resolve',
+      args: passthrough.args,
+      address: passthrough.address,
+    })
+  }
+
+  const result = decodeFunctionResult({
+    abi: universalResolverResolveSnippet,
+    functionName: 'resolve',
+    data,
+  })
+  return { data: result[0], resolver: result[1] }
+}
+
+const universalWrapper = generateFunction({ encode, decode })
+
+export default universalWrapper

package/src/functions/subgraph/client.test.ts

@@ -0,0 +1,170 @@
+import { namehash } from 'viem'
+import { requestMiddleware, responseMiddleware } from './client.js'
+
+const queryWithoutId = `
+query getNames($id: ID!, $expiryDate: Int) {
+    account(id: $id) {
+      registrations(first: 1000, where: { expiryDate_gt: $expiryDate }) {
+        registrationDate
+        expiryDate
+        domain {
+          labelName
+          labelhash
+          name
+          isMigrated
+          parent {
+            name
+          }
+        }
+      }
+      domains(first: 1000) {
+        labelName
+        labelhash
+        name
+        isMigrated
+        parent {
+          name
+        }
+        createdAt
+      }
+    }
+  }
+`
+
+const mockRequest = {
+  method: 'POST',
+  headers: {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    'Content-Type': 'application/json',
+  },
+  body: JSON.stringify({ query: queryWithoutId }),
+}
+
+const mockResponse = {
+  data: {
+    account: {
+      registrations: [
+        {
+          registrationDate: '1659245504',
+          expiryDate: '1690781504',
+          domain: {
+            id: '0xb1ccf7f6bb648f39ba48bf80f4a8a4522f474ee7d1edd6ea65f7fa51fe8b1612',
+            labelName: 'randydandy',
+            labelhash:
+              '0x63fd5bfdd0b1eb9f4c33c209b7c3e7dcb87a761d926a65e267f7cb99ee313ddd',
+            name: '0xde2551f43e950a2a4d4e6052f25edc450c48a5338faa27f09d1ee99ca9dc04fd',
+            isMigrated: true,
+            parent: {
+              name: '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae',
+              invalidName: true,
+            },
+            invalidName: true,
+          },
+        },
+        {
+          registrationDate: '1635284756',
+          expiryDate: '1666841708',
+          domain: {
+            id: '0xde2551f43e950a2a4d4e6052f25edc450c48a5338faa27f09d1ee99ca9dc04fd',
+            labelName: 'randydandy',
+            labelhash:
+              '0x6a877a8d92ad83c8d044d0c5b69aa0da3050f4d653dcc149fca952d6439e4105',
+            name: 'randydandy.eth',
+            isMigrated: true,
+            parent: {
+              name: '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae',
+              invalidName: true,
+            },
+          },
+        },
+        {
+          registrationDate: '1659250465',
+          expiryDate: '1690786465',
+          domain: {
+            id: '0xaf119e72f050e5acad6b2d97826a7afb45afe9407376a2ab8240b62173b2d7c2',
+            labelName: 'nullbyte',
+            labelhash:
+              '0xc8985f8323b3dc707003a6ef5b379d9e8a058b6d6bcc2cfb307c61ca36920e27',
+            name: '0xb54c7c79c89d571f1fbf4c67f524e336a04441eeee4d76f156e835da99a46ddb',
+            isMigrated: true,
+            parent: {
+              name: '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae',
+              invalidName: true,
+            },
+            invalidName: true,
+          },
+        },
+      ],
+      domains: [
+        {
+          id: '0xaf119e72f050e5acad6b2d97826a7afb45afe9407376a2ab8240b62173b2d7c2',
+          labelName: 'nullbyte',
+          labelhash:
+            '0xc8985f8323b3dc707003a6ef5b379d9e8a058b6d6bcc2cfb307c61ca36920e27',
+          name: '0xb54c7c79c89d571f1fbf4c67f524e336a04441eeee4d76f156e835da99a46ddb',
+          isMigrated: true,
+          parent: {
+            name: '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae',
+            invalidName: true,
+          },
+          createdAt: '1659250465',
+          invalidName: true,
+        },
+        {
+          id: '0xb1ccf7f6bb648f39ba48bf80f4a8a4522f474ee7d1edd6ea65f7fa51fe8b1612',
+          labelName: 'randydandy',
+          labelhash:
+            '0x63fd5bfdd0b1eb9f4c33c209b7c3e7dcb87a761d926a65e267f7cb99ee313ddd',
+          name: '0xde2551f43e950a2a4d4e6052f25edc450c48a5338faa27f09d1ee99ca9dc04fd',
+          isMigrated: true,
+          parent: {
+            name: '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae',
+            invalidName: true,
+          },
+          createdAt: '1659245504',
+          invalidName: true,
+        },
+        {
+          id: '0xde2551f43e950a2a4d4e6052f25edc450c48a5338faa27f09d1ee99ca9dc04fd',
+          labelName: 'randydandy',
+          labelhash:
+            '0x6a877a8d92ad83c8d044d0c5b69aa0da3050f4d653dcc149fca952d6439e4105',
+          name: 'randydandy.eth',
+          isMigrated: true,
+          parent: {
+            name: '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae',
+            invalidName: true,
+          },
+          createdAt: '1635284756',
+        },
+      ],
+    },
+  },
+  headers: {
+    map: {
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      'Content-Type': 'application/json',
+    },
+  },
+  status: 200,
+}
+
+describe('requestMiddleware', () => {
+  it('should add id to a SelectionSet if name is present and id is not', () => {
+    const result = requestMiddleware(mockRequest as any)
+    const body = (result as any).body as string
+    expect(body.match(/domain.*id.*id.*domains.*id.*id/)?.length).toBe(1)
+  })
+})
+
+describe('responseMiddleware', () => {
+  it('should replace name with the namehash when there is an invalid name and id combo', () => {
+    const response = { ...mockResponse }
+    responseMiddleware(response as any)
+    expect(response.data.account.domains[0].name).toBe(
+      namehash(
+        '0xb54c7c79c89d571f1fbf4c67f524e336a04441eeee4d76f156e835da99a46ddb',
+      ),
+    )
+  })
+})