@wagmi/solid 0.0.12 → 0.0.14

package/src/primitives/useSimulateContract.ts

@@ -0,0 +1,121 @@
+import type {
+  Config,
+  ResolvedRegister,
+  SimulateContractErrorType,
+} from '@wagmi/core'
+import type { ConfigParameter } from '@wagmi/core/internal'
+import {
+  type SimulateContractData,
+  type SimulateContractOptions,
+  simulateContractQueryOptions,
+} from '@wagmi/core/query'
+import type { Accessor } from 'solid-js'
+import { createMemo } from 'solid-js'
+import type { Abi, ContractFunctionArgs, ContractFunctionName } from 'viem'
+import { type UseQueryReturnType, useQuery } from '../utils/query.js'
+import { useChainId } from './useChainId.js'
+import { useConfig } from './useConfig.js'
+import { useConnection } from './useConnection.js'
+
+/** https://wagmi.sh/solid/api/primitives/useSimulateContract */
+export function useSimulateContract<
+  const abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+  const 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: useSimulateContract.Parameters<
+    abi,
+    functionName,
+    args,
+    config,
+    chainId,
+    selectData
+  > = () => ({}) as any,
+): useSimulateContract.ReturnType<
+  abi,
+  functionName,
+  args,
+  config,
+  chainId,
+  selectData
+> {
+  const config = useConfig(parameters)
+  const connection = useConnection()
+  const chainId = useChainId(() => ({ config: config() }))
+  const options = createMemo(() =>
+    simulateContractQueryOptions(config(), {
+      ...(parameters() as any),
+      account: parameters().account ?? connection().address,
+      chainId: parameters().chainId ?? chainId(),
+      connector: parameters().connector ?? connection().connector,
+    }),
+  )
+  return useQuery(options) as any
+}
+
+export namespace useSimulateContract {
+  export type Parameters<
+    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>,
+  > = Accessor<
+    SolidParameters<abi, functionName, args, config, chainId, selectData>
+  >
+
+  export type ReturnType<
+    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>
+
+  export type SolidParameters<
+    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>,
+  > = SimulateContractOptions<
+    abi,
+    functionName,
+    args,
+    config,
+    chainId,
+    selectData
+  > &
+    ConfigParameter<config>
+}

package/src/primitives/useWatchContractEvent.ts

@@ -0,0 +1,82 @@
+import {
+  type Config,
+  type ResolvedRegister,
+  type WatchContractEventParameters,
+  watchContractEvent,
+} from '@wagmi/core'
+import type {
+  ConfigParameter,
+  EnabledParameter,
+  UnionCompute,
+  UnionExactPartial,
+} from '@wagmi/core/internal'
+import { type Accessor, createEffect, onCleanup } from 'solid-js'
+import type { Abi, ContractEventName } from 'viem'
+import { useChainId } from './useChainId.js'
+import { useConfig } from './useConfig.js'
+
+/** https://wagmi.sh/solid/api/primitives/useWatchContractEvent */
+export function useWatchContractEvent<
+  const abi extends Abi | readonly unknown[],
+  eventName extends ContractEventName<abi>,
+  strict extends boolean | undefined = undefined,
+  config extends Config = ResolvedRegister['config'],
+  chainId extends
+    config['chains'][number]['id'] = config['chains'][number]['id'],
+>(
+  parameters: useWatchContractEvent.Parameters<
+    abi,
+    eventName,
+    strict,
+    config,
+    chainId
+  > = () => ({}) as any,
+): useWatchContractEvent.ReturnType {
+  const config = useConfig(parameters)
+  const configChainId = useChainId(() => ({ config: config() }))
+  createEffect(() => {
+    const {
+      config: _,
+      chainId = configChainId(),
+      enabled = true,
+      onLogs,
+      ...rest
+    } = parameters()
+    if (!enabled) return
+    if (!onLogs) return
+    const unwatch = watchContractEvent(config(), {
+      ...(rest as any),
+      chainId,
+      onLogs,
+    })
+    onCleanup(() => unwatch())
+  })
+}
+
+export namespace useWatchContractEvent {
+  export type Parameters<
+    abi extends Abi | readonly unknown[] = Abi,
+    eventName extends ContractEventName<abi> = ContractEventName<abi>,
+    strict extends boolean | undefined = undefined,
+    config extends Config = Config,
+    chainId extends
+      config['chains'][number]['id'] = config['chains'][number]['id'],
+  > = Accessor<SolidParameters<abi, eventName, strict, config, chainId>>
+
+  export type ReturnType = void
+
+  export type SolidParameters<
+    abi extends Abi | readonly unknown[] = Abi,
+    eventName extends ContractEventName<abi> = ContractEventName<abi>,
+    strict extends boolean | undefined = undefined,
+    config extends Config = Config,
+    chainId extends
+      config['chains'][number]['id'] = config['chains'][number]['id'],
+  > = UnionCompute<
+    UnionExactPartial<
+      WatchContractEventParameters<abi, eventName, strict, config, chainId>
+    > &
+      ConfigParameter<config> &
+      EnabledParameter
+  >
+}

package/src/primitives/useWriteContract.ts

