@wagmi/vue 0.4.10 → 0.4.12

package/src/composables/useReadContract.ts

@@ -7,15 +7,11 @@ import type { UnionCompute } from '@wagmi/core/internal'
 import {
   type ReadContractData,
   type ReadContractOptions,
-  type ReadContractQueryFnData,
-  type ReadContractQueryKey,
   readContractQueryOptions,
-  structuralSharing,
 } from '@wagmi/core/query'
 import type { Abi, ContractFunctionArgs, ContractFunctionName } from 'viem'
-import { computed } from 'vue'
-
-import type { ConfigParameter, QueryParameter } from '../types/properties.js'
+import { computed, type MaybeRef } from 'vue'
+import type { ConfigParameter } 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'
@@ -35,19 +31,31 @@ export type UseReadContractParameters<
   > = ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
   config extends Config = Config,
   selectData = ReadContractData<abi, functionName, args>,
-> = UnionCompute<
-  DeepMaybeRef<
-    ReadContractOptions<abi, functionName, args, config> &
-      ConfigParameter<config> &
-      QueryParameter<
-        ReadContractQueryFnData<abi, functionName, args>,
-        ReadContractErrorType,
-        selectData,
-        ReadContractQueryKey<abi, functionName, args, config>
-      >
+> = MaybeRef<
+  UnionCompute<
+    ReadContractOptions<abi, functionName, args, config, selectData> &
+      ConfigParameter<config>
   >
 >
 
+type UseReadContractParametersLoose<
+  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,
+  selectData = ReadContractData<abi, functionName, args>,
+> = DeepMaybeRef<
+  ReadContractOptions<abi, functionName, args, config, selectData> &
+    ConfigParameter<Config>
+>
+
 export type UseReadContractReturnType<
   abi extends Abi | readonly unknown[] = Abi,
   functionName extends ContractFunctionName<
@@ -66,51 +74,45 @@ export type UseReadContractReturnType<
 export function useReadContract<
   const abi extends Abi | readonly unknown[],
   functionName extends ContractFunctionName<abi, 'pure' | 'view'>,
-  args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
+  const args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
   config extends Config = ResolvedRegister['config'],
   selectData = ReadContractData<abi, functionName, args>,
 >(
-  parameters_: UseReadContractParameters<
+  parameters: UseReadContractParameters<
     abi,
     functionName,
     args,
     config,
     selectData
-  > = {} as any,
-): UseReadContractReturnType<abi, functionName, args, selectData> {
-  const parameters = computed(() => deepUnref(parameters_)) as any
-
-  const config = useConfig(parameters)
-  const configChainId = useChainId({ config })
-
-  const queryOptions = computed(() => {
-    const {
-      abi,
-      address,
-      chainId = configChainId.value,
-      code,
-      functionName,
-      query = {},
-    } = parameters.value
-    const options = readContractQueryOptions<config, abi, functionName, args>(
-      config as any,
-      { ...parameters.value, chainId },
-    )
-    const enabled = Boolean(
-      (address || code) && abi && functionName && (query.enabled ?? true),
-    )
-    return {
-      ...query,
-      ...options,
-      enabled,
-      structuralSharing: query.structuralSharing ?? structuralSharing,
-    }
-  })
-
-  return useQuery(queryOptions) as UseReadContractReturnType<
+  >,
+): UseReadContractReturnType<abi, functionName, args, selectData>
+export function useReadContract<
+  const abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'pure' | 'view'>,
+  const args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
+  config extends Config = ResolvedRegister['config'],
+  selectData = ReadContractData<abi, functionName, args>,
+>(
+  parameters: UseReadContractParametersLoose<
     abi,
     functionName,
     args,
+    config,
     selectData
-  >
+  >,
+): UseReadContractReturnType
+export function useReadContract(
+  parameters: UseReadContractParametersLoose = {},
+): UseReadContractReturnType {
+  const params = computed(() => deepUnref(parameters)) as any
+  const config = useConfig(params)
+  const chainId = useChainId({ config })
+  const options = computed(() =>
+    readContractQueryOptions(config as any, {
+      ...params.value,
+      chainId: params.value.chainId ?? chainId.value,
+      query: params.value.query,
+    }),
+  )
+  return useQuery(options as any) as any
 }

package/src/composables/useSimulateContract.ts

