viem 0.2.11 → 0.2.13

package/src/actions/public/watchContractEvent.ts

@@ -0,0 +1,157 @@
+import type { Abi, ExtractAbiEvent, Narrow } from 'abitype'
+import type { PublicClient, Transport } from '../../clients/index.js'
+import type {
+  Address,
+  Chain,
+  GetEventArgs,
+  InferEventName,
+  Filter,
+  Log,
+} from '../../types/index.js'
+import type { GetAbiItemParameters } from '../../utils/index.js'
+import { getAbiItem } from '../../utils/index.js'
+import { observe } from '../../utils/observe.js'
+import { poll } from '../../utils/poll.js'
+import { createContractEventFilter } from './createContractEventFilter.js'
+import type { CreateContractEventFilterParameters } from './createContractEventFilter.js'
+import { getBlockNumber } from './getBlockNumber.js'
+import { getFilterChanges } from './getFilterChanges.js'
+import { getLogs } from './getLogs.js'
+import type { GetLogsParameters } from './getLogs.js'
+import { uninstallFilter } from './uninstallFilter.js'
+
+export type OnLogsParameter<
+  TAbi extends Abi | readonly unknown[] = readonly unknown[],
+  TEventName extends string = string,
+> = TAbi extends Abi
+  ? Log<bigint, number, ExtractAbiEvent<TAbi, TEventName>>[]
+  : Log[]
+export type OnLogsFn<
+  TAbi extends Abi | readonly unknown[] = readonly unknown[],
+  TEventName extends string = string,
+> = (logs: OnLogsParameter<TAbi, TEventName>) => void
+
+export type WatchContractEventParameters<
+  TAbi extends Abi | readonly unknown[] = readonly unknown[],
+  TEventName extends string = string,
+> = {
+  /** The address of the contract. */
+  address?: Address | Address[]
+  /** Contract ABI. */
+  abi: Narrow<TAbi>
+  args?: GetEventArgs<TAbi, TEventName>
+  /** Whether or not the event logs should be batched on each invocation. */
+  batch?: boolean
+  /** Contract event. */
+  eventName?: InferEventName<TAbi, TEventName>
+  /** 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<TAbi, TEventName>
+  /** Polling frequency (in ms). Defaults to Client's pollingInterval config. */
+  pollingInterval?: number
+}
+
+export type WatchContractEventReturnType = () => void
+
+export function watchContractEvent<
+  TChain extends Chain | undefined,
+  TAbi extends Abi | readonly unknown[],
+  TEventName extends string,
+>(
+  client: PublicClient<Transport, TChain>,
+  {
+    abi,
+    address,
+    args,
+    batch = true,
+    eventName,
+    onError,
+    onLogs,
+    pollingInterval = client.pollingInterval,
+  }: WatchContractEventParameters<TAbi, TEventName>,
+): WatchContractEventReturnType {
+  const observerId = JSON.stringify([
+    'watchContractEvent',
+    address,
+    args,
+    batch,
+    client.uid,
+    eventName,
+    pollingInterval,
+  ])
+
+  return observe(observerId, { onLogs, onError }, (emit) => {
+    let previousBlockNumber: bigint
+    let filter: Filter<'event', TAbi, TEventName> | undefined
+    let initialized = false
+
+    const unwatch = poll(
+      async () => {
+        if (!initialized) {
+          try {
+            filter = (await createContractEventFilter(client, {
+              abi,
+              address,
+              args,
+              eventName,
+            } as unknown as CreateContractEventFilterParameters)) as Filter<
+              'event',
+              TAbi,
+              TEventName
+            >
+          } catch {}
+          initialized = true
+          return
+        }
+
+        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, {
+                address,
+                args,
+                fromBlock: previousBlockNumber + 1n,
+                toBlock: blockNumber,
+                event: getAbiItem({
+                  abi,
+                  name: eventName,
+                } as unknown as GetAbiItemParameters),
+              } as unknown as GetLogsParameters)
+            } else {
+              logs = []
+            }
+            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) {
+          emit.onError?.(err as Error)
+        }
+      },
+      {
+        emitOnBegin: true,
+        interval: pollingInterval,
+      },
+    )
+
+    return async () => {
+      if (filter) await uninstallFilter(client, { filter })
+      unwatch()
+    }
+  })
+}

