@ensdomains/ensjs 3.0.0-beta.8 → 3.0.0

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

@@ -86,8 +86,8 @@ export const encodeAbi = async <
     }
     case 'cbor': {
       contentType = 4
-      const { encode } = await import('cbor')
-      encodedData = bytesToHex(encode(data))
+      const { cborEncode } = await import('@ensdomains/address-encoder/utils')
+      encodedData = bytesToHex(new Uint8Array(cborEncode(data)))
       break
     }
     default: {

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

@@ -1,5 +1,6 @@
 import { type Hex } from 'viem'
 import type { Prettify } from '../types.js'
+import type { EncodedAbi } from './encoders/encodeAbi.js'
 import { encodeClearRecords } from './encoders/encodeClearRecords.js'
 import {
   encodeSetAbi,
@@ -19,13 +20,13 @@ export type RecordOptions = Prettify<{
   /** Clears all current records */
   clearRecords?: boolean
   /** ContentHash value */
-  contentHash?: string
+  contentHash?: string | null
   /** Array of text records */
   texts?: Omit<EncodeSetTextParameters, 'namehash'>[]
   /** Array of coin records */
   coins?: Omit<EncodeSetAddrParameters, 'namehash'>[]
   /** ABI value */
-  abi?: Omit<EncodeSetAbiParameters, 'namehash'>
+  abi?: EncodedAbi | null
 }>
 
 export const generateRecordCallArray = ({
@@ -42,13 +43,14 @@ export const generateRecordCallArray = ({
     calls.push(encodeClearRecords(namehash))
   }
 
-  if (typeof contentHash === 'string') {
+  if (contentHash !== undefined) {
     const data = encodeSetContentHash({ namehash, contentHash })
     if (data) calls.push(data)
   }
 
-  if (abi) {
-    const data = encodeSetAbi({ namehash, ...abi } as EncodeSetAbiParameters)
+  if (abi !== undefined) {
+    const abi_ = abi ?? { contentType: 0, encodedData: null }
+    const data = encodeSetAbi({ namehash, ...abi_ } as EncodeSetAbiParameters)
     if (data) calls.push(data)
   }
 

package/src/utils/getRevertErrorData.ts

@@ -3,5 +3,7 @@ import { BaseError, RawContractError } from 'viem'
 export const getRevertErrorData = (err: unknown) => {
   if (!(err instanceof BaseError)) return undefined
   const error = err.walk() as RawContractError
-  return typeof error.data === 'object' ? error.data.data : error.data
+  const hex = typeof error.data === 'object' ? error.data.data : error.data
+  if (hex === '0x') return undefined
+  return hex
 }

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
+}