viem 1.19.1 → 1.19.3

package/utils/formatters/transaction.ts

@@ -29,7 +29,7 @@ export type FormattedTransaction<
   _ExcludedPendingDependencies extends string = TransactionPendingDependencies &
     ExtractChainFormatterExclude<TChain, 'transaction'>,
 > = UnionOmit<_FormatterReturnType, TransactionPendingDependencies> & {
-  [K in _ExcludedPendingDependencies]: never
+  [_key in _ExcludedPendingDependencies]: never
 } & Pick<
     Transaction<bigint, number, TBlockTag extends 'pending' ? true : false>,
     TransactionPendingDependencies

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