@wagmi/core 1.4.1 → 2.0.0

package/src/actions/connect.ts

@@ -0,0 +1,86 @@
+import { ResourceUnavailableRpcError, UserRejectedRequestError } from 'viem'
+import { type Address } from 'viem'
+
+import { type Config, type Connector } from '../createConfig.js'
+import { type CreateConnectorFn } from '../createConnector.js'
+import type { BaseError } from '../errors/base.js'
+import { ConnectorAlreadyConnectedError } from '../errors/config.js'
+import type { ChainIdParameter } from '../types/properties.js'
+import type { Evaluate } from '../types/utils.js'
+
+export type ConnectParameters<config extends Config = Config> = Evaluate<
+  {
+    connector: Connector | CreateConnectorFn
+  } & ChainIdParameter<config>
+>
+
+export type ConnectReturnType<config extends Config = Config> = {
+  accounts: readonly [Address, ...Address[]]
+  chainId:
+    | config['chains'][number]['id']
+    | (number extends config['chains'][number]['id'] ? number : number & {})
+}
+
+export type ConnectError =
+  // connect()
+  | ConnectorAlreadyConnectedError
+  // connector.connect()
+  | UserRejectedRequestError
+  | ResourceUnavailableRpcError
+  // base
+  | BaseError
+  | Error
+
+/** https://alpha.wagmi.sh/core/api/actions/connect */
+export async function connect<config extends Config>(
+  config: config,
+  parameters: ConnectParameters<config>,
+): Promise<ConnectReturnType<config>> {
+  // "Register" connector if not already created
+  let connector: Connector
+  if (typeof parameters.connector === 'function') {
+    connector = config._internal.setup(parameters.connector)
+  } else connector = parameters.connector
+
+  // Check if connector is already connected
+  if (connector.uid === config.state.current)
+    throw new ConnectorAlreadyConnectedError()
+
+  try {
+    config.setState((x) => ({ ...x, status: 'connecting' }))
+    connector.emitter.emit('message', { type: 'connecting' })
+
+    const data = await connector.connect({ chainId: parameters.chainId })
+    const accounts = data.accounts as readonly [Address, ...Address[]]
+
+    connector.emitter.off('connect', config._internal.connect)
+    connector.emitter.on('change', config._internal.change)
+    connector.emitter.on('disconnect', config._internal.disconnect)
+
+    await config.storage?.setItem('recentConnectorId', connector.id)
+    config.setState((x) => ({
+      ...x,
+      connections: new Map(x.connections).set(connector.uid, {
+        accounts,
+        chainId: data.chainId,
+        connector: connector,
+      }),
+      current: connector.uid,
+      status: 'connected',
+    }))
+
+    return {
+      accounts,
+      chainId: data.chainId,
+    }
+  } catch (error) {
+    config.setState((x) => {
+      return {
+        ...x,
+        // Keep existing connector connected in case of error
+        status: x.current ? 'connected' : 'disconnected',
+      }
+    })
+    throw error
+  }
+}

package/src/actions/disconnect.ts

