@wagmi/core 1.4.1 → 2.0.0

package/src/actions/reconnect.ts

@@ -0,0 +1,102 @@
+import type { Address } from 'viem'
+
+import type { Config, Connection, Connector } from '../createConfig.js'
+import { type CreateConnectorFn } from '../createConnector.js'
+import type { Evaluate } from '../types/utils.js'
+
+export type ReconnectParameters = {
+  /** Connectors to attempt reconnect with */
+  connectors?: readonly (CreateConnectorFn | Connector)[] | undefined
+}
+
+export type ReconnectReturnType = Evaluate<Connection>[]
+
+export type ReconnectError = Error
+
+let isReconnecting = false
+
+/** https://alpha.wagmi.sh/core/api/actions/reconnect */
+export async function reconnect(
+  config: Config,
+  parameters: ReconnectParameters = {},
+): Promise<ReconnectReturnType> {
+  // If already reconnecting, do nothing
+  if (isReconnecting) return []
+  isReconnecting = true
+
+  config.setState((x) => ({
+    ...x,
+    status: x.current ? 'reconnecting' : 'connecting',
+  }))
+
+  const connectors: Connector[] = []
+  if (parameters.connectors?.length) {
+    for (const connector_ of parameters.connectors) {
+      let connector: Connector
+      // "Register" connector if not already created
+      if (typeof connector_ === 'function')
+        connector = config._internal.setup(connector_)
+      else connector = connector_
+      connectors.push(connector)
+    }
+  } else connectors.push(...config.connectors)
+
+  // Try recently-used connectors first
+  const recentConnectorId = await config.storage?.getItem('recentConnectorId')
+  const scores: Record<string, number> = {}
+  for (const [, connection] of config.state.connections) {
+    scores[connection.connector.id] = 1
+  }
+  if (recentConnectorId) scores[recentConnectorId] = 0
+  const sorted =
+    Object.keys(scores).length > 0
+      ? // .toSorted()
+        [...connectors].sort(
+          (a, b) => (scores[a.id] ?? 10) - (scores[b.id] ?? 10),
+        )
+      : connectors
+
+  // Iterate through each connector and try to connect
+  let connected = false
+  const connections = []
+  for (const connector of sorted) {
+    const isAuthorized = await connector.isAuthorized()
+    if (!isAuthorized) continue
+
+    const data = await connector.connect()
+    connector.emitter.off('connect', config._internal.connect)
+    connector.emitter.on('change', config._internal.change)
+    connector.emitter.on('disconnect', config._internal.disconnect)
+
+    config.setState((x) => {
+      const connections = new Map(connected ? x.connections : new Map()).set(
+        connector.uid,
+        { accounts: data.accounts, chainId: data.chainId, connector },
+      )
+      return {
+        ...x,
+        current: connected ? x.current : connector.uid,
+        connections,
+      }
+    })
+    connections.push({
+      accounts: data.accounts as readonly [Address, ...Address[]],
+      chainId: data.chainId,
+      connector,
+    })
+    connected = true
+  }
+
+  // If connecting didn't succeed, set to disconnected
+  if (!connected)
+    config.setState((x) => ({
+      ...x,
+      connections: new Map(),
+      current: undefined,
+      status: 'disconnected',
+    }))
+  else config.setState((x) => ({ ...x, status: 'connected' }))
+
+  isReconnecting = false
+  return connections
+}

package/src/actions/sendTransaction.ts

