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

package/src/functions/public/getAvailable.ts

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

package/src/functions/public/getContentHashRecord.ts

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

package/src/functions/public/getExpiry.ts

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

package/src/functions/public/getName.ts

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

package/src/functions/public/getOwner.ts

@@ -3,10 +3,7 @@ import type { ClientWithEns } from '../../contracts/consts.js'
 import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
 import type { SimpleTransactionRequest } from '../../types.js'
 import { EMPTY_ADDRESS } from '../../utils/consts.js'
-import {
-  generateFunction,
-  type GeneratedFunction,
-} from '../../utils/generateFunction.js'
+import { generateFunction } from '../../utils/generateFunction.js'
 import { namehash as makeNamehash } from '../../utils/normalise.js'
 import {
   ownerFromContract,
@@ -15,11 +12,13 @@ import {
 import { checkIsDotEth } from '../../utils/validation.js'
 import multicallWrapper from './multicallWrapper.js'
 
-export type GetOwnerParameters = {
+export type GetOwnerParameters<
+  TContract extends OwnerContract | undefined = undefined,
+> = {
   /** Name to get owner for */
   name: string
   /** Optional specific contract to get ownership value from */
-  contract?: OwnerContract
+  contract?: TContract
 }
 
 type BaseGetOwnerReturnType = {
@@ -55,19 +54,22 @@ type UnwrappedOwnership = {
   ownershipLevel: 'registry'
 }
 
-export type GetOwnerReturnType =
+export type GetOwnerReturnType<
+  TContract extends OwnerContract | undefined = undefined,
+> =
   | (BaseGetOwnerReturnType &
-      (
-        | RegistrarOnlyOwnership
-        | WrappedOwnership
-        | UnwrappedEth2ldOwnership
-        | UnwrappedOwnership
-      ))
+      (TContract extends 'registrar'
+        ? RegistrarOnlyOwnership
+        : TContract extends 'nameWrapper'
+        ? WrappedOwnership
+        : TContract extends 'registry'
+        ? UnwrappedOwnership
+        : WrappedOwnership | UnwrappedEth2ldOwnership | UnwrappedOwnership))
   | null
 
-const encode = (
+const encode = <TContract extends OwnerContract | undefined = undefined>(
   client: ClientWithEns,
-  { name, contract }: GetOwnerParameters,
+  { name, contract }: GetOwnerParameters<TContract>,
 ): SimpleTransactionRequest => {
   const namehash = makeNamehash(name)
   const labels = name.split('.')
@@ -102,13 +104,13 @@ const encode = (
 }
 
 const addressDecode = (data: Hex) =>
-  decodeAbiParameters([{ type: 'address' }], data)[0]
+  decodeAbiParameters([{ type: 'address' }], data)[0] as Address
 
-const decode = async (
+const decode = async <TContract extends OwnerContract | undefined = undefined>(
   client: ClientWithEns,
   data: Hex | BaseError,
-  { name, contract }: GetOwnerParameters,
-): Promise<GetOwnerReturnType> => {
+  { name, contract }: GetOwnerParameters<TContract>,
+): Promise<GetOwnerReturnType<TContract>> => {
   if (typeof data === 'object') throw data
   const labels = name.split('.')
   if (contract || labels.length === 1) {
@@ -117,12 +119,12 @@ const decode = async (
       return {
         ownershipLevel: 'registrar',
         registrant: singleOwner,
-      } as RegistrarOnlyOwnership
+      } as GetOwnerReturnType<TContract>
     }
     return {
       ownershipLevel: contract || 'registry',
       owner: singleOwner,
-    } as UnwrappedOwnership | WrappedOwnership
+    } as GetOwnerReturnType<TContract>
   }
 
   const result = await multicallWrapper.decode(client, data, [])
@@ -150,7 +152,7 @@ const decode = async (
       return {
         owner: nameWrapperOwner,
         ownershipLevel: 'nameWrapper',
-      } as WrappedOwnership
+      } as GetOwnerReturnType<TContract>
     }
     // if there is a registrar owner, then it's not a subdomain but we have also passed the namewrapper clause
     // this means that it's an unwrapped second-level name
@@ -161,7 +163,7 @@ const decode = async (
         registrant: registrarOwner!,
         owner: registryOwner!,
         ownershipLevel: 'registrar',
-      } as UnwrappedEth2ldOwnership
+      } as GetOwnerReturnType<TContract>
     }
     if (registryOwner !== EMPTY_ADDRESS) {
       // if there is no registrar owner, but the label length is two, then the domain is an expired 2LD .eth
@@ -171,7 +173,7 @@ const decode = async (
           registrant: null,
           owner: registryOwner,
           ownershipLevel: 'registrar',
-        } as UnwrappedEth2ldOwnership
+        } as GetOwnerReturnType<TContract>
       }
       // this means that the subname is wrapped
       if (
@@ -182,13 +184,13 @@ const decode = async (
         return {
           owner: nameWrapperOwner,
           ownershipLevel: 'nameWrapper',
-        } as WrappedOwnership
+        } as GetOwnerReturnType<TContract>
       }
       // unwrapped subnames do not have NFTs associated, so do not have a registrant
       return {
         owner: registryOwner,
         ownershipLevel: 'registry',
-      } as UnwrappedOwnership
+      } as GetOwnerReturnType<TContract>
     }
     // .eth names with no registrar owner are either unregistered or expired
     return null
