@wagmi/core 1.4.1 → 2.0.0

package/src/actions/watchChainId.ts

@@ -0,0 +1,20 @@
+import type { Config } from '../createConfig.js'
+import type { GetChainIdReturnType } from './getChainId.js'
+
+export type WatchChainIdParameters<config extends Config = Config> = {
+  onChange(
+    chainId: GetChainIdReturnType<config>,
+    prevChainId: GetChainIdReturnType<config>,
+  ): void
+}
+
+export type WatchChainIdReturnType = () => void
+
+/** https://alpha.wagmi.sh/core/api/actions/watchChainId */
+export function watchChainId<config extends Config>(
+  config: config,
+  parameters: WatchChainIdParameters<config>,
+): WatchChainIdReturnType {
+  const { onChange } = parameters
+  return config.subscribe((state) => state.chainId, onChange)
+}

package/src/actions/watchClient.ts

@@ -0,0 +1,34 @@
+import type { Config } from '../createConfig.js'
+import { type GetClientReturnType, getClient } from './getClient.js'
+
+export type WatchClientParameters<
+  config extends Config = Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+> = {
+  onChange(
+    publicClient: GetClientReturnType<config, chainId>,
+    prevClient: GetClientReturnType<config, chainId>,
+  ): void
+}
+
+export type WatchClientReturnType = () => void
+
+/** https://alpha.wagmi.sh/core/api/actions/watchClient */
+export function watchClient<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+>(
+  config: config,
+  parameters: WatchClientParameters<config, chainId>,
+): WatchClientReturnType {
+  const { onChange } = parameters
+  return config.subscribe(
+    () => getClient(config) as GetClientReturnType<config, chainId>,
+    onChange,
+    {
+      equalityFn(a, b) {
+        return a?.uid === b?.uid
+      },
+    },
+  )
+}

package/src/actions/watchConnections.ts

@@ -0,0 +1,26 @@
+import type { Config } from '../createConfig.js'
+import { deepEqual } from '../utils/deepEqual.js'
+import {
+  type GetConnectionsReturnType,
+  getConnections,
+} from './getConnections.js'
+
+export type WatchConnectionsParameters = {
+  onChange(
+    connections: GetConnectionsReturnType,
+    prevConnections: GetConnectionsReturnType,
+  ): void
+}
+
+export type WatchConnectionsReturnType = () => void
+
+/** https://alpha.wagmi.sh/core/api/actions/watchConnections */
+export function watchConnections(
+  config: Config,
+  parameters: WatchConnectionsParameters,
+): WatchConnectionsReturnType {
+  const { onChange } = parameters
+  return config.subscribe(() => getConnections(config), onChange, {
+    equalityFn: deepEqual,
+  })
+}

package/src/actions/watchContractEvent.ts

@@ -0,0 +1,98 @@
+import type {
+  Abi,
+  Chain,
+  ContractEventName,
+  Transport,
+  WebSocketTransport,
+} from 'viem'
+import {
+  type WatchContractEventParameters as viem_WatchContractEventParameters,
+  type WatchContractEventReturnType as viem_WatchContractEventReturnType,
+  watchContractEvent as viem_watchContractEvent,
+} from 'viem/actions'
+import type { Config } from '../createConfig.js'
+import type { SelectChains } from '../types/chain.js'
+import type {
+  ChainIdParameter,
+  SyncConnectedChainParameter,
+} from '../types/properties.js'
+import type { UnionEvaluate } from '../types/utils.js'
+
+export type WatchContractEventParameters<
+  abi extends Abi | readonly unknown[] = Abi,
+  eventName extends ContractEventName<abi> | undefined = ContractEventName<abi>,
+  strict extends boolean | undefined = undefined,
+  config extends Config = Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+  ///
+  chains extends readonly Chain[] = SelectChains<config, chainId>,
+> = {
+  [key in keyof chains]: UnionEvaluate<
+    viem_WatchContractEventParameters<
+      abi,
+      eventName,
+      strict,
+      config['_internal']['transports'][chains[key]['id']] extends infer transport extends Transport
+        ? Transport extends transport
+          ? WebSocketTransport
+          : transport
+        : WebSocketTransport
+    > &
+      ChainIdParameter<config, chainId> &
+      SyncConnectedChainParameter
+  >
+}[number]
+
+export type WatchContractEventReturnType = viem_WatchContractEventReturnType
+
+// TODO: wrap in viem's `observe` to avoid duplicate invocations.
+/** https://alpha.wagmi.sh/core/api/actions/watchContractEvent */
+export function watchContractEvent<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+  const abi extends Abi | readonly unknown[],
+  eventName extends ContractEventName<abi> | undefined,
+  strict extends boolean | undefined = undefined,
+>(
+  config: config,
+  parameters: WatchContractEventParameters<
+    abi,
+    eventName,
+    strict,
+    config,
+    chainId
+  >,
+) {
+  const { syncConnectedChain = config._internal.syncConnectedChain, ...rest } =
+    parameters
+
+  let unwatch: WatchContractEventReturnType | undefined
+  const listener = (chainId: number | undefined) => {
+    if (unwatch) unwatch()
+
+    const client = config.getClient({ chainId })
+    unwatch = viem_watchContractEvent(
+      client,
+      rest as unknown as viem_WatchContractEventParameters,
+    )
+    return unwatch
+  }
+
+  // set up listener for transaction changes
+  const unlisten = listener(parameters.chainId)
+
+  // set up subscriber for connected chain changes
+  let unsubscribe: (() => void) | undefined
+  if (syncConnectedChain && !parameters.chainId)
+    unsubscribe = config.subscribe(
+      ({ chainId }) => chainId,
+      async (chainId) => {
+        return listener(chainId)
+      },
+    )
+
+  return () => {
+    unlisten?.()
+    unsubscribe?.()
+  }
+}

