@wagmi/vue 0.0.0-canary-20240515232917

package/src/composables/useSendTransaction.ts

@@ -0,0 +1,76 @@
+import { useMutation } from '@tanstack/vue-query'
+import type {
+  Config,
+  ResolvedRegister,
+  SendTransactionErrorType,
+} from '@wagmi/core'
+import type { Evaluate } from '@wagmi/core/internal'
+import {
+  type SendTransactionData,
+  type SendTransactionMutate,
+  type SendTransactionMutateAsync,
+  type SendTransactionVariables,
+  sendTransactionMutationOptions,
+} from '@wagmi/core/query'
+
+import type { ConfigParameter } from '../types/properties.js'
+import type {
+  UseMutationParameters,
+  UseMutationReturnType,
+} from '../utils/query.js'
+import { useConfig } from './useConfig.js'
+
+export type UseSendTransactionParameters<
+  config extends Config = Config,
+  context = unknown,
+> = Evaluate<
+  ConfigParameter<config> & {
+    mutation?:
+      | UseMutationParameters<
+          SendTransactionData,
+          SendTransactionErrorType,
+          SendTransactionVariables<config, config['chains'][number]['id']>,
+          context
+        >
+      | undefined
+  }
+>
+
+export type UseSendTransactionReturnType<
+  config extends Config = Config,
+  context = unknown,
+> = Evaluate<
+  UseMutationReturnType<
+    SendTransactionData,
+    SendTransactionErrorType,
+    SendTransactionVariables<config, config['chains'][number]['id']>,
+    context
+  > & {
+    sendTransaction: SendTransactionMutate<config, context>
+    sendTransactionAsync: SendTransactionMutateAsync<config, context>
+  }
+>
+
+/** https://wagmi.sh/vue/api/composables/useSendTransaction */
+export function useSendTransaction<
+  config extends Config = ResolvedRegister['config'],
+  context = unknown,
+>(
+  parameters: UseSendTransactionParameters<config, context> = {},
+): UseSendTransactionReturnType<config, context> {
+  const { mutation } = parameters
+
+  const config = useConfig(parameters)
+
+  const mutationOptions = sendTransactionMutationOptions(config)
+  const { mutate, mutateAsync, ...result } = useMutation({
+    ...mutation,
+    ...mutationOptions,
+  })
+
+  return {
+    ...result,
+    sendTransaction: mutate,
+    sendTransactionAsync: mutateAsync,
+  } as UseSendTransactionReturnType<config, context>
+}

package/src/composables/useSignMessage.ts

@@ -0,0 +1,63 @@
+import { type SignMessageErrorType } from '@wagmi/core'
+import type { Evaluate } from '@wagmi/core/internal'
+import {
+  type SignMessageData,
+  type SignMessageMutate,
+  type SignMessageMutateAsync,
+  type SignMessageVariables,
+  signMessageMutationOptions,
+} from '@wagmi/core/query'
+
+import type { ConfigParameter } from '../types/properties.js'
+import {
+  type UseMutationParameters,
+  type UseMutationReturnType,
+  useMutation,
+} from '../utils/query.js'
+import { useConfig } from './useConfig.js'
+
+export type UseSignMessageParameters<context = unknown> = Evaluate<
+  ConfigParameter & {
+    mutation?:
+      | UseMutationParameters<
+          SignMessageData,
+          SignMessageErrorType,
+          SignMessageVariables,
+          context
+        >
+      | undefined
+  }
+>
+
+export type UseSignMessageReturnType<context = unknown> = Evaluate<
+  UseMutationReturnType<
+    SignMessageData,
+    SignMessageErrorType,
+    SignMessageVariables,
+    context
+  > & {
+    signMessage: SignMessageMutate<context>
+    signMessageAsync: SignMessageMutateAsync<context>
+  }
+>
+
+/** https://wagmi.sh/vue/api/composables/useSignMessage */
+export function useSignMessage<context = unknown>(
+  parameters: UseSignMessageParameters<context> = {},
+): UseSignMessageReturnType<context> {
+  const { mutation } = parameters
+
+  const config = useConfig(parameters)
+
+  const mutationOptions = signMessageMutationOptions(config)
+  const { mutate, mutateAsync, ...result } = useMutation({
+    ...mutation,
+    ...mutationOptions,
+  })
+
+  return {
+    ...result,
+    signMessage: mutate,
+    signMessageAsync: mutateAsync,
+  }
+}