@@ -206,7 +208,7 @@ const decode = async (
     return {
       owner: nameWrapperOwner,
       ownershipLevel: 'nameWrapper',
-    } as WrappedOwnership
+    } as GetOwnerReturnType<TContract>
   }
 
   // for unwrapped non .eth names, the owner is the registry owner
@@ -214,14 +216,30 @@ const decode = async (
     return {
       owner: registryOwner,
       ownershipLevel: 'registry',
-    } as UnwrappedOwnership
+    } as GetOwnerReturnType<TContract>
   }
 
   // for anything else, return
   return null
 }
 
-type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
+type EncoderFunction = typeof encode
+type DecoderFunction = typeof decode
+
+type BatchableFunctionObject = {
+  encode: EncoderFunction
+  decode: DecoderFunction
+  batch: <
+    TContract extends OwnerContract | undefined = undefined,
+    TParams extends GetOwnerParameters<TContract> = GetOwnerParameters<TContract>,
+  >(
+    args: TParams,
+  ) => {
+    args: [TParams]
+    encode: EncoderFunction
+    decode: typeof decode<TContract>
+  }
+}
 
 /**
  * Gets the owner(s) of a name.
@@ -232,7 +250,8 @@ type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
  * @example
  * import { createPublicClient, http } from 'viem'
  * import { mainnet } from 'viem/chains'
- * import { addEnsContracts, getOwner } from '@ensdomains/ensjs'
+ * import { addEnsContracts } from '@ensdomains/ensjs'
+ * import { getOwner } from '@ensdomains/ensjs/public'
  *
  * const client = createPublicClient({
  *   chain: addEnsContracts(mainnet),
@@ -241,10 +260,12 @@ type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
  * const result = await getOwner(client, { name: 'ens.eth' })
  * // { owner: '0xb6E040C9ECAaE172a89bD561c5F73e1C48d28cd9', registrant: '0xb6E040C9ECAaE172a89bD561c5F73e1C48d28cd9', ownershipLevel: 'registrar }
  */
-const getOwner = generateFunction({ encode, decode }) as ((
+const getOwner = generateFunction({ encode, decode }) as (<
+  TContract extends OwnerContract | undefined = undefined,
+>(
   client: ClientWithEns,
-  { name, contract }: GetOwnerParameters,
-) => Promise<GetOwnerReturnType>) &
+  { name, contract }: GetOwnerParameters<TContract>,
+) => Promise<GetOwnerReturnType<TContract>>) &
   BatchableFunctionObject
 
 export default getOwner

package/src/functions/public/getPrice.ts

@@ -129,13 +129,14 @@ type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
  * @example
  * import { createPublicClient, http } from 'viem'
  * import { mainnet } from 'viem/chains'
- * import { addEnsContracts, getPrice } from '@ensdomains/ensjs'
+ * import { addEnsContracts } from '@ensdomains/ensjs'
+ * import { getPrice } from '@ensdomains/ensjs/public'
  *
  * const client = createPublicClient({
  *   chain: addEnsContracts(mainnet),
  *   transport: http(),
  * })
