viem 2.42.0 → 2.43.0

package/utils/abi/parseEventLogs.ts

@@ -1,11 +1,6 @@
 // TODO(v3): checksum address.
 
 import type { Abi, AbiEvent, AbiEventParameter, Address } from 'abitype'
-import {
-  AbiEventSignatureNotFoundError,
-  DecodeLogDataMismatch,
-  DecodeLogTopicsMismatch,
-} from '../../errors/abi.js'
 import type { ErrorType } from '../../errors/utils.js'
 import type { ContractEventName, GetEventArgs } from '../../types/contract.js'
 import type { Log } from '../../types/log.js'
@@ -115,52 +110,74 @@ export function parseEventLogs<
 
   return logs
     .map((log) => {
-      try {
-        const abiItem = (abi as Abi).find(
-          (abiItem) =>
-            abiItem.type === 'event' &&
-            log.topics[0] === toEventSelector(abiItem),
-        ) as AbiEvent
-        if (!abiItem) return null
-
-        const event = decodeEventLog({
-          ...log,
-          abi: [abiItem],
-          strict,
-        })
-
-        // Check that the decoded event name matches the provided event name.
-        if (eventName && !eventName.includes(event.eventName)) return null
-
-        // Check that the decoded event args match the provided args.
-        if (
-          !includesArgs({
-            args: event.args,
-            inputs: abiItem.inputs,
-            matchArgs: args,
+      // Find all matching ABI items with the same selector.
+      // Multiple events can share the same selector but differ in indexed parameters
+      // (e.g., ERC20 vs ERC721 Transfer events).
+      const abiItems = (abi as Abi).filter(
+        (abiItem) =>
+          abiItem.type === 'event' &&
+          log.topics[0] === toEventSelector(abiItem),
+      ) as AbiEvent[]
+      if (abiItems.length === 0) return null
+
+      // Try each matching ABI item until one successfully decodes.
+      let event: { eventName: string; args: unknown } | undefined
+      let abiItem: AbiEvent | undefined
+
+      for (const item of abiItems) {
+        try {
+          event = decodeEventLog({
+            ...log,
+            abi: [item],
+            strict: true,
           })
-        )
-          return null
-
-        return { ...event, ...log }
-      } catch (err) {
-        let eventName: string | undefined
-        let isUnnamed: boolean | undefined
-
-        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))
+          abiItem = item
+          break
+        } catch {
+          // Try next ABI item
         }
+      }
 
-        // Set args to empty if there is an error decoding (e.g. indexed/non-indexed params mismatch).
-        return { ...log, args: isUnnamed ? [] : {}, eventName }
+      // If strict decoding failed for all, and we're in non-strict mode,
+      // fall back to the first matching ABI item.
+      if (!event && !strict) {
+        abiItem = abiItems[0]
+        try {
+          event = decodeEventLog({
+            ...log,
+            abi: [abiItem],
+            strict: false,
+          })
+        } catch {
+          // If decoding still fails, return partial log in non-strict mode.
+          const isUnnamed = abiItem.inputs?.some(
+            (x) => !('name' in x && x.name),
+          )
+          return {
+            ...log,
+            args: isUnnamed ? [] : {},
+            eventName: abiItem.name,
+          }
+        }
       }
+
+      // If no event was found, return null.
+      if (!event || !abiItem) return null
+
+      // Check that the decoded event name matches the provided event name.
+      if (eventName && !eventName.includes(event.eventName)) return null
+
+      // Check that the decoded event args match the provided args.
+      if (
+        !includesArgs({
+          args: event.args,
+          inputs: abiItem.inputs,
+          matchArgs: args,
+        })
+      )
+        return null
+
+      return { ...event, ...log }
     })
     .filter(Boolean) as unknown as ParseEventLogsReturnType<
     abi,

package/utils/chain/defineChain.ts

@@ -1,14 +1,44 @@
 import type { Chain, ChainFormatters } from '../../types/chain.js'
 import type { Assign, Prettify } from '../../types/utils.js'
 
+export type DefineChainReturnType<chain extends Chain = Chain> = Prettify<
+  chain &
+    (chain['extendSchema'] extends Record<string, unknown>
+      ? {
+          extend: <const extended extends chain['extendSchema']>(
+            extended: extended,
+          ) => Assign<chain, extended>
+        }
+      : {})
+>
+
 export function defineChain<
   formatters extends ChainFormatters,
   const chain extends Chain<formatters>,
->(chain: chain): Prettify<Assign<Chain<undefined>, chain>> {
-  return {
+>(chain: chain): DefineChainReturnType<Assign<Chain<undefined>, chain>> {
+  const chainInstance = {
     formatters: undefined,
     fees: undefined,
     serializers: undefined,
     ...chain,
   } as Assign<Chain<undefined>, chain>
+
+  function extend(base: typeof chainInstance) {
+    type ExtendFn = (base: typeof chainInstance) => unknown
+    return (fnOrExtended: ExtendFn | Record<string, unknown>) => {
+      const properties = (
+        typeof fnOrExtended === 'function' ? fnOrExtended(base) : fnOrExtended
+      ) as (typeof chainInstance)['extendSchema']
+      const combined = { ...base, ...properties }
+      return Object.assign(combined, { extend: extend(combined) })
+    }
+  }
+
+  return Object.assign(chainInstance, {
+    extend: extend(chainInstance),
+  }) as never
+}
+
+export function extendSchema<schema extends Record<string, unknown>>(): schema {
+  return {} as schema
 }

package/utils/cursor.ts

@@ -233,7 +233,7 @@ export function createCursor(
   const cursor: Cursor = Object.create(staticCursor)
   cursor.bytes = bytes
   cursor.dataView = new DataView(
-    bytes.buffer,
+    bytes.buffer ?? bytes,
     bytes.byteOffset,
     bytes.byteLength,
   )

package/utils/formatters/log.ts

@@ -16,6 +16,11 @@ export function formatLog(
     ...log,
     blockHash: log.blockHash ? log.blockHash : null,
     blockNumber: log.blockNumber ? BigInt(log.blockNumber) : null,
+    blockTimestamp: log.blockTimestamp
+      ? BigInt(log.blockTimestamp)
+      : log.blockTimestamp === null
+        ? null
+        : undefined,
     logIndex: log.logIndex ? Number(log.logIndex) : null,
     transactionHash: log.transactionHash ? log.transactionHash : null,
     transactionIndex: log.transactionIndex

package/utils/formatters/transaction.ts

@@ -111,9 +111,8 @@ export function formatTransaction(
     delete transaction_.maxFeePerGas
     delete transaction_.maxPriorityFeePerGas
   }
-  if (transaction_.type === 'eip1559') {
-    delete transaction_.maxFeePerBlobGas
-  }
+  if (transaction_.type === 'eip1559') delete transaction_.maxFeePerBlobGas
+
   return transaction_
 }
 

package/utils/rpc/socket.ts

@@ -247,13 +247,14 @@ export async function getSocketRpcClient<socket extends {}>(
                 body,
               })
 
-            // If we are unsubscribing from a topic, we want to remove the listener.
-            if (body.method === 'eth_unsubscribe')
-              subscriptions.delete(body.params?.[0])
-
             onResponse(response)
           }
 
+          // If we are unsubscribing from a topic, remove the listener immediately
+          // to prevent it from being re-subscribed on reconnect.
+          if (body.method === 'eth_unsubscribe')
+            subscriptions.delete(body.params?.[0])
+
           requests.set(id, { onResponse: callback, onError })
           try {
             socket.request({