package/src/composables/useSignTypedData.ts

@@ -0,0 +1,64 @@
+import type { SignTypedDataErrorType } from '@wagmi/core'
+import type { Evaluate } from '@wagmi/core/internal'
+import {
+  type SignTypedDataData,
+  type SignTypedDataMutate,
+  type SignTypedDataMutateAsync,
+  type SignTypedDataVariables,
+  signTypedDataMutationOptions,
+} from '@wagmi/core/query'
+
+import type { ConfigParameter } from '../types/properties.js'
+import {
+  type UseMutationParameters,
+  type UseMutationReturnType,
+  useMutation,
+} from '../utils/query.js'
+import { useConfig } from './useConfig.js'
+
+export type UseSignTypedDataParameters<context = unknown> = Evaluate<
+  ConfigParameter & {
+    mutation?:
+      | UseMutationParameters<
+          SignTypedDataData,
+          SignTypedDataErrorType,
+          SignTypedDataVariables,
+          context
+        >
+      | undefined
+  }
+>
+
+export type UseSignTypedDataReturnType<context = unknown> = Evaluate<
+  UseMutationReturnType<
+    SignTypedDataData,
+    SignTypedDataErrorType,
+    SignTypedDataVariables,
+    context
+  > & {
+    signTypedData: SignTypedDataMutate<context>
+    signTypedDataAsync: SignTypedDataMutateAsync<context>
+  }
+>
+
+/** https://wagmi.sh/vue/api/composables/useSignTypedData */
+export function useSignTypedData<context = unknown>(
+  parameters: UseSignTypedDataParameters<context> = {},
+): UseSignTypedDataReturnType<context> {
+  const { mutation } = parameters
+
+  const config = useConfig(parameters)
+
+  const mutationOptions = signTypedDataMutationOptions(config)
+  const { mutate, mutateAsync, ...result } = useMutation({
+    ...mutation,
+    ...mutationOptions,
+  })
+
+  type Return = UseSignTypedDataReturnType<context>
+  return {
+    ...result,
+    signTypedData: mutate as Return['signTypedData'],
+    signTypedDataAsync: mutateAsync as Return['signTypedDataAsync'],
+  }
+}

package/src/composables/useSimulateContract.ts

@@ -0,0 +1,148 @@
+import type {
+  Config,
+  ResolvedRegister,
+  SimulateContractErrorType,
+} from '@wagmi/core'
+import {
+  type SimulateContractData,
+  type SimulateContractOptions,
+  type SimulateContractQueryFnData,
+  type SimulateContractQueryKey,
+  simulateContractQueryOptions,
+} from '@wagmi/core/query'
+import type { Abi, ContractFunctionArgs, ContractFunctionName } from 'viem'
+import { type MaybeRef, computed } from 'vue'
+
+import {
+  type ConfigParameter,
+  type QueryParameter,
+} from '../types/properties.js'
+import type { DeepMaybeRef } from '../types/ref.js'
+import { deepUnref } from '../utils/cloneDeep.js'
+import { type UseQueryReturnType, useQuery } from '../utils/query.js'
+import { useChainId } from './useChainId.js'
+import { useConfig } from './useConfig.js'
+import { useConnectorClient } from './useConnectorClient.js'
+
+export type UseSimulateContractParameters<
+  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 = undefined,
+  selectData = SimulateContractData<abi, functionName, args, config, chainId>,
+> = MaybeRef<
+  DeepMaybeRef<
+    SimulateContractOptions<abi, functionName, args, config, chainId>
+  > &
+    ConfigParameter<config> &
+    QueryParameter<
+      SimulateContractQueryFnData<abi, functionName, args, config, chainId>,
+      SimulateContractErrorType,
+      selectData,
+      SimulateContractQueryKey<abi, functionName, args, config, chainId>
+    >
+>
+
+export type UseSimulateContractReturnType<
+  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 = undefined,
+  selectData = SimulateContractData<abi, functionName, args, config, chainId>,
+> = UseQueryReturnType<selectData, SimulateContractErrorType>
+
+/** https://wagmi.sh/vue/api/composables/useSimulateContract */
+export function useSimulateContract<
+  const abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+  args extends ContractFunctionArgs<
+    abi,
+    'nonpayable' | 'payable',
+    functionName
+  >,
+  config extends Config = ResolvedRegister['config'],
+  chainId extends config['chains'][number]['id'] | undefined = undefined,
+  selectData = SimulateContractData<abi, functionName, args, config, chainId>,
+>(
+  parameters_: UseSimulateContractParameters<
+    abi,
+    functionName,
+    args,
+    config,
+    chainId,
+    selectData
+  > = {} as any,
+): UseSimulateContractReturnType<
+  abi,
+  functionName,
+  args,
+  config,
+  chainId,
+  selectData
+> {
+  const parameters = computed(() => deepUnref(parameters_)) as any
+
+  const config = useConfig(parameters)
+  const { data: connectorClient } = useConnectorClient(
+    computed(() => ({
+      connector: parameters.value.connector,
+      query: { enabled: parameters.value.account === undefined },
+    })),
+  )
+  const configChainId = useChainId({ config })
+
+  const queryOptions = computed(() => {
+    const {
+      abi,
+      account = connectorClient?.value?.account,
+      address,
+      chainId = configChainId.value,
+      functionName,
+      query = {},
+    } = parameters.value
+    const options = simulateContractQueryOptions<
+      config,
+      abi,
+      functionName,
+      args,
+      chainId
+    >(config as any, {
+      ...parameters.value,
+      account,
+      chainId,
+    })
+    const enabled = Boolean(
+      abi && address && functionName && (query.enabled ?? true),
+    )
+    return {
+      ...query,
+      ...options,
+      enabled,
+    }
+  })
+
+  return useQuery(queryOptions as any) as UseSimulateContractReturnType<
+    abi,
+    functionName,
+    args,
+    config,
+    chainId,
+    selectData
+  >
+}

