viem 2.0.0-beta.6 → 2.0.0-beta.9

package/utils/abi/parseEventLogs.ts

@@ -0,0 +1,129 @@
+import type { Abi } from 'abitype'
+import type { ErrorType } from '../../errors/utils.js'
+import {
+  AbiEventSignatureNotFoundError,
+  DecodeLogDataMismatch,
+  DecodeLogTopicsMismatch,
+  type RpcLog,
+} from '../../index.js'
+import type { ContractEventName } from '../../types/contract.js'
+import type { Log } from '../../types/log.js'
+import {
+  type DecodeEventLogErrorType,
+  decodeEventLog,
+} from './decodeEventLog.js'
+
+export type ParseEventLogsParameters<
+  abi extends Abi | readonly unknown[] = Abi,
+  eventName extends
+    | ContractEventName<abi>
+    | ContractEventName<abi>[]
+    | undefined = ContractEventName<abi>,
+  strict extends boolean | undefined = boolean | undefined,
+> = {
+  /** Contract ABI. */
+  abi: abi
+  /** Contract event. */
+  eventName?:
+    | eventName
+    | ContractEventName<abi>
+    | ContractEventName<abi>[]
+    | undefined
+  /** List of logs. */
+  logs: (Log | RpcLog)[]
+  strict?: strict | boolean | undefined
+}
+
+export type ParseEventLogsReturnType<
+  abi extends Abi | readonly unknown[] = Abi,
+  eventName extends
+    | ContractEventName<abi>
+    | ContractEventName<abi>[]
+    | undefined = ContractEventName<abi>,
+  strict extends boolean | undefined = boolean | undefined,
+  ///
+  derivedEventName extends
+    | ContractEventName<abi>
+    | undefined = eventName extends ContractEventName<abi>[]
+    ? eventName[number]
+    : eventName,
+> = Log<bigint, number, false, undefined, strict, abi, derivedEventName>[]
+
+export type ParseEventLogsErrorType = DecodeEventLogErrorType | ErrorType
+
+/**
+ * Extracts & decodes logs matching the provided signature(s) (`abi` + optional `eventName`)
+ * from a set of opaque logs.
+ *
+ * @param parameters - {@link ParseEventLogsParameters}
+ * @returns The logs. {@link ParseEventLogsReturnType}
+ *
+ * @example
+ * import { createClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { parseEventLogs } from 'viem/op-stack'
+ *
+ * const client = createClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ *
+ * const receipt = await getTransactionReceipt(client, {
+ *   hash: '0xec23b2ba4bc59ba61554507c1b1bc91649e6586eb2dd00c728e8ed0db8bb37ea',
+ * })
+ *
+ * const logs = parseEventLogs({ logs: receipt.logs })
+ * // [{ args: { ... }, eventName: 'TransactionDeposited', ... }, ...]
+ */
+export function parseEventLogs<
+  abi extends Abi | readonly unknown[],
+  strict extends boolean | undefined = true,
+  eventName extends
+    | ContractEventName<abi>
+    | ContractEventName<abi>[]
+    | undefined = undefined,
+>({
+  abi,
+  eventName,
+  logs,
+  strict = true,
+}: ParseEventLogsParameters<abi, eventName, strict>): ParseEventLogsReturnType<
+  abi,
+  eventName,
+  strict
+> {
+  return logs
+    .map((log) => {
+      try {
+        const event = decodeEventLog({
+          ...log,
+          abi,
+          strict,
+        })
+        if (eventName && !eventName.includes(event.eventName!)) return null
+        return { ...event, ...log }
+      } catch (err) {
+        let eventName
+        let isUnnamed
+
+        if (err instanceof AbiEventSignatureNotFoundError) return null
+        if (
+          err instanceof DecodeLogDataMismatch ||
+          err instanceof DecodeLogTopicsMismatch
+        ) {
+          // If strict mode is on, and log data/topics do not match event definition, skip.
+          if (strict) return null
+          eventName = err.abiItem.name
+          isUnnamed = err.abiItem.inputs?.some((x) => !('name' in x && x.name))
+        }
+
+        // Set args to empty if there is an error decoding (e.g. indexed/non-indexed params mismatch).
+        return { ...log, args: isUnnamed ? [] : {}, eventName }
+      }
+    })
+    .filter(Boolean) as unknown as ParseEventLogsReturnType<
+    abi,
+    eventName,
+    strict
+  >
+}