@@ -0,0 +1,68 @@
+import {
+  type Config,
+  type Connection,
+  type Connector,
+} from '../createConfig.js'
+import {
+  ConnectorNotConnectedError,
+  ConnectorNotFoundError,
+} from '../errors/config.js'
+
+export type DisconnectParameters = {
+  connector?: Connector | undefined
+}
+
+export type DisconnectReturnType = void
+
+export type DisconnectError = Error
+
+/** https://alpha.wagmi.sh/core/api/actions/disconnect */
+export async function disconnect(
+  config: Config,
+  parameters: DisconnectParameters = {},
+): Promise<DisconnectReturnType> {
+  let connector: Connector | undefined
+  if (parameters.connector) connector = parameters.connector
+  else {
+    const { connections, current } = config.state
+    const connection = connections.get(current!)
+    connector = connection?.connector
+  }
+
+  if (!connector) throw new ConnectorNotFoundError()
+  const connections = config.state.connections
+  if (!connections.has(connector.uid)) throw new ConnectorNotConnectedError()
+
+  await connector.disconnect()
+  connector.emitter.off('change', config._internal.change)
+  connector.emitter.off('disconnect', config._internal.disconnect)
+  connector.emitter.on('connect', config._internal.connect)
+
+  connections.delete(connector.uid)
+
+  config.setState((x) => {
+    if (connections.size === 0)
+      return {
+        ...x,
+        connections: new Map(),
+        current: undefined,
+        status: 'disconnected',
+      }
+
+    const nextConnection = connections.values().next().value as Connection
+    return {
+      ...x,
+      connections: new Map(connections),
+      current: nextConnection.connector.uid,
+    }
+  })
+
+  // Set recent connector if exists
+  {
+    const current = config.state.current
+    if (!current) return
+    const connector = config.state.connections.get(current)?.connector
+    if (!connector) return
+    await config.storage?.setItem('recentConnectorId', connector.id)
+  }
+}

package/src/actions/estimateFeesPerGas.ts

@@ -0,0 +1,76 @@
+import {
+  type Chain,
+  type FeeValuesEIP1559,
+  type FeeValuesLegacy,
+  type FeeValuesType,
+  formatUnits,
+} from 'viem'
+import {
+  type EstimateFeesPerGasParameters as viem_EstimateFeesPerGasParameters,
+  type EstimateFeesPerGasReturnType as viem_EstimateFeesPerGasReturnType,
+  estimateFeesPerGas as viem_estimateFeesPerGas,
+} from 'viem/actions'
+
+import { type Config } from '../createConfig.js'
+import type { ChainIdParameter } from '../types/properties.js'
+import type { Unit } from '../types/unit.js'
+import type { Evaluate } from '../types/utils.js'
+import type { UnionEvaluate, UnionLooseOmit } from '../types/utils.js'
+import { getUnit } from '../utils/getUnit.js'
+
+export type EstimateFeesPerGasParameters<
+  type extends FeeValuesType = FeeValuesType,
+  config extends Config = Config,
+> = UnionEvaluate<
+  UnionLooseOmit<
+    viem_EstimateFeesPerGasParameters<Chain, Chain, type>,
+    'chain'
+  > &
+    ChainIdParameter<config> & {
+      formatUnits?: Unit | undefined
+    }
+>
+
+export type EstimateFeesPerGasReturnType<
+  type extends FeeValuesType = FeeValuesType,
+> = Evaluate<
+  viem_EstimateFeesPerGasReturnType<type> & {
+    formatted: UnionEvaluate<
+      | (type extends 'legacy' ? FeeValuesLegacy<string> : never)
+      | (type extends 'eip1559' ? FeeValuesEIP1559<string> : never)
+    >
+  }
+>
+
+export type EstimateFeesPerGasError = Error
+
+export async function estimateFeesPerGas<
+  config extends Config,
+  type extends FeeValuesType = 'eip1559',
+>(
+  config: config,
+  parameters: EstimateFeesPerGasParameters<type, config> = {},
+): Promise<EstimateFeesPerGasReturnType<type>> {
+  const { chainId, formatUnits: units = 'gwei', ...rest } = parameters
+
+  const client = config.getClient({ chainId })
+
+  const { gasPrice, maxFeePerGas, maxPriorityFeePerGas } =
+    await viem_estimateFeesPerGas(client, rest)
+
+  const unit = getUnit(units)
+  const formatted = {
+    gasPrice: gasPrice ? formatUnits(gasPrice, unit) : undefined,
+    maxFeePerGas: maxFeePerGas ? formatUnits(maxFeePerGas, unit) : undefined,
+    maxPriorityFeePerGas: maxPriorityFeePerGas
+      ? formatUnits(maxPriorityFeePerGas, unit)
+      : undefined,
+  }
+
+  return {
+    formatted,
+    gasPrice,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+  } as EstimateFeesPerGasReturnType<type>
+}

package/src/actions/estimateGas.ts