@@ -0,0 +1,78 @@
+import type {
+  Config,
+  ResolvedRegister,
+  WriteContractErrorType,
+} from '@wagmi/core'
+import type { Compute, ConfigParameter } from '@wagmi/core/internal'
+import {
+  type WriteContractData,
+  type WriteContractMutate,
+  type WriteContractMutateAsync,
+  type WriteContractOptions,
+  type WriteContractVariables,
+  writeContractMutationOptions,
+} from '@wagmi/core/query'
+import type { Accessor } from 'solid-js'
+import { mergeProps } from 'solid-js'
+import type { Abi } from 'viem'
+import { type UseMutationReturnType, useMutation } from '../utils/query.js'
+import { useConfig } from './useConfig.js'
+
+/** https://wagmi.sh/solid/api/primitives/useWriteContract */
+export function useWriteContract<
+  config extends Config = ResolvedRegister['config'],
+  context = unknown,
+>(
+  parameters: useWriteContract.Parameters<config, context> = () => ({}),
+): useWriteContract.ReturnType<config, context> {
+  const config = useConfig(parameters)
+  const mutation = useMutation(() =>
+    writeContractMutationOptions(config(), parameters()),
+  )
+  type Return = useWriteContract.ReturnType<config, context>
+  return mergeProps(mutation, {
+    get writeContract() {
+      return mutation.mutate as Return['mutate']
+    },
+    get writeContractAsync() {
+      return mutation.mutateAsync as Return['mutateAsync']
+    },
+  }) as unknown as Return
+}
+
+export namespace useWriteContract {
+  export type Parameters<
+    config extends Config = Config,
+    context = unknown,
+  > = Accessor<SolidParameters<config, context>>
+
+  export type ReturnType<
+    config extends Config = Config,
+    context = unknown,
+  > = Compute<
+    UseMutationReturnType<
+      WriteContractData,
+      WriteContractErrorType,
+      WriteContractVariables<
+        Abi,
+        string,
+        readonly unknown[],
+        config,
+        config['chains'][number]['id']
+      >,
+      context,
+      WriteContractMutate<config, context>,
+      WriteContractMutateAsync<config, context>
+    > & {
+      /** @deprecated use `mutate` instead */
+      writeContract: WriteContractMutate<config, context>
+      /** @deprecated use `mutateAsync` instead */
+      writeContractAsync: WriteContractMutateAsync<config, context>
+    }
+  >
+
+  export type SolidParameters<
+    config extends Config = Config,
+    context = unknown,
+  > = Compute<ConfigParameter<config> & WriteContractOptions<config, context>>
+}

package/src/primitives/useWriteContractSync.ts

@@ -0,0 +1,80 @@
+import type {
+  Config,
+  ResolvedRegister,
+  WriteContractSyncErrorType,
+} from '@wagmi/core'
+import type { Compute, ConfigParameter } from '@wagmi/core/internal'
+import {
+  type WriteContractSyncData,
+  type WriteContractSyncMutate,
+  type WriteContractSyncMutateAsync,
+  type WriteContractSyncOptions,
+  type WriteContractSyncVariables,
+  writeContractSyncMutationOptions,
+} from '@wagmi/core/query'
+import type { Accessor } from 'solid-js'
+import { mergeProps } from 'solid-js'
+import type { Abi } from 'viem'
+import { type UseMutationReturnType, useMutation } from '../utils/query.js'
+import { useConfig } from './useConfig.js'
+
+/** https://wagmi.sh/solid/api/primitives/useWriteContractSync */
+export function useWriteContractSync<
+  config extends Config = ResolvedRegister['config'],
+  context = unknown,
+>(
+  parameters: useWriteContractSync.Parameters<config, context> = () => ({}),
+): useWriteContractSync.ReturnType<config, context> {
+  const config = useConfig(parameters)
+  const mutation = useMutation(() =>
+    writeContractSyncMutationOptions(config(), parameters()),
+  )
+  type Return = useWriteContractSync.ReturnType<config, context>
+  return mergeProps(mutation, {
+    get writeContractSync() {
+      return mutation.mutate as Return['mutate']
+    },
+    get writeContractSyncAsync() {
+      return mutation.mutateAsync as Return['mutateAsync']
+    },
+  }) as unknown as Return
+}
+
+export namespace useWriteContractSync {
+  export type Parameters<
+    config extends Config = Config,
+    context = unknown,
+  > = Accessor<SolidParameters<config, context>>
+
+  export type ReturnType<
+    config extends Config = Config,
+    context = unknown,
+  > = Compute<
+    UseMutationReturnType<
+      WriteContractSyncData,
+      WriteContractSyncErrorType,
+      WriteContractSyncVariables<
+        Abi,
+        string,
+        readonly unknown[],
+        config,
+        config['chains'][number]['id']
+      >,
+      context,
+      WriteContractSyncMutate<config, context>,
+      WriteContractSyncMutateAsync<config, context>
+    > & {
+      /** @deprecated use `mutate` instead */
+      writeContractSync: WriteContractSyncMutate<config, context>
+      /** @deprecated use `mutateAsync` instead */
+      writeContractSyncAsync: WriteContractSyncMutateAsync<config, context>
+    }
+  >
+
+  export type SolidParameters<
+    config extends Config = Config,
+    context = unknown,
+  > = Compute<
+    ConfigParameter<config> & WriteContractSyncOptions<config, context>
+  >
+}

package/src/version.ts

@@ -1 +1 @@
-export const version = '0.0.12'
+export const version = '0.0.14'