@@ -0,0 +1,68 @@
+import type {
+  Account,
+  Address,
+  Chain,
+  SendTransactionParameters as viem_SendTransactionParameters,
+  SendTransactionReturnType as viem_SendTransactionReturnType,
+} from 'viem'
+import { sendTransaction as viem_sendTransaction } 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 } from '../types/utils.js'
+import { assertActiveChain } from '../utils/assertActiveChain.js'
+import { getConnectorClient } from './getConnectorClient.js'
+
+export type SendTransactionParameters<
+  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]: Evaluate<
+    Omit<
+      viem_SendTransactionParameters<chains[key], Account, chains[key]>,
+      'chain'
+    > &
+      ChainIdParameter<config, chainId> &
+      ConnectorParameter & {
+        to: Address
+      }
+  >
+}[number]
+
+export type SendTransactionReturnType = viem_SendTransactionReturnType
+
+export type SendTransactionError = Error
+
+/** https://alpha.wagmi.sh/core/api/actions/sendTransaction */
+export async function sendTransaction<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+>(
+  config: config,
+  parameters: SendTransactionParameters<config, chainId>,
+): Promise<SendTransactionReturnType> {
+  const { account, chainId, connector, ...rest } = parameters
+
+  const client = await getConnectorClient(config, {
+    account,
+    chainId,
+    connector,
+  })
+  if (chainId)
+    assertActiveChain(config, { activeChainId: client.chain.id, chainId })
+
+  const hash = await viem_sendTransaction(client, {
+    ...(rest as unknown as viem_SendTransactionParameters),
+    // Setting to `null` to not validate inside `viem_sendTransaction`
+    // since we already validated above
+    chain: null,
+  } as viem_SendTransactionParameters)
+
+  return hash
+}

package/src/actions/signMessage.ts

@@ -0,0 +1,29 @@
+import type { Account } from 'viem'
+import {
+  type SignMessageParameters as viem_SignMessageParameters,
+  type SignMessageReturnType as viem_SignMessageReturnType,
+  signMessage as viem_signMessage,
+} from 'viem/actions'
+
+import { type Config } from '../createConfig.js'
+import type { ConnectorParameter } from '../types/properties.js'
+import type { Evaluate } from '../types/utils.js'
+import { getConnectorClient } from './getConnectorClient.js'
+
+export type SignMessageParameters = Evaluate<
+  viem_SignMessageParameters<Account> & ConnectorParameter
+>
+
+export type SignMessageReturnType = viem_SignMessageReturnType
+
+export type SignMessageError = Error
+
+/** https://alpha.wagmi.sh/core/api/actions/signMessage */
+export async function signMessage(
+  config: Config,
+  parameters: SignMessageParameters,
+): Promise<SignMessageReturnType> {
+  const { account, connector, ...rest } = parameters
+  const client = await getConnectorClient(config, { account, connector })
+  return viem_signMessage(client, rest)
+}

package/src/actions/signTypedData.ts

@@ -0,0 +1,36 @@
+import type { Account, TypedData } from 'viem'
+import {
+  type SignTypedDataParameters as viem_SignTypedDataParameters,
+  type SignTypedDataReturnType as viem_SignTypedDataReturnType,
+  signTypedData as viem_signTypedData,
+} from 'viem/actions'
+
+import { type Config } from '../createConfig.js'
+import type { ConnectorParameter } from '../types/properties.js'
+import { getConnectorClient } from './getConnectorClient.js'
+
+export type SignTypedDataParameters<
+  typedData extends TypedData | Record<string, unknown> = TypedData,
+  primaryType extends keyof typedData | 'EIP712Domain' = keyof typedData,
+> = viem_SignTypedDataParameters<typedData, primaryType, Account> &
+  ConnectorParameter
+
+export type SignTypedDataReturnType = viem_SignTypedDataReturnType
+
+export type SignTypedDataError = Error
+
+/** https://alpha.wagmi.sh/core/api/actions/signTypedData */
+export async function signTypedData<
+  const typedData extends TypedData | Record<string, unknown>,
+  primaryType extends keyof typedData | 'EIP712Domain',
+>(
+  config: Config,
+  parameters: SignTypedDataParameters<typedData, primaryType>,
+): Promise<SignTypedDataReturnType> {
+  const { account, connector, ...rest } = parameters
+  const client = await getConnectorClient(config, { account, connector })
+  return viem_signTypedData(
+    client,
+    rest as unknown as viem_SignTypedDataParameters,
+  )
+}

package/src/actions/simulateContract.ts