package/src/composables/useSwitchAccount.ts

@@ -0,0 +1,84 @@
+import { useMutation } from '@tanstack/vue-query'
+import type {
+  Config,
+  Connector,
+  ResolvedRegister,
+  SwitchAccountErrorType,
+} from '@wagmi/core'
+import type { Evaluate } from '@wagmi/core/internal'
+import {
+  type SwitchAccountData,
+  type SwitchAccountMutate,
+  type SwitchAccountMutateAsync,
+  type SwitchAccountVariables,
+  switchAccountMutationOptions,
+} from '@wagmi/core/query'
+import { type Ref, computed } from 'vue'
+
+import type { ConfigParameter } from '../types/properties.js'
+import type {
+  UseMutationParameters,
+  UseMutationReturnType,
+} from '../utils/query.js'
+import { useConfig } from './useConfig.js'
+import { useConnections } from './useConnections.js'
+
+export type UseSwitchAccountParameters<
+  config extends Config = Config,
+  context = unknown,
+> = Evaluate<
+  ConfigParameter<config> & {
+    mutation?:
+      | UseMutationParameters<
+          SwitchAccountData<config>,
+          SwitchAccountErrorType,
+          SwitchAccountVariables,
+          context
+        >
+      | undefined
+  }
+>
+
+export type UseSwitchAccountReturnType<
+  config extends Config = Config,
+  context = unknown,
+> = Evaluate<
+  UseMutationReturnType<
+    SwitchAccountData<config>,
+    SwitchAccountErrorType,
+    SwitchAccountVariables,
+    context
+  > & {
+    connectors: Ref<readonly Connector[]>
+    switchAccount: SwitchAccountMutate<config, context>
+    switchAccountAsync: SwitchAccountMutateAsync<config, context>
+  }
+>
+
+/** https://wagmi.sh/vue/api/composables/useSwitchAccount */
+export function useSwitchAccount<
+  config extends Config = ResolvedRegister['config'],
+  context = unknown,
+>(
+  parameters: UseSwitchAccountParameters<config, context> = {},
+): UseSwitchAccountReturnType<config, context> {
+  const { mutation } = parameters
+
+  const config = useConfig(parameters)
+  const connections = useConnections({ config })
+
+  const mutationOptions = switchAccountMutationOptions(config)
+  const { mutate, mutateAsync, ...result } = useMutation({
+    ...mutation,
+    ...mutationOptions,
+  })
+
+  return {
+    ...result,
+    connectors: computed(() =>
+      connections.value.map((connection) => connection.connector),
+    ),
+    switchAccount: mutate,
+    switchAccountAsync: mutateAsync,
+  }
+}