- * const result = await getPrice(client, { nameOrNames: 'ens.eth' })
+ * const result = await getPrice(client, { nameOrNames: 'ens.eth', duration: 31536000 })
  * // { base: 352828971668930335n, premium: 0n }
  */
 const getPrice = generateFunction({ encode, decode }) as ((

package/src/functions/public/getRecords.ts

@@ -5,6 +5,7 @@ import {
   decodeFunctionResult,
   encodeFunctionData,
   getContractError,
+  hexToBigInt,
   toHex,
   type Address,
   type Hex,
@@ -106,39 +107,55 @@ const encode = (
   client: ClientWithEns,
   { name, resolver, records }: GetRecordsParameters,
 ): TransactionRequestWithPassthrough => {
-  const calls: (CallObj | null)[] = []
-  if (records.texts) {
-    for (const key of records.texts) {
-      calls.push({
-        key,
-        call: _getText.encode(client, { name, key }),
-        type: 'text',
-      })
+  const calls = Object.keys(records).reduce((prev, key) => {
+    if (key === 'texts') {
+      return [
+        ...prev,
+        ...records.texts!.map(
+          (text) =>
+            ({
+              key: text,
+              call: _getText.encode(client, { name, key: text }),
+              type: 'text',
+            } as const),
+        ),
+      ]
     }
-  }
-  if (records.coins) {
-    for (const coin of records.coins) {
-      calls.push({
-        key: coin,
-        call: _getAddr.encode(client, { name, coin }),
-        type: 'coin',
-      })
+    if (key === 'coins') {
+      return [
+        ...prev,
+        ...records.coins!.map(
+          (coin) =>
+            ({
+              key: coin,
+              call: _getAddr.encode(client, { name, coin }),
+              type: 'coin',
+            } as const),
+        ),
+      ]
     }
-  }
-  if (records.contentHash) {
-    calls.push({
-      key: 'contentHash',
-      call: _getContentHash.encode(client, { name }),
-      type: 'contentHash',
-    })
-  }
-  if (records.abi) {
-    calls.push({
-      key: 'abi',
-      call: _getAbi.encode(client, { name }),
-      type: 'abi',
-    })
-  }
+    if (key === 'contentHash') {
+      return [
+        ...prev,
+        {
+          key: 'contentHash',
+          call: _getContentHash.encode(client, { name }),
+          type: 'contentHash',
+        } as const,
+      ]
+    }
+    if (key === 'abi') {
+      return [
+        ...prev,
+        {
+          key: 'abi',
+          call: _getAbi.encode(client, { name }),
+          type: 'abi',
+        } as const,
+      ]
+    }
+    return prev
+  }, [] as (CallObj | null)[])
 
   const passthrough = calls
 
@@ -174,7 +191,7 @@ const decode = async <TParams extends GetRecordsParameters>(
   client: ClientWithEns,
   data: Hex | BaseError,
   passthrough: (CallObj | null)[],
-  { name, resolver }: TParams,
+  { name, resolver, records: recordsParams }: TParams,
 ): Promise<GetRecordsReturnType<TParams>> => {
   const calls = passthrough
   let recordData: (Hex | null)[] = []
@@ -231,7 +248,7 @@ const decode = async <TParams extends GetRecordsParameters>(
           client,
           contract: 'ensUniversalResolver',
         }),
-      })
+      }) as BaseError
     }
     const result = decodeFunctionResult({
       abi: universalResolverResolveArraySnippet,
@@ -255,82 +272,84 @@ const decode = async <TParams extends GetRecordsParameters>(
   const filteredCalls = calls.filter((x) => x) as CallObj[]
   const filteredRecordData = recordData.filter((x) => x) as Hex[]
 
-  const returnedRecords: GetRecordsReturnType<GetRecordsParameters> =
-    await Promise.all(
-      filteredRecordData.map(async (item, i) => {
-        const { key, type } = filteredCalls[i]
-        const baseItem = { key, type }
-        if (type === 'contentHash') {
-          const decodedFromAbi = decodeAbiParameters(
-            [{ type: 'bytes' }] as const,
-            item,
-          )[0]
-          if (BigInt(decodedFromAbi) === 0n) {
-            return { ...baseItem, value: null }
-          }
+  const decodedRecords = await Promise.all(
+    filteredRecordData.map(async (item, i) => {
+      const { key, type } = filteredCalls[i]
+      const baseItem = { key, type }
+      if (type === 'contentHash') {
+        const decodedFromAbi = decodeAbiParameters(
+          [{ type: 'bytes' }] as const,
+          item,
+        )[0]
+        if (decodedFromAbi === '0x' || hexToBigInt(decodedFromAbi) === 0n) {
+          return { ...baseItem, value: null }
+        }
+      }
+      if (type === 'text') {
+        const decodedFromAbi = await _getText.decode(client, item)
+        return { ...baseItem, value: decodedFromAbi }
+      }
+      if (type === 'coin') {
+        const decodedFromAbi = await _getAddr.decode(client, item, {
+          name,
+          coin: key,
+        })
+        return { ...baseItem, value: decodedFromAbi }
+      }
+      if (type === 'contentHash') {
+        const decodedFromAbi = await _getContentHash.decode(client, item)
+        return { ...baseItem, value: decodedFromAbi }
+      }
+      // abi
+      const decodedFromAbi = await _getAbi.decode(client, item)
+      return { ...baseItem, value: decodedFromAbi }
+    }),
+  )
+
+  const records = decodedRecords.reduce(
+    (prev, curr) => {
+      if (curr.type === 'text' || curr.type === 'coin') {
+        if (!curr.value) {
+          return prev
         }
-        if (type === 'text') {
-          const decodedFromAbi = await _getText.decode(client, item)
-          return { ...baseItem, value: decodedFromAbi }
+      }
+      if (curr.type === 'text') {
+        return {
+          ...prev,
+          texts: [
+            ...(prev.texts || []),
+            { key: curr.key, value: curr.value } as DecodedText,
+          ],
         }
-        if (type === 'coin') {
-          const decodedFromAbi = await _getAddr.decode(client, item, {
-            name,
-            coin: key,
-          })
-          return { ...baseItem, value: decodedFromAbi }
+      }
+      if (curr.type === 'coin') {
+        return {
+          ...prev,
+          coins: [...(prev.coins || []), curr.value as DecodedAddr],
         }
-        if (type === 'contentHash') {
-          const decodedFromAbi = await _getContentHash.decode(client, item)
-          return { ...baseItem, value: decodedFromAbi }
+      }
+      if (curr.type === 'contentHash') {
+        return {
+          ...prev,
+          contentHash: curr.value as InternalGetContentHashReturnType,
         }
-        // abi
-        const decodedFromAbi = await _getAbi.decode(client, item)
-        return { ...baseItem, value: decodedFromAbi }
-      }),
-    ).then((results) =>
-      results.reduce(
-        (prev, curr) => {
-          if (curr.type === 'text' || curr.type === 'coin') {
-            if (!curr.value) {
-              return prev
-            }
-          }
-          if (curr.type === 'text') {
-            return {
-              ...prev,
-              texts: [
-                ...(prev.texts || []),
-                { key: curr.key, value: curr.value } as DecodedText,
-              ],
-            }
-          }
-          if (curr.type === 'coin') {
-            return {
-              ...prev,
-              coins: [...(prev.coins || []), curr.value as DecodedAddr],
-            }
-          }
-          if (curr.type === 'contentHash') {
-            return {
-              ...prev,
-              contentHash: curr.value as InternalGetContentHashReturnType,
-            }
-          }
-          // abi
-          return { ...prev, abi: curr.value as InternalGetAbiReturnType }
-        },
-        {
-          resolverAddress,
-        } as GetRecordsReturnType<
-          GetRecordsParameters & {
-            records: Required<GetRecordsParameters['records']>
-          }
-        >,
-      ),
-    )
+      }
+      // abi
+      return { ...prev, abi: curr.value as InternalGetAbiReturnType }
+    },
+    {
+      resolverAddress,
+      ...('texts' in recordsParams ? { texts: [] } : {}),
+      ...('coins' in recordsParams ? { coins: [] } : {}),
+      ...('contentHash' in recordsParams ? { contentHash: null } : {}),
+    } as GetRecordsReturnType<
+      GetRecordsParameters & {
+        records: Required<GetRecordsParameters['records']>
+      }
+    >,
+  )
 
-  return returnedRecords as GetRecordsReturnType<TParams>
+  return records as GetRecordsReturnType<TParams>
 }
 
 type EncoderFunction = typeof encode
@@ -357,7 +376,8 @@ type BatchableFunctionObject = {
  * @example
  * import { createPublicClient, http } from 'viem'
  * import { mainnet } from 'viem/chains'
- * import { addEnsContracts, getRecords } from '@ensdomains/ensjs'
+ * import { addEnsContracts } from '@ensdomains/ensjs'
+ * import { getRecords } from '@ensdomains/ensjs/public'
  *
  * const client = createPublicClient({
  *   chain: addEnsContracts(mainnet),

package/src/functions/public/getResolver.ts

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