viem 0.0.0-w-20230725184008 → 0.0.0-w-20230810155401

package/src/actions/public/watchEvent.ts

@@ -1,4 +1,4 @@
-import type { AbiEvent, Address } from 'abitype'
+import type { Abi, AbiEvent, Address, Narrow } from 'abitype'
 
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
@@ -9,64 +9,130 @@ 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, TStrict, [TAbiEvent], TEventName>[]
-export type OnLogsFn<
+> = Log<bigint, number, false, TAbiEvent, TStrict, TAbiEvents, TEventName>[]
+export type WatchEventOnLogsFn<
   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>,
-> = (logs: OnLogsParameter<TAbiEvent, TStrict, TEventName>) => void
+  _EventName extends string | undefined = MaybeAbiEventName<TAbiEvent>,
+> = (
+  logs: WatchEventOnLogsParameter<TAbiEvent, TAbiEvents, TStrict, _EventName>,
+) => void
 
 export type WatchEventParameters<
   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>,
+  _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, TStrict, TEventName>
-  /** Polling frequency (in ms). Defaults to Client's pollingInterval config. */
-  pollingInterval?: number
-} & (
-  | {
-      event: TAbiEvent
-      args?: MaybeExtractEventArgsFromAbi<[TAbiEvent], TEventName>
-      /**
-       * Whether or not the logs must match the indexed/non-indexed arguments on `event`.
-       * @default false
-       */
-      strict?: TStrict
-    }
-  | {
-      event?: never
-      args?: never
-      strict?: 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: Narrow<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?: Narrow<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
 
@@ -104,9 +170,13 @@ export type WatchEventReturnType = () => void
  */
 export function watchEvent<
   TChain extends Chain | undefined,
-  TAbiEvent extends AbiEvent | undefined,
-  TEventName extends string | undefined,
+  TAbiEvent extends AbiEvent | undefined = undefined,
+  TAbiEvents extends
+    | readonly AbiEvent[]
+    | readonly unknown[]
+    | undefined = TAbiEvent extends AbiEvent ? [TAbiEvent] : undefined,
   TStrict extends boolean | undefined = undefined,
+  _EventName extends string | undefined = undefined,
 >(
   client: Client<Transport, TChain>,
   {
@@ -114,91 +184,179 @@ export function watchEvent<
     args,
     batch = true,
     event,
+    events,
     onError,
     onLogs,
+    poll: poll_,
     pollingInterval = client.pollingInterval,
     strict: strict_,
-  }: WatchEventParameters<TAbiEvent, TStrict>,
+  }: 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!,
-              strict,
-            } 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/wallet/deployContract.ts

@@ -19,7 +19,7 @@ export type DeployContractParameters<
   TAbi extends Abi | readonly unknown[] = Abi,
   TChain extends Chain | undefined = Chain | undefined,
   TAccount extends Account | undefined = Account | undefined,
-  TChainOverride extends Chain | undefined = undefined,
+  TChainOverride extends Chain | undefined = Chain | undefined,
 > = UnionOmit<
   SendTransactionParameters<TChain, TAccount, TChainOverride>,
   'accessList' | 'chain' | 'to' | 'data'

package/src/actions/wallet/sendTransaction.ts

@@ -11,7 +11,7 @@ import type {
   TransactionRequest,
   TransactionSerializable,
 } from '../../types/transaction.js'
-import type { IsUndefined, UnionOmit } from '../../types/utils.js'
+import type { UnionOmit } from '../../types/utils.js'
 import { assertCurrentChain } from '../../utils/chain.js'
 import { getTransactionError } from '../../utils/errors/getTransactionError.js'
 import { extract } from '../../utils/formatters/extract.js'
@@ -19,17 +19,20 @@ import {
   type FormattedTransactionRequest,
   formatTransactionRequest,
 } from '../../utils/formatters/transactionRequest.js'
-import { assertRequest } from '../../utils/transaction/assertRequest.js'
+import {
+  type AssertRequestParameters,
+  assertRequest,
+} from '../../utils/transaction/assertRequest.js'
 import { prepareRequest } from '../../utils/transaction/prepareRequest.js'
 import { getChainId } from '../public/getChainId.js'
 
 export type SendTransactionParameters<
   TChain extends Chain | undefined = Chain | undefined,
   TAccount extends Account | undefined = Account | undefined,
-  TChainOverride extends Chain | undefined = Chain,
+  TChainOverride extends Chain | undefined = Chain | undefined,
 > = UnionOmit<
   FormattedTransactionRequest<
-    IsUndefined<TChain> extends true ? TChainOverride : TChain
+    TChainOverride extends Chain ? TChainOverride : TChain
   >,
   'from'
 > &
@@ -113,7 +116,7 @@ export async function sendTransaction<
   const account = parseAccount(account_)
 
   try {
-    assertRequest(args)
+    assertRequest(args as AssertRequestParameters)
 
     let chainId
     if (chain !== null) {
@@ -139,7 +142,7 @@ export async function sendTransaction<
         to,
         value,
         ...rest,
-      })
+      } as any)
 
       if (!chainId) chainId = await getChainId(client)
 