package/src/composables/useSwitchChain.ts

@@ -0,0 +1,80 @@
+import { useMutation } from '@tanstack/vue-query'
+import {
+  type Config,
+  type ResolvedRegister,
+  type SwitchChainErrorType,
+} from '@wagmi/core'
+import { type Evaluate } from '@wagmi/core/internal'
+import {
+  type SwitchChainData,
+  type SwitchChainMutate,
+  type SwitchChainMutateAsync,
+  type SwitchChainVariables,
+  switchChainMutationOptions,
+} from '@wagmi/core/query'
+
+import { type ConfigParameter } from '../types/properties.js'
+import {
+  type UseMutationParameters,
+  type UseMutationReturnType,
+} from '../utils/query.js'
+import { type UseChainsReturnType, useChains } from './useChains.js'
+import { useConfig } from './useConfig.js'
+
+export type UseSwitchChainParameters<
+  config extends Config = Config,
+  context = unknown,
+> = Evaluate<
+  ConfigParameter<config> & {
+    mutation?:
+      | UseMutationParameters<
+          SwitchChainData<config, config['chains'][number]['id']>,
+          SwitchChainErrorType,
+          SwitchChainVariables<config, config['chains'][number]['id']>,
+          context
+        >
+      | undefined
+  }
+>
+
+export type UseSwitchChainReturnType<
+  config extends Config = Config,
+  context = unknown,
+> = Evaluate<
+  UseMutationReturnType<
+    SwitchChainData<config, config['chains'][number]['id']>,
+    SwitchChainErrorType,
+    SwitchChainVariables<config, config['chains'][number]['id']>,
+    context
+  > & {
+    chains: Evaluate<UseChainsReturnType<config>>
+    switchChain: SwitchChainMutate<config, context>
+    switchChainAsync: SwitchChainMutateAsync<config, context>
+  }
+>
+
+/** https://wagmi.sh/vue/api/composables/useSwitchChain */
+export function useSwitchChain<
+  config extends Config = ResolvedRegister['config'],
+  context = unknown,
+>(
+  parameters: UseSwitchChainParameters<config, context> = {},
+): UseSwitchChainReturnType<config, context> {
+  const { mutation } = parameters
+
+  const config = useConfig(parameters)
+
+  const mutationOptions = switchChainMutationOptions(config)
+  const { mutate, mutateAsync, ...result } = useMutation({
+    ...mutation,
+    ...mutationOptions,
+  })
+
+  type Return = UseSwitchChainReturnType<config, context>
+  return {
+    ...result,
+    chains: useChains({ config }),
+    switchChain: mutate as Return['switchChain'],
+    switchChainAsync: mutateAsync as Return['switchChainAsync'],
+  } as Return
+}

package/src/composables/useTransaction.ts

@@ -0,0 +1,88 @@
+import type {
+  Config,
+  GetTransactionErrorType,
+  ResolvedRegister,
+} from '@wagmi/core'
+import { type Evaluate } from '@wagmi/core/internal'
+import {
+  type GetTransactionData,
+  type GetTransactionOptions,
+  type GetTransactionQueryFnData,
+  type GetTransactionQueryKey,
+  getTransactionQueryOptions,
+} from '@wagmi/core/query'
+
+import { computed } from 'vue'
+import type { ConfigParameter, QueryParameter } from '../types/properties.js'
+import type { DeepMaybeRef } from '../types/ref.js'
+import { deepUnref } from '../utils/cloneDeep.js'
+import { type UseQueryReturnType, useQuery } from '../utils/query.js'
+import { useChainId } from './useChainId.js'
+import { useConfig } from './useConfig.js'
+
+export type UseTransactionParameters<
+  config extends Config = Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+  selectData = GetTransactionData<config, chainId>,
+> = Evaluate<
+  DeepMaybeRef<
+    GetTransactionOptions<config, chainId> &
+      ConfigParameter<config> &
+      QueryParameter<
+        GetTransactionQueryFnData<config, chainId>,
+        GetTransactionErrorType,
+        selectData,
+        GetTransactionQueryKey<config, chainId>
+      >
+  >
+>
+
+export type UseTransactionReturnType<
+  config extends Config = Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+  selectData = GetTransactionData<config, chainId>,
+> = UseQueryReturnType<selectData, GetTransactionErrorType>
+
+/** https://wagmi.sh/vue/api/composables/useTransaction */
+export function useTransaction<
+  config extends Config = ResolvedRegister['config'],
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+  selectData = GetTransactionData<config, chainId>,
+>(
+  parameters_: UseTransactionParameters<config, chainId, selectData> = {},
+): UseTransactionReturnType<config, chainId, selectData> {
+  const parameters = computed(() => deepUnref(parameters_))
+
+  const config = useConfig(parameters)
+  const configChainId = useChainId({ config })
+
+  const queryOptions = computed(() => {
+    const {
+      blockHash,
+      blockNumber,
+      blockTag,
+      chainId = configChainId.value,
+      hash,
+      query = {},
+    } = parameters.value
+    const options = getTransactionQueryOptions(config, {
+      ...parameters.value,
+      chainId,
+    })
+    const enabled = Boolean(
+      !(blockHash && blockNumber && blockTag && hash) &&
+        (query.enabled ?? true),
+    )
+    return {
+      ...query,
+      ...options,
+      enabled,
+    }
+  })
+
+  return useQuery(queryOptions as any) as UseTransactionReturnType<
+    config,
+    chainId,
+    selectData
+  >
+}

