@wagmi/core 1.4.1 → 2.0.0-alpha.1

package/src/actions/getPublicClient.ts

@@ -0,0 +1,34 @@
+import { type PublicClient, publicActions } from 'viem'
+
+import type { Config } from '../createConfig.js'
+import type { ChainIdParameter } from '../types/properties.js'
+import type { Evaluate } from '../types/utils.js'
+
+export type GetPublicClientParameters<
+  config extends Config = Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+> = ChainIdParameter<config, chainId>
+
+export type GetPublicClientReturnType<
+  config extends Config = Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+> = Evaluate<
+  PublicClient<
+    config['_internal']['transports'][chainId],
+    Extract<config['chains'][number], { id: chainId }>
+  >
+>
+
+export function getPublicClient<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+>(
+  config: config,
+  parameters: GetPublicClientParameters<config, chainId> = {},
+): GetPublicClientReturnType<config, chainId> {
+  const client = config.getClient(parameters)
+  return client.extend(publicActions) as GetPublicClientReturnType<
+    config,
+    chainId
+  >
+}

package/src/actions/getToken.ts

@@ -0,0 +1,140 @@
+import type { Address, Hex } from 'viem'
+import {
+  ContractFunctionExecutionError,
+  formatUnits,
+  hexToString,
+  trim,
+} from 'viem'
+
+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 GetTokenParameters<config extends Config = Config> = Evaluate<
+  {
+    address: Address
+    formatUnits?: Unit
+  } & ChainIdParameter<config>
+>
+
+export type GetTokenReturnType = {
+  address: Address
+  decimals: number
+  name: string | undefined
+  symbol: string | undefined
+  totalSupply: {
+    formatted: string
+    value: bigint
+  }
+}
+
+export type GetTokenError = Error
+
+export async function getToken<config extends Config>(
+  config: config,
+  parameters: GetTokenParameters<config>,
+): Promise<GetTokenReturnType> {
+  const { address, chainId, formatUnits: unit = 18 } = parameters
+
+  function getAbi<type extends 'bytes32' | 'string'>(type: type) {
+    return [
+      {
+        type: 'function',
+        name: 'decimals',
+        stateMutability: 'view',
+        inputs: [],
+        outputs: [{ type: 'uint8' }],
+      },
+      {
+        type: 'function',
+        name: 'name',
+        stateMutability: 'view',
+        inputs: [],
+        outputs: [{ type }],
+      },
+      {
+        type: 'function',
+        name: 'symbol',
+        stateMutability: 'view',
+        inputs: [],
+        outputs: [{ type }],
+      },
+      {
+        type: 'function',
+        name: 'totalSupply',
+        stateMutability: 'view',
+        inputs: [],
+        outputs: [{ type: 'uint256' }],
+      },
+    ] as const
+  }
+
+  try {
+    const abi = getAbi('string')
+    const contractConfig = { address, abi, chainId } as const
+    const [decimals, name, symbol, totalSupply] = await readContracts(config, {
+      allowFailure: true,
+      contracts: [
+        { ...contractConfig, functionName: 'decimals' },
+        { ...contractConfig, functionName: 'name' },
+        { ...contractConfig, functionName: 'symbol' },
+        { ...contractConfig, functionName: 'totalSupply' },
+      ] as const,
+    })
+
+    // throw if `name` or `symbol` failed
+    if (name.error instanceof ContractFunctionExecutionError) throw name.error
+    if (symbol.error instanceof ContractFunctionExecutionError)
+      throw symbol.error
+
+    // `decimals` and `totalSupply` are required
+    if (decimals.error) throw decimals.error
+    if (totalSupply.error) throw totalSupply.error
+
+    return {
+      address,
+      decimals: decimals.result,
+      name: name.result,
+      symbol: symbol.result,
+      totalSupply: {
+        formatted: formatUnits(totalSupply.result!, getUnit(unit)),
+        value: totalSupply.result,
+      },
+    }
+  } 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 abi = getAbi('bytes32')
+      const contractConfig = { address, abi, chainId } as const
+      const [decimals, name, symbol, totalSupply] = await readContracts(
+        config,
+        {
+          allowFailure: false,
+          contracts: [
+            { ...contractConfig, functionName: 'decimals' },
+            { ...contractConfig, functionName: 'name' },
+            { ...contractConfig, functionName: 'symbol' },
+            { ...contractConfig, functionName: 'totalSupply' },
+          ] as const,
+        },
+      )
+      return {
+        address,
+        decimals,
+        name: hexToString(trim(name as Hex, { dir: 'right' })),
+        symbol: hexToString(trim(symbol as Hex, { dir: 'right' })),
+        totalSupply: {
+          formatted: formatUnits(totalSupply, getUnit(unit)),
+          value: totalSupply,
+        },
+      }
+    }
+
+    throw error
+  }
+}

