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

package/src/functions/dns/importDnsName.ts

@@ -21,13 +21,13 @@ import type {
   WriteTransactionParameters,
 } from '../../types.js'
 import { packetToBytes } from '../../utils/hexEncodedName.js'
-import type { PrepareDnsImportReturnType } from './prepareDnsImport.js'
+import type { GetDnsImportDataReturnType } from './getDnsImportData.js'
 
 type BaseImportDnsNameDataParameters = {
   /** Name to import */
   name: string
-  /** Data returned from `prepareDnsImport()` */
-  preparedData: PrepareDnsImportReturnType
+  /** Data returned from `getDnsImportData()` */
+  dnsImportData: GetDnsImportDataReturnType
   /** Address to claim the name for */
   address?: Address
   /** Address of the resolver to use (default: `ensPublicResolver`) */
@@ -65,9 +65,14 @@ export const makeFunctionData = <
   TAccount extends Account | undefined,
 >(
   wallet: WalletWithEns<Transport, TChain, TAccount>,
-  { name, preparedData, address, resolverAddress }: ImportDnsNameDataParameters,
+  {
+    name,
+    dnsImportData,
+    address,
+    resolverAddress,
+  }: ImportDnsNameDataParameters,
 ): ImportDnsNameDataReturnType => {
-  const data = preparedData.rrsets.map((rrset) => ({
+  const data = dnsImportData.rrsets.map((rrset) => ({
     rrset: bytesToHex(rrset.rrset),
     sig: bytesToHex(rrset.sig),
   }))
@@ -81,7 +86,7 @@ export const makeFunctionData = <
     if (resolverAddress)
       throw new AdditionalParameterSpecifiedError({
         parameter: 'resolverAddress',
-        allowedParameters: ['name', 'preparedData'],
+        allowedParameters: ['name', 'dnsImportData'],
         details:
           'resolverAddress cannot be specified when claiming without an address',
       })
@@ -90,7 +95,7 @@ export const makeFunctionData = <
       data: encodeFunctionData({
         abi: dnsRegistrarProveAndClaimSnippet,
         functionName: 'proveAndClaim',
-        args: [hexEncodedName, data, bytesToHex(preparedData.proof)],
+        args: [hexEncodedName, data, bytesToHex(dnsImportData.proof)],
       }),
     }
   }
@@ -107,7 +112,7 @@ export const makeFunctionData = <
       args: [
         hexEncodedName,
         data,
-        bytesToHex(preparedData.proof),
+        bytesToHex(dnsImportData.proof),
         resolverAddress_,
         address,
       ],
@@ -124,9 +129,9 @@ export const makeFunctionData = <
  * @example
  * import { createPublicClient, createWalletClient, http, custom } from 'viem'
  * import { mainnet } from 'viem/chains'
- * import { addContracts, prepareDnsImport, importDnsName } from '@ensdomains/ensjs'
+ * import { addEnsContracts, getDnsImportData, importDnsName } from '@ensdomains/ensjs'
  *
- * const [mainnetWithEns] = addContracts([mainnet])
+ * const mainnetWithEns = addEnsContracts(mainnet)
  * const client = createPublicClient({
  *   chain: mainnetWithEns,
  *   transport: http(),
@@ -135,12 +140,12 @@ export const makeFunctionData = <
  *   chain: mainnetWithEns,
  *   transport: custom(window.ethereum),
  * })
- * const preparedData = await prepareDnsImport(client, {
+ * const dnsImportData = await getDnsImportData(client, {
  *   name: 'example.com',
  * })
- * const hash = await importDnsName(client, {
+ * const hash = await importDnsName(wallet, {
  *   name: 'example.com',
- *   preparedData,
+ *   dnsImportData,
  * })
  */
 async function importDnsName<
@@ -152,7 +157,7 @@ async function importDnsName<
   {
     name,
     address,
-    preparedData,
+    dnsImportData,
     resolverAddress,
     ...txArgs
   }: ImportDnsNameParameters<TChain, TAccount, TChainOverride>,
@@ -160,7 +165,7 @@ async function importDnsName<
   const data = makeFunctionData(wallet, {
     name,
     address,
-    preparedData,
+    dnsImportData,
     resolverAddress,
   } as ImportDnsNameDataParameters)
   const writeArgs = {

package/src/functions/public/_getContentHash.ts

@@ -4,7 +4,7 @@ import { publicResolverContenthashSnippet } from '../../contracts/publicResolver
 import type { Prettify, SimpleTransactionRequest } from '../../types.js'
 import { EMPTY_ADDRESS } from '../../utils/consts.js'
 import {
-  decodeContenthash,
+  decodeContentHash,
   type DecodedContentHash,
 } from '../../utils/contentHash.js'
 import { generateFunction } from '../../utils/generateFunction.js'
@@ -44,7 +44,7 @@ const decode = async (
     data,
   })
 
-  return decodeContenthash(response)
+  return decodeContentHash(response)
 }
 
 const _getContentHash = generateFunction({ encode, decode })

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,42 @@ 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 })
+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/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 */