package/src/actions/public/watchEvent.ts

@@ -0,0 +1,151 @@
+import type { AbiEvent } from 'abitype'
+import type { PublicClient, Transport } from '../../clients/index.js'
+import type {
+  Address,
+  Chain,
+  Filter,
+  Log,
+  MaybeAbiEventName,
+  MaybeExtractEventArgsFromAbi,
+} from '../../types/index.js'
+import { observe } from '../../utils/observe.js'
+import { poll } from '../../utils/poll.js'
+import { createEventFilter } from './createEventFilter.js'
+import type { CreateEventFilterParameters } from './createEventFilter.js'
+import { getBlockNumber } from './getBlockNumber.js'
+import { getFilterChanges } from './getFilterChanges.js'
+import { getLogs } from './getLogs.js'
+import { uninstallFilter } from './uninstallFilter.js'
+
+export type OnLogsParameter<
+  TAbiEvent extends AbiEvent | undefined = undefined,
+  TEventName extends string | undefined = MaybeAbiEventName<TAbiEvent>,
+> = Log<bigint, number, TAbiEvent, [TAbiEvent], TEventName>[]
+export type OnLogsFn<
+  TAbiEvent extends AbiEvent | undefined = undefined,
+  TEventName extends string | undefined = MaybeAbiEventName<TAbiEvent>,
+> = (logs: OnLogsParameter<TAbiEvent, TEventName>) => void
+
+export type WatchEventParameters<
+  TAbiEvent extends AbiEvent | undefined = undefined,
+  TEventName 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. */
+  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
+    }
+)
+
+export type WatchEventReturnType = () => void
+
+export function watchEvent<
+  TChain extends Chain | undefined,
+  TAbiEvent extends AbiEvent | undefined,
+  TEventName extends string | undefined,
+>(
+  client: PublicClient<Transport, TChain>,
+  {
+    address,
+    args,
+    batch = true,
+    event,
+    onError,
+    onLogs,
+    pollingInterval = client.pollingInterval,
+  }: WatchEventParameters<TAbiEvent>,
+): WatchEventReturnType {
+  const observerId = JSON.stringify([
+    'watchEvent',
+    address,
+    args,
+    batch,
+    client.uid,
+    event,
+    pollingInterval,
+  ])
+
+  return observe(observerId, { onLogs, onError }, (emit) => {
+    let previousBlockNumber: bigint
+    let filter: Filter<'event', [TAbiEvent], TEventName, any>
+    let initialized = false
+
+    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
+        }
+
+        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, {
+                address,
+                args,
+                fromBlock: previousBlockNumber + 1n,
+                toBlock: blockNumber,
+                event: event!,
+              })
+            } else {
+              logs = []
+            }
+            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) {
+          emit.onError?.(err as Error)
+        }
+      },
+      {
+        emitOnBegin: true,
+        interval: pollingInterval,
+      },
+    )
+
+    return async () => {
+      if (filter) await uninstallFilter(client, { filter })
+      unwatch()
+    }
+  })
+}

package/src/actions/public/watchPendingTransactions.ts