@@ -0,0 +1,161 @@
+import type {
+  Abi,
+  Account,
+  Address,
+  Chain,
+  ContractFunctionArgs,
+  ContractFunctionName,
+} from 'viem'
+import {
+  type SimulateContractParameters as viem_SimulateContractParameters,
+  type SimulateContractReturnType as viem_SimulateContractReturnType,
+  simulateContract as viem_simulateContract,
+} 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 { PartialBy, UnionEvaluate, UnionOmit } from '../types/utils.js'
+import { assertActiveChain } from '../utils/assertActiveChain.js'
+import { getConnectorClient } from './getConnectorClient.js'
+
+export type SimulateContractParameters<
+  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']
+    | undefined = config['chains'][number]['id'],
+  ///
+  chains extends readonly Chain[] = SelectChains<config, chainId>,
+> = {
+  [key in keyof chains]: UnionEvaluate<
+    UnionOmit<
+      viem_SimulateContractParameters<
+        abi,
+        functionName,
+        args,
+        chains[key],
+        chains[key]
+      >,
+      'chain'
+    >
+  > &
+    ChainIdParameter<config, chainId> &
+    ConnectorParameter
+}[number]
+
+export type SimulateContractReturnType<
+  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']
+    | undefined = config['chains'][number]['id'],
+  ///
+  chains extends readonly Chain[] = SelectChains<config, chainId>,
+> = {
+  [key in keyof chains]: viem_SimulateContractReturnType<
+    abi,
+    functionName,
+    args,
+    chains[key]
+  > extends infer type extends viem_SimulateContractReturnType<
+    abi,
+    functionName,
+    args
+  >
+    ? UnionEvaluate<
+        UnionOmit<type, 'request'> & {
+          request: UnionEvaluate<
+            UnionOmit<type['request'], 'chain'> &
+              PartialBy<
+                { __mode: 'prepared'; chainId: chainId },
+                chainId extends config['chains'][number]['id']
+                  ? never
+                  : 'chainId'
+              >
+          >
+        }
+      >
+    : never
+}[number]
+
+export type SimulateContractError = Error
+
+/** https://alpha.wagmi.sh/core/api/actions/simulateContract */
+export async function simulateContract<
+  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'] | undefined = undefined,
+>(
+  config: config,
+  parameters: SimulateContractParameters<
+    abi,
+    functionName,
+    args,
+    config,
+    chainId
+  >,
+): Promise<
+  SimulateContractReturnType<abi, functionName, args, config, chainId>
+> {
+  const { abi, chainId, connector, ...rest } =
+    parameters as SimulateContractParameters
+
+  let account: Address | Account
+  let activeChainId: number | undefined
+  if (parameters.account) account = parameters.account
+  else {
+    const connectorClient = await getConnectorClient(config, {
+      chainId,
+      connector,
+    })
+    account = connectorClient.account
+    activeChainId = connectorClient.chain.id
+  }
+  if (chainId) assertActiveChain(config, { activeChainId, chainId })
+
+  const client = config.getClient({ chainId })
+  const { result, request } = await viem_simulateContract(client, {
+    ...rest,
+    abi,
+    account,
+  })
+
+  return {
+    result,
+    request: { __mode: 'prepared', ...request, chainId },
+  } as unknown as SimulateContractReturnType<
+    abi,
+    functionName,
+    args,
+    config,
+    chainId
+  >
+}

package/src/actions/switchAccount.ts

@@ -0,0 +1,37 @@
+import type { Address } from 'viem'
+
+import { type Config, type Connector } from '../createConfig.js'
+import { ConnectorNotConnectedError } from '../errors/config.js'
+
+export type SwitchAccountParameters = {
+  connector: Connector
+}
+
+export type SwitchAccountReturnType<config extends Config = Config> = {
+  accounts: readonly [Address, ...Address[]]
+  chainId:
+    | config['chains'][number]['id']
+    | (number extends config['chains'][number]['id'] ? number : number & {})
+}
+
+export type SwitchAccountError = ConnectorNotConnectedError | Error
+
+/** https://alpha.wagmi.sh/core/api/actions/switchAccount */
+export async function switchAccount<config extends Config>(
+  config: config,
+  parameters: SwitchAccountParameters,
+): Promise<SwitchAccountReturnType<config>> {
+  const { connector } = parameters
+  const connection = config.state.connections.get(connector.uid)
+  if (!connection) throw new ConnectorNotConnectedError()
+
+  await config.storage?.setItem('recentConnectorId', connector.id)
+  config.setState((x) => ({
+    ...x,
+    current: connector.uid,
+  }))
+  return {
+    accounts: connection.accounts,
+    chainId: connection.chainId,
+  }
+}