package/src/composables/useTransactionReceipt.ts

@@ -0,0 +1,85 @@
+import {
+  type Config,
+  type GetTransactionReceiptErrorType,
+  type ResolvedRegister,
+} from '@wagmi/core'
+import { type Evaluate } from '@wagmi/core/internal'
+import {
+  type GetTransactionReceiptData,
+  type GetTransactionReceiptOptions,
+  type GetTransactionReceiptQueryKey,
+  getTransactionReceiptQueryOptions,
+} from '@wagmi/core/query'
+import { type GetTransactionReceiptQueryFnData } from '@wagmi/core/query'
+
+import { computed } from 'vue'
+import {
+  type ConfigParameter,
+  type QueryParameter,
+} from '../types/properties.js'
+import type { DeepMaybeRef } from '../types/ref.js'
+import { deepUnref } from '../utils/cloneDeep.js'
+import { type UseQueryReturnType, useQuery } from '../utils/query.js'
+import { useChainId } from './useChainId.js'
+import { useConfig } from './useConfig.js'
+
+export type UseTransactionReceiptParameters<
+  config extends Config = Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+  selectData = GetTransactionReceiptData<config, chainId>,
+> = Evaluate<
+  DeepMaybeRef<
+    GetTransactionReceiptOptions<config, chainId> &
+      ConfigParameter<config> &
+      QueryParameter<
+        GetTransactionReceiptQueryFnData<config, chainId>,
+        GetTransactionReceiptErrorType,
+        selectData,
+        GetTransactionReceiptQueryKey<config, chainId>
+      >
+  >
+>
+
+export type UseTransactionReceiptReturnType<
+  config extends Config = Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+  selectData = GetTransactionReceiptData<config, chainId>,
+> = UseQueryReturnType<selectData, GetTransactionReceiptErrorType>
+
+/** https://wagmi.sh/vue/api/composables/useTransactionReceipt */
+export function useTransactionReceipt<
+  config extends Config = ResolvedRegister['config'],
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+  selectData = GetTransactionReceiptData<config, chainId>,
+>(
+  parameters_: UseTransactionReceiptParameters<
+    config,
+    chainId,
+    selectData
+  > = {},
+): UseTransactionReceiptReturnType<config, chainId, selectData> {
+  const parameters = computed(() => deepUnref(parameters_))
+
+  const config = useConfig(parameters)
+  const configChainId = useChainId({ config })
+
+  const queryOptions = computed(() => {
+    const { chainId = configChainId.value, hash, query = {} } = parameters.value
+    const options = getTransactionReceiptQueryOptions(config, {
+      ...parameters.value,
+      chainId,
+    })
+    const enabled = Boolean(hash && (query.enabled ?? true))
+    return {
+      ...(query as any),
+      ...options,
+      enabled,
+    }
+  })
+
+  return useQuery(queryOptions) as UseTransactionReceiptReturnType<
+    config,
+    chainId,
+    selectData
+  >
+}