@@ -0,0 +1,134 @@
+import type { PublicClient, Transport } from '../../clients/index.js'
+import type {
+  Chain,
+  Filter,
+  GetTransportConfig,
+  Hash,
+} from '../../types/index.js'
+import { observe } from '../../utils/observe.js'
+import { poll } from '../../utils/poll.js'
+import { createPendingTransactionFilter } from './createPendingTransactionFilter.js'
+import { getFilterChanges } from './getFilterChanges.js'
+import { uninstallFilter } from './uninstallFilter.js'
+
+export type OnTransactionsParameter = Hash[]
+export type OnTransactionsFn = (transactions: OnTransactionsParameter) => void
+
+type PollOptions = {
+  /** Whether or not the transaction hashes should be batched on each invocation. */
+  batch?: boolean
+  /** Polling frequency (in ms). Defaults to Client's pollingInterval config. */
+  pollingInterval?: number
+}
+
+export type WatchPendingTransactionsParameters<
+  TTransport extends Transport = Transport,
+> = {
+  /** 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 transactions are received. */
+  onTransactions: OnTransactionsFn
+} & (GetTransportConfig<TTransport>['type'] extends 'webSocket'
+  ?
+      | {
+          batch?: never
+          /** Whether or not the WebSocket Transport should poll the JSON-RPC, rather than using `eth_subscribe`. */
+          poll?: false
+          pollingInterval?: never
+        }
+      | (PollOptions & { poll?: true })
+  : PollOptions & {
+      poll?: true
+    })
+
+export type WatchPendingTransactionsReturnType = () => void
+
+export function watchPendingTransactions<
+  TTransport extends Transport,
+  TChain extends Chain | undefined,
+>(
+  client: PublicClient<TTransport, TChain>,
+  {
+    batch = true,
+    onError,
+    onTransactions,
+    poll: poll_,
+    pollingInterval = client.pollingInterval,
+  }: WatchPendingTransactionsParameters<TTransport>,
+) {
+  const enablePolling =
+    typeof poll_ !== 'undefined' ? poll_ : client.transport.type !== 'webSocket'
+
+  const pollPendingTransactions = () => {
+    const observerId = JSON.stringify([
+      'watchPendingTransactions',
+      client.uid,
+      batch,
+      pollingInterval,
+    ])
+    return observe(observerId, { onTransactions, onError }, (emit) => {
+      let filter: Filter<'transaction'>
+
+      const unwatch = poll(
+        async () => {
+          try {
+            if (!filter) {
+              try {
+                filter = await createPendingTransactionFilter(client)
+                return
+              } catch (err) {
+                unwatch()
+                throw err
+              }
+            }
+
+            const hashes = await getFilterChanges(client, { filter })
+            if (hashes.length === 0) return
+            if (batch) emit.onTransactions(hashes)
+            else hashes.forEach((hash) => emit.onTransactions([hash]))
+          } catch (err) {
+            emit.onError?.(err as Error)
+          }
+        },
+        {
+          emitOnBegin: true,
+          interval: pollingInterval,
+        },
+      )
+
+      return async () => {
+        if (filter) await uninstallFilter(client, { filter })
+        unwatch()
+      }
+    })
+  }
+
+  const subscribePendingTransactions = () => {
+    let active = true
+    let unsubscribe = () => (active = false)
+    ;(async () => {
+      try {
+        const { unsubscribe: unsubscribe_ } = await client.transport.subscribe({
+          params: ['newPendingTransactions'],
+          onData(data: any) {
+            if (!active) return
+            const transaction = data.result
+            onTransactions([transaction])
+          },
+          onError(error: Error) {
+            onError?.(error)
+          },
+        })
+        unsubscribe = unsubscribe_
+        if (!active) unsubscribe()
+      } catch (err) {
+        onError?.(err as Error)
+      }
+    })()
+    return unsubscribe
+  }
+
+  return enablePolling
+    ? pollPendingTransactions()
+    : subscribePendingTransactions()
+}

package/src/actions/test/dropTransaction.ts

@@ -0,0 +1,21 @@
+import type {
+  TestClient,
+  TestClientMode,
+  Transport,
+} from '../../clients/index.js'
+import type { Chain, Hash } from '../../types/index.js'
+
+export type DropTransactionParameters = {
+  /** The hash of the transaction to drop. */
+  hash: Hash
+}
+
+export async function dropTransaction<TChain extends Chain | undefined>(
+  client: TestClient<TestClientMode, Transport, TChain>,
+  { hash }: DropTransactionParameters,
+) {
+  return await client.request({
+    method: `${client.mode}_dropTransaction`,
+    params: [hash],
+  })
+}