package/src/actions/switchChain.ts

@@ -0,0 +1,63 @@
+import {
+  SwitchChainError as SwitchChainError_,
+  UserRejectedRequestError,
+} from 'viem'
+
+import { type Config } from '../createConfig.js'
+import type { BaseError } from '../errors/base.js'
+import { ChainNotConfiguredError } from '../errors/config.js'
+import { SwitchChainNotSupportedError } from '../errors/connector.js'
+import { type ProviderNotFoundError } from '../errors/connector.js'
+import type { ConnectorParameter } from '../types/properties.js'
+import type { Evaluate } from '../types/utils.js'
+
+export type SwitchChainParameters<
+  config extends Config = Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+> = Evaluate<
+  {
+    chainId: chainId | config['chains'][number]['id']
+  } & ConnectorParameter
+>
+
+export type SwitchChainReturnType<
+  config extends Config = Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+> = Extract<
+  config['chains'][number],
+  { id: Config extends config ? number : chainId }
+>
+
+export type SwitchChainError =
+  | ProviderNotFoundError
+  | SwitchChainError_
+  | UserRejectedRequestError
+  | BaseError
+  | Error
+
+/** https://alpha.wagmi.sh/core/api/actions/switchChain */
+export async function switchChain<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+>(
+  config: config,
+  parameters: SwitchChainParameters<config, chainId>,
+): Promise<SwitchChainReturnType<config, chainId>> {
+  const { chainId } = parameters
+
+  const connection = config.state.connections.get(
+    parameters.connector?.uid ?? config.state.current!,
+  )
+  if (connection) {
+    const connector = connection.connector
+    if (!connector.switchChain)
+      throw new SwitchChainNotSupportedError({ connector })
+    const chain = await connector.switchChain({ chainId })
+    return chain as SwitchChainReturnType<config, chainId>
+  }
+
+  const chain = config.chains.find((x) => x.id === chainId)
+  if (!chain) throw new ChainNotConfiguredError()
+  config.setState((x) => ({ ...x, chainId }))
+  return chain as SwitchChainReturnType<config, chainId>
+}

package/src/actions/waitForTransactionReceipt.ts

@@ -0,0 +1,69 @@
+import type {
+  CallParameters,
+  Chain,
+  WaitForTransactionReceiptParameters as viem_WaitForTransactionReceiptParameters,
+  WaitForTransactionReceiptReturnType as viem_WaitForTransactionReceiptReturnType,
+} from 'viem'
+import { hexToString } from 'viem'
+import {
+  call,
+  getTransaction,
+  waitForTransactionReceipt as viem_waitForTransactionReceipt,
+} from 'viem/actions'
+
+import type { Config } from '../createConfig.js'
+import type { SelectChains } from '../types/chain.js'
+import type { ChainIdParameter } from '../types/properties.js'
+import type { Evaluate } from '../types/utils.js'
+
+export type WaitForTransactionReceiptParameters<
+  config extends Config = Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+> = Evaluate<
+  viem_WaitForTransactionReceiptParameters & ChainIdParameter<config, chainId>
+>
+
+export type WaitForTransactionReceiptReturnType<
+  config extends Config = Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+  ///
+  chains extends readonly Chain[] = SelectChains<config, chainId>,
+> = Evaluate<
+  {
+    [key in keyof chains]: viem_WaitForTransactionReceiptReturnType<chains[key]>
+  }[number]
+>
+
+export type WaitForTransactionReceiptError = Error
+
+export async function waitForTransactionReceipt<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+>(
+  config: config,
+  parameters: WaitForTransactionReceiptParameters<config, chainId>,
+): Promise<WaitForTransactionReceiptReturnType<config, chainId>> {
+  const { chainId, timeout = 0, ...rest } = parameters
+  const client = config.getClient({ chainId })
+
+  const receipt = await viem_waitForTransactionReceipt(client, {
+    ...rest,
+    timeout,
+  })
+  if (receipt.status === 'reverted') {
+    const txn = await getTransaction(client, { hash: receipt.transactionHash })
+    const code = (await call(client, {
+      ...txn,
+      gasPrice: txn.type !== 'eip1559' ? txn.gasPrice : undefined,
+      maxFeePerGas: txn.type === 'eip1559' ? txn.maxFeePerGas : undefined,
+      maxPriorityFeePerGas:
+        txn.type === 'eip1559' ? txn.maxPriorityFeePerGas : undefined,
+    } as CallParameters)) as unknown as string
+    const reason = hexToString(`0x${code.substring(138)}`)
+    throw new Error(reason)
+  }
+  return receipt as unknown as WaitForTransactionReceiptReturnType<
+    config,
+    chainId
+  >
+}