package/utils/buildRequest.ts

@@ -51,35 +51,14 @@ import {
   type UserRejectedRequestErrorType,
 } from '../errors/rpc.js'
 import type { ErrorType } from '../errors/utils.js'
+import type {
+  EIP1193RequestFn,
+  EIP1193RequestOptions,
+} from '../types/eip1193.js'
 import type { CreateBatchSchedulerErrorType } from './promise/createBatchScheduler.js'
 import { type WithRetryErrorType, withRetry } from './promise/withRetry.js'
 import type { GetSocketErrorType } from './rpc.js'
 
-export type IsDeterministicErrorType = ErrorType
-
-export const isDeterministicError = (error: Error) => {
-  if ('code' in error)
-    return (
-      error.code !== -1 &&
-      error.code !== -32004 &&
-      error.code !== -32005 &&
-      error.code !== -32042 &&
-      error.code !== -32603
-    )
-  if (error instanceof HttpRequestError && error.status)
-    return (
-      error.status !== 403 &&
-      error.status !== 408 &&
-      error.status !== 413 &&
-      error.status !== 429 &&
-      error.status !== 500 &&
-      error.status !== 502 &&
-      error.status !== 503 &&
-      error.status !== 504
-    )
-  return false
-}
-
 export type RequestErrorType =
   | ChainDisconnectedErrorType
   | CreateBatchSchedulerErrorType
@@ -110,20 +89,16 @@ export type RequestErrorType =
   | WithRetryErrorType
   | ErrorType
 
