viem 0.0.0-portable-types-20230522163654 → 0.0.0-refactor-generics-20230831161903

package/src/actions/public/watchEvent.ts

@@ -1,6 +1,6 @@
-import type { AbiEvent, Address } from 'abitype'
+import type { Abi, AbiEvent, Address } from 'abitype'
 
-import type { PublicClient } from '../../clients/createPublicClient.js'
+import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import type { Chain } from '../../types/chain.js'
 import type {
@@ -9,60 +9,135 @@ import type {
 } from '../../types/contract.js'
 import type { Filter } from '../../types/filter.js'
 import type { Log } from '../../types/log.js'
+import type { LogTopic } from '../../types/misc.js'
+import type { GetTransportConfig } from '../../types/transport.js'
+import type { EncodeEventTopicsParameters } from '../../utils/index.js'
 import { observe } from '../../utils/observe.js'
 import { poll } from '../../utils/poll.js'
 import { stringify } from '../../utils/stringify.js'
 
+import {
+  DecodeLogDataMismatch,
+  DecodeLogTopicsMismatch,
+} from '../../errors/abi.js'
+import { InvalidInputRpcError } from '../../errors/rpc.js'
+import {
+  decodeEventLog,
+  encodeEventTopics,
+  formatLog,
+} from '../../utils/index.js'
 import {
   type CreateEventFilterParameters,
   createEventFilter,
 } from './createEventFilter.js'
 import { getBlockNumber } from './getBlockNumber.js'
 import { getFilterChanges } from './getFilterChanges.js'
-import { getLogs } from './getLogs.js'
+import { type GetLogsParameters, getLogs } from './getLogs.js'
 import { uninstallFilter } from './uninstallFilter.js'
 
-export type OnLogsParameter<
+type PollOptions = {
+  /**
+   * Whether or not the transaction hashes should be batched on each invocation.
+   * @default true
+   */
+  batch?: boolean
+  /**
+   * Polling frequency (in ms). Defaults to Client's pollingInterval config.
+   * @default client.pollingInterval
+   */
+  pollingInterval?: number
+}
+
+export type WatchEventOnLogsParameter<
   TAbiEvent extends AbiEvent | undefined = undefined,
+  TAbiEvents extends
+    | readonly AbiEvent[]
+    | readonly unknown[]
+    | undefined = TAbiEvent extends AbiEvent ? [TAbiEvent] : undefined,
+  TStrict extends boolean | undefined = undefined,
   TEventName extends string | undefined = MaybeAbiEventName<TAbiEvent>,
-> = Log<bigint, number, TAbiEvent, [TAbiEvent], TEventName>[]
-export type OnLogsFn<
+> = Log<bigint, number, false, TAbiEvent, TStrict, TAbiEvents, TEventName>[]
+export type WatchEventOnLogsFn<
   TAbiEvent extends AbiEvent | undefined = undefined,
-  TEventName extends string | undefined = MaybeAbiEventName<TAbiEvent>,
-> = (logs: OnLogsParameter<TAbiEvent, TEventName>) => void
+  TAbiEvents extends
+    | readonly AbiEvent[]
+    | readonly unknown[]
+    | undefined = TAbiEvent extends AbiEvent ? [TAbiEvent] : undefined,
+  TStrict extends boolean | undefined = undefined,
+  _EventName extends string | undefined = MaybeAbiEventName<TAbiEvent>,
+> = (
+  logs: WatchEventOnLogsParameter<TAbiEvent, TAbiEvents, TStrict, _EventName>,
+) => void
 
 export type WatchEventParameters<
   TAbiEvent extends AbiEvent | undefined = undefined,
-  TEventName extends string | undefined = MaybeAbiEventName<TAbiEvent>,
+  TAbiEvents extends
+    | readonly AbiEvent[]
+    | readonly unknown[]
+    | undefined = TAbiEvent extends AbiEvent ? [TAbiEvent] : undefined,
+  TStrict extends boolean | undefined = undefined,
+  _EventName extends string | undefined = MaybeAbiEventName<TAbiEvent>,
 > = {
   /** The address of the contract. */
   address?: Address | Address[]
-  /**
-   * Whether or not the event logs should be batched on each invocation.
-   * @default true
-   */
-  batch?: boolean
   /** The callback to call when an error occurred when trying to get for a new block. */
   onError?: (error: Error) => void
   /** The callback to call when new event logs are received. */
-  onLogs: OnLogsFn<TAbiEvent, TEventName>
-  /** Polling frequency (in ms). Defaults to Client's pollingInterval config. */
-  pollingInterval?: number
-} & (
-  | {
-      event: TAbiEvent
-      args?: MaybeExtractEventArgsFromAbi<[TAbiEvent], TEventName>
-    }
-  | {
-      event?: never
-      args?: never
-    }
-)
+  onLogs: WatchEventOnLogsFn<TAbiEvent, TAbiEvents, TStrict, _EventName>
+} & (GetTransportConfig<Transport>['type'] extends 'webSocket'
+  ?
+      | {
+          batch?: never
+          /**
+           * Whether or not the WebSocket Transport should poll the JSON-RPC, rather than using `eth_subscribe`.
+           * @default false
+           */
+          poll?: false
+          pollingInterval?: never
+        }
+      | (PollOptions & {
+          /**
+           * Whether or not the WebSocket Transport should poll the JSON-RPC, rather than using `eth_subscribe`.
+           * @default true
+           */
+          poll?: true
+        })
+  : PollOptions & {
+      poll?: true
+    }) &
+  (
+    | {
+        event: TAbiEvent
+        events?: never
+        args?: MaybeExtractEventArgsFromAbi<TAbiEvents, _EventName>
+        /**
+         * Whether or not the logs must match the indexed/non-indexed arguments on `event`.
+         * @default false
+         */
+        strict?: TStrict
+      }
+    | {
+        event?: never
+        events?: TAbiEvents
+        args?: never
+        /**
+         * Whether or not the logs must match the indexed/non-indexed arguments on `event`.
+         * @default false
+         */
+        strict?: TStrict
+      }
+    | {
+        event?: never
+        events?: never
+        args?: never
+        strict?: never
+      }
+  )
 
 export type WatchEventReturnType = () => void
 
 /**
- * Watches and returns emitted [Event Logs](https://viem.sh/docs/glossary/terms#event-log).
+ * Watches and returns emitted [Event Logs](https://viem.sh/docs/glossary/terms.html#event-log).
  *
  * - Docs: https://viem.sh/docs/actions/public/watchEvent.html
  * - JSON-RPC Methods:
@@ -74,7 +149,7 @@ export type WatchEventReturnType = () => void
  *
  * This Action will batch up all the Event Logs found within the [`pollingInterval`](https://viem.sh/docs/actions/public/watchEvent.html#pollinginterval-optional), and invoke them via [`onLogs`](https://viem.sh/docs/actions/public/watchEvent.html#onLogs).
  *
- * `watchEvent` will attempt to create an [Event Filter](https://viem.sh/docs/actions/public/createEventFilter.html) and listen to changes to the Filter per polling interval, however, if the RPC Provider does not support Filters (e.g. `eth_newFilter`), then `watchEvent` will fall back to using [`getLogs`](https://viem.sh/docs/actions/public/getLogs) instead.
+ * `watchEvent` will attempt to create an [Event Filter](https://viem.sh/docs/actions/public/createEventFilter.html) and listen to changes to the Filter per polling interval, however, if the RPC Provider does not support Filters (e.g. `eth_newFilter`), then `watchEvent` will fall back to using [`getLogs`](https://viem.sh/docs/actions/public/getLogs.html) instead.
  *
  * @param client - Client to use
  * @param parameters - {@link WatchEventParameters}
@@ -95,97 +170,193 @@ export type WatchEventReturnType = () => void
  */
 export function watchEvent<
   TChain extends Chain | undefined,