package/src/actions/getTransaction.ts

@@ -0,0 +1,44 @@
+import type { Chain } from 'viem'
+import {
+  type GetTransactionParameters as viem_GetTransactionParameters,
+  type GetTransactionReturnType as viem_GetTransactionReturnType,
+  getTransaction as viem_getTransaction,
+} 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 GetTransactionParameters<
+  config extends Config = Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+> = Evaluate<viem_GetTransactionParameters & ChainIdParameter<config, chainId>>
+
+export type GetTransactionReturnType<
+  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_GetTransactionReturnType<chains[key]>
+  }[number]
+>
+
+export type GetTransactionError = Error
+
+/** https://alpha.wagmi.sh/core/api/actions/getTransaction */
+export function getTransaction<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+>(
+  config: config,
+  parameters: GetTransactionParameters<config, chainId>,
+): Promise<GetTransactionReturnType<config, chainId>> {
+  const { chainId } = parameters
+  const client = config.getClient({ chainId })
+  return viem_getTransaction(client, parameters) as unknown as Promise<
+    GetTransactionReturnType<config, chainId>
+  >
+}

package/src/actions/getWalletClient.ts

@@ -0,0 +1,41 @@
+import { type Account, type WalletClient, walletActions } from 'viem'
+
+import type { Config } from '../createConfig.js'
+import type { Evaluate } from '../types/utils.js'
+import {
+  type GetConnectorClientError,
+  type GetConnectorClientParameters,
+  getConnectorClient,
+} from './getConnectorClient.js'
+
+export type GetWalletClientParameters<
+  config extends Config = Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+> = GetConnectorClientParameters<Config, chainId>
+
+export type GetWalletClientReturnType<
+  config extends Config = Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+> = Evaluate<
+  WalletClient<
+    config['_internal']['transports'][chainId],
+    Extract<config['chains'][number], { id: chainId }>,
+    Account
+  >
+>
+
+export type GetWalletClientError = GetConnectorClientError
+
+export async function getWalletClient<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+>(
+  config: config,
+  parameters: GetWalletClientParameters<config, chainId> = {},
+): Promise<GetWalletClientReturnType<config, chainId>> {
+  const client = await getConnectorClient(config, parameters)
+  return client.extend(walletActions) as unknown as GetWalletClientReturnType<
+    config,
+    chainId
+  >
+}

package/src/actions/multicall.ts

@@ -0,0 +1,37 @@
+import type {
+  ContractFunctionParameters,
+  MulticallParameters as viem_MulticallParameters,
+  MulticallReturnType as viem_MulticallReturnType,
+} from 'viem'
+import { multicall as viem_multicall } from 'viem/actions'
+
+import type { Config } from '../createConfig.js'
+import type { ChainIdParameter } from '../types/properties.js'
+
+export type MulticallParameters<
+  contracts extends readonly unknown[] = readonly ContractFunctionParameters[],
+  allowFailure extends boolean = true,
+  config extends Config = Config,
+> = viem_MulticallParameters<contracts, allowFailure> & ChainIdParameter<config>
+
+export type MulticallReturnType<
+  contracts extends readonly unknown[] = readonly ContractFunctionParameters[],
+  allowFailure extends boolean = true,
+> = viem_MulticallReturnType<contracts, allowFailure>
+
+export async function multicall<
+  config extends Config,
+  const contracts extends readonly unknown[],
+  allowFailure extends boolean = true,
+>(
+  config: config,
+  parameters: MulticallParameters<contracts, allowFailure, config>,
+): Promise<MulticallReturnType<contracts, allowFailure>> {
+  const { allowFailure = true, chainId, contracts, ...rest } = parameters
+  const client = config.getClient({ chainId })
+  return viem_multicall(client, {
+    allowFailure,
+    contracts,
+    ...rest,
+  }) as Promise<MulticallReturnType<contracts, allowFailure>>
+}

package/src/actions/readContract.ts

