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

package/src/functions/public/_getAddr.ts

@@ -1,5 +1,10 @@
-import { formatsByCoinType, formatsByName } from '@ensdomains/address-encoder'
-import { decodeFunctionResult, encodeFunctionData, trim, type Hex } from 'viem'
+import {
+  decodeFunctionResult,
+  encodeFunctionData,
+  hexToBytes,
+  trim,
+  type Hex,
+} from 'viem'
 import { namehash } from '../../utils/normalise.js'
 
 import type { ClientWithEns } from '../../contracts/consts.js'
@@ -7,7 +12,6 @@ import {
   publicResolverMultiAddrSnippet,
   publicResolverSingleAddrSnippet,
 } from '../../contracts/publicResolver.js'
-import { CoinFormatterNotFoundError } from '../../errors/public.js'
 import type {
   DecodedAddr,
   Prettify,
@@ -15,6 +19,7 @@ import type {
 } from '../../types.js'
 import { EMPTY_ADDRESS } from '../../utils/consts.js'
 import { generateFunction } from '../../utils/generateFunction.js'
+import { getCoderFromCoin } from '../../utils/normaliseCoinId.js'
 
 export type InternalGetAddrParameters = {
   /** Name to get the address record for */
@@ -31,7 +36,8 @@ const encode = (
   _client: ClientWithEns,
   { name, coin = 60, bypassFormat }: InternalGetAddrParameters,
 ): SimpleTransactionRequest => {
-  if (coin === 60 || coin === '60') {
+  const coder = getCoderFromCoin(coin)
+  if (coder.coinType === 60) {
     return {
       to: EMPTY_ADDRESS,
       data: encodeFunctionData({
@@ -52,19 +58,13 @@ const encode = (
       }),
     }
   }
-  const formatter =
-    typeof coin === 'string' && Number.isNaN(parseInt(coin))
-      ? formatsByName[coin]
-      : formatsByCoinType[typeof coin === 'number' ? coin : parseInt(coin)]
-
-  if (!formatter) throw new CoinFormatterNotFoundError({ coinType: coin })
 
   return {
     to: EMPTY_ADDRESS,
     data: encodeFunctionData({
       abi: publicResolverMultiAddrSnippet,
       functionName: 'addr',
-      args: [namehash(name), BigInt(formatter.coinType)],
+      args: [namehash(name), BigInt(coder.coinType)],
     }),
   }
 }
@@ -72,21 +72,14 @@ const encode = (
 const decode = async (
   _client: ClientWithEns,
   data: Hex,
-  { coin }: InternalGetAddrParameters,
+  { coin = 60 }: InternalGetAddrParameters,
 ): Promise<InternalGetAddrReturnType> => {
   if (data === '0x') return null
-  if (!coin) {
-    coin = 60
-  }
-
-  const formatter =
-    typeof coin === 'string' && Number.isNaN(parseInt(coin))
-      ? formatsByName[coin]
-      : formatsByCoinType[typeof coin === 'number' ? coin : parseInt(coin)]
 
+  const coder = getCoderFromCoin(coin)
   let response: Hex
 
-  if (coin === 60 || coin === '60') {
+  if (coder.coinType === 60) {
     response = decodeFunctionResult({
       abi: publicResolverSingleAddrSnippet,
       functionName: 'addr',
@@ -107,13 +100,13 @@ const decode = async (
     return null
   }
 
-  const decodedAddr = formatter.encoder(Buffer.from(response.slice(2), 'hex'))
+  const decodedAddr = coder.encode(hexToBytes(response))
 
   if (!decodedAddr) {
     return null
   }
 
-  return { id: formatter.coinType, name: formatter.name, value: decodedAddr }
+  return { id: coder.coinType, name: coder.name, value: decodedAddr }
 }
 
 const _getAddr = generateFunction({ encode, decode })

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/batch.ts

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

package/src/functions/public/getAbiRecord.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, getAbiRecord } from '@ensdomains/ensjs'
+ * import { addEnsContracts } from '@ensdomains/ensjs'
+ * import { getAbiRecord } from '@ensdomains/ensjs/public'
  *
  * const client = createPublicClient({
  *   chain: addEnsContracts(mainnet),

package/src/functions/public/getAddressRecord.ts

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

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 ((