@@ -6,18 +6,16 @@ import type {
 import {
   type SimulateContractData,
   type SimulateContractOptions,
-  type SimulateContractQueryFnData,
-  type SimulateContractQueryKey,
   simulateContractQueryOptions,
 } from '@wagmi/core/query'
 import type { Abi, ContractFunctionArgs, ContractFunctionName } from 'viem'
 import { computed, type MaybeRef } from 'vue'
-import type { ConfigParameter, QueryParameter } from '../types/properties.js'
+import type { ConfigParameter } from '../types/properties.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'
+import { useConnection } from './useConnection.js'
 
 export type UseSimulateContractParameters<
   abi extends Abi | readonly unknown[] = Abi,
@@ -34,14 +32,15 @@ export type UseSimulateContractParameters<
   chainId extends config['chains'][number]['id'] | undefined = undefined,
   selectData = SimulateContractData<abi, functionName, args, config, chainId>,
 > = MaybeRef<
-  SimulateContractOptions<abi, functionName, args, config, chainId> &
-    ConfigParameter<config> &
-    QueryParameter<
-      SimulateContractQueryFnData<abi, functionName, args, config, chainId>,
-      SimulateContractErrorType,
-      selectData,
-      SimulateContractQueryKey<abi, functionName, args, config, chainId>
-    >
+  SimulateContractOptions<
+    abi,
+    functionName,
+    args,
+    config,
+    chainId,
+    selectData
+  > &
+    ConfigParameter<config>
 >
 
 export type UseSimulateContractReturnType<
@@ -73,7 +72,7 @@ export function useSimulateContract<
   chainId extends config['chains'][number]['id'] | undefined = undefined,
   selectData = SimulateContractData<abi, functionName, args, config, chainId>,
 >(
-  parameters_: UseSimulateContractParameters<
+  parameters: UseSimulateContractParameters<
     abi,
     functionName,
     args,
@@ -89,53 +88,18 @@ export function useSimulateContract<
   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 params = computed(() => deepUnref(parameters)) as any
+  const config = useConfig(params)
+  const { address, connector } = useConnection()
+  const chainId = useChainId({ config })
+  const options = computed(() =>
+    simulateContractQueryOptions(config as any, {
+      ...params.value,
+      account: params.value.account ?? address.value,
+      chainId: params.value.chainId ?? chainId.value,
+      connector: params.value.connector ?? connector.value,
+      query: params.value.query,
+    }),
   )
-  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
-  >
+  return useQuery(options as any) as any
 }

package/src/composables/useTransaction.ts

@@ -7,13 +7,10 @@ import type { Compute } 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 { ConfigParameter } 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'
@@ -27,14 +24,7 @@ export type UseTransactionParameters<
   selectData = GetTransactionData<config, chainId>,
 > = Compute<
   DeepMaybeRef<
-    GetTransactionOptions<config, chainId> &
-      ConfigParameter<config> &
-      QueryParameter<
-        GetTransactionQueryFnData<config, chainId>,
-        GetTransactionErrorType,
-        selectData,
-        GetTransactionQueryKey<config, chainId>
-      >
+    GetTransactionOptions<config, chainId, selectData> & ConfigParameter<config>
   >
 >
 
@@ -52,40 +42,17 @@ export function useTransaction<
     config['chains'][number]['id'] = config['chains'][number]['id'],
   selectData = GetTransactionData<config, chainId>,
 >(
-  parameters_: UseTransactionParameters<config, chainId, selectData> = {},
+  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
-  >
+  const params = computed(() => deepUnref(parameters))
+  const config = useConfig(params)
+  const chainId = useChainId({ config })
+  const options = computed(() =>
+    getTransactionQueryOptions(config as any, {
+      ...params.value,
+      chainId: params.value.chainId ?? chainId.value,
+      query: params.value.query as any,
+    }),
+  )
+  return useQuery(options as any) as any
 }

package/src/composables/useTransactionReceipt.ts

@@ -4,16 +4,13 @@ import type {
   ResolvedRegister,
 } from '@wagmi/core'
 import type { Compute } from '@wagmi/core/internal'
-import type { GetTransactionReceiptQueryFnData } from '@wagmi/core/query'
 import {
   type GetTransactionReceiptData,
   type GetTransactionReceiptOptions,
-  type GetTransactionReceiptQueryKey,
   getTransactionReceiptQueryOptions,
 } from '@wagmi/core/query'
-
 import { computed } from 'vue'
-import type { ConfigParameter, QueryParameter } from '../types/properties.js'
+import type { ConfigParameter } 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'
@@ -27,14 +24,8 @@ export type UseTransactionReceiptParameters<
   selectData = GetTransactionReceiptData<config, chainId>,
 > = Compute<
   DeepMaybeRef<
-    GetTransactionReceiptOptions<config, chainId> &
-      ConfigParameter<config> &
-      QueryParameter<
-        GetTransactionReceiptQueryFnData<config, chainId>,
-        GetTransactionReceiptErrorType,
-        selectData,
-        GetTransactionReceiptQueryKey<config, chainId>
-      >
+    GetTransactionReceiptOptions<config, chainId, selectData> &
+      ConfigParameter<config>
   >
 >
 
@@ -52,34 +43,17 @@ export function useTransactionReceipt<
     config['chains'][number]['id'] = config['chains'][number]['id'],
   selectData = GetTransactionReceiptData<config, chainId>,
 >(
-  parameters_: UseTransactionReceiptParameters<
-    config,
-    chainId,
-    selectData
-  > = {},
+  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
-  >
+  const params = computed(() => deepUnref(parameters))
+  const config = useConfig(params)
+  const chainId = useChainId({ config })
+  const options = computed(() =>
+    getTransactionReceiptQueryOptions(config as any, {
+      ...params.value,
+      chainId: params.value.chainId ?? chainId.value,
+      query: params.value.query as any,
+    }),
+  )
+  return useQuery(options as any) as any
 }

package/src/composables/useWaitForTransactionReceipt.ts

@@ -7,13 +7,10 @@ import type { Compute } from '@wagmi/core/internal'
 import {
   type WaitForTransactionReceiptData,
   type WaitForTransactionReceiptOptions,
-  type WaitForTransactionReceiptQueryFnData,
-  type WaitForTransactionReceiptQueryKey,
   waitForTransactionReceiptQueryOptions,
 } from '@wagmi/core/query'
 import { computed } from 'vue'
-
-import type { ConfigParameter, QueryParameter } from '../types/properties.js'
+import type { ConfigParameter } 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'
@@ -27,14 +24,8 @@ export type UseWaitForTransactionReceiptParameters<
   selectData = WaitForTransactionReceiptData<config, chainId>,
 > = Compute<
   DeepMaybeRef<
-    WaitForTransactionReceiptOptions<config, chainId> &
-      ConfigParameter<config> &
-      QueryParameter<
-        WaitForTransactionReceiptQueryFnData<config, chainId>,
-        WaitForTransactionReceiptErrorType,
-        selectData,
-        WaitForTransactionReceiptQueryKey<config, chainId>
-      >
+    WaitForTransactionReceiptOptions<config, chainId, selectData> &
+      ConfigParameter<config>
   >
 >
 
@@ -52,33 +43,21 @@ export function useWaitForTransactionReceipt<
     config['chains'][number]['id'] = config['chains'][number]['id'],
   selectData = WaitForTransactionReceiptData<config, chainId>,
 >(
-  parameters_: UseWaitForTransactionReceiptParameters<
+  parameters: UseWaitForTransactionReceiptParameters<
     config,
     chainId,
     selectData
   > = {},
 ): UseWaitForTransactionReceiptReturnType<config, chainId, selectData> {
-  const parameters = computed(() => deepUnref(parameters_))
-  const config = useConfig(parameters_)
-  const configChainId = useChainId()
-
-  const queryOptions = computed(() => {
-    const { chainId = configChainId.value, hash, query = {} } = parameters.value
-
-    const options = waitForTransactionReceiptQueryOptions(config, {
-      ...parameters.value,
-      chainId,
-    })
-    const enabled = Boolean(hash && (query.enabled ?? true))
-
-    return {
-      ...query,
-      ...options,
-      enabled,
-    }
-  })
-
-  return useQuery(
-    queryOptions as any,
-  ) as UseWaitForTransactionReceiptReturnType<config, chainId, selectData>
+  const params = computed(() => deepUnref(parameters))
+  const config = useConfig(params)
+  const chainId = useChainId({ config })
+  const options = computed(() =>
+    waitForTransactionReceiptQueryOptions(config as any, {
+      ...params.value,
+      chainId: params.value.chainId ?? chainId.value,
+      query: params.value.query as any,
+    }),
+  )
+  return useQuery(options as any) as any
 }

package/src/exports/internal.ts

@@ -2,7 +2,4 @@
 // Types
 ////////////////////////////////////////////////////////////////////////////////
 
-export type {
-  ConfigParameter,
-  QueryParameter,
-} from '../types/properties.js'
+export type { ConfigParameter } from '../types/properties.js'

package/src/types/properties.ts

@@ -1,8 +1,5 @@
-import type { DefaultError, QueryKey } from '@tanstack/vue-query'
 import type { Config } from '@wagmi/core'
 import type { MaybeRef } from 'vue'
-import type { UseQueryParameters } from '../utils/query.js'
-import type { DeepUnwrapRef } from './ref.js'
 
 export type ConfigParameter<config extends Config = Config> = {
   config?: Config | config | undefined
@@ -11,17 +8,3 @@ export type ConfigParameter<config extends Config = Config> = {
 export type EnabledParameter = {
   enabled?: MaybeRef<boolean> | undefined
 }
-
-export type QueryParameter<
-  queryFnData = unknown,
-  error = DefaultError,
-  data = queryFnData,
-  queryKey extends QueryKey = QueryKey,
-> = {
-  query?:
-    | Omit<
-        DeepUnwrapRef<UseQueryParameters<queryFnData, error, data, queryKey>>,
-        'queryFn' | 'queryHash' | 'queryKey' | 'queryKeyHashFn' | 'throwOnError'
-      >
-    | undefined
-}

package/src/version.ts

@@ -1 +1 @@
-export const version = '0.4.10'
+export const version = '0.4.12'