@wagmi/core 1.4.1 → 2.0.0

package/src/actions/getConnectorClient.ts

@@ -0,0 +1,96 @@
+import {
+  type Account,
+  type Address,
+  type Client,
+  createClient,
+  custom,
+} from 'viem'
+
+import { parseAccount } from 'viem/utils'
+import type { Config, Connection } from '../createConfig.js'
+import {
+  ConnectorAccountNotFound,
+  ConnectorNotConnectedError,
+} from '../errors/config.js'
+import type {
+  ChainIdParameter,
+  ConnectorParameter,
+} from '../types/properties.js'
+import type { Evaluate } from '../types/utils.js'
+
+export type GetConnectorClientParameters<
+  config extends Config = Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+> = Evaluate<
+  ChainIdParameter<config, chainId> &
+    ConnectorParameter & {
+      account?: Address | Account | undefined
+    }
+>
+
+export type GetConnectorClientReturnType<
+  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 }>,
+    Account
+  >
+>
+
+export type GetConnectorClientError =
+  | ConnectorAccountNotFound
+  | ConnectorNotConnectedError
+  | Error
+
+/** https://alpha.wagmi.sh/core/api/actions/getConnectorClient */
+export async function getConnectorClient<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+>(
+  config: config,
+  parameters: GetConnectorClientParameters<config, chainId> = {},
+): Promise<GetConnectorClientReturnType<config, chainId>> {
+  // Get connection
+  let connection: Connection | undefined
+  if (parameters.connector) {
+    const { connector } = parameters
+    const [accounts, chainId] = await Promise.all([
+      connector.getAccounts(),
+      connector.getChainId(),
+    ])
+    connection = {
+      accounts: accounts as readonly [Address, ...Address[]],
+      chainId,
+      connector,
+    }
+  } else connection = config.state.connections.get(config.state.current!)
+  if (!connection) throw new ConnectorNotConnectedError()
+
+  const chainId = parameters.chainId ?? connection.chainId
+
+  // If connector has custom `getClient` implementation
+  type Return = GetConnectorClientReturnType<config, chainId>
+  const connector = connection.connector
+  if (connector.getClient)
+    return connector.getClient({ chainId: chainId }) as unknown as Return
+
+  // Default using `custom` transport
+  const account = parseAccount(parameters.account ?? connection.accounts[0]!)
+  const chain = config.chains.find((chain) => chain.id === chainId)
+  const provider = (await connection.connector.getProvider({ chainId })) as {
+    request(...args: any): Promise<any>
+  }
+
+  // if account was provided, check that it exists on the connector
+  if (parameters.account && !connection.accounts.includes(account.address))
+    throw new ConnectorAccountNotFound({ address: account.address, connector })
+
+  return createClient({
+    account,
+    chain,
+    name: 'Connector Client',
+    transport: (opts) => custom(provider)({ ...opts, retryCount: 0 }),
+  }) as unknown as Return
+}

package/src/actions/getEnsAddress.ts

@@ -0,0 +1,27 @@
+import {
+  type GetEnsAddressParameters as viem_GetEnsAddressParameters,
+  type GetEnsAddressReturnType as viem_GetEnsAddressReturnType,
+  getEnsAddress as viem_getEnsAddress,
+} 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 GetEnsAddressParameters<config extends Config = Config> = Evaluate<
+  viem_GetEnsAddressParameters & ChainIdParameter<config>
+>
+
+export type GetEnsAddressReturnType = viem_GetEnsAddressReturnType
+
+export type GetEnsAddressError = Error
+
+/** https://alpha.wagmi.sh/core/api/actions/getEnsAddress */
+export function getEnsAddress<config extends Config>(
+  config: config,
+  parameters: GetEnsAddressParameters<config>,
+): Promise<GetEnsAddressReturnType> {
+  const { chainId } = parameters
+  const client = config.getClient({ chainId })
+  return viem_getEnsAddress(client, parameters)
+}

package/src/actions/getEnsAvatar.ts

@@ -0,0 +1,27 @@
+import {
+  type GetEnsAvatarParameters as viem_GetEnsAvatarParameters,
+  type GetEnsAvatarReturnType as viem_GetEnsAvatarReturnType,
+  getEnsAvatar as viem_getEnsAvatar,
+} 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 GetEnsAvatarParameters<config extends Config = Config> = Evaluate<
+  viem_GetEnsAvatarParameters & ChainIdParameter<config>
+>
+
+export type GetEnsAvatarReturnType = viem_GetEnsAvatarReturnType
+
+export type GetEnsAvatarError = Error
+
+/** https://alpha.wagmi.sh/core/api/actions/getEnsAvatar */
+export function getEnsAvatar<config extends Config>(
+  config: config,
+  parameters: GetEnsAvatarParameters<config>,
+): Promise<GetEnsAvatarReturnType> {
+  const { chainId } = parameters
+  const client = config.getClient({ chainId })
+  return viem_getEnsAvatar(client, parameters)
+}

package/src/actions/getEnsName.ts

@@ -0,0 +1,27 @@
+import {
+  type GetEnsNameParameters as viem_GetEnsNameParameters,
+  type GetEnsNameReturnType as viem_GetEnsNameReturnType,
+  getEnsName as viem_getEnsName,
+} 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 GetEnsNameParameters<config extends Config = Config> = Evaluate<
+  viem_GetEnsNameParameters & ChainIdParameter<config>
+>
+
+export type GetEnsNameReturnType = viem_GetEnsNameReturnType
+
+export type GetEnsNameError = Error
+
+/** https://alpha.wagmi.sh/core/api/actions/getEnsName */
+export function getEnsName<config extends Config>(
+  config: config,
+  parameters: GetEnsNameParameters<config>,
+): Promise<GetEnsNameReturnType> {
+  const { chainId } = parameters
+  const client = config.getClient({ chainId })
+  return viem_getEnsName(client, parameters)
+}

package/src/actions/getEnsResolver.ts

@@ -0,0 +1,27 @@
+import {
+  type GetEnsResolverParameters as viem_GetEnsResolverParameters,
+  type GetEnsResolverReturnType as viem_GetEnsResolverReturnType,
+  getEnsResolver as viem_getEnsResolver,
+} 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 GetEnsResolverParameters<config extends Config = Config> = Evaluate<
+  viem_GetEnsResolverParameters & ChainIdParameter<config>
+>
+
+export type GetEnsResolverReturnType = viem_GetEnsResolverReturnType
+
+export type GetEnsResolverError = Error
+
+/** https://alpha.wagmi.sh/core/api/actions/getEnsResolver */
+export function getEnsResolver<config extends Config>(
+  config: config,
+  parameters: GetEnsResolverParameters<config>,
+): Promise<GetEnsResolverReturnType> {
+  const { chainId } = parameters
+  const client = config.getClient({ chainId })
+  return viem_getEnsResolver(client, parameters)
+}

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