@@ -0,0 +1,62 @@
+import type { Account, Address, Chain } from 'viem'
+import {
+  type EstimateGasParameters as viem_EstimateGasParameters,
+  type EstimateGasReturnType as viem_EstimateGasReturnType,
+  estimateGas as viem_estimateGas,
+} 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 UnionEvaluate, type UnionLooseOmit } from '../types/utils.js'
+import { getConnectorClient } from './getConnectorClient.js'
+
+export type EstimateGasParameters<
+  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<
+    UnionLooseOmit<viem_EstimateGasParameters<chains[key], Account>, 'chain'> &
+      ChainIdParameter<config, chainId> &
+      ConnectorParameter
+  >
+}[number]
+
+export type EstimateGasReturnType = viem_EstimateGasReturnType
+
+export type EstimateGasError = Error
+
+/** https://alpha.wagmi.sh/core/api/actions/estimateGas */
+export async function estimateGas<
+  config extends Config,
+  chainId extends config['chains'][number]['id'] | undefined = undefined,
+>(
+  config: config,
+  parameters: EstimateGasParameters<config, chainId>,
+): Promise<EstimateGasReturnType> {
+  const { chainId, connector, ...rest } = parameters
+
+  let account: Address | Account
+  if (parameters.account) account = parameters.account
+  else {
+    const connectorClient = await getConnectorClient(config, {
+      account: parameters.account,
+      chainId,
+      connector,
+    })
+    account = connectorClient.account
+  }
+
+  const client = config.getClient({ chainId })
+  return viem_estimateGas(client, {
+    ...(rest as viem_EstimateGasParameters),
+    account,
+  })
+}

package/src/actions/getAccount.ts

@@ -0,0 +1,109 @@
+import { type Address } from 'viem'
+
+import { type Config, type Connector } from '../createConfig.js'
+
+export type GetAccountReturnType =
+  | {
+      address: Address
+      addresses: readonly [Address, ...Address[]]
+      chainId: number
+      connector: Connector
+      isConnected: true
+      isConnecting: false
+      isDisconnected: false
+      isReconnecting: false
+      status: 'connected'
+    }
+  | {
+      address: Address | undefined
+      addresses: readonly Address[] | undefined
+      chainId: number | undefined
+      connector: Connector | undefined
+      isConnected: boolean
+      isConnecting: false
+      isDisconnected: false
+      isReconnecting: true
+      status: 'reconnecting'
+    }
+  | {
+      address: Address | undefined
+      addresses: readonly Address[] | undefined
+      chainId: number | undefined
+      connector: Connector | undefined
+      isConnected: false
+      isReconnecting: false
+      isConnecting: true
+      isDisconnected: false
+      status: 'connecting'
+    }
+  | {
+      address: undefined
+      addresses: undefined
+      chainId: undefined
+      connector: undefined
+      isConnected: false
+      isReconnecting: false
+      isConnecting: false
+      isDisconnected: true
+      status: 'disconnected'
+    }
+
+/** https://alpha.wagmi.sh/core/api/actions/getAccount */
+export function getAccount(config: Config): GetAccountReturnType {
+  const uid = config.state.current!
+  const connection = config.state.connections.get(uid)
+  const addresses = connection?.accounts
+  const address = addresses?.[0]
+  const status = config.state.status
+
+  switch (status) {
+    case 'connected':
+      return {
+        address: address!,
+        addresses: addresses!,
+        chainId: connection?.chainId!,
+        connector: connection?.connector!,
+        isConnected: true,
+        isConnecting: false,
+        isDisconnected: false,
+        isReconnecting: false,
+        status,
+      }
+    case 'reconnecting':
+      return {
+        address,
+        addresses,
+        chainId: connection?.chainId,
+        connector: connection?.connector,
+        isConnected: !!address,
+        isConnecting: false,
+        isDisconnected: false,
+        isReconnecting: true,
+        status,
+      }
+    case 'connecting':
+      return {
+        address,
+        addresses,
+        chainId: connection?.chainId,
+        connector: connection?.connector,
+        isConnected: false,
+        isConnecting: true,
+        isDisconnected: false,
+        isReconnecting: false,
+        status,
+      }
+    case 'disconnected':
+      return {
+        address: undefined,
+        addresses: undefined,
+        chainId: undefined,
+        connector: undefined,
+        isConnected: false,
+        isConnecting: false,
+        isDisconnected: true,
+        isReconnecting: false,
+        status,
+      }
+  }
+}