package/src/actions/test/getAutomine.ts

@@ -0,0 +1,16 @@
+import type {
+  TestClient,
+  TestClientMode,
+  Transport,
+} from '../../clients/index.js'
+import type { Chain } from '../../types/index.js'
+
+export type GetAutomineReturnType = boolean
+
+export async function getAutomine<TChain extends Chain | undefined>(
+  client: TestClient<TestClientMode, Transport, TChain>,
+): Promise<GetAutomineReturnType> {
+  return await client.request({
+    method: `${client.mode}_getAutomine`,
+  })
+}

package/src/actions/test/getTxpoolContent.ts

@@ -0,0 +1,20 @@
+import type { Address } from 'abitype'
+import type {
+  TestClient,
+  TestClientMode,
+  Transport,
+} from '../../clients/index.js'
+import type { Chain, RpcTransaction } from '../../types/index.js'
+
+export type GetTxpoolContentReturnType = {
+  pending: Record<Address, Record<string, RpcTransaction>>
+  queued: Record<Address, Record<string, RpcTransaction>>
+}
+
+export async function getTxpoolContent<TChain extends Chain | undefined>(
+  client: TestClient<TestClientMode, Transport, TChain>,
+): Promise<GetTxpoolContentReturnType> {
+  return await client.request({
+    method: 'txpool_content',
+  })
+}

package/src/actions/test/getTxpoolStatus.ts

@@ -0,0 +1,24 @@
+import type { Chain } from '@wagmi/chains'
+import type {
+  TestClient,
+  TestClientMode,
+  Transport,
+} from '../../clients/index.js'
+import { hexToNumber } from '../../utils/index.js'
+
+export type GetTxpoolStatusReturnType = {
+  pending: number
+  queued: number
+}
+
+export async function getTxpoolStatus<TChain extends Chain | undefined>(
+  client: TestClient<TestClientMode, Transport, TChain>,
+): Promise<GetTxpoolStatusReturnType> {
+  const { pending, queued } = await client.request({
+    method: 'txpool_status',
+  })
+  return {
+    pending: hexToNumber(pending),
+    queued: hexToNumber(queued),
+  }
+}

package/src/actions/test/impersonateAccount.ts

@@ -0,0 +1,21 @@
+import type {
+  TestClient,
+  TestClientMode,
+  Transport,
+} from '../../clients/index.js'
+import type { Address, Chain } from '../../types/index.js'
+
+export type ImpersonateAccountParameters = {
+  /** The account to impersonate. */
+  address: Address
+}
+
+export async function impersonateAccount<TChain extends Chain | undefined>(
+  client: TestClient<TestClientMode, Transport, TChain>,
+  { address }: ImpersonateAccountParameters,
+) {
+  return await client.request({
+    method: `${client.mode}_impersonateAccount`,
+    params: [address],
+  })
+}

package/src/actions/test/increaseTime.ts

@@ -0,0 +1,22 @@
+import type { Chain } from '@wagmi/chains'
+import type {
+  TestClient,
+  TestClientMode,
+  Transport,
+} from '../../clients/index.js'
+import { numberToHex } from '../../utils/index.js'
+
+export type IncreaseTimeParameters = {
+  /** The amount of seconds to jump forward in time. */
+  seconds: number
+}
+
+export async function increaseTime<TChain extends Chain | undefined>(
+  client: TestClient<TestClientMode, Transport, TChain>,
+  { seconds }: IncreaseTimeParameters,
+) {
+  return await client.request({
+    method: 'evm_increaseTime',
+    params: [numberToHex(seconds)],
+  })
+}

package/src/actions/test/index.ts