package/src/actions/watchPendingTransactions.ts

@@ -0,0 +1,79 @@
+import type { Chain, Transport, WebSocketTransport } from 'viem'
+import {
+  type WatchPendingTransactionsParameters as viem_WatchPendingTransactionsParameters,
+  type WatchPendingTransactionsReturnType as viem_WatchPendingTransactionsReturnType,
+  watchPendingTransactions as viem_watchPendingTransactions,
+} from 'viem/actions'
+
+import type { Config } from '../createConfig.js'
+import type { SelectChains } from '../types/chain.js'
+import type {
+  ChainIdParameter,
+  SyncConnectedChainParameter,
+} from '../types/properties.js'
+import type { UnionEvaluate } from '../types/utils.js'
+
+export type WatchPendingTransactionsParameters<
+  config extends Config = Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+  ///
+  chains extends readonly Chain[] = SelectChains<config, chainId>,
+> = {
+  [key in keyof chains]: UnionEvaluate<
+    viem_WatchPendingTransactionsParameters<
+      config['_internal']['transports'][chains[key]['id']] extends infer transport extends Transport
+        ? Transport extends transport
+          ? WebSocketTransport
+          : transport
+        : WebSocketTransport
+    > &
+      ChainIdParameter<config, chainId> &
+      SyncConnectedChainParameter
+  >
+}[number]
+
+export type WatchPendingTransactionsReturnType =
+  viem_WatchPendingTransactionsReturnType
+
+// TODO: wrap in viem's `observe` to avoid duplicate invocations.
+/** https://alpha.wagmi.sh/core/api/actions/watchPendingTransactions */
+export function watchPendingTransactions<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+>(
+  config: config,
+  parameters: WatchPendingTransactionsParameters<config, chainId>,
+) {
+  const { syncConnectedChain = config._internal.syncConnectedChain, ...rest } =
+    parameters
+
+  let unwatch: WatchPendingTransactionsReturnType | undefined
+  const listener = (chainId: number | undefined) => {
+    if (unwatch) unwatch()
+
+    const client = config.getClient({ chainId })
+    unwatch = viem_watchPendingTransactions(
+      client,
+      rest as viem_WatchPendingTransactionsParameters,
+    )
+    return unwatch
+  }
+
+  // set up listener for transaction changes
+  const unlisten = listener(parameters.chainId)
+
+  // set up subscriber for connected chain changes
+  let unsubscribe: (() => void) | undefined
+  if (syncConnectedChain && !parameters.chainId)
+    unsubscribe = config.subscribe(
+      ({ chainId }) => chainId,
+      async (chainId) => {
+        return listener(chainId)
+      },
+    )
+
+  return () => {
+    unlisten?.()
+    unsubscribe?.()
+  }
+}

package/src/actions/watchPublicClient.ts