package/src/actions/getBalance.ts

@@ -0,0 +1,141 @@
+import {
+  type Address,
+  ContractFunctionExecutionError,
+  type Hex,
+  formatUnits,
+  hexToString,
+  trim,
+} from 'viem'
+import {
+  type GetBalanceParameters as viem_GetBalanceParameters,
+  getBalance as viem_getBalance,
+} from 'viem/actions'
+
+import type { Config } from '../createConfig.js'
+import type { ChainIdParameter } from '../types/properties.js'
+import { type Unit } from '../types/unit.js'
+import { type Evaluate } from '../types/utils.js'
+import { getUnit } from '../utils/getUnit.js'
+import { readContracts } from './readContracts.js'
+
+export type GetBalanceParameters<config extends Config = Config> = Evaluate<
+  ChainIdParameter<config> &
+    viem_GetBalanceParameters & {
+      /** @deprecated */
+      token?: Address | undefined
+      unit?: Unit | undefined
+    }
+>
+
+export type GetBalanceReturnType = {
+  decimals: number
+  formatted: string
+  symbol: string
+  value: bigint
+}
+
+export type GetBalanceError = Error
+
+/** https://alpha.wagmi.sh/core/api/actions/getBalance */
+export async function getBalance<config extends Config>(
+  config: config,
+  parameters: GetBalanceParameters<config>,
+): Promise<GetBalanceReturnType> {
+  const {
+    address,
+    blockNumber,
+    blockTag,
+    chainId,
+    token: tokenAddress,
+    unit = 'ether',
+  } = parameters
+
+  if (tokenAddress) {
+    try {
+      return getTokenBalance(config, {
+        balanceAddress: address,
+        symbolType: 'string',
+        tokenAddress,
+      })
+    } catch (error) {
+      // In the chance that there is an error upon decoding the contract result,
+      // it could be likely that the contract data is represented as bytes32 instead
+      // of a string.
+      if (error instanceof ContractFunctionExecutionError) {
+        const balance = await getTokenBalance(config, {
+          balanceAddress: address,
+          symbolType: 'bytes32',
+          tokenAddress,
+        })
+        const symbol = hexToString(
+          trim(balance.symbol as Hex, { dir: 'right' }),
+        )
+        return { ...balance, symbol }
+      }
+      throw error
+    }
+  }
+
+  const client = config.getClient({ chainId })
+  const value = await viem_getBalance(
+    client,
+    blockNumber ? { address, blockNumber } : { address, blockTag },
+  )
+  const chain = config.chains.find((x) => x.id === chainId) ?? client.chain!
+  return {
+    decimals: chain.nativeCurrency.decimals,
+    formatted: formatUnits(value, getUnit(unit)),
+    symbol: chain.nativeCurrency.symbol,
+    value,
+  }
+}
+
+type GetTokenBalanceParameters = {
+  balanceAddress: Address
+  symbolType: 'bytes32' | 'string'
+  tokenAddress: Address
+  unit?: Unit | undefined
+}
+
+async function getTokenBalance(
+  config: Config,
+  parameters: GetTokenBalanceParameters,
+) {
+  const { balanceAddress, symbolType, tokenAddress, unit } = parameters
+  const contract = {
+    abi: [
+      {
+        type: 'function',
+        name: 'balanceOf',
+        stateMutability: 'view',
+        inputs: [{ type: 'address' }],
+        outputs: [{ type: 'uint256' }],
+      },
+      {
+        type: 'function',
+        name: 'decimals',
+        stateMutability: 'view',
+        inputs: [],
+        outputs: [{ type: 'uint8' }],
+      },
+      {
+        type: 'function',
+        name: 'symbol',
+        stateMutability: 'view',
+        inputs: [],
+        outputs: [{ type: symbolType }],
+      },
+    ],
+    address: tokenAddress,
+  } as const
+  const [value, decimals, symbol] = await readContracts(config, {
+    allowFailure: false,
+    contracts: [
+      { ...contract, functionName: 'balanceOf', args: [balanceAddress] },
+      { ...contract, functionName: 'decimals' },
+      { ...contract, functionName: 'symbol' },
+    ] as const,
+  })
+  const formatted = formatUnits(value ?? '0', getUnit(unit ?? decimals))
+  return { decimals, formatted, symbol, value }
+}

