viem 2.0.0-beta.0 → 2.0.0-beta.10

package/types/filter.ts

@@ -42,18 +42,18 @@ export type Filter<
             strict: TStrict
           }
         : TArgs extends MaybeExtractEventArgsFromAbi<TAbi, TEventName>
-        ? {
-            abi: TAbi
-            args: TArgs
-            eventName: TEventName
-            strict: TStrict
-          }
-        : {
-            abi: TAbi
-            args?: never
-            eventName: TEventName
-            strict: TStrict
-          }
+          ? {
+              abi: TAbi
+              args: TArgs
+              eventName: TEventName
+              strict: TStrict
+            }
+          : {
+              abi: TAbi
+              args?: never
+              eventName: TEventName
+              strict: TStrict
+            }
       : {
           abi?: never
           args?: never

package/types/log.ts

@@ -75,10 +75,10 @@ type GetTopics<
 > = true extends _FailedToParseArgs
   ? [Hex, ...Hex[]] | []
   : TAbiEvent extends AbiEvent
-  ? Topics<TAbiEvent['inputs']>
-  : _AbiEvent extends AbiEvent
-  ? Topics<_AbiEvent['inputs']>
-  : [Hex, ...Hex[]] | []
+    ? Topics<TAbiEvent['inputs']>
+    : _AbiEvent extends AbiEvent
+      ? Topics<_AbiEvent['inputs']>
+      : [Hex, ...Hex[]] | []
 
 type GetInferredLogValues<
   TAbiEvent extends AbiEvent | undefined = undefined,

package/types/multicall.ts

@@ -20,21 +20,7 @@ export type MulticallContracts<
 > = contracts extends readonly [] // no contracts, return empty
   ? readonly []
   : contracts extends readonly [infer contract] // one contract left before returning `result`
-  ? readonly [
-      ...result,
-      MaybePartial<
-        Prettify<
-          GetMulticallContractParameters<contract, options['mutability']> &
-            options['properties']
-        >,
-        options['optional']
-      >,
-    ]
-  : contracts extends readonly [infer contract, ...infer rest] // grab first contract and recurse through `rest`
-  ? MulticallContracts<
-      [...rest],
-      options,
-      [
+    ? readonly [
         ...result,
         MaybePartial<
           Prettify<
@@ -44,21 +30,39 @@ export type MulticallContracts<
           options['optional']
         >,
       ]
-    >
-  : readonly unknown[] extends contracts
-  ? contracts
-  : // If `contracts` is *some* array but we couldn't assign `unknown[]` to it, then it must hold some known/homogenous type!
-  // use this to infer the param types in the case of Array.map() argument
-  contracts extends readonly (infer contract extends ContractFunctionParameters)[]
-  ? readonly MaybePartial<
-      Prettify<contract & options['properties']>,
-      options['optional']
-    >[]
-  : // Fallback
-    readonly MaybePartial<
-      Prettify<ContractFunctionParameters & options['properties']>,
-      options['optional']
-    >[]
+    : contracts extends readonly [infer contract, ...infer rest] // grab first contract and recurse through `rest`
+      ? MulticallContracts<
+          [...rest],
+          options,
+          [
+            ...result,
+            MaybePartial<
+              Prettify<
+                GetMulticallContractParameters<
+                  contract,
+                  options['mutability']
+                > &
+                  options['properties']
+              >,
+              options['optional']
+            >,
+          ]
+        >
+      : readonly unknown[] extends contracts
+        ? contracts
+        : // If `contracts` is *some* array but we couldn't assign `unknown[]` to it, then it must hold some known/homogenous type!
+          // use this to infer the param types in the case of Array.map() argument
+          contracts extends readonly (infer contract extends
+              ContractFunctionParameters)[]
+          ? readonly MaybePartial<
+              Prettify<contract & options['properties']>,
+              options['optional']
+            >[]
+          : // Fallback
+            readonly MaybePartial<
+              Prettify<ContractFunctionParameters & options['properties']>,
+              options['optional']
+            >[]
 
 export type MulticallResults<
   contracts extends readonly unknown[] = readonly ContractFunctionParameters[],
@@ -72,20 +76,7 @@ export type MulticallResults<
 > = contracts extends readonly [] // no contracts, return empty
   ? readonly []
   : contracts extends readonly [infer contract] // one contract left before returning `result`
-  ? [
-      ...result,
-      MulticallResponse<
-        GetMulticallContractReturnType<contract, options['mutability']>,
-        options['error'],
-        allowFailure
-      >,
-    ]
-  : contracts extends readonly [infer contract, ...infer rest] // grab first contract and recurse through `rest`
-  ? MulticallResults<
-      [...rest],
-      allowFailure,
-      options,
-      [
+    ? [
         ...result,
         MulticallResponse<
           GetMulticallContractReturnType<contract, options['mutability']>,
@@ -93,19 +84,33 @@ export type MulticallResults<
           allowFailure
         >,
       ]
-    >
-  : readonly unknown[] extends contracts
-  ? MulticallResponse<unknown, options['error'], allowFailure>[]
-  : // If `contracts` is *some* array but we couldn't assign `unknown[]` to it, then it must hold some known/homogenous type!
-  // use this to infer the param types in the case of Array.map() argument
-  contracts extends readonly (infer contract extends ContractFunctionParameters)[]
-  ? MulticallResponse<
-      GetMulticallContractReturnType<contract, options['mutability']>,
-      options['error'],
-      allowFailure
-    >[]
-  : // Fallback
-    MulticallResponse<unknown, options['error'], allowFailure>[]
+    : contracts extends readonly [infer contract, ...infer rest] // grab first contract and recurse through `rest`
+      ? MulticallResults<
+          [...rest],
+          allowFailure,
+          options,
+          [
+            ...result,
+            MulticallResponse<
+              GetMulticallContractReturnType<contract, options['mutability']>,
+              options['error'],
+              allowFailure
+            >,
+          ]
+        >
+      : readonly unknown[] extends contracts
+        ? MulticallResponse<unknown, options['error'], allowFailure>[]
+        : // If `contracts` is *some* array but we couldn't assign `unknown[]` to it, then it must hold some known/homogenous type!
+          // use this to infer the param types in the case of Array.map() argument
+          contracts extends readonly (infer contract extends
+              ContractFunctionParameters)[]
+          ? MulticallResponse<
+              GetMulticallContractReturnType<contract, options['mutability']>,
+              options['error'],
+              allowFailure
+            >[]
+          : // Fallback
+            MulticallResponse<unknown, options['error'], allowFailure>[]
 
 export type MulticallResponse<
   result = unknown,
@@ -144,10 +149,10 @@ type GetMulticallContractParameters<
       ? ContractFunctionParameters<abi, mutability, functionName, args> // `args` valid, pass through
       : ContractFunctionParameters<abi, mutability, functionName> // invalid `args`
     : // 1b. `functionName` is invalid, check if `abi` is declared as `Abi`
-    Abi extends abi
-    ? ContractFunctionParameters // `abi` declared as `Abi`, unable to infer types further
-    : // `abi` is const-asserted or defined inline, infer types for `functionName` and `args`
-      ContractFunctionParameters<abi, mutability>
+      Abi extends abi
+      ? ContractFunctionParameters // `abi` declared as `Abi`, unable to infer types further
+      : // `abi` is const-asserted or defined inline, infer types for `functionName` and `args`
+        ContractFunctionParameters<abi, mutability>
   : ContractFunctionParameters<readonly unknown[]> // invalid `contract['abi']`, set to `readonly unknown[]`
 
 type GetMulticallContractReturnType<

package/types/rpc.ts

@@ -17,7 +17,7 @@ import type {
   TransactionRequestEIP2930,
   TransactionRequestLegacy,
 } from './transaction.js'
-import type { UnionOmit } from './utils.js'
+import type { UnionOmit, UnionPartialBy } from './utils.js'
 
 export type Index = `0x${string}`
 export type Quantity = `0x${string}`
@@ -47,8 +47,13 @@ export type RpcTransactionRequest =
   | TransactionRequestEIP2930<Quantity, Index, '0x1'>
   | TransactionRequestEIP1559<Quantity, Index, '0x2'>
 export type RpcTransaction<TPending extends boolean = boolean> = UnionOmit<
-  | TransactionLegacy<Quantity, Index, TPending, '0x0'>
-  | TransactionEIP2930<Quantity, Index, TPending, '0x1'>
-  | TransactionEIP1559<Quantity, Index, TPending, '0x2'>,
+  UnionPartialBy<
+    | TransactionLegacy<Quantity, Index, TPending, '0x0'>
+    | TransactionEIP2930<Quantity, Index, TPending, '0x1'>
+    | TransactionEIP1559<Quantity, Index, TPending, '0x2'>,
+    // `yParity` is optional on the RPC type as some nodes do not return it
+    // for 1559 & 2930 transactions (they should!).
+    'yParity'
+  >,
   'typeHex'
 >

package/types/transaction.ts

@@ -80,16 +80,21 @@ export type TransactionBase<
   v: TQuantity
   /** Value in wei sent with this transaction */
   value: TQuantity
+  /** The parity of the y-value of the secp256k1 signature. */
+  yParity: TIndex
 }
 export type TransactionLegacy<
   TQuantity = bigint,
   TIndex = number,
   TPending extends boolean = boolean,
   TType = 'legacy',
-> = TransactionBase<TQuantity, TIndex, TPending> &
+> = Omit<TransactionBase<TQuantity, TIndex, TPending>, 'yParity'> &
   FeeValuesLegacy<TQuantity> & {
+    /** EIP-2930 Access List. */
     accessList?: never
+    /** Chain ID that this transaction is valid on. */
     chainId?: TIndex
+    yParity?: never
     type: TType
   }
 export type TransactionEIP2930<
@@ -99,7 +104,9 @@ export type TransactionEIP2930<
   TType = 'eip2930',
 > = TransactionBase<TQuantity, TIndex, TPending> &
   FeeValuesLegacy<TQuantity> & {
+    /** EIP-2930 Access List. */
     accessList: AccessList
+    /** Chain ID that this transaction is valid on. */
     chainId: TIndex
     type: TType
   }
@@ -110,7 +117,9 @@ export type TransactionEIP1559<
   TType = 'eip1559',
 > = TransactionBase<TQuantity, TIndex, TPending> &
   FeeValuesEIP1559<TQuantity> & {
+    /** EIP-2930 Access List. */
     accessList: AccessList
+    /** Chain ID that this transaction is valid on. */
     chainId: TIndex
     type: TType
   }
@@ -177,10 +186,10 @@ export type TransactionSerialized<TType extends TransactionType = 'legacy'> =
   TType extends 'eip1559'
     ? TransactionSerializedEIP1559
     : TType extends 'eip2930'
-    ? TransactionSerializedEIP2930
-    : TType extends 'legacy'
-    ? TransactionSerializedLegacy
-    : TransactionSerializedGeneric
+      ? TransactionSerializedEIP2930
+      : TType extends 'legacy'
+        ? TransactionSerializedLegacy
+        : TransactionSerializedGeneric
 
 export type TransactionSerializableBase<
   TQuantity = bigint,

package/types/utils.ts

@@ -97,12 +97,11 @@ export type MaybeRequired<T, TRequired extends boolean> = TRequired extends true
  */
 export type Assign<T, U> = Assign_<T, U> & U
 type Assign_<T, U> = {
-  [K in
-    keyof T as K extends keyof U
-      ? U[K] extends void
-        ? never
-        : K
-      : K]: K extends keyof U ? U[K] : T[K]
+  [K in keyof T as K extends keyof U
+    ? U[K] extends void
+      ? never
+      : K
+    : K]: K extends keyof U ? U[K] : T[K]
 }
 
 /**
@@ -130,6 +129,15 @@ export type Omit<type, keys extends keyof type> = Pick<
   Exclude<keyof type, keys>
 >
 
+/**
+ * @description Creates a type that is a partial of T, but with the required keys K.
+ *
+ * @example
+ * PartialBy<{ a: string, b: number }, 'a'>
+ * => { a?: string, b: number }
+ */
+export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>
+
 /**
  * @description Combines members of an intersection into a readable type.
  *
@@ -142,6 +150,15 @@ export type Prettify<T> = {
   [K in keyof T]: T[K]
 } & {}
 
+/**
+ * @description Creates a type that is T with the required keys K.
+ *
+ * @example
+ * RequiredBy<{ a?: string, b: number }, 'a'>
+ * => { a: string, b: number }
+ */
+export type RequiredBy<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>
+
 /**
  * @description Creates a type that extracts the values of T.
  *
@@ -189,7 +206,7 @@ export type OneOf<
   ///
   keys extends KeyofUnion<union> = KeyofUnion<union>,
 > = union extends infer Item
-  ? Prettify<Item & { [K in Exclude<keys, keyof Item>]?: undefined }>
+  ? Prettify<Item & { [_K in Exclude<keys, keyof Item>]?: undefined }>
   : never
 type KeyofUnion<type> = type extends type ? keyof type : never
 
@@ -220,3 +237,25 @@ export type UnionLooseOmit<type, keys extends string> = type extends any
 export type UnionOmit<type, keys extends keyof type> = type extends any
   ? Omit<type, keys>
   : never
+
+/**
+ * @description Creates a type that is a partial of T, but with the required keys K.
+ *
+ * @example
+ * PartialBy<{ a: string, b: number } | { a: string, b: undefined, c: number }, 'a'>
+ * => { a?: string, b: number } | { a?: string, b: undefined, c: number }
+ */
+export type UnionPartialBy<T, K extends keyof T> = T extends any
+  ? PartialBy<T, K>
+  : never
+
+/**
+ * @description Creates a type that is T with the required keys K.
+ *
+ * @example
+ * RequiredBy<{ a?: string, b: number } | { a?: string, c?: number }, 'a'>
+ * => { a: string, b: number } | { a: string, c?: number }
+ */
+export type UnionRequiredBy<T, K extends keyof T> = T extends any
+  ? RequiredBy<T, K>
+  : never

package/utils/abi/decodeEventLog.ts

@@ -56,7 +56,8 @@ export type DecodeEventLogReturnType<
   data extends Hex | undefined = undefined,
   strict extends boolean = true,
   ///
-  allEventNames extends ContractEventName<abi> = eventName extends ContractEventName<abi>
+  allEventNames extends
+    ContractEventName<abi> = eventName extends ContractEventName<abi>
     ? eventName
     : ContractEventName<abi>,
 > = IsNarrowable<abi, Abi> extends true

package/utils/abi/decodeFunctionData.ts

@@ -29,7 +29,8 @@ export type DecodeFunctionDataParameters<
 export type DecodeFunctionDataReturnType<
   abi extends Abi | readonly unknown[] = Abi,
   ///
-  allFunctionNames extends ContractFunctionName<abi> = ContractFunctionName<abi>,
+  allFunctionNames extends
+    ContractFunctionName<abi> = ContractFunctionName<abi>,
 > = IsNarrowable<abi, Abi> extends true
   ? UnionEvaluate<
       {

package/utils/abi/decodeFunctionResult.ts

@@ -47,8 +47,8 @@ export type DecodeFunctionResultParameters<
     ? Abi extends abi
       ? true
       : [ExtractAbiFunctions<abi>] extends [never]
-      ? false
-      : true
+        ? false
+        : true
     : true,
   allArgs = ContractFunctionArgs<
     abi,

package/utils/abi/encodeDeployData.ts

@@ -24,8 +24,8 @@ export type EncodeDeployDataParameters<
     ? Abi extends abi
       ? true
       : [Extract<abi[number], { type: 'constructor' }>] extends [never]
-      ? false
-      : true
+        ? false
+        : true
     : true,
   allArgs = ContractConstructorArgs<abi>,
 > = {

package/utils/abi/encodeErrorResult.ts

@@ -34,8 +34,8 @@ export type EncodeErrorResultParameters<
     ? Abi extends abi
       ? true
       : [ExtractAbiErrors<abi>] extends [never]
-      ? false
-      : true
+        ? false
+        : true
     : true,
   allArgs = ContractErrorArgs<
     abi,

package/utils/abi/encodeEventTopics.ts

@@ -44,8 +44,8 @@ export type EncodeEventTopicsParameters<
     ? Abi extends abi
       ? true
       : [ExtractAbiEvents<abi>] extends [never]
-      ? false
-      : true
+        ? false
+        : true
     : true,
   allArgs = ContractEventArgs<
     abi,
@@ -101,8 +101,8 @@ export function encodeEventTopics<
     const args_ = Array.isArray(args)
       ? args
       : Object.values(args).length > 0
-      ? indexedInputs?.map((x: any) => (args as any)[x.name]) ?? []
-      : []
+        ? indexedInputs?.map((x: any) => (args as any)[x.name]) ?? []
+        : []
 
     if (args_.length > 0) {
       topics =
@@ -112,8 +112,8 @@ export function encodeEventTopics<
                 encodeArg({ param, value: args_[i][j] }),
               )
             : args_[i]
-            ? encodeArg({ param, value: args_[i] })
-            : null,
+              ? encodeArg({ param, value: args_[i] })
+              : null,
         ) ?? []
     }
   }

package/utils/abi/encodeFunctionData.ts

@@ -36,8 +36,8 @@ export type EncodeFunctionDataParameters<
     ? Abi extends abi
       ? true
       : [ExtractAbiFunctions<abi>] extends [never]
-      ? false
-      : true
+        ? false
+        : true
     : true,
   allArgs = ContractFunctionArgs<
     abi,

package/utils/abi/encodeFunctionResult.ts

@@ -30,8 +30,8 @@ export type EncodeFunctionResultParameters<
     ? Abi extends abi
       ? true
       : [ExtractAbiFunctions<abi>] extends [never]
-      ? false
-      : true
+        ? false
+        : true
     : true,
   allFunctionNames = ContractFunctionName<abi>,
 > = {

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