@@ -0,0 +1,81 @@
+export { dropTransaction } from './dropTransaction.js'
+export type { DropTransactionParameters } from './dropTransaction.js'
+
+export { getAutomine } from './getAutomine.js'
+export type { GetAutomineReturnType } from './getAutomine.js'
+
+export { getTxpoolContent } from './getTxpoolContent.js'
+export type { GetTxpoolContentReturnType } from './getTxpoolContent.js'
+
+export { getTxpoolStatus } from './getTxpoolStatus.js'
+export type { GetTxpoolStatusReturnType } from './getTxpoolStatus.js'
+
+export { impersonateAccount } from './impersonateAccount.js'
+export type { ImpersonateAccountParameters } from './impersonateAccount.js'
+
+export { increaseTime } from './increaseTime.js'
+export type { IncreaseTimeParameters } from './increaseTime.js'
+
+export { inspectTxpool } from './inspectTxpool.js'
+export type { InspectTxpoolReturnType } from './inspectTxpool.js'
+
+export { mine } from './mine.js'
+export type { MineParameters } from './mine.js'
+
+export { removeBlockTimestampInterval } from './removeBlockTimestampInterval.js'
+
+export { reset } from './reset.js'
+export type { ResetParameters } from './reset.js'
+
+export { revert } from './revert.js'
+export type { RevertParameters } from './revert.js'
+
+export { sendUnsignedTransaction } from './sendUnsignedTransaction.js'
+export type {
+  SendUnsignedTransactionParameters,
+  SendUnsignedTransactionReturnType,
+} from './sendUnsignedTransaction.js'
+
+export { setAutomine } from './setAutomine.js'
+
+export { setBalance } from './setBalance.js'
+export type { SetBalanceParameters } from './setBalance.js'
+
+export { setBlockGasLimit } from './setBlockGasLimit.js'
+export type { SetBlockGasLimitParameters } from './setBlockGasLimit.js'
+
+export { setBlockTimestampInterval } from './setBlockTimestampInterval.js'
+export type { SetBlockTimestampIntervalParameters } from './setBlockTimestampInterval.js'
+
+export { setCode } from './setCode.js'
+export type { SetCodeParameters } from './setCode.js'
+
+export { setCoinbase } from './setCoinbase.js'
+export type { SetCoinbaseParameters } from './setCoinbase.js'
+
+export { setIntervalMining } from './setIntervalMining.js'
+export type { SetIntervalMiningParameters } from './setIntervalMining.js'
+
+export { setLoggingEnabled } from './setLoggingEnabled.js'
+
+export { setMinGasPrice } from './setMinGasPrice.js'
+export type { SetMinGasPriceParameters } from './setMinGasPrice.js'
+
+export { setNextBlockBaseFeePerGas } from './setNextBlockBaseFeePerGas.js'
+export type { SetNextBlockBaseFeePerGasParameters } from './setNextBlockBaseFeePerGas.js'
+
+export { setNextBlockTimestamp } from './setNextBlockTimestamp.js'
+export type { SetNextBlockTimestampParameters } from './setNextBlockTimestamp.js'
+
+export { setNonce } from './setNonce.js'
+export type { SetNonceParameters } from './setNonce.js'
+
+export { setRpcUrl } from './setRpcUrl.js'
+
+export { setStorageAt } from './setStorageAt.js'
+export type { SetStorageAtParameters } from './setStorageAt.js'
+
+export { snapshot } from './snapshot.js'
+
+export { stopImpersonatingAccount } from './stopImpersonatingAccount.js'
+export type { StopImpersonatingAccountParameters } from './stopImpersonatingAccount.js'

package/src/actions/test/inspectTxpool.ts

@@ -0,0 +1,19 @@
+import type {
+  TestClient,
+  TestClientMode,
+  Transport,
+} from '../../clients/index.js'
+import type { Address, Chain } from '../../types/index.js'
+
+export type InspectTxpoolReturnType = {
+  pending: Record<Address, Record<string, string>>
+  queued: Record<Address, Record<string, string>>
+}
+
+export async function inspectTxpool<TChain extends Chain | undefined>(
+  client: TestClient<TestClientMode, Transport, TChain>,
+): Promise<InspectTxpoolReturnType> {
+  return await client.request({
+    method: 'txpool_inspect',
+  })
+}