package/src/actions/getBlockNumber.ts

@@ -0,0 +1,27 @@
+import {
+  type GetBlockNumberParameters as viem_GetBlockNumberParameters,
+  type GetBlockNumberReturnType as viem_GetBlockNumberReturnType,
+  getBlockNumber as viem_getBlockNumber,
+} from 'viem/actions'
+
+import { type Config } from '../createConfig.js'
+import type { ChainIdParameter } from '../types/properties.js'
+import type { Evaluate } from '../types/utils.js'
+
+export type GetBlockNumberParameters<config extends Config = Config> = Evaluate<
+  viem_GetBlockNumberParameters & ChainIdParameter<config>
+>
+
+export type GetBlockNumberReturnType = viem_GetBlockNumberReturnType
+
+export type GetBlockNumberError = Error
+
+/** https://alpha.wagmi.sh/core/api/actions/getBlockNumber */
+export function getBlockNumber<config extends Config>(
+  config: config,
+  parameters: GetBlockNumberParameters<config> = {},
+): Promise<GetBlockNumberReturnType> {
+  const { chainId } = parameters
+  const client = config.getClient({ chainId })
+  return viem_getBlockNumber(client, parameters)
+}

package/src/actions/getChainId.ts

@@ -0,0 +1,11 @@
+import type { Config } from '../createConfig.js'
+
+export type GetChainIdReturnType<config extends Config = Config> =
+  config['chains'][number]['id']
+
+/** https://alpha.wagmi.sh/core/api/actions/getChainId */
+export function getChainId<config extends Config>(
+  config: config,
+): GetChainIdReturnType<config> {
+  return config.state.chainId
+}

package/src/actions/getClient.ts

@@ -0,0 +1,30 @@
+import { type Client } from 'viem'
+
+import type { Config } from '../createConfig.js'
+import type { ChainIdParameter } from '../types/properties.js'
+import type { Evaluate } from '../types/utils.js'
+
+export type GetClientParameters<
+  config extends Config = Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+> = ChainIdParameter<config, chainId>
+
+export type GetClientReturnType<
+  config extends Config = Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+> = Evaluate<
+  Client<
+    config['_internal']['transports'][chainId],
+    Extract<config['chains'][number], { id: chainId }>
+  >
+>
+
+export function getClient<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+>(
+  config: config,
+  parameters: GetClientParameters<config, chainId> = {},
+): GetClientReturnType<config, chainId> {
+  return config.getClient(parameters) as GetClientReturnType<config, chainId>
+}

package/src/actions/getConnections.ts

@@ -0,0 +1,16 @@
+import type { Config, Connection } from '../createConfig.js'
+import type { Evaluate } from '../types/utils.js'
+import { deepEqual } from '../utils/deepEqual.js'
+
+export type GetConnectionsReturnType = Evaluate<Connection>[]
+
+let previousConnections: Connection[] = []
+
+/** https://alpha.wagmi.sh/core/api/actions/getConnections */
+export function getConnections(config: Config): GetConnectionsReturnType {
+  const connections = [...config.state.connections.values()]
+  if (config.state.status === 'reconnecting') return previousConnections
+  if (deepEqual(previousConnections, connections)) return previousConnections
+  previousConnections = connections
+  return connections
+}