@ensdomains/ensjs 3.0.0-beta.8 → 3.0.0-beta.9

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,7 +19,7 @@ import type {
 } from '../../types.js'
 import { EMPTY_ADDRESS } from '../../utils/consts.js'
 import { generateFunction } from '../../utils/generateFunction.js'
-import { normaliseCoinId } from '../../utils/normaliseCoinId.js'
+import { getCoderFromCoin } from '../../utils/normaliseCoinId.js'
 
 export type InternalGetAddrParameters = {
   /** Name to get the address record for */
@@ -32,11 +36,8 @@ const encode = (
   _client: ClientWithEns,
   { name, coin = 60, bypassFormat }: InternalGetAddrParameters,
 ): SimpleTransactionRequest => {
-  const normalisedCoin = normaliseCoinId(coin)
-  if (
-    (normalisedCoin.type === 'id' && normalisedCoin.value === 60) ||
-    (normalisedCoin.type === 'name' && normalisedCoin.value === 'ETH')
-  ) {
+  const coder = getCoderFromCoin(coin)
+  if (coder.coinType === 60) {
     return {
       to: EMPTY_ADDRESS,
       data: encodeFunctionData({
@@ -57,20 +58,13 @@ const encode = (
       }),
     }
   }
-  const formatter =
-    normalisedCoin.type === 'name'
-      ? formatsByName[normalisedCoin.value]
-      : formatsByCoinType[normalisedCoin.value]
-
-  if (!formatter)
-    throw new CoinFormatterNotFoundError({ coinType: normalisedCoin.value })
 
   return {
     to: EMPTY_ADDRESS,
     data: encodeFunctionData({
       abi: publicResolverMultiAddrSnippet,
       functionName: 'addr',
-      args: [namehash(name), BigInt(formatter.coinType)],
+      args: [namehash(name), BigInt(coder.coinType)],
     }),
   }
 }
@@ -82,19 +76,10 @@ const decode = async (
 ): Promise<InternalGetAddrReturnType> => {
   if (data === '0x') return null
 
-  const normalisedCoin = normaliseCoinId(coin)
-
-  const formatter =
-    normalisedCoin.type === 'name'
-      ? formatsByName[normalisedCoin.value]
-      : formatsByCoinType[normalisedCoin.value]
-
+  const coder = getCoderFromCoin(coin)
   let response: Hex
 
-  if (
-    (normalisedCoin.type === 'id' && normalisedCoin.value === 60) ||
-    (normalisedCoin.type === 'name' && normalisedCoin.value === 'ETH')
-  ) {
+  if (coder.coinType === 60) {
     response = decodeFunctionResult({
       abi: publicResolverSingleAddrSnippet,
       functionName: 'addr',
@@ -115,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/getName.ts

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

package/src/functions/public/getRecords.ts

@@ -248,7 +248,7 @@ const decode = async <TParams extends GetRecordsParameters>(
           client,
           contract: 'ensUniversalResolver',
         }),
-      })
+      }) as BaseError
     }
     const result = decodeFunctionResult({
       abi: universalResolverResolveArraySnippet,

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',

package/src/functions/public/getWrapperData.ts

@@ -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',

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',

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

@@ -1,5 +1,6 @@
-import { formatsByCoinType } from '@ensdomains/address-encoder'
+import { getCoderByCoinType } from '@ensdomains/address-encoder'
 import { gql } from 'graphql-request'
+import { hexToBytes } from 'viem'
 import type { ClientWithEns } from '../../contracts/consts.js'
 import { decodeContentHash } from '../../utils/contentHash.js'
 import { namehash } from '../../utils/normalise.js'
@@ -276,7 +277,7 @@ const getNameHistory = async (
         }
         case 'MulticoinAddrChanged': {
           const { multiaddr, ...event_ } = event
-          const format = formatsByCoinType[parseInt(event.coinType)]
+          const format = getCoderByCoinType(parseInt(event.coinType))
           if (!format) {
             return {
               ...event_,
@@ -297,7 +298,7 @@ const getNameHistory = async (
             ...event_,
             coinName: format.name,
             decoded: true,
-            addr: format.encoder(Buffer.from(multiaddr.slice(2), 'hex')),
+            addr: format.encode(hexToBytes(multiaddr)),
           }
         }
         case 'ContenthashChanged': {

package/src/types.ts

@@ -11,9 +11,12 @@ export type Prettify<T> = {
   [K in keyof T]: T[K]
 } & {}
 
-export type SimpleTransactionRequest = Prettify<
-  Required<Pick<TransactionRequest, 'to' | 'data'>>
->
+export type SimpleTransactionRequest = {
+  [P in keyof Pick<TransactionRequest, 'to' | 'data'>]-?: Exclude<
+    TransactionRequest[P],
+    null
+  >
+}
 
 export type TransactionRequestWithPassthrough = SimpleTransactionRequest & {
   passthrough?: any

package/src/utils/encoders/encodeSetAddr.ts

@@ -1,6 +1,6 @@
-import { formatsByCoinType, formatsByName } from '@ensdomains/address-encoder'
 import { bytesToHex, encodeFunctionData, type Address, type Hex } from 'viem'
 import { publicResolverSetAddrSnippet } from '../../contracts/publicResolver.js'
+import { getCoderFromCoin } from '../normaliseCoinId.js'
 
 export type EncodeSetAddrParameters = {
   namehash: Hex
@@ -15,22 +15,11 @@ export const encodeSetAddr = ({
   coin,
   value,
 }: EncodeSetAddrParameters): EncodeSetAddrReturnType => {
-  let coinTypeInstance
-  if (typeof coin === 'number') {
-    coinTypeInstance = formatsByCoinType[coin]
-  } else if (!Number.isNaN(parseInt(coin))) {
-    coinTypeInstance = formatsByCoinType[parseInt(coin)]
-  } else {
-    coinTypeInstance = formatsByName[coin.toUpperCase()]
-  }
-  const inputCoinType = coinTypeInstance.coinType
-  let encodedAddress: Hex | Uint8Array = value
-    ? coinTypeInstance.decoder(value)
-    : '0x'
+  const coder = getCoderFromCoin(coin)
+  const inputCoinType = coder.coinType
+  let encodedAddress: Hex | Uint8Array = value ? coder.decode(value) : '0x'
   if (inputCoinType === 60 && encodedAddress === '0x')
-    encodedAddress = coinTypeInstance.decoder(
-      '0x0000000000000000000000000000000000000000',
-    )
+    encodedAddress = coder.decode('0x0000000000000000000000000000000000000000')
   if (typeof encodedAddress !== 'string') {
     encodedAddress = bytesToHex(encodedAddress)
   }

package/src/utils/normaliseCoinId.ts

@@ -1,11 +1,36 @@
+import {
+  getCoderByCoinName,
+  getCoderByCoinType,
+  type Coin,
+} from '@ensdomains/address-encoder'
+import { CoinFormatterNotFoundError } from '../errors/public.js'
+
 export const normaliseCoinId = (coinId: string | number) => {
   const isString = typeof coinId === 'string'
 
   if (isString && Number.isNaN(parseInt(coinId))) {
-    return { type: 'name', value: coinId.toUpperCase() } as const
+    return {
+      type: 'name',
+      value: coinId.toLowerCase().replace(/legacy$/, 'Legacy'),
+    } as const
   }
   return {
     type: 'id',
     value: isString ? parseInt(coinId as string) : (coinId as number),
   } as const
 }
+
+export const getCoderFromCoin = (coinId: string | number): Coin => {
+  const normalisedCoin = normaliseCoinId(coinId)
+  let coder: Coin
+  try {
+    coder =
+      normalisedCoin.type === 'id'
+        ? getCoderByCoinType(normalisedCoin.value)
+        : getCoderByCoinName(normalisedCoin.value)
+  } catch {
+    throw new CoinFormatterNotFoundError({ coinType: coinId })
+  }
+
+  return coder
+}