@@ -0,0 +1,55 @@
+import { type Abi } from 'viem'
+import type { ContractFunctionArgs, ContractFunctionName } from 'viem'
+import {
+  type ReadContractParameters as viem_ReadContractParameters,
+  type ReadContractReturnType as viem_ReadContractReturnType,
+  readContract as viem_readContract,
+} from 'viem/actions'
+
+import { type Config } from '../createConfig.js'
+import type { ChainIdParameter } from '../types/properties.js'
+
+export type ReadContractParameters<
+  abi extends Abi | readonly unknown[] = Abi,
+  functionName extends ContractFunctionName<
+    abi,
+    'pure' | 'view'
+  > = ContractFunctionName<abi, 'pure' | 'view'>,
+  args extends ContractFunctionArgs<
+    abi,
+    'pure' | 'view',
+    functionName
+  > = ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
+  config extends Config = Config,
+> = viem_ReadContractParameters<abi, functionName, args> &
+  ChainIdParameter<config>
+
+export type ReadContractReturnType<
+  abi extends Abi | readonly unknown[] = Abi,
+  functionName extends ContractFunctionName<
+    abi,
+    'pure' | 'view'
+  > = ContractFunctionName<abi, 'pure' | 'view'>,
+  args extends ContractFunctionArgs<
+    abi,
+    'pure' | 'view',
+    functionName
+  > = ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
+> = viem_ReadContractReturnType<abi, functionName, args>
+
+export type ReadContractError = Error
+
+/** https://alpha.wagmi.sh/core/api/actions/readContract */
+export function readContract<
+  config extends Config,
+  const abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'pure' | 'view'>,
+  args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
+>(
+  config: config,
+  parameters: ReadContractParameters<abi, functionName, args, config>,
+): Promise<ReadContractReturnType<abi, functionName, args>> {
+  const { chainId } = parameters
+  const client = config.getClient({ chainId })
+  return viem_readContract(client, parameters as any)
+}

package/src/actions/readContracts.ts

@@ -0,0 +1,98 @@
+import type {
+  ContractFunctionParameters,
+  MulticallParameters as viem_MulticallParameters,
+  MulticallReturnType as viem_MulticallReturnType,
+} from 'viem'
+import { ContractFunctionExecutionError } from 'viem'
+
+import { type Config } from '../createConfig.js'
+import { type ChainIdParameter } from '../types/properties.js'
+import { multicall } from './multicall.js'
+import { readContract } from './readContract.js'
+
+export type ReadContractsParameters<
+  contracts extends readonly unknown[] = readonly ContractFunctionParameters[],
+  allowFailure extends boolean = true,
+  config extends Config = Config,
+> = viem_MulticallParameters<
+  contracts,
+  allowFailure,
+  { properties: ChainIdParameter<config> }
+>
+
+export type ReadContractsReturnType<
+  contracts extends readonly unknown[] = readonly ContractFunctionParameters[],
+  allowFailure extends boolean = true,
+> = viem_MulticallReturnType<contracts, allowFailure>
+
+export type ReadContractsError = Error
+
+export async function readContracts<
+  config extends Config,
+  const contracts extends readonly ContractFunctionParameters[],
+  allowFailure extends boolean = true,
+>(
+  config: config,
+  parameters: ReadContractsParameters<contracts, allowFailure, config>,
+): Promise<ReadContractsReturnType<contracts, allowFailure>> {
+  const { allowFailure = true, blockNumber, blockTag, ...rest } = parameters
+  const contracts = parameters.contracts as (ContractFunctionParameters & {
+    chainId?: number | undefined
+  })[]
+
+  try {
+    const contractsByChainId = contracts.reduce(
+      (contracts, contract, index) => {
+        const chainId = contract.chainId ?? config.state.chainId
+        return {
+          ...contracts,
+          [chainId]: [...(contracts[chainId] || []), { contract, index }],
+        }
+      },
+      {} as {
+        [chainId: number]: {
+          contract: ContractFunctionParameters
+          index: number
+        }[]
+      },
+    )
+    const promises = () =>
+      Object.entries(contractsByChainId).map(([chainId, contracts]) =>
+        multicall(config, {
+          ...rest,
+          allowFailure,
+          chainId: parseInt(chainId),
+          contracts: contracts.map(({ contract }) => contract),
+        }),
+      )
+
+    const multicallResults = (await Promise.all(promises())).flat()
+    // Reorder the contract results back to the order they were
+    // provided in.
+    const resultIndexes = Object.values(contractsByChainId).flatMap(
+      (contracts) => contracts.map(({ index }) => index),
+    )
+    return multicallResults.reduce((results, result, index) => {
+      if (results) results[resultIndexes[index]!] = result
+      return results
+    }, [] as unknown[]) as ReadContractsReturnType<contracts, allowFailure>
+  } catch (error) {
+    if (error instanceof ContractFunctionExecutionError) throw error
+
+    const promises = () =>
+      contracts.map((contract) =>
+        readContract(config, { ...contract, blockNumber, blockTag }),
+      )
+    if (allowFailure)
+      return (await Promise.allSettled(promises())).map((result) => {
+        if (result.status === 'fulfilled')
+          return { result: result.value, status: 'success' }
+        return { error: result.reason, result: undefined, status: 'failure' }
+      }) as ReadContractsReturnType<contracts, allowFailure>
+
+    return (await Promise.all(promises())) as ReadContractsReturnType<
+      contracts,
+      allowFailure
+    >
+  }
+}

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)
+}