package/src/actions/wallet/writeContract.ts

@@ -3,6 +3,7 @@ import type { Abi } from 'abitype'
 import type { Account } from '../../accounts/types.js'
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
+import type { GetAccountParameter } from '../../types/account.js'
 import type { Chain, GetChain } from '../../types/chain.js'
 import type { ContractFunctionConfig, GetValue } from '../../types/contract.js'
 import type { Hex } from '../../types/misc.js'
@@ -11,7 +12,7 @@ import {
   type EncodeFunctionDataParameters,
   encodeFunctionData,
 } from '../../utils/abi/encodeFunctionData.js'
-
+import type { FormattedTransactionRequest } from '../../utils/formatters/transactionRequest.js'
 import {
   type SendTransactionParameters,
   type SendTransactionReturnType,
@@ -22,14 +23,17 @@ export type WriteContractParameters<
   TAbi extends Abi | readonly unknown[] = Abi,
   TFunctionName extends string = string,
   TChain extends Chain | undefined = Chain,
-  TAccount extends Account | undefined = undefined,
-  TChainOverride extends Chain | undefined = undefined,
+  TAccount extends Account | undefined = Account | undefined,
+  TChainOverride extends Chain | undefined = Chain | undefined,
 > = ContractFunctionConfig<TAbi, TFunctionName, 'payable' | 'nonpayable'> &
+  GetAccountParameter<TAccount> &
+  GetChain<TChain, TChainOverride> &
   UnionOmit<
-    SendTransactionParameters<TChain, TAccount, TChainOverride>,
-    'chain' | 'to' | 'data' | 'value'
+    FormattedTransactionRequest<
+      TChainOverride extends Chain ? TChainOverride : TChain
+    >,
+    'from' | 'to' | 'data' | 'value'
   > &
-  GetChain<TChain, TChainOverride> &
   GetValue<
     TAbi,
     TFunctionName,
@@ -102,7 +106,7 @@ export async function writeContract<
   TAccount extends Account | undefined,
   TAbi extends Abi | readonly unknown[],
   TFunctionName extends string,
-  TChainOverride extends Chain | undefined = undefined,
+  TChainOverride extends Chain | undefined,
 >(
   client: Client<Transport, TChain, TAccount>,
   {

package/src/chains/{formatters/celo.ts → celo/formatters.ts}

@@ -1,9 +1,5 @@
-import type { Address } from 'abitype'
-
-import { type Formatters } from '../../types/formatter.js'
-import type { Hash, Hex } from '../../types/misc.js'
-import type { RpcTransaction } from '../../types/rpc.js'
-import type { Transaction } from '../../types/transaction.js'
+import { type ChainFormatters } from '../../types/chain.js'
+import type { Hash } from '../../types/misc.js'
 import { hexToBigInt } from '../../utils/encoding/fromHex.js'
 import { numberToHex } from '../../utils/encoding/toHex.js'
 import { defineBlock } from '../../utils/formatters/block.js'
@@ -13,47 +9,28 @@ import {
 } from '../../utils/formatters/transaction.js'
 import { defineTransactionReceipt } from '../../utils/formatters/transactionReceipt.js'
 import { defineTransactionRequest } from '../../utils/formatters/transactionRequest.js'
-
-export type CeloFormatOverrides = {
-  RpcBlock: {
-    randomness: {
-      committed: Hex
-      revealed: Hex
-    }
-    transactions:
-      | Hash[]
-      | (RpcTransaction & {
-          feeCurrency: Address | null
-          gatewayFee: Hex | null
-          gatewayFeeRecipient: Address | null
-        })[]
-  }
-  RpcTransaction: {
-    feeCurrency: Address | null
-    gatewayFee: Hex | null
-    gatewayFeeRecipient: Address | null
-  }
-  RpcTransactionReceipt: {
-    feeCurrency: Address | null
-    gatewayFee: Hex | null
-    gatewayFeeRecipient: Address | null
-  }
-  TransactionRequest: {
-    feeCurrency?: Address
-    gatewayFee?: bigint
-    gatewayFeeRecipient?: Address
-  }
-  Transaction: {
-    feeCurrency: Address | null
-    gatewayFee: bigint | null
-    gatewayFeeRecipient: Address | null
-  }
-}
+import type {
+  CeloBlockOverrides,
+  CeloRpcTransaction,
+  CeloRpcTransactionOverrides,
+  CeloRpcTransactionReceiptOverrides,
+  CeloRpcTransactionRequestOverrides,
+  CeloTransaction,
+  CeloTransactionOverrides,
+  CeloTransactionReceiptOverrides,
+  CeloTransactionRequestOverrides,
+} from './types.js'
 
 export const formattersCelo = {
   block: /*#__PURE__*/ defineBlock({
     exclude: ['difficulty', 'gasLimit', 'mixHash', 'nonce', 'uncles'],
-    format(args: CeloFormatOverrides['RpcBlock']) {
+    format(
+      args: CeloBlockOverrides & {
+        transactions: Hash[] | CeloRpcTransaction[]
+      },
+    ): CeloBlockOverrides & {
+      transactions: Hash[] | CeloTransaction[]
+    } {
       const transactions = args.transactions?.map((transaction) => {
         if (typeof transaction === 'string') return transaction
         return {
@@ -64,7 +41,7 @@ export const formattersCelo = {
             : null,
           gatewayFeeRecipient: transaction.gatewayFeeRecipient,
         }
-      }) as Hash[] | (Transaction & CeloFormatOverrides['Transaction'])[]
+      }) as Hash[] | CeloTransaction[]
       return {
         randomness: args.randomness,
         transactions,
@@ -72,7 +49,7 @@ export const formattersCelo = {
     },
   }),
   transaction: /*#__PURE__*/ defineTransaction({
-    format(args: CeloFormatOverrides['RpcTransaction']) {
+    format(args: CeloRpcTransactionOverrides): CeloTransactionOverrides {
       return {
         feeCurrency: args.feeCurrency,
         gatewayFee: args.gatewayFee ? hexToBigInt(args.gatewayFee) : null,
@@ -81,7 +58,9 @@ export const formattersCelo = {
     },
   }),
   transactionReceipt: /*#__PURE__*/ defineTransactionReceipt({
-    format(args: CeloFormatOverrides['RpcTransactionReceipt']) {
+    format(
+      args: CeloRpcTransactionReceiptOverrides,
+    ): CeloTransactionReceiptOverrides {
       return {
         feeCurrency: args.feeCurrency,
         gatewayFee: args.gatewayFee ? hexToBigInt(args.gatewayFee) : null,
@@ -90,7 +69,9 @@ export const formattersCelo = {
     },
   }),
   transactionRequest: /*#__PURE__*/ defineTransactionRequest({
-    format(args: CeloFormatOverrides['TransactionRequest']) {
+    format(
+      args: CeloTransactionRequestOverrides,
+    ): CeloRpcTransactionRequestOverrides {
       return {
         feeCurrency: args.feeCurrency,
         gatewayFee:
@@ -101,4 +82,4 @@ export const formattersCelo = {
       }
     },
   }),
-} as const satisfies Formatters
+} as const satisfies ChainFormatters