@ensdomains/ensjs 3.0.0-beta.1 → 3.0.0-beta.10

package/src/functions/public/getSupportedInterfaces.ts

@@ -1,4 +1,10 @@
-import { BaseError, encodeFunctionData, type Address, type Hex } from 'viem'
+import {
+  BaseError,
+  encodeFunctionData,
+  padHex,
+  type Address,
+  type Hex,
+} from 'viem'
 import type { ClientWithEns } from '../../contracts/consts.js'
 import { erc165SupportsInterfaceSnippet } from '../../contracts/erc165.js'
 import type {
@@ -8,12 +14,18 @@ import type {
 import { generateFunction } from '../../utils/generateFunction.js'
 import multicallWrapper from './multicallWrapper.js'
 
-export type GetSupportedInterfacesParameters = {
+export type GetSupportedInterfacesParameters<
+  TInterfaces extends readonly Hex[],
+> = {
   address: Address
-  interfaces: Hex[]
+  interfaces: TInterfaces
 }
 
-export type GetSupportedInterfacesReturnType = boolean[]
+export type GetSupportedInterfacesReturnType<
+  TInterfaces extends readonly Hex[],
+> = {
+  -readonly [K in keyof TInterfaces]: boolean
+}
 
 const encodeInterface = (interfaceId: Hex): Hex =>
   encodeFunctionData({
@@ -22,9 +34,9 @@ const encodeInterface = (interfaceId: Hex): Hex =>
     args: [interfaceId],
   })
 
-const encode = (
+const encode = <TInterfaces extends Hex[]>(
   client: ClientWithEns,
-  { address, interfaces }: GetSupportedInterfacesParameters,
+  { address, interfaces }: GetSupportedInterfacesParameters<TInterfaces>,
 ): TransactionRequestWithPassthrough => {
   const calls = interfaces.map((interfaceId) => ({
     to: address,
@@ -39,16 +51,64 @@ const encode = (
   }
 }
 
-const decode = async (
+const decode = async <const TInterfaces extends readonly Hex[]>(
   client: ClientWithEns,
   data: Hex | BaseError,
   passthrough: SimpleTransactionRequest[],
-): Promise<GetSupportedInterfacesReturnType> => {
+): Promise<GetSupportedInterfacesReturnType<TInterfaces>> => {
   if (typeof data === 'object') throw data
   const result = await multicallWrapper.decode(client, data, passthrough)
-  return result.map((r) => r.success && r.returnData === '0x01')
+  return result.map(
+    (r) => r.success && r.returnData === padHex('0x01'),
+  ) as GetSupportedInterfacesReturnType<TInterfaces>
+}
+
+type EncoderFunction = typeof encode
+type DecoderFunction = typeof decode
+
+type BatchableFunctionObject = {
+  encode: EncoderFunction
+  decode: DecoderFunction
+  batch: <
+    const TInterfaces extends readonly Hex[],
+    TParams extends GetSupportedInterfacesParameters<TInterfaces>,
+  >(
+    args: TParams,
+  ) => {
+    args: [TParams]
+    encode: EncoderFunction
+    decode: typeof decode<TInterfaces>
+  }
 }
 
-const getSupportedInterfaces = generateFunction({ encode, decode })
+/**
+ * Gets the supported interfaces for any contract address.
+ * @param client - {@link ClientWithEns}
+ * @param parameters - {@link GetSupportedInterfacesParameters}
+ * @returns Array of booleans matching the input array {@link GetSupportedInterfacesReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { addEnsContracts } from '@ensdomains/ensjs'
+ * import { getSupportedInterfaces } from '@ensdomains/ensjs/public'
+ *
+ * const client = createPublicClient({
+ *   chain: addEnsContracts(mainnet),
+ *   transport: http(),
+ * })
+ * const result = await getSupportedInterfaces(client, {
+ *   address: '0x58774Bb8acD458A640aF0B88238369A167546ef2',
+ *   interfaces: ['0x2f435428', '0x23b872dd'],
+ * })
+ * // [true, false]
+ */
+const getSupportedInterfaces = generateFunction({ encode, decode }) as (<
+  const TInterfaces extends readonly Hex[],
+>(
+  client: ClientWithEns,
+  { address, interfaces }: GetSupportedInterfacesParameters<TInterfaces>,
+) => Promise<GetSupportedInterfacesReturnType<TInterfaces>>) &
+  BatchableFunctionObject
 
 export default getSupportedInterfaces

package/src/functions/public/getTextRecord.ts

@@ -47,7 +47,8 @@ type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
  * @example
  * import { createPublicClient, http } from 'viem'
  * import { mainnet } from 'viem/chains'
- * import { addEnsContracts, getTextRecord } from '@ensdomains/ensjs'
+ * import { addEnsContracts } from '@ensdomains/ensjs'
+ * import { getTextRecord } from '@ensdomains/ensjs/public'
  *
  * const client = createPublicClient({
  *   chain: addEnsContracts(mainnet),

package/src/functions/public/getWrapperData.ts

@@ -16,7 +16,7 @@ import type {
   TransactionRequestWithPassthrough,
 } from '../../types.js'
 import { EMPTY_ADDRESS } from '../../utils/consts.js'
-import { decodeFuses } from '../../utils/fuses.js'
+import { decodeFuses, type DecodedFuses } from '../../utils/fuses.js'
 import {
   generateFunction,
   type GeneratedFunction,
@@ -31,7 +31,7 @@ export type GetWrapperDataParameters = {
 
 export type GetWrapperDataReturnType = Prettify<{
   /** Fuse object */
-  fuses: ReturnType<typeof decodeFuses> & {
+  fuses: DecodedFuses & {
     value: number
   }
   /** Expiry of the name */
@@ -71,7 +71,7 @@ const decode = async (
       functionName: 'getData',
       args: passthrough.args,
       address: passthrough.address,
-    })
+    }) as BaseError
   const [owner, fuses, expiry] = decodeFunctionResult({
     abi: nameWrapperGetDataSnippet,
     functionName: 'getData',
@@ -111,7 +111,8 @@ type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
  * @example
  * import { createPublicClient, http } from 'viem'
  * import { mainnet } from 'viem/chains'
- * import { addEnsContracts, getWrapperData } from '@ensdomains/ensjs'
+ * import { addEnsContracts } from '@ensdomains/ensjs'
+ * import { getWrapperData } from '@ensdomains/ensjs/public'
  *
  * const client = createPublicClient({
  *   chain: addEnsContracts(mainnet),

package/src/functions/public/getWrapperName.ts

@@ -58,7 +58,7 @@ const decode = async (
       functionName: 'names',
       args: passthrough.args,
       address: passthrough.address,
-    })
+    }) as BaseError
   const result = decodeFunctionResult({
     abi: nameWrapperNamesSnippet,
     functionName: 'names',
@@ -79,7 +79,8 @@ type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
  * @example
  * import { createPublicClient, http } from 'viem'
  * import { mainnet } from 'viem/chains'
- * import { addEnsContracts, getWrapperName } from '@ensdomains/ensjs'
+ * import { addEnsContracts } from '@ensdomains/ensjs'
+ * import { getWrapperName } from '@ensdomains/ensjs/public'
  *
  * const client = createPublicClient({
  *   chain: addEnsContracts(mainnet),

package/src/functions/public/multicallWrapper.ts

@@ -52,7 +52,7 @@ const decode = async (
       abi: multicallTryAggregateSnippet,
       functionName: 'tryAggregate',
       args: [],
-    })
+    }) as BaseError
   }
   const result = decodeFunctionResult({
     abi: multicallTryAggregateSnippet,

package/src/functions/public/universalWrapper.ts

@@ -92,7 +92,7 @@ const decode = async (
       functionName: 'resolve',
       args: passthrough.args,
       address: passthrough.address,
-    })
+    }) as BaseError
   }
 
   const result = decodeFunctionResult({

package/src/functions/subgraph/client.ts

@@ -1,6 +1,6 @@
 import type { Kind, SelectionNode, SelectionSetNode } from 'graphql'
+import type { RequestMiddleware, ResponseMiddleware } from 'graphql-request'
 import { GraphQLClient } from 'graphql-request'
-import type { RequestMiddleware, Response } from 'graphql-request/dist/types.js'
 import { parse, print, visit } from 'graphql/language/index.js'
 import traverse from 'traverse'
 import type { ClientWithEns } from '../../contracts/consts.js'
@@ -56,7 +56,7 @@ export const requestMiddleware: RequestMiddleware = (request) => {
   }
 }
 
-export const responseMiddleware = (response: Response<unknown> | Error) => {
+export const responseMiddleware: ResponseMiddleware = (response) => {
   traverse(response).forEach(function (responseItem: unknown) {
     if (
       responseItem instanceof Object &&