-  TAbiEvent extends AbiEvent | undefined,
-  TEventName extends string | undefined,
+  const TAbiEvent extends AbiEvent | undefined = undefined,
+  const TAbiEvents extends
+    | readonly AbiEvent[]
+    | readonly unknown[]
+    | undefined = TAbiEvent extends AbiEvent ? [TAbiEvent] : undefined,
+  TStrict extends boolean | undefined = undefined,
+  _EventName extends string | undefined = undefined,
 >(
-  client: PublicClient<Transport, TChain>,
+  client: Client<Transport, TChain>,
   {
     address,
     args,
     batch = true,
     event,
+    events,
     onError,
     onLogs,
+    poll: poll_,
     pollingInterval = client.pollingInterval,
-  }: WatchEventParameters<TAbiEvent>,
+    strict: strict_,
+  }: WatchEventParameters<TAbiEvent, TAbiEvents, TStrict>,
 ): WatchEventReturnType {
-  const observerId = stringify([
-    'watchEvent',
-    address,
-    args,
-    batch,
-    client.uid,
-    event,
-    pollingInterval,
-  ])
+  const enablePolling =
+    typeof poll_ !== 'undefined' ? poll_ : client.transport.type !== 'webSocket'
+  const strict = strict_ ?? false
 
-  return observe(observerId, { onLogs, onError }, (emit) => {
-    let previousBlockNumber: bigint
-    let filter: Filter<'event', [TAbiEvent], TEventName, any>
-    let initialized = false
+  const pollEvent = () => {
+    const observerId = stringify([
+      'watchEvent',
+      address,
+      args,
+      batch,
+      client.uid,
+      event,
+      pollingInterval,
+    ])
 
-    const unwatch = poll(
-      async () => {
-        if (!initialized) {
-          try {
-            filter = (await createEventFilter(client, {
-              address,
-              args,
-              event: event!,
-            } as unknown as CreateEventFilterParameters)) as unknown as Filter<
-              'event',
-              [TAbiEvent],
-              TEventName
-            >
-          } catch {}
-          initialized = true
-          return
-        }
+    return observe(observerId, { onLogs, onError }, (emit) => {
+      let previousBlockNumber: bigint
+      let filter: Filter<'event', TAbiEvents, _EventName, any>
+      let initialized = false
 
-        try {
-          let logs: Log[]
-          if (filter) {
-            logs = await getFilterChanges(client, { filter })
-          } else {
-            // If the filter doesn't exist, we will fall back to use `getLogs`.
-            // The fall back exists because some RPC Providers do not support filters.
-
-            // Fetch the block number to use for `getLogs`.
-            const blockNumber = await getBlockNumber(client)
-
-            // If the block number has changed, we will need to fetch the logs.
-            // If the block number doesn't exist, we are yet to reach the first poll interval,
-            // so do not emit any logs.
-            if (previousBlockNumber && previousBlockNumber !== blockNumber) {
-              logs = await getLogs(client, {
+      const unwatch = poll(
+        async () => {
+          if (!initialized) {
+            try {
+              filter = (await createEventFilter(client, {
                 address,
                 args,
-                fromBlock: previousBlockNumber + 1n,
-                toBlock: blockNumber,
                 event: event!,
-              })
+                events,
+                strict,
+              } as unknown as CreateEventFilterParameters)) as unknown as Filter<
+                'event',
+                TAbiEvents,
+                _EventName
+              >
+            } catch {}
+            initialized = true
+            return
+          }
+
+          try {
+            let logs: Log[]
+            if (filter) {
+              logs = await getFilterChanges(client, { filter })
             } else {
-              logs = []
+              // If the filter doesn't exist, we will fall back to use `getLogs`.
+              // The fall back exists because some RPC Providers do not support filters.
+
+              // Fetch the block number to use for `getLogs`.
+              const blockNumber = await getBlockNumber(client)
+
+              // If the block number has changed, we will need to fetch the logs.
+              // If the block number doesn't exist, we are yet to reach the first poll interval,
+              // so do not emit any logs.
+              if (previousBlockNumber && previousBlockNumber !== blockNumber) {
+                logs = await getLogs(client, {
+                  address,
+                  args,
+                  event: event!,
+                  events,
+                  fromBlock: previousBlockNumber + 1n,
+                  toBlock: blockNumber,
+                } as unknown as GetLogsParameters)
+              } else {
+                logs = []
+              }
+              previousBlockNumber = blockNumber
             }
-            previousBlockNumber = blockNumber
+
+            if (logs.length === 0) return
+            if (batch) emit.onLogs(logs as any)
+            else logs.forEach((log) => emit.onLogs([log] as any))
+          } catch (err) {
+            // If a filter has been set and gets uninstalled, providers will throw an InvalidInput error.
+            // Reinitalize the filter when this occurs
+            if (filter && err instanceof InvalidInputRpcError)
+              initialized = false
+            emit.onError?.(err as Error)
           }
+        },
+        {
+          emitOnBegin: true,
+          interval: pollingInterval,
+        },
+      )
 
-          if (logs.length === 0) return
-          if (batch) emit.onLogs(logs as any)
-          else logs.forEach((log) => emit.onLogs([log] as any))
-        } catch (err) {
-          emit.onError?.(err as Error)
+      return async () => {
+        if (filter) await uninstallFilter(client, { filter })
+        unwatch()
+      }
+    })
+  }
+
+  const subscribeEvent = () => {
+    let active = true
+    let unsubscribe = () => (active = false)
+    ;(async () => {
+      try {
+        const events_ = events ?? (event ? [event] : undefined)
+        let topics: LogTopic[] = []
+        if (events_) {
+          topics = [
+            (events_ as AbiEvent[]).flatMap((event) =>
+              encodeEventTopics({
+                abi: [event],
+                eventName: (event as AbiEvent).name,
+                args,
+              } as EncodeEventTopicsParameters),
+            ),
+          ]
+          if (event) topics = topics[0] as LogTopic[]
         }
-      },
-      {
-        emitOnBegin: true,
-        interval: pollingInterval,
-      },
-    )
-
-    return async () => {
-      if (filter) await uninstallFilter(client, { filter })
-      unwatch()
-    }
-  })
+
+        const { unsubscribe: unsubscribe_ } = await client.transport.subscribe({
+          params: ['logs', { address, topics }],
+          onData(data: any) {
+            if (!active) return
+            const log = data.result
+            try {
+              const { eventName, args } = decodeEventLog({
+                abi: events_ as Abi,
+                data: log.data,
+                topics: log.topics as any,
+                strict,
+              })
+              const formatted = formatLog(log, {
+                args,
+                eventName: eventName as string,
+              })
+              onLogs([formatted] as any)
+            } catch (err) {
+              let eventName
+              let isUnnamed
+              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
+                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).
+              const formatted = formatLog(log, {
+                args: isUnnamed ? [] : {},
+                eventName,
+              })
+              onLogs([formatted] as any)
+            }
+          },
+          onError(error: Error) {
+            onError?.(error)
+          },
+        })
+        unsubscribe = unsubscribe_
+        if (!active) unsubscribe()
+      } catch (err) {
+        onError?.(err as Error)
+      }
+    })()
+    return unsubscribe
+  }
+
+  return enablePolling ? pollEvent() : subscribeEvent()
 }

package/src/actions/public/watchPendingTransactions.ts

@@ -1,4 +1,4 @@
-import type { PublicClient } from '../../clients/createPublicClient.js'
+import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import type { Chain } from '../../types/chain.js'
 import type { Filter } from '../../types/filter.js'
@@ -92,7 +92,7 @@ export function watchPendingTransactions<
   TTransport extends Transport,
   TChain extends Chain | undefined,
 >(
-  client: PublicClient<TTransport, TChain>,
+  client: Client<TTransport, TChain>,
   {
     batch = true,
     onError,

package/src/actions/test/dropTransaction.ts

@@ -3,6 +3,7 @@ import type {
   TestClientMode,
 } from '../../clients/createTestClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
+import type { Account } from '../../types/account.js'
 import type { Chain } from '../../types/chain.js'
 import type { Hash } from '../../types/misc.js'
 
@@ -33,8 +34,11 @@ export type DropTransactionParameters = {
  *   hash: '0xe58dceb6b20b03965bb678e27d141e151d7d4efc2334c2d6a49b9fac523f7364'
  * })
  */
-export async function dropTransaction<TChain extends Chain | undefined>(
-  client: TestClient<TestClientMode, Transport, TChain>,
+export async function dropTransaction<
+  TChain extends Chain | undefined,
+  TAccount extends Account | undefined,
+>(
+  client: TestClient<TestClientMode, Transport, TChain, TAccount, false>,
   { hash }: DropTransactionParameters,
 ) {
   await client.request({

package/src/actions/test/getAutomine.ts

@@ -3,6 +3,7 @@ import type {
   TestClientMode,
 } from '../../clients/createTestClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
+import type { Account } from '../../types/account.js'
 import type { Chain } from '../../types/chain.js'
 
 export type GetAutomineReturnType = boolean
@@ -27,9 +28,16 @@ export type GetAutomineReturnType = boolean
  * })
  * const isAutomining = await getAutomine(client)
  */
-export async function getAutomine<TChain extends Chain | undefined>(
-  client: TestClient<TestClientMode, Transport, TChain>,
+export async function getAutomine<
+  TChain extends Chain | undefined,
+  TAccount extends Account | undefined,
+>(
+  client: TestClient<TestClientMode, Transport, TChain, TAccount, false>,
 ): Promise<GetAutomineReturnType> {
+  if (client.mode === 'ganache')
+    return await client.request({
+      method: 'eth_mining',
+    })
   return await client.request({
     method: `${client.mode}_getAutomine`,
   })

package/src/actions/test/getTxpoolContent.ts

@@ -5,6 +5,7 @@ import type {
   TestClientMode,
 } from '../../clients/createTestClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
+import type { Account } from '../../types/account.js'
 import type { Chain } from '../../types/chain.js'
 import type { RpcTransaction } from '../../types/rpc.js'
 
@@ -35,8 +36,11 @@ export type GetTxpoolContentReturnType = {
  * })
  * const content = await getTxpoolContent(client)
  */
-export async function getTxpoolContent<TChain extends Chain | undefined>(
-  client: TestClient<TestClientMode, Transport, TChain>,
+export async function getTxpoolContent<
+  TChain extends Chain | undefined,
+  TAccount extends Account | undefined,
+>(
+  client: TestClient<TestClientMode, Transport, TChain, TAccount, false>,
 ): Promise<GetTxpoolContentReturnType> {
   return await client.request({
     method: 'txpool_content',

package/src/actions/test/getTxpoolStatus.ts

@@ -3,6 +3,7 @@ import type {
   TestClientMode,
 } from '../../clients/createTestClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
+import type { Account } from '../../types/account.js'
 import type { Chain } from '../../types/chain.js'
 import { hexToNumber } from '../../utils/encoding/fromHex.js'
 
@@ -31,8 +32,11 @@ export type GetTxpoolStatusReturnType = {
  * })
  * const status = await getTxpoolStatus(client)
  */
-export async function getTxpoolStatus<TChain extends Chain | undefined>(
-  client: TestClient<TestClientMode, Transport, TChain>,
+export async function getTxpoolStatus<
+  TChain extends Chain | undefined,
+  TAccount extends Account | undefined,
+>(
+  client: TestClient<TestClientMode, Transport, TChain, TAccount, false>,
 ): Promise<GetTxpoolStatusReturnType> {
   const { pending, queued } = await client.request({
     method: 'txpool_status',

package/src/actions/test/impersonateAccount.ts

@@ -5,6 +5,7 @@ import type {
   TestClientMode,
 } from '../../clients/createTestClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
+import type { Account } from '../../types/account.js'
 import type { Chain } from '../../types/chain.js'
 
 export type ImpersonateAccountParameters = {
@@ -34,8 +35,11 @@ export type ImpersonateAccountParameters = {
  *   address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
  * })
  */
-export async function impersonateAccount<TChain extends Chain | undefined>(
-  client: TestClient<TestClientMode, Transport, TChain>,
+export async function impersonateAccount<
+  TChain extends Chain | undefined,
+  TAccount extends Account | undefined,
+>(
+  client: TestClient<TestClientMode, Transport, TChain, TAccount, false>,
   { address }: ImpersonateAccountParameters,
 ) {
   await client.request({

package/src/actions/test/increaseTime.ts

@@ -3,6 +3,7 @@ import type {
   TestClientMode,
 } from '../../clients/createTestClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
+import type { Account } from '../../types/account.js'
 import type { Chain } from '../../types/chain.js'
 import { numberToHex } from '../../utils/encoding/toHex.js'
 
@@ -33,8 +34,11 @@ export type IncreaseTimeParameters = {
  *   seconds: 420,
  * })
  */
-export async function increaseTime<TChain extends Chain | undefined>(
-  client: TestClient<TestClientMode, Transport, TChain>,
+export async function increaseTime<
+  TChain extends Chain | undefined,
+  TAccount extends Account | undefined,
+>(
+  client: TestClient<TestClientMode, Transport, TChain, TAccount, false>,
   { seconds }: IncreaseTimeParameters,
 ) {
   return await client.request({

package/src/actions/test/inspectTxpool.ts

@@ -5,6 +5,7 @@ import type {
   TestClientMode,
 } from '../../clients/createTestClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
+import type { Account } from '../../types/account.js'
 import type { Chain } from '../../types/chain.js'
 
 export type InspectTxpoolReturnType = {
@@ -32,8 +33,11 @@ export type InspectTxpoolReturnType = {
  * })
  * const data = await inspectTxpool(client)
  */
-export async function inspectTxpool<TChain extends Chain | undefined>(
-  client: TestClient<TestClientMode, Transport, TChain>,
+export async function inspectTxpool<
+  TChain extends Chain | undefined,
+  TAccount extends Account | undefined,
+>(
+  client: TestClient<TestClientMode, Transport, TChain, TAccount, false>,
 ): Promise<InspectTxpoolReturnType> {
   return await client.request({
     method: 'txpool_inspect',

package/src/actions/test/mine.ts

@@ -3,6 +3,7 @@ import type {
   TestClientMode,
 } from '../../clients/createTestClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
+import type { Account } from '../../types/account.js'
 import type { Chain } from '../../types/chain.js'
 import { numberToHex } from '../../utils/encoding/toHex.js'
 
@@ -33,12 +34,21 @@ export type MineParameters = {
  * })
  * await mine(client, { blocks: 1 })
  */
-export async function mine<TChain extends Chain | undefined>(
-  client: TestClient<TestClientMode, Transport, TChain>,
+export async function mine<
+  TChain extends Chain | undefined,
+  TAccount extends Account | undefined,
+>(
+  client: TestClient<TestClientMode, Transport, TChain, TAccount, false>,
   { blocks, interval }: MineParameters,
 ) {
-  await client.request({
-    method: `${client.mode}_mine`,
-    params: [numberToHex(blocks), numberToHex(interval || 0)],
-  })
+  if (client.mode === 'ganache')
+    await client.request({
+      method: 'evm_mine',
+      params: [{ blocks: numberToHex(blocks) }],
+    })
+  else
+    await client.request({
+      method: `${client.mode}_mine`,
+      params: [numberToHex(blocks), numberToHex(interval || 0)],
+    })
 }