-export function buildRequest<TRequest extends (args: any) => Promise<any>>(
-  request: TRequest,
-  {
-    retryDelay = 150,
-    retryCount = 3,
-  }: {
-    // The base delay (in ms) between retries.
-    retryDelay?: number
-    // The max number of times to retry.
-    retryCount?: number
-  } = {},
-) {
-  return (async (args: any) =>
-    withRetry(
+export function buildRequest<request extends (args: any) => Promise<any>>(
+  request: request,
+  options: EIP1193RequestOptions = {},
+): EIP1193RequestFn {
+  return async (args, overrideOptions = {}) => {
+    const { retryDelay = 150, retryCount = 3 } = {
+      ...options,
+      ...overrideOptions,
+    }
+    return withRetry(
       async () => {
         try {
           return await request(args)
@@ -208,7 +183,37 @@ export function buildRequest<TRequest extends (args: any) => Promise<any>>(
           return ~~(1 << count) * retryDelay
         },
         retryCount,
-        shouldRetry: ({ error }) => !isDeterministicError(error),
+        shouldRetry: ({ error }) => shouldRetry(error),
       },
-    )) as TRequest
+    )
+  }
+}
+
+export function shouldRetry(error: Error) {
+  if ('code' in error && typeof error.code === 'number') {
+    if (error.code === -1) return true // Unknown error
+    if (error.code === LimitExceededRpcError.code) return true
+    if (error.code === InternalRpcError.code) return true
+    return false
+  }
+  if (error instanceof HttpRequestError && error.status) {
+    // Forbidden
+    if (error.status === 403) return true
+    // Request Timeout
+    if (error.status === 408) return true
+    // Request Entity Too Large
+    if (error.status === 413) return true
+    // Too Many Requests
+    if (error.status === 429) return true
+    // Internal Server Error
+    if (error.status === 500) return true
+    // Bad Gateway
+    if (error.status === 502) return true
+    // Service Unavailable
+    if (error.status === 503) return true
+    // Gateway Timeout
+    if (error.status === 504) return true
+    return false
+  }
+  return true
 }

package/utils/ccip.ts

@@ -112,8 +112,7 @@ export async function ccipFetch({
 
   for (let i = 0; i < urls.length; i++) {
     const url = urls[i]
-    const method =
-      url.includes('{sender}') || url.includes('{data}') ? 'GET' : 'POST'
+    const method = url.includes('{data}') ? 'GET' : 'POST'
     const body = method === 'POST' ? { data, sender } : undefined
 
     try {
@@ -137,7 +136,9 @@ export async function ccipFetch({
       if (!response.ok) {
         error = new HttpRequestError({
           body,
-          details: stringify(result.error) || response.statusText,
+          details: result?.error
+            ? stringify(result.error)
+            : response.statusText,
           headers: response.headers,
           status: response.status,
           url,

package/utils/encoding/fromBytes.ts

@@ -27,14 +27,14 @@ export type FromBytesParameters<
 export type FromBytesReturnType<TTo> = TTo extends 'string'
   ? string
   : TTo extends 'hex'
-  ? Hex
-  : TTo extends 'bigint'
-  ? bigint
-  : TTo extends 'number'
-  ? number
-  : TTo extends 'boolean'
-  ? boolean
-  : never
+    ? Hex
+    : TTo extends 'bigint'
+      ? bigint
+      : TTo extends 'number'
+        ? number
+        : TTo extends 'boolean'
+          ? boolean
+          : never
 
 export type FromBytesErrorType =
   | BytesToHexErrorType

package/utils/encoding/fromHex.ts

@@ -41,14 +41,14 @@ export type FromHexParameters<
 export type FromHexReturnType<TTo> = TTo extends 'string'
   ? string
   : TTo extends 'bigint'
-  ? bigint
-  : TTo extends 'number'
-  ? number
-  : TTo extends 'bytes'
-  ? ByteArray
-  : TTo extends 'boolean'
-  ? boolean
-  : never
+    ? bigint
+    : TTo extends 'number'
+      ? number
+      : TTo extends 'bytes'
+        ? ByteArray
+        : TTo extends 'boolean'
+          ? boolean
+          : never
 
 export type FromHexErrorType =
   | HexToNumberErrorType

package/utils/encoding/toBytes.ts

@@ -114,9 +114,9 @@ const charCodeMap = {
 function charCodeToBase16(char: number) {
   if (char >= charCodeMap.zero && char <= charCodeMap.nine)
     return char - charCodeMap.zero
-  else if (char >= charCodeMap.A && char <= charCodeMap.F)
+  if (char >= charCodeMap.A && char <= charCodeMap.F)
     return char - (charCodeMap.A - 10)
-  else if (char >= charCodeMap.a && char <= charCodeMap.f)
+  if (char >= charCodeMap.a && char <= charCodeMap.f)
     return char - (charCodeMap.a - 10)
   return undefined
 }

package/utils/encoding/toRlp.ts

@@ -88,7 +88,9 @@ function getEncodableList(list: Encodable[]): Encodable {
         else if (sizeOfBodyLength === 3) cursor.pushUint24(bodyLength)
         else cursor.pushUint32(bodyLength)
       }
-      list.forEach((x) => x.encode(cursor))
+      for (const { encode } of list) {
+        encode(cursor)
+      }
     },
   }
 }

package/utils/ens/avatar/utils.ts

@@ -117,7 +117,9 @@ export function resolveAvatarUri({
       isOnChain: false,
       isEncoded: false,
     }
-  } else if (protocol === 'ar:/' && target) {
+  }
+
+  if (protocol === 'ar:/' && target) {
     return {
       uri: `${arweaveGateway}/${target}${subtarget || ''}`,
       isOnChain: false,

package/utils/ens/namehash.ts

@@ -28,7 +28,7 @@ export type NamehashErrorType =
  * - Since ENS names prohibit certain forbidden characters (e.g. underscore) and have other validation rules, you likely want to [normalize ENS names](https://docs.ens.domains/contract-api-reference/name-processing#normalising-names) with [UTS-46 normalization](https://unicode.org/reports/tr46) before passing them to `namehash`. You can use the built-in [`normalize`](https://viem.sh/docs/ens/utilities/normalize.html) function for this.
  *
  * @example
- * namehash('wagmi-dev.eth')
+ * namehash('wevm.eth')
  * '0xf246651c1b9a6b141d19c2604e9a58f567973833990f830d882534a747801359'
  *
  * @link https://eips.ethereum.org/EIPS/eip-137

package/utils/ens/normalize.ts

@@ -7,8 +7,8 @@ export type NormalizeErrorType = ErrorType
  * @description Normalizes ENS name according to ENSIP-15.
  *
  * @example
- * normalize('wagmi-dev.eth')
- * 'wagmi-dev.eth'
+ * normalize('wevm.eth')
+ * 'wevm.eth'
  *
  * @see https://docs.ens.domains/contract-api-reference/name-processing#normalising-names
  * @see https://github.com/ensdomains/docs/blob/9edf9443de4333a0ea7ec658a870672d5d180d53/ens-improvement-proposals/ensip-15-normalization-standard.md

package/utils/errors/getContractError.ts

@@ -48,8 +48,8 @@ export function getContractError<err extends ErrorType<string>>(
     err instanceof RawContractError
       ? err
       : err instanceof BaseError
-      ? err.walk((err) => 'data' in (err as Error)) || err.walk()
-      : {}
+        ? err.walk((err) => 'data' in (err as Error)) || err.walk()
+        : {}
   ) as RawContractError
 
   const cause = (() => {

package/utils/errors/getNodeError.ts

@@ -73,36 +73,37 @@ export function getNodeError(
       cause: err,
       message: executionRevertedError.details,
     }) as any
-  } else if (ExecutionRevertedError.nodeMessage.test(message))
+  }
+  if (ExecutionRevertedError.nodeMessage.test(message))
     return new ExecutionRevertedError({
       cause: err,
       message: err.details,
     }) as any
-  else if (FeeCapTooHighError.nodeMessage.test(message))
+  if (FeeCapTooHighError.nodeMessage.test(message))
     return new FeeCapTooHighError({
       cause: err,
       maxFeePerGas: args?.maxFeePerGas,
     }) as any
-  else if (FeeCapTooLowError.nodeMessage.test(message))
+  if (FeeCapTooLowError.nodeMessage.test(message))
     return new FeeCapTooLowError({
       cause: err,
       maxFeePerGas: args?.maxFeePerGas,
     }) as any
-  else if (NonceTooHighError.nodeMessage.test(message))
+  if (NonceTooHighError.nodeMessage.test(message))
     return new NonceTooHighError({ cause: err, nonce: args?.nonce }) as any
-  else if (NonceTooLowError.nodeMessage.test(message))
+  if (NonceTooLowError.nodeMessage.test(message))
     return new NonceTooLowError({ cause: err, nonce: args?.nonce }) as any
-  else if (NonceMaxValueError.nodeMessage.test(message))
+  if (NonceMaxValueError.nodeMessage.test(message))
     return new NonceMaxValueError({ cause: err, nonce: args?.nonce }) as any
-  else if (InsufficientFundsError.nodeMessage.test(message))
+  if (InsufficientFundsError.nodeMessage.test(message))
     return new InsufficientFundsError({ cause: err }) as any
-  else if (IntrinsicGasTooHighError.nodeMessage.test(message))
+  if (IntrinsicGasTooHighError.nodeMessage.test(message))
     return new IntrinsicGasTooHighError({ cause: err, gas: args?.gas }) as any
-  else if (IntrinsicGasTooLowError.nodeMessage.test(message))
+  if (IntrinsicGasTooLowError.nodeMessage.test(message))
     return new IntrinsicGasTooLowError({ cause: err, gas: args?.gas }) as any
-  else if (TransactionTypeNotSupportedError.nodeMessage.test(message))
+  if (TransactionTypeNotSupportedError.nodeMessage.test(message))
     return new TransactionTypeNotSupportedError({ cause: err }) as any
-  else if (TipAboveFeeCapError.nodeMessage.test(message))
+  if (TipAboveFeeCapError.nodeMessage.test(message))
     return new TipAboveFeeCapError({
       cause: err,
       maxFeePerGas: args?.maxFeePerGas,

package/utils/formatters/block.ts

@@ -15,9 +15,7 @@ import { type FormattedTransaction, formatTransaction } from './transaction.js'
 type BlockPendingDependencies = 'hash' | 'logsBloom' | 'nonce' | 'number'
 
 export type FormattedBlock<
-  TChain extends { formatters?: Chain['formatters'] } | undefined =
-    | { formatters?: Chain['formatters'] }
-    | undefined,
+  TChain extends Chain | undefined = undefined,
   TIncludeTransactions extends boolean = boolean,
   TBlockTag extends BlockTag = BlockTag,
   _FormatterReturnType = ExtractChainFormatterReturnType<
@@ -28,7 +26,7 @@ export type FormattedBlock<
   _ExcludedPendingDependencies extends string = BlockPendingDependencies &
     ExtractChainFormatterExclude<TChain, 'block'>,
   _Formatted = Omit<_FormatterReturnType, BlockPendingDependencies> & {
-    [K in _ExcludedPendingDependencies]: never
+    [_key in _ExcludedPendingDependencies]: never
   } & Pick<
       Block<bigint, TIncludeTransactions, TBlockTag>,
       BlockPendingDependencies

package/utils/formatters/formatter.ts

@@ -31,7 +31,7 @@ export function defineFormatter<TType extends string, TParameters, TReturnType>(
           ...formatted,
           ...overrides(args),
         } as Prettify<Assign<TReturnType, TOverrideReturnType>> & {
-          [K in TExclude[number]]: never
+          [_key in TExclude[number]]: never
         }
       },
       type,

package/utils/formatters/transaction.ts

@@ -17,9 +17,7 @@ type TransactionPendingDependencies =
   | 'transactionIndex'
 
 export type FormattedTransaction<
-  TChain extends { formatters?: Chain['formatters'] } | undefined =
-    | { formatters?: Chain['formatters'] }
-    | undefined,
+  TChain extends Chain | undefined = undefined,
   TBlockTag extends BlockTag = BlockTag,
   _FormatterReturnType = ExtractChainFormatterReturnType<
     TChain,
@@ -29,7 +27,7 @@ export type FormattedTransaction<
   _ExcludedPendingDependencies extends string = TransactionPendingDependencies &
     ExtractChainFormatterExclude<TChain, 'transaction'>,
 > = UnionLooseOmit<_FormatterReturnType, TransactionPendingDependencies> & {
-  [K in _ExcludedPendingDependencies]: never
+  [_K in _ExcludedPendingDependencies]: never
 } & Pick<
     Transaction<bigint, number, TBlockTag extends 'pending' ? true : false>,
     TransactionPendingDependencies

package/utils/formatters/transactionReceipt.ts

@@ -12,7 +12,7 @@ import { formatLog } from './log.js'
 import { transactionType } from './transaction.js'
 
 export type FormattedTransactionReceipt<
-  TChain extends Chain | undefined = Chain | undefined,
+  TChain extends Chain | undefined = undefined,
 > = ExtractChainFormatterReturnType<
   TChain,
   'transactionReceipt',

package/utils/getAction.ts

@@ -1,13 +1,23 @@
 import type { Client } from '../clients/createClient.js'
 
+/**
+ * Retrieves and returns an action from the client (if exists), and falls
+ * back to the tree-shakable action.
+ *
+ * Useful for extracting overridden actions from a client (ie. if a consumer
+ * wants to override the `sendTransaction` implementation).
+ */
 export function getAction<params extends {}, returnType extends {}>(
   client: Client,
   action: (_: any, params: params) => returnType,
+  // Some minifiers drop `Function.prototype.name`, meaning that `action.name`
+  // will not work. For that case, the consumer needs to pass the name explicitly.
+  name: string,
 ) {
   return (params: params): returnType =>
     (
       client as Client & {
         [key: string]: (params: params) => returnType
       }
-    )[action.name]?.(params) ?? action(client, params)
+    )[action.name || name]?.(params) ?? action(client, params)
 }

package/utils/index.ts

@@ -1,7 +1,5 @@
 export {
-  type IsDeterministicErrorType,
   type RequestErrorType,
-  isDeterministicError,
   buildRequest,
 } from './buildRequest.js'
 
@@ -113,6 +111,12 @@ export {
   type EncodeFunctionResultParameters,
   encodeFunctionResult,
 } from './abi/encodeFunctionResult.js'
+export {
+  type ParseEventLogsErrorType,
+  type ParseEventLogsParameters,
+  type ParseEventLogsReturnType,
+  parseEventLogs,
+} from './abi/parseEventLogs.js'
 export {
   type GetAbiItemErrorType,
   type GetAbiItemParameters,

package/utils/observe.ts

@@ -61,7 +61,7 @@ export function observe<TCallbacks extends Callbacks>(
     ) => {
       const listeners = getListeners()
       if (listeners.length === 0) return
-      listeners.forEach((listener) => listener.fns[key]?.(...args))
+      for (const listener of listeners) listener.fns[key]?.(...args)
     }) as TCallbacks[Extract<keyof TCallbacks, string>]
   }
 

package/utils/promise/createBatchScheduler.ts

@@ -66,12 +66,16 @@ export function createBatchScheduler<
     fn(args as TParameters[])
       .then((data) => {
         if (sort && Array.isArray(data)) data.sort(sort)
-        scheduler.forEach(({ pendingPromise }, i) =>
-          pendingPromise.resolve?.([data[i], data]),
-        )
+        for (let i = 0; i < scheduler.length; i++) {
+          const { pendingPromise } = scheduler[i]
+          pendingPromise.resolve?.([data[i], data])
+        }
       })
       .catch((err) => {
-        scheduler.forEach(({ pendingPromise }) => pendingPromise.reject?.(err))
+        for (let i = 0; i < scheduler.length; i++) {
+          const { pendingPromise } = scheduler[i]
+          pendingPromise.reject?.(err)
+        }
       })
   }
 

package/utils/transaction/getSerializedTransactionType.ts

@@ -16,8 +16,8 @@ export type GetSerializedTransactionType<
 > = TTransactionSerialized extends TransactionSerializedEIP1559
   ? 'eip1559'
   : TTransactionSerialized extends TransactionSerializedEIP2930
-  ? 'eip2930'
-  : 'legacy'
+    ? 'eip2930'
+    : 'legacy'
 
 export type GetSerializedTransactionTypeErrorType =
   | HexToNumberErrorType

package/utils/transaction/getTransactionType.ts

@@ -12,7 +12,8 @@ import type {
 } from '../../types/transaction.js'
 
 export type GetTransactionType<
-  TTransactionSerializable extends TransactionSerializable = TransactionSerializable,
+  TTransactionSerializable extends
+    TransactionSerializable = TransactionSerializable,
 > =
   | (TTransactionSerializable extends TransactionSerializableLegacy
       ? 'legacy'

package/utils/transaction/serializeTransaction.ts

@@ -39,12 +39,15 @@ import {
 } from './serializeAccessList.js'
 
 export type SerializedTransactionReturnType<
-  TTransactionSerializable extends TransactionSerializable = TransactionSerializable,
-  TTransactionType extends TransactionType = GetTransactionType<TTransactionSerializable>,
+  TTransactionSerializable extends
+    TransactionSerializable = TransactionSerializable,
+  TTransactionType extends
+    TransactionType = GetTransactionType<TTransactionSerializable>,
 > = TransactionSerialized<TTransactionType>
 
 export type SerializeTransactionFn<
-  TTransactionSerializable extends TransactionSerializable = TransactionSerializable,
+  TTransactionSerializable extends
+    TransactionSerializable = TransactionSerializable,
 > = typeof serializeTransaction<TTransactionSerializable>
 
 export type SerializeTransactionErrorType =

package/utils/unit/formatEther.ts

@@ -4,6 +4,17 @@ import { type FormatUnitsErrorType, formatUnits } from './formatUnits.js'
 
 export type FormatEtherErrorType = FormatUnitsErrorType
 
+/**
+ * Converts numerical wei to a string representation of ether.
+ *
+ * - Docs: https://viem.sh/docs/utilities/formatEther.html
+ *
+ * @example
+ * import { formatEther } from 'viem'
+ *
+ * formatEther(1000000000000000000n)
+ * // '1'
+ */
 export function formatEther(wei: bigint, unit: 'wei' | 'gwei' = 'wei') {
   return formatUnits(wei, etherUnits[unit])
 }

package/utils/unit/formatGwei.ts

@@ -4,6 +4,17 @@ import { type FormatUnitsErrorType, formatUnits } from './formatUnits.js'
 
 export type FormatGweiErrorType = FormatUnitsErrorType
 
+/**
+ * Converts numerical wei to a string representation of gwei.
+ *
+ * - Docs: https://viem.sh/docs/utilities/formatGwei.html
+ *
+ * @example
+ * import { formatGwei } from 'viem'
+ *
+ * formatGwei(1000000000n)
+ * // '1'
+ */
 export function formatGwei(wei: bigint, unit: 'wei' = 'wei') {
   return formatUnits(wei, gweiUnits[unit])
 }