package/src/actions/watchAccount.ts

@@ -0,0 +1,32 @@
+import { type Config } from '../createConfig.js'
+import { deepEqual } from '../utils/deepEqual.js'
+import { type GetAccountReturnType, getAccount } from './getAccount.js'
+
+export type WatchAccountParameters = {
+  onChange(
+    account: GetAccountReturnType,
+    prevAccount: GetAccountReturnType,
+  ): void
+}
+
+export type WatchAccountReturnType = () => void
+
+/** https://alpha.wagmi.sh/core/api/actions/watchAccount */
+export function watchAccount(
+  config: Config,
+  parameters: WatchAccountParameters,
+): WatchAccountReturnType {
+  const { onChange } = parameters
+  return config.subscribe(() => getAccount(config), onChange, {
+    equalityFn(a, b) {
+      const { connector: aConnector, ...aRest } = a
+      const { connector: bConnector, ...bRest } = b
+      return (
+        deepEqual(aRest, bRest) &&
+        // check connector separately
+        aConnector?.id === bConnector?.id &&
+        aConnector?.uid === bConnector?.uid
+      )
+    },
+  })
+}

package/src/actions/watchBlockNumber.ts

@@ -0,0 +1,78 @@
+import {
+  type WatchBlockNumberParameters as viem_WatchBlockNumberParameters,
+  type WatchBlockNumberReturnType as viem_WatchBlockNumberReturnType,
+  watchBlockNumber as viem_watchBlockNumber,
+} from 'viem/actions'
+
+import type { Chain, Transport, WebSocketTransport } from 'viem'
+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 WatchBlockNumberParameters<
+  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_WatchBlockNumberParameters<
+      config['_internal']['transports'][chains[key]['id']] extends infer transport extends Transport
+        ? Transport extends transport
+          ? WebSocketTransport
+          : transport
+        : WebSocketTransport
+    > &
+      ChainIdParameter<config, chainId> &
+      SyncConnectedChainParameter
+  >
+}[number]
+
+export type WatchBlockNumberReturnType = viem_WatchBlockNumberReturnType
+
+// TODO: wrap in viem's `observe` to avoid duplicate invocations.
+/** https://alpha.wagmi.sh/core/api/actions/watchBlockNumber */
+export function watchBlockNumber<
+  config extends Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+>(
+  config: config,
+  parameters: WatchBlockNumberParameters<config, chainId>,
+): WatchBlockNumberReturnType {
+  const { syncConnectedChain = config._internal.syncConnectedChain, ...rest } =
+    parameters
+
+  let unwatch: WatchBlockNumberReturnType | undefined
+  const listener = (chainId: number | undefined) => {
+    if (unwatch) unwatch()
+
+    const client = config.getClient({ chainId })
+    unwatch = viem_watchBlockNumber(
+      client,
+      rest as unknown as viem_WatchBlockNumberParameters,
+    )
+    return unwatch
+  }
+
+  // set up listener for block number 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?.()
+  }
+}