@@ -0,0 +1,37 @@
+import type { Config } from '../createConfig.js'
+import {
+  type GetPublicClientReturnType,
+  getPublicClient,
+} from './getPublicClient.js'
+
+export type WatchPublicClientParameters<
+  config extends Config = Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+> = {
+  onChange(
+    publicClient: GetPublicClientReturnType<config, chainId>,
+    prevPublicClient: GetPublicClientReturnType<config, chainId>,
+  ): void
+}
+
+export type WatchPublicClientReturnType = () => void
+
+/** https://alpha.wagmi.sh/core/api/actions/watchPublicClient */
+export function watchPublicClient<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+>(
+  config: config,
+  parameters: WatchPublicClientParameters<config, chainId>,
+): WatchPublicClientReturnType {
+  const { onChange } = parameters
+  return config.subscribe(
+    () => getPublicClient(config) as GetPublicClientReturnType<config, chainId>,
+    onChange,
+    {
+      equalityFn(a, b) {
+        return a?.uid === b?.uid
+      },
+    },
+  )
+}

package/src/actions/writeContract.ts

@@ -0,0 +1,111 @@
+import type {
+  Abi,
+  Account,
+  Chain,
+  ContractFunctionArgs,
+  ContractFunctionName,
+  WriteContractParameters as viem_WriteContractParameters,
+  WriteContractReturnType as viem_WriteContractReturnType,
+} from 'viem'
+import { writeContract as viem_writeContract } from 'viem/actions'
+
+import type { Config } from '../createConfig.js'
+import type { SelectChains } from '../types/chain.js'
+import type {
+  ChainIdParameter,
+  ConnectorParameter,
+} from '../types/properties.js'
+import type { Evaluate, UnionOmit } from '../types/utils.js'
+import { assertActiveChain } from '../utils/assertActiveChain.js'
+import { getConnectorClient } from './getConnectorClient.js'
+import {
+  type SimulateContractParameters,
+  simulateContract,
+} from './simulateContract.js'
+
+export type WriteContractParameters<
+  abi extends Abi | readonly unknown[] = Abi,
+  functionName extends ContractFunctionName<
+    abi,
+    'nonpayable' | 'payable'
+  > = ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+  args extends ContractFunctionArgs<
+    abi,
+    'nonpayable' | 'payable',
+    functionName
+  > = ContractFunctionArgs<abi, 'nonpayable' | 'payable', functionName>,
+  config extends Config = Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+  ///
+  chains extends readonly Chain[] = SelectChains<config, chainId>,
+> = {
+  [key in keyof chains]: UnionOmit<
+    viem_WriteContractParameters<
+      abi,
+      functionName,
+      args,
+      chains[key],
+      Account,
+      chains[key]
+    >,
+    'chain'
+  >
+}[number] &
+  Evaluate<ChainIdParameter<config, chainId>> &
+  ConnectorParameter & { __mode?: 'prepared' }
+
+export type WriteContractReturnType = viem_WriteContractReturnType
+
+export type WriteContractError = Error
+
+/** https://alpha.wagmi.sh/core/api/actions/writeContract */
+export async function writeContract<
+  config extends Config,
+  const abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+  args extends ContractFunctionArgs<
+    abi,
+    'nonpayable' | 'payable',
+    functionName
+  >,
+  chainId extends config['chains'][number]['id'],
+>(
+  config: config,
+  parameters: WriteContractParameters<abi, functionName, args, config, chainId>,
+): Promise<WriteContractReturnType> {
+  const { account, chainId, connector, __mode, ...rest } = parameters
+
+  const client = await getConnectorClient(config, {
+    account,
+    chainId,
+    connector,
+  })
+
+  let request
+  if (__mode === 'prepared') {
+    if (chainId)
+      assertActiveChain(config, { activeChainId: client.chain.id, chainId })
+    request = rest
+  } else {
+    const { request: simulateRequest } = await simulateContract(
+      config,
+      rest as unknown as SimulateContractParameters<
+        abi,
+        functionName,
+        args,
+        config,
+        chainId
+      >,
+    )
+    request = simulateRequest
+  }
+
+  const hash = await viem_writeContract(client, {
+    ...(request as any),
+    // Setting to `null` to not validate inside `viem_writeContract` since we
+    // already validated above with `assertActiveChain` and in `simulateContract`
+    chain: null,
+  })
+
+  return hash
+}