wagmi/src/tempo/hooks/token.ts

React Hooks for Ethereum

import type { UseMutationResult } from '@tanstack/react-query'
import type { Config, ResolvedRegister } from '@wagmi/core'
import type {
  ConfigParameter,
  ExactPartial,
  UnionCompute,
} from '@wagmi/core/internal'
import { Actions } from '@wagmi/core/tempo'
import { useEffect } from 'react'
import { useChainId } from '../../hooks/useChainId.js'
import { useConfig } from '../../hooks/useConfig.js'
import {
  type UseMutationParameters,
  type UseQueryReturnType,
  useMutation,
  useQuery,
} from '../../utils/query.js'
import type { QueryParameter } from '../utils.js'

/**
 * Hook for approving a spender to transfer TIP20 tokens.
 *
 * @example
 * ```tsx
 * import { Hooks } from 'wagmi/tempo'
 *
 * function App() {
 *   const { mutate, isPending } = Hooks.token.useApprove()
 *
 *   return (
 *     <button
 *       onClick={() => mutate({ spender: '0x...', amount: 100n })}
 *       disabled={isPending}
 *     >
 *       Approve
 *     </button>
 *   )
 * }
 * ```
 *
 * @param parameters - Parameters.
 * @returns Mutation result.
 */
export function useApprove<
  config extends Config = ResolvedRegister['config'],
  context = unknown,
>(
  parameters: useApprove.Parameters<config, context> = {},
): useApprove.ReturnType<config, context> {
  const { mutation } = parameters
  const config = useConfig(parameters)
  return useMutation({
    ...mutation,
    async mutationFn(variables) {
      return Actions.token.approve(config, variables as never)
    },
    mutationKey: ['approve'],
  }) as never
}

export declare namespace useApprove {
  type Parameters<
    config extends Config = Config,
    context = unknown,
  > = ConfigParameter<config> & {
    mutation?:
      | UseMutationParameters<
          Actions.token.approve.ReturnValue,
          Actions.token.approve.ErrorType,
          Actions.token.approve.Parameters<config>,
          context
        >
      | undefined
  }

  type ReturnType<
    config extends Config = Config,
    context = unknown,
  > = UseMutationResult<
    Actions.token.approve.ReturnValue,
    Actions.token.approve.ErrorType,
    Actions.token.approve.Parameters<config>,
    context
  >
}

/**
 * Hook for approving a spender to transfer TIP20 tokens.
 *
 * Note: This is a synchronous hook that waits for the transaction
 * to be included on a block before returning a response.
 *
 * @example
 * ```tsx
 * import { Hooks } from 'wagmi/tempo'
 *
 * function App() {
 *   const { mutate, isPending } = Hooks.token.useApproveSync()
 *
 *   return (
 *     <button
 *       onClick={() => mutate({ spender: '0x...', amount: 100n })}
 *       disabled={isPending}
 *     >
 *       Approve
 *     </button>
 *   )
 * }
 * ```
 *
 * @param parameters - Parameters.
 * @returns Mutation result.
 */
export function useApproveSync<
  config extends Config = ResolvedRegister['config'],
  context = unknown,
>(
  parameters: useApproveSync.Parameters<config, context> = {},
): useApproveSync.ReturnType<config, context> {
  const { mutation } = parameters
  const config = useConfig(parameters)
  return useMutation({
    ...mutation,
    async mutationFn(variables) {
      return Actions.token.approveSync(config, variables as never)
    },
    mutationKey: ['approveSync'],
  }) as never
}

export declare namespace useApproveSync {
  type Parameters<
    config extends Config = Config,
    context = unknown,
  > = ConfigParameter<config> & {
    mutation?:
      | UseMutationParameters<
          Actions.token.approveSync.ReturnValue,
          Actions.token.approveSync.ErrorType,
          Actions.token.approveSync.Parameters<config>,
          context
        >
      | undefined
  }

  type ReturnType<
    config extends Config = Config,
    context = unknown,
  > = UseMutationResult<
    Actions.token.approveSync.ReturnValue,
    Actions.token.approveSync.ErrorType,
    Actions.token.approveSync.Parameters<config>,
    context
  >
}

/**
 * Hook for burning TIP20 tokens from the caller's balance.
 *
 * @example
 * ```tsx
 * import { Hooks } from 'wagmi/tempo'
 *
 * function App() {
 *   const { mutate, isPending } = Hooks.token.useBurn()
 *
 *   return (
 *     <button
 *       onClick={() => mutate({ amount: 100n, token: '0x...' })}
 *       disabled={isPending}
 *     >
 *       Burn
 *     </button>
 *   )
 * }
 * ```
 *
 * @param parameters - Parameters.
 * @returns Mutation result.
 */
export function useBurn<
  config extends Config = ResolvedRegister['config'],
  context = unknown,
>(
  parameters: useBurn.Parameters<config, context> = {},
): useBurn.ReturnType<config, context> {
  const { mutation } = parameters
  const config = useConfig(parameters)
  return useMutation({
    ...mutation,
    async mutationFn(variables) {
      return Actions.token.burn(config, variables as never)
    },
    mutationKey: ['burn'],
  }) as never
}

export declare namespace useBurn {
  type Parameters<
    config extends Config = Config,
    context = unknown,
  > = ConfigParameter<config> & {
    mutation?:
      | UseMutationParameters<
          Actions.token.burn.ReturnValue,
          Actions.token.burn.ErrorType,
          Actions.token.burn.Parameters<config>,
          context
        >
      | undefined
  }

  type ReturnType<
    config extends Config = Config,
    context = unknown,
  > = UseMutationResult<
    Actions.token.burn.ReturnValue,
    Actions.token.burn.ErrorType,
    Actions.token.burn.Parameters<config>,
    context
  >
}

/**
 * Hook for burning TIP20 tokens from the caller's balance.
 *
 * Note: This is a synchronous hook that waits for the transaction
 * to be included on a block before returning a response.
 *
 * @example
 * ```tsx
 * import { Hooks } from 'wagmi/tempo'
 *
 * function App() {
 *   const { mutate, isPending } = Hooks.token.useBurnSync()
 *
 *   return (
 *     <button
 *       onClick={() => mutate({ amount: 100n, token: '0x...' })}
 *       disabled={isPending}
 *     >
 *       Burn
 *     </button>
 *   )
 * }
 * ```
 *
 * @param parameters - Parameters.
 * @returns Mutation result.
 */
export function useBurnSync<
  config extends Config = ResolvedRegister['config'],
  context = unknown,
>(
  parameters: useBurnSync.Parameters<config, context> = {},
): useBurnSync.ReturnType<config, context> {
  const { mutation } = parameters
  const config = useConfig(parameters)
  return useMutation({
    ...mutation,
    async mutationFn(variables) {
      return Actions.token.burnSync(config, variables as never)
    },
    mutationKey: ['burnSync'],
  }) as never
}

export declare namespace useBurnSync {
  type Parameters<
    config extends Config = Config,
    context = unknown,
  > = ConfigParameter<config> & {
    mutation?:
      | UseMutationParameters<
          Actions.token.burnSync.ReturnValue,
          Actions.token.burnSync.ErrorType,
          Actions.token.burnSync.Parameters<config>,
          context
        >
      | undefined
  }

  type ReturnType<
    config extends Config = Config,
    context = unknown,
  > = UseMutationResult<
    Actions.token.burnSync.ReturnValue,
    Actions.token.burnSync.ErrorType,
    Actions.token.burnSync.Parameters<config>,
    context
  >
}

/**
 * Hook for burning TIP20 tokens from a blocked address.
 *
 * @example
 * ```tsx
 * import { Hooks } from 'wagmi/tempo'
 *
 * function App() {
 *   const { mutate, isPending } = Hooks.token.useBurnBlocked()
 *
 *   return (
 *     <button
 *       onClick={() => mutate({ from: '0x...', amount: 100n, token: '0x...' })}
 *       disabled={isPending}
 *     >
 *       Burn Blocked
 *     </button>
 *   )
 * }
 * ```
 *
 * @param parameters - Parameters.
 * @returns Mutation result.
 */
export function useBurnBlocked<
  config extends Config = ResolvedRegister['config'],
  context = unknown,
>(
  parameters: useBurnBlocked.Parameters<config, context> = {},
): useBurnBlocked.ReturnType<config, context> {
  const { mutation } = parameters
  const config = useConfig(parameters)
  return useMutation({
    ...mutation,
    async mutationFn(variables) {
      return Actions.token.burnBlocked(config, variables as never)
    },
    mutationKey: ['burnBlocked'],
  }) as never
}

export declare namespace useBurnBlocked {
  type Parameters<
    config extends Config = Config,
    context = unknown,
  > = ConfigParameter<config> & {
    mutation?:
      | UseMutationParameters<
          Actions.token.burnBlocked.ReturnValue,
          Actions.token.burnBlocked.ErrorType,
          Actions.token.burnBlocked.Parameters<config>,
          context
        >
      | undefined
  }

  type ReturnType<
    config extends Config = Config,
    context = unknown,
  > = UseMutationResult<
    Actions.token.burnBlocked.ReturnValue,
    Actions.token.burnBlocked.ErrorType,
    Actions.token.burnBlocked.Parameters<config>,
    context
  >
}

/**
 * Hook for burning TIP20 tokens from a blocked address.
 *
 * Note: This is a synchronous hook that waits for the transaction
 * to be included on a block before returning a response.
 *
 * @example
 * ```tsx
 * import { Hooks } from 'wagmi/tempo'
 *
 * function App() {
 *   const { mutate, isPending } = Hooks.token.useBurnBlockedSync()
 *
 *   return (
 *     <button
 *       onClick={() => mutate({ from: '0x...', amount: 100n, token: '0x...' })}
 *       disabled={isPending}
 *     >
 *       Burn Blocked
 *     </button>
 *   )
 * }
 * ```
 *
 * @param parameters - Parameters.
 * @returns Mutation result.
 */
export function useBurnBlockedSync<
  config extends Config = ResolvedRegister['config'],
  context = unknown,
>(
  parameters: useBurnBlockedSync.Parameters<config, context> = {},
): useBurnBlockedSync.ReturnType<config, context> {
  const { mutation } = parameters
  const config = useConfig(parameters)
  return useMutation({
    ...mutation,
    async mutationFn(variables) {
      return Actions.token.burnBlockedSync(config, variables as never)
    },
    mutationKey: ['burnBlockedSync'],
  }) as never
}

export declare namespace useBurnBlockedSync {
  type Parameters<
    config extends Config = Config,
    context = unknown,
  > = ConfigParameter<config> & {
    mutation?:
      | UseMutationParameters<
          Actions.token.burnBlockedSync.ReturnValue,
          Actions.token.burnBlockedSync.ErrorType,
          Actions.token.burnBlockedSync.Parameters<config>,
          context
        >
      | undefined
  }

  type ReturnType<
    config extends Config = Config,
    context = unknown,
  > = UseMutationResult<
    Actions.token.burnBlockedSync.ReturnValue,
    Actions.token.burnBlockedSync.ErrorType,
    Actions.token.burnBlockedSync.Parameters<config>,
    context
  >
}

/**
 * Hook for changing the transfer policy ID for a TIP20 token.
 *
 * @example
 * ```tsx
 * import { Hooks } from 'wagmi/tempo'
 *
 * function App() {
 *   const { mutate, isPending } = Hooks.token.useChangeTransferPolicy()
 *
 *   return (
 *     <button
 *       onClick={() => mutate({ token: '0x...', policyId: 1n })}
 *       disabled={isPending}
 *     >
 *       Change Policy
 *     </button>
 *   )
 * }
 * ```
 *
 * @param parameters - Parameters.
 * @returns Mutation result.
 */
export function useChangeTransferPolicy<
  config extends Config = ResolvedRegister['config'],
  context = unknown,
>(
  parameters: useChangeTransferPolicy.Parameters<config, context> = {},
): useChangeTransferPolicy.ReturnType<config, context> {
  const { mutation } = parameters
  const config = useConfig(parameters)
  return useMutation({
    ...mutation,
    async mutationFn(variables) {
      return Actions.token.changeTransferPolicy(config, variables as never)
    },
    mutationKey: ['changeTransferPolicy'],
  }) as never
}

export declare namespace useChangeTransferPolicy {
  type Parameters<
    config extends Config = Config,
    context = unknown,
  > = ConfigParameter<config> & {
    mutation?:
      | UseMutationParameters<
          Actions.token.changeTransferPolicy.ReturnValue,
          Actions.token.changeTransferPolicy.ErrorType,
          Actions.token.changeTransferPolicy.Parameters<config>,
          context
        >
      | undefined
  }

  type ReturnType<
    config extends Config = Config,
    context = unknown,
  > = UseMutationResult<
    Actions.token.changeTransferPolicy.ReturnValue,
    Actions.token.changeTransferPolicy.ErrorType,
    Actions.token.changeTransferPolicy.Parameters<config>,
    context
  >
}

/**
 * Hook for changing the transfer policy ID for a TIP20 token.
 *
 * Note: This is a synchronous hook that waits for the transaction
 * to be included on a block before returning a response.
 *
 * @example
 * ```tsx
 * import { Hooks } from 'wagmi/tempo'
 *
 * function App() {
 *   const { mutate, isPending } = Hooks.token.useChangeTransferPolicySync()
 *
 *   return (
 *     <button
 *       onClick={() => mutate({ token: '0x...', policyId: 1n })}
 *       disabled={isPending}
 *     >
 *       Change Policy
 *     </button>
 *   )
 * }
 * ```
 *
 * @param parameters - Parameters.
 * @returns Mutation result.
 */
export function useChangeTransferPolicySync<
  config extends Config = ResolvedRegister['config'],
  context = unknown,
>(
  parameters: useChangeTransferPolicySync.Parameters<config, context> = {},
): useChangeTransferPolicySync.ReturnType<config, context> {
  const { mutation } = parameters
  const config = useConfig(parameters)
  return useMutation({
    ...mutation,
    async mutationFn(variables) {
      return Actions.token.changeTransferPolicySync(config, variables as never)
    },
    mutationKey: ['changeTransferPolicySync'],
  }) as never
}

export declare namespace useChangeTransferPolicySync {
  type Parameters<
    config extends Config = Config,
    context = unknown,
  > = ConfigParameter<config> & {
    mutation?:
      | UseMutationParameters<
          Actions.token.changeTransferPolicySync.ReturnValue,
          Actions.token.changeTransferPolicySync.ErrorType,
          Actions.token.changeTransferPolicySync.Parameters<config>,
          context
        >
      | undefined
  }

  type ReturnType<
    config extends Config = Config,
    context = unknown,
  > = UseMutationResult<
    Actions.token.changeTransferPolicySync.ReturnValue,
    Actions.token.changeTransferPolicySync.ErrorType,
    Actions.token.changeTransferPolicySync.Parameters<config>,
    context
  >
}

/**
 * Hook for creating a new TIP20 token.
 *
 * @example
 * ```tsx
 * import { Hooks } from 'wagmi/tempo'
 *
 * function App() {
 *   const { mutate, isPending } = Hooks.token.useCreate()
 *
 *   return (
 *     <button
 *       onClick={() => mutate({ name: 'My Token', symbol: 'MTK', currency: 'USD' })}
 *       disabled={isPending}
 *     >
 *       Create Token
 *     </button>
 *   )
 * }
 * ```
 *
 * @param parameters - Parameters.
 * @returns Mutation result.
 */
export function useCreate<
  config extends Config = ResolvedRegister['config'],
  context = unknown,
>(
  parameters: useCreate.Parameters<config, context> = {},
): useCreate.ReturnType<config, context> {
  const { mutation } = parameters
  const config = useConfig(parameters)
  return useMutation({
    ...mutation,
    async mutationFn(variables) {
      return Actions.token.create(config, variables as never)
    },
    mutationKey: ['create'],
  }) as never
}

export declare namespace useCreate {
  type Parameters<
    config extends Config = Config,
    context = unknown,
  > = ConfigParameter<config> & {
    mutation?:
      | UseMutationParameters<
          Actions.token.create.ReturnValue,
          Actions.token.create.ErrorType,
          Actions.token.create.Parameters<config>,
          context
        >
      | undefined
  }

  type ReturnType<
    config extends Config = Config,
    context = unknown,
  > = UseMutationResult<
    Actions.token.create.ReturnValue,
    Actions.token.create.ErrorType,
    Actions.token.create.Parameters<config>,
    context
  >
}

/**
 * Hook for creating a new TIP20 token.
 *
 * Note: This is a synchronous hook that waits for the transaction
 * to be included on a block before returning a response.
 *
 * @example
 * ```tsx
 * import { Hooks } from 'wagmi/tempo'
 *
 * function App() {
 *   const { mutate, isPending } = Hooks.token.useCreateSync()
 *
 *   return (
 *     <button
 *       onClick={() => mutate({ name: 'My Token', symbol: 'MTK', currency: 'USD' })}
 *       disabled={isPending}
 *     >
 *       Create Token
 *     </button>
 *   )
 * }
 * ```
 *
 * @param parameters - Parameters.
 * @returns Mutation result.
 */
export function useCreateSync<
  config extends Config = ResolvedRegister['config'],
  context = unknown,
>(
  parameters: useCreateSync.Parameters<config, context> = {},
): useCreateSync.ReturnType<config, context> {
  const { mutation } = parameters
  const config = useConfig(parameters)
  return useMutation({
    ...mutation,
    async mutationFn(variables) {
      return Actions.token.createSync(config, variables as never)
    },
    mutationKey: ['createSync'],
  }) as never
}

export declare namespace useCreateSync {
  type Parameters<
    config extends Config = Config,
    context = unknown,
  > = ConfigParameter<config> & {
    mutation?:
      | UseMutationParameters<
          Actions.token.createSync.ReturnValue,
          Actions.token.createSync.ErrorType,
          Actions.token.createSync.Parameters<config>,
          context
        >
      | undefined
  }

  type ReturnType<
    config extends Config = Config,
    context = unknown,
  > = UseMutationResult<
    Actions.token.createSync.ReturnValue,
    Actions.token.createSync.ErrorType,
    Actions.token.createSync.Parameters<config>,
    context
  >
}

/**
 * Hook for updating the quote token for a TIP20 token.
 *
 * @example
 * ```tsx
 * import { Hooks } from 'wagmi/tempo'
 *
 * function App() {
 *   const { mutate, isPending } = Hooks.token.useUpdateQuoteToken()
 *
 *   return (
 *     <button
 *       onClick={() => mutate({ token: '0x...' })}
 *       disabled={isPending}
 *     >
 *       Update Quote Token
 *     </button>
 *   )
 * }
 * ```
 *
 * @param parameters - Parameters.
 * @returns Mutation result.
 */
export function useUpdateQuoteToken<
  config extends Config = ResolvedRegister['config'],
  context = unknown,
>(
  parameters: useUpdateQuoteToken.Parameters<config, context> = {},
): useUpdateQuoteToken.ReturnType<config, context> {
  const { mutation } = parameters
  const config = useConfig(parameters)
  return useMutation({
    ...mutation,
    async mutationFn(variables) {
      return Actions.token.updateQuoteToken(config, variables as never)
    },
    mutationKey: ['updateQuoteToken'],
  }) as never
}

export declare namespace useUpdateQuoteToken {
  type Parameters<
    config extends Config = Config,
    context = unknown,
  > = ConfigParameter<config> & {
    mutation?:
      | UseMutationParameters<
          Actions.token.updateQuoteToken.ReturnValue,
          Actions.token.updateQuoteToken.ErrorType,
          Actions.token.updateQuoteToken.Parameters<config>,
          context
        >
      | undefined
  }

  type ReturnType<
    config extends Config = Config,
    context = unknown,
  > = UseMutationResult<
    Actions.token.updateQuoteToken.ReturnValue,
    Actions.token.updateQuoteToken.ErrorType,
    Actions.token.updateQuoteToken.Parameters<config>,
    context
  >
}

/**
 * Hook for updating the quote token for a TIP20 token.
 *
 * Note: This is a synchronous hook that waits for the transaction
 * to be included on a block before returning a response.
 *
 * @example
 * ```tsx
 * import { Hooks } from 'wagmi/tempo'
 *
 * function App() {
 *   const { mutate, isPending } = Hooks.token.useUpdateQuoteTokenSync()
 *
 *   return (
 *     <button
 *       onClick={() => mutate({ token: '0x...' })}
 *       disabled={isPending}
 *     >
 *       Update Quote Token
 *     </button>
 *   )
 * }
 * ```
 *
 * @param parameters - Parameters.
 * @returns Mutation result.
 */
export function useUpdateQuoteTokenSync<
  config extends Config = ResolvedRegister['config'],
  context = unknown,
>(
  parameters: useUpdateQuoteTokenSync.Parameters<config, context> = {},
): useUpdateQuoteTokenSync.ReturnType<config, context> {
  const { mutation } = parameters
  const config = useConfig(parameters)
  return useMutation({
    ...mutation,
    async mutationFn(variables) {
      return Actions.token.updateQuoteTokenSync(config, variables as never)
    },
    mutationKey: ['updateQuoteTokenSync'],
  }) as never
}

export declare namespace useUpdateQuoteTokenSync {
  type Parameters<
    config extends Config = Config,
    context = unknown,
  > = ConfigParameter<config> & {
    mutation?:
      | UseMutationParameters<
          Actions.token.updateQuoteTokenSync.ReturnValue,
          Actions.token.updateQuoteTokenSync.ErrorType,
          Actions.token.updateQuoteTokenSync.Parameters<config>,
          context
        >
      | undefined
  }

  type ReturnType<
    config extends Config = Config,
    context = unknown,
  > = UseMutationResult<
    Actions.token.updateQuoteTokenSync.ReturnValue,
    Actions.token.updateQuoteTokenSync.ErrorType,
    Actions.token.updateQuoteTokenSync.Parameters<config>,
    context
  >
}

/**
 * Hook for getting TIP20 token allowance.
 *
 * @example
 * ```tsx
 * import { Hooks } from 'wagmi/tempo'
 *
 * function App() {
 *   const { data, isLoading } = Hooks.token.useGetAllowance({
 *     account: '0x...',
 *     spender: '0x...',
 *   })
 *
 *   if (isLoading) return <div>Loading...</div>
 *   return <div>Allowance: {data?.toString()}</div>
 * }
 * ```
 *
 * @param parameters - Parameters.
 * @returns Query result with token allowance.
 */
export function useGetAllowance<
  config extends Config = ResolvedRegister['config'],
  selectData = Actions.token.getAllowance.ReturnValue,
>(
  parameters: useGetAllowance.Parameters<config, selectData> = {},
): useGetAllowance.ReturnValue<selectData> {
  const config = useConfig(parameters)
  const chainId = useChainId({ config })
  const options = Actions.token.getAllowance.queryOptions(config, {
    ...parameters,
    chainId: parameters.chainId ?? chainId,
  } as never)
  return useQuery(options) as never
}

export declare namespace useGetAllowance {
  export type Parameters<
    config extends Config = ResolvedRegister['config'],
    selectData = Actions.token.getAllowance.ReturnValue,
  > = ConfigParameter<config> &
    QueryParameter<
      Actions.token.getAllowance.ReturnValue,
      Actions.token.getAllowance.ErrorType,
      selectData,
      Actions.token.getAllowance.QueryKey<config>
    > &
    ExactPartial<Actions.token.getAllowance.Parameters<config>>

  export type ReturnValue<selectData = Actions.token.getAllowance.ReturnValue> =
    UseQueryReturnType<selectData, Error>
}

/**
 * Hook for getting TIP20 token balance for an address.
 *
 * @example
 * ```tsx
 * import { Hooks } from 'wagmi/tempo'
 *
 * function App() {
 *   const { data, isLoading } = Hooks.token.useGetBalance({
 *     account: '0x...',
 *   })
 *
 *   if (isLoading) return <div>Loading...</div>
 *   return <div>Balance: {data?.toString()}</div>
 * }
 * ```
 *
 * @param parameters - Parameters.
 * @returns Query result with token balance.
 */
export function useGetBalance<
  config extends Config = ResolvedRegister['config'],
  selectData = Actions.token.getBalance.ReturnValue,
>(
  parameters: useGetBalance.Parameters<config, selectData> = {},
): useGetBalance.ReturnValue<selectData> {
  const config = useConfig(parameters)
  const chainId = useChainId({ config })
  const options = Actions.token.getBalance.queryOptions(config, {
    ...parameters,
    chainId: parameters.chainId ?? chainId,
  } as never)
  return useQuery(options) as never
}

export declare namespace useGetBalance {
  export type Parameters<
    config extends Config = ResolvedRegister['config'],
    selectData = Actions.token.getBalance.ReturnValue,
  > = ConfigParameter<config> &
    QueryParameter<
      Actions.token.getBalance.ReturnValue,
      Actions.token.getBalance.ErrorType,
      selectData,
      Actions.token.getBalance.QueryKey<config>
    > &
    ExactPartial<Actions.token.getBalance.Parameters<config>>

  export type ReturnValue<selectData = Actions.token.getBalance.ReturnValue> =
    UseQueryReturnType<selectData, Error>
}

/**
 * Hook for getting TIP20 token metadata.
 *
 * @example
 * ```tsx
 * import { Hooks } from 'wagmi/tempo'
 *
 * function App() {
 *   const { data, isLoading } = Hooks.token.useGetMetadata({
 *     token: '0x...',
 *   })
 *
 *   if (isLoading) return <div>Loading...</div>
 *   return <div>{data?.name} ({data?.symbol})</div>
 * }
 * ```
 *
 * @param parameters - Parameters.
 * @returns Query result with token metadata.
 */
export function useGetMetadata<
  config extends Config = ResolvedRegister['config'],
  selectData = Actions.token.getMetadata.ReturnValue,
>(
  parameters: useGetMetadata.Parameters<config, selectData> = {},
): useGetMetadata.ReturnValue<selectData> {
  const config = useConfig(parameters)
  const chainId = useChainId({ config })
  const options = Actions.token.getMetadata.queryOptions(config, {
    ...parameters,
    chainId: parameters.chainId ?? chainId,
  } as never)
  return useQuery(options) as never
}

export declare namespace useGetMetadata {
  export type Parameters<
    config extends Config = ResolvedRegister['config'],
    selectData = Actions.token.getMetadata.ReturnValue,
  > = ConfigParameter<config> &
    QueryParameter<
      Actions.token.getMetadata.ReturnValue,
      Actions.token.getMetadata.ErrorType,
      selectData,
      Actions.token.getMetadata.QueryKey<config>
    > &
    ExactPartial<Actions.token.getMetadata.Parameters<config>>

  export type ReturnValue<selectData = Actions.token.getMetadata.ReturnValue> =
    UseQueryReturnType<selectData, Error>
}

/**
 * Hook for getting the admin role for a specific role in a TIP20 token.
 *
 * @example
 * ```tsx
 * import { Hooks } from 'wagmi/tempo'
 *
 * function App() {
 *   const { data, isLoading } = Hooks.token.useGetRoleAdmin({
 *     role: 'issuer',
 *     token: '0x...',
 *   })
 *
 *   if (isLoading) return <div>Loading...</div>
 *   return <div>Admin Role: {data}</div>
 * }
 * ```
 *
 * @param parameters - Parameters.
 * @returns Query result with admin role hash.
 */
export function useGetRoleAdmin<
  config extends Config = ResolvedRegister['config'],
  selectData = Actions.token.getRoleAdmin.ReturnValue,
>(
  parameters: useGetRoleAdmin.Parameters<config, selectData>,
): useGetRoleAdmin.ReturnValue<selectData> {
  const config = useConfig(parameters)
  const chainId = useChainId({ config })
  const options = Actions.token.getRoleAdmin.queryOptions(config, {
    ...parameters,
    chainId: parameters.chainId ?? chainId,
  } as never)
  return useQuery(options) as never
}

export declare namespace useGetRoleAdmin {
  export type Parameters<
    config extends Config = ResolvedRegister['config'],
    selectData = Actions.token.getRoleAdmin.ReturnValue,
  > = ConfigParameter<config> &
    QueryParameter<
      Actions.token.getRoleAdmin.ReturnValue,
      Actions.token.getRoleAdmin.ErrorType,
      selectData,
      Actions.token.getRoleAdmin.QueryKey<config>
    > &
    ExactPartial<Actions.token.getRoleAdmin.Parameters<config>>

  export type ReturnValue<selectData = Actions.token.getRoleAdmin.ReturnValue> =
    UseQueryReturnType<selectData, Error>
}

/**
 * Hook for granting roles for a TIP20 token.
 *
 * @example
 * ```tsx
 * import { Hooks } from 'wagmi/tempo'
 *
 * function App() {
 *   const { mutate, isPending } = Hooks.token.useGrantRoles()
 *
 *   return (
 *     <button
 *       onClick={() => mutate({ token: '0x...', to: '0x...', roles: ['issuer'] })}
 *       disabled={isPending}
 *     >
 *       Grant Roles
 *     </button>
 *   )
 * }
 * ```
 *
 * @param parameters - Parameters.
 * @returns Mutation result.
 */
export function useGrantRoles<
  config extends Config = ResolvedRegister['config'],
  context = unknown,
>(
  parameters: useGrantRoles.Parameters<config, context> = {},
): useGrantRoles.ReturnType<config, context> {
  const { mutation } = parameters
  const config = useConfig(parameters)
  return useMutation({
    ...mutation,
    async mutationFn(variables) {
      return Actions.token.grantRoles(config, variables as never)
    },
    mutationKey: ['grantRoles'],
  }) as never
}

export declare namespace useGrantRoles {
  type Parameters<
    config extends Config = Config,
    context = unknown,
  > = ConfigParameter<config> & {
    mutation?:
      | UseMutationParameters<
          Actions.token.grantRoles.ReturnValue,
          Actions.token.grantRoles.ErrorType,
          Actions.token.grantRoles.Parameters<config>,
          context
        >
      | undefined
  }

  type ReturnType<
    config extends Config = Config,
    context = unknown,
  > = UseMutationResult<
    Actions.token.grantRoles.ReturnValue,
    Actions.token.grantRoles.ErrorType,
    Actions.token.grantRoles.Parameters<config>,
    context
  >
}

/**
 * Hook for granting roles for a TIP20 token.
 *
 * Note: This is a synchronous hook that waits for the transaction
 * to be included on a block before returning a response.
 *
 * @example
 * ```tsx
 * import { Hooks } from 'wagmi/tempo'
 *
 * function App() {
 *   const { mutate, isPending } = Hooks.token.useGrantRolesSync()
 *
 *   return (
 *     <button
 *       onClick={() => mutate({ token: '0x...', to: '0x...', roles: ['issuer'] })}
 *       disabled={isPending}
 *     >
 *       Grant Roles
 *     </button>
 *   )
 * }
 * ```
 *
 * @param parameters - Parameters.
 * @returns Mutation result.
 */
export function useGrantRolesSync<
  config extends Config = ResolvedRegister['config'],
  context = unknown,
>(
  parameters: useGrantRolesSync.Parameters<config, context> = {},
): useGrantRolesSync.ReturnType<config, context> {
  const { mutation } = parameters
  const config = useConfig(parameters)
  return useMutation({
    ...mutation,
    async mutationFn(variables) {
      return Actions.token.grantRolesSync(config, variables as never)
    },
    mutationKey: ['grantRolesSync'],
  }) as never
}

export declare namespace useGrantRolesSync {
  type Parameters<
    config extends Config = Config,
    context = unknown,
  > = ConfigParameter<config> & {
    mutation?:
      | UseMutationParameters<
          Actions.token.grantRolesSync.ReturnValue,
          Actions.token.grantRolesSync.ErrorType,
          Actions.token.grantRolesSync.Parameters<config>,
          context
        >
      | undefined
  }

  type ReturnType<
    config extends Config = Config,
    context = unknown,
  > = UseMutationResult<
    Actions.token.grantRolesSync.ReturnValue,
    Actions.token.grantRolesSync.ErrorType,
    Actions.token.grantRolesSync.Parameters<config>,
    context
  >
}

/**
 * Hook for checking if an account has a specific role for a TIP20 token.
 *
 * @example
 * ```tsx
 * import { Hooks } from 'wagmi/tempo'
 *
 * function App() {
 *   const { data, isLoading } = Hooks.token.useHasRole({
 *     account: '0x...',
 *     role: 'issuer',
 *     token: '0x...',
 *   })
 *
 *   if (isLoading) return <div>Loading...</div>
 *   return <div>Has Role: {data ? 'Yes' : 'No'}</div>
 * }
 * ```
 *
 * @param parameters - Parameters.
 * @returns Query result with boolean indicating if account has role.
 */
export function useHasRole<
  config extends Config = ResolvedRegister['config'],
  selectData = Actions.token.hasRole.ReturnValue,
>(
  parameters: useHasRole.Parameters<config, selectData>,
): useHasRole.ReturnValue<selectData> {
  const config = useConfig(parameters)
  const chainId = useChainId({ config })
  const options = Actions.token.hasRole.queryOptions(config, {
    ...parameters,
    chainId: parameters.chainId ?? chainId,
  } as never)
  return useQuery(options) as never
}

export declare namespace useHasRole {
  export type Parameters<
    config extends Config = ResolvedRegister['config'],
    selectData = Actions.token.hasRole.ReturnValue,
  > = ConfigParameter<config> &
    QueryParameter<
      Actions.token.hasRole.ReturnValue,
      Actions.token.hasRole.ErrorType,
      selectData,
      Actions.token.hasRole.QueryKey<config>
    > &
    ExactPartial<Actions.token.hasRole.Parameters<config>>

  export type ReturnValue<selectData = Actions.token.hasRole.ReturnValue> =
    UseQueryReturnType<selectData, Error>
}

/**
 * Hook for minting TIP20 tokens to an address.
 *
 * @example
 * ```tsx
 * import { Hooks } from 'wagmi/tempo'
 *
 * function App() {
 *   const { mutate, isPending } = Hooks.token.useMint()
 *
 *   return (
 *     <button
 *       onClick={() => mutate({ to: '0x...', amount: 100n, token: '0x...' })}
 *       disabled={isPending}
 *     >
 *       Mint
 *     </button>
 *   )
 * }
 * ```
 *
 * @param parameters - Parameters.
 * @returns Mutation result.
 */
export function useMint<
  config extends Config = ResolvedRegister['config'],
  context = unknown,
>(
  parameters: useMint.Parameters<config, context> = {},
): useMint.ReturnType<config, context> {
  const { mutation } = parameters
  const config = useConfig(parameters)
  return useMutation({
    ...mutation,
    async mutationFn(variables) {
      return Actions.token.mint(config, variables as never)
    },
    mutationKey: ['mint'],
  }) as never
}

export declare namespace useMint {
  type Parameters<
    config extends Config = Config,
    context = unknown,
  > = ConfigParameter<config> & {
    mutation?:
      | UseMutationParameters<
          Actions.token.mint.ReturnValue,
          Actions.token.mint.ErrorType,
          Actions.token.mint.Parameters<config>,
          context
        >
      | undefined
  }

  type ReturnType<
    config extends Config = Config,
    context = unknown,
  > = UseMutationResult<
    Actions.token.mint.ReturnValue,
    Actions.token.mint.ErrorType,
    Actions.token.mint.Parameters<config>,
    context
  >
}

/**
 * Hook for minting TIP20 tokens to an address.
 *
 * Note: This is a synchronous hook that waits for the transaction
 * to be included on a block before returning a response.
 *
 * @example
 * ```tsx
 * import { Hooks } from 'wagmi/tempo'
 *
 * function App() {
 *   const { mutate, isPending } = Hooks.token.useMintSync()
 *
 *   return (
 *     <button
 *       onClick={() => mutate({ to: '0x...', amount: 100n, token: '0x...' })}
 *       disabled={isPending}
 *     >
 *       Mint
 *     </button>
 *   )
 * }
 * ```
 *
 * @param parameters - Parameters.
 * @returns Mutation result.
 */
export function useMintSync<
  config extends Config = ResolvedRegister['config'],
  context = unknown,
>(
  parameters: useMintSync.Parameters<config, context> = {},
): useMintSync.ReturnType<config, context> {
  const { mutation } = parameters
  const config = useConfig(parameters)
  return useMutation({
    ...mutation,
    async mutationFn(variables) {
      return Actions.token.mintSync(config, variables as never)
    },
    mutationKey: ['mintSync'],
  }) as never
}

export declare namespace useMintSync {
  type Parameters<
    config extends Config = Config,
    context = unknown,
  > = ConfigParameter<config> & {
    mutation?:
      | UseMutationParameters<
          Actions.token.mintSync.ReturnValue,
          Actions.token.mintSync.ErrorType,
          Actions.token.mintSync.Parameters<config>,
          context
        >
      | undefined
  }

  type ReturnType<
    config extends Config = Config,
    context = unknown,
  > = UseMutationResult<
    Actions.token.mintSync.ReturnValue,
    Actions.token.mintSync.ErrorType,
    Actions.token.mintSync.Parameters<config>,
    context
  >
}

/**
 * Hook for pausing a TIP20 token.
 *
 * @example
 * ```tsx
 * import { Hooks } from 'wagmi/tempo'
 *
 * function App() {
 *   const { mutate, isPending } = Hooks.token.usePause()
 *
 *   return (
 *     <button
 *       onClick={() => mutate({ token: '0x...' })}
 *       disabled={isPending}
 *     >
 *       Pause
 *     </button>
 *   )
 * }
 * ```
 *
 * @param parameters - Parameters.
 * @returns Mutation result.
 */
export function usePause<
  config extends Config = ResolvedRegister['config'],
  context = unknown,
>(
  parameters: usePause.Parameters<config, context> = {},
): usePause.ReturnType<config, context> {
  const { mutation } = parameters
  const config = useConfig(parameters)
  return useMutation({
    ...mutation,
    async mutationFn(variables) {
      return Actions.token.pause(config, variables as never)
    },
    mutationKey: ['pause'],
  }) as never
}

export declare namespace usePause {
  type Parameters<
    config extends Config = Config,
    context = unknown,
  > = ConfigParameter<config> & {
    mutation?:
      | UseMutationParameters<
          Actions.token.pause.ReturnValue,
          Actions.token.pause.ErrorType,
          Actions.token.pause.Parameters<config>,
          context
        >
      | undefined
  }

  type ReturnType<
    config extends Config = Config,
    context = unknown,
  > = UseMutationResult<
    Actions.token.pause.ReturnValue,
    Actions.token.pause.ErrorType,
    Actions.token.pause.Parameters<config>,
    context
  >
}

/**
 * Hook for pausing a TIP20 token.
 *
 * Note: This is a synchronous hook that waits for the transaction
 * to be included on a block before returning a response.
 *
 * @example
 * ```tsx
 * import { Hooks } from 'wagmi/tempo'
 *
 * function App() {
 *   const { mutate, isPending } = Hooks.token.usePauseSync()
 *
 *   return (
 *     <button
 *       onClick={() => mutate({ token: '0x...' })}
 *       disabled={isPending}
 *     >
 *       Pause
 *     </button>
 *   )
 * }
 * ```
 *
 * @param parameters - Parameters.
 * @returns Mutation result.
 */
export function usePauseSync<
  config extends Config = ResolvedRegister['config'],
  context = unknown,
>(
  parameters: usePauseSync.Parameters<config, context> = {},
): usePauseSync.ReturnType<config, context> {
  const { mutation } = parameters
  const config = useConfig(parameters)
  return useMutation({
    ...mutation,
    async mutationFn(variables) {
      return Actions.token.pauseSync(config, variables as never)
    },
    mutationKey: ['pauseSync'],
  }) as never
}

export declare namespace usePauseSync {
  type Parameters<
    config extends Config = Config,
    context = unknown,
  > = ConfigParameter<config> & {
    mutation?:
      | UseMutationParameters<
          Actions.token.pauseSync.ReturnValue,
          Actions.token.pauseSync.ErrorType,
          Actions.token.pauseSync.Parameters<config>,
          context
        >
      | undefined
  }

  type ReturnType<
    config extends Config = Config,
    context = unknown,
  > = UseMutationResult<
    Actions.token.pauseSync.ReturnValue,
    Actions.token.pauseSync.ErrorType,
    Actions.token.pauseSync.Parameters<config>,
    context
  >
}

/**
 * Hook for renouncing roles for a TIP20 token.
 *
 * @example
 * ```tsx
 * import { Hooks } from 'wagmi/tempo'
 *
 * function App() {
 *   const { mutate, isPending } = Hooks.token.useRenounceRoles()
 *
 *   return (
 *     <button
 *       onClick={() => mutate({ token: '0x...', roles: ['issuer'] })}
 *       disabled={isPending}
 *     >
 *       Renounce Roles
 *     </button>
 *   )
 * }
 * ```
 *
 * @param parameters - Parameters.
 * @returns Mutation result.
 */
export function useRenounceRoles<
  config extends Config = ResolvedRegister['config'],
  context = unknown,
>(
  parameters: useRenounceRoles.Parameters<config, context> = {},
): useRenounceRoles.ReturnType<config, context> {
  const { mutation } = parameters
  const config = useConfig(parameters)
  return useMutation({
    ...mutation,
    async mutationFn(variables) {
      return Actions.token.renounceRoles(config, variables as never)
    },
    mutationKey: ['renounceRoles'],
  }) as never
}

export declare namespace useRenounceRoles {
  type Parameters<
    config extends Config = Config,
    context = unknown,
  > = ConfigParameter<config> & {
    mutation?:
      | UseMutationParameters<
          Actions.token.renounceRoles.ReturnValue,
          Actions.token.renounceRoles.ErrorType,
          Actions.token.renounceRoles.Parameters<config>,
          context
        >
      | undefined
  }

  type ReturnType<
    config extends Config = Config,
    context = unknown,
  > = UseMutationResult<
    Actions.token.renounceRoles.ReturnValue,
    Actions.token.renounceRoles.ErrorType,
    Actions.token.renounceRoles.Parameters<config>,
    context
  >
}

/**
 * Hook for renouncing roles for a TIP20 token.
 *
 * Note: This is a synchronous hook that waits for the transaction
 * to be included on a block before returning a response.
 *
 * @example
 * ```tsx
 * import { Hooks } from 'wagmi/tempo'
 *
 * function App() {
 *   const { mutate, isPending } = Hooks.token.useRenounceRolesSync()
 *
 *   return (
 *     <button
 *       onClick={() => mutate({ token: '0x...', roles: ['issuer'] })}
 *       disabled={isPending}
 *     >
 *       Renounce Roles
 *     </button>
 *   )
 * }
 * ```
 *
 * @param parameters - Parameters.
 * @returns Mutation result.
 */
export function useRenounceRolesSync<
  config extends Config = ResolvedRegister['config'],
  context = unknown,
>(
  parameters: useRenounceRolesSync.Parameters<config, context> = {},
): useRenounceRolesSync.ReturnType<config, context> {
  const { mutation } = parameters
  const config = useConfig(parameters)
  return useMutation({
    ...mutation,
    async mutationFn(variables) {
      return Actions.token.renounceRolesSync(config, variables as never)
    },
    mutationKey: ['renounceRolesSync'],
  }) as never
}

export declare namespace useRenounceRolesSync {
  type Parameters<
    config extends Config = Config,
    context = unknown,
  > = ConfigParameter<config> & {
    mutation?:
      | UseMutationParameters<
          Actions.token.renounceRolesSync.ReturnValue,
          Actions.token.renounceRolesSync.ErrorType,
          Actions.token.renounceRolesSync.Parameters<config>,
          context
        >
      | undefined
  }

  type ReturnType<
    config extends Config = Config,
    context = unknown,
  > = UseMutationResult<
    Actions.token.renounceRolesSync.ReturnValue,
    Actions.token.renounceRolesSync.ErrorType,
    Actions.token.renounceRolesSync.Parameters<config>,
    context
  >
}

/**
 * Hook for revoking roles for a TIP20 token.
 *
 * @example
 * ```tsx
 * import { Hooks } from 'wagmi/tempo'
 *
 * function App() {
 *   const { mutate, isPending } = Hooks.token.useRevokeRoles()
 *
 *   return (
 *     <button
 *       onClick={() => mutate({ token: '0x...', from: '0x...', roles: ['issuer'] })}
 *       disabled={isPending}
 *     >
 *       Revoke Roles
 *     </button>
 *   )
 * }
 * ```
 *
 * @param parameters - Parameters.
 * @returns Mutation result.
 */
export function useRevokeRoles<
  config extends Config = ResolvedRegister['config'],
  context = unknown,
>(
  parameters: useRevokeRoles.Parameters<config, context> = {},
): useRevokeRoles.ReturnType<config, context> {
  const { mutation } = parameters
  const config = useConfig(parameters)
  return useMutation({
    ...mutation,
    async mutationFn(variables) {
      return Actions.token.revokeRoles(config, variables as never)
    },
    mutationKey: ['revokeRoles'],
  }) as never
}

export declare namespace useRevokeRoles {
  type Parameters<
    config extends Config = Config,
    context = unknown,
  > = ConfigParameter<config> & {
    mutation?:
      | UseMutationParameters<
          Actions.token.revokeRoles.ReturnValue,
          Actions.token.revokeRoles.ErrorType,
          Actions.token.revokeRoles.Parameters<config>,
          context
        >
      | undefined
  }

  type ReturnType<
    config extends Config = Config,
    context = unknown,
  > = UseMutationResult<
    Actions.token.revokeRoles.ReturnValue,
    Actions.token.revokeRoles.ErrorType,
    Actions.token.revokeRoles.Parameters<config>,
    context
  >
}

/**
 * Hook for revoking roles for a TIP20 token.
 *
 * Note: This is a synchronous hook that waits for the transaction
 * to be included on a block before returning a response.
 *
 * @example
 * ```tsx
 * import { Hooks } from 'wagmi/tempo'
 *
 * function App() {
 *   const { mutate, isPending } = Hooks.token.useRevokeRolesSync()
 *
 *   return (
 *     <button
 *       onClick={() => mutate({ token: '0x...', from: '0x...', roles: ['issuer'] })}
 *       disabled={isPending}
 *     >
 *       Revoke Roles
 *     </button>
 *   )
 * }
 * ```
 *
 * @param parameters - Parameters.
 * @returns Mutation result.
 */
export function useRevokeRolesSync<
  config extends Config = ResolvedRegister['config'],
  context = unknown,
>(
  parameters: useRevokeRolesSync.Parameters<config, context> = {},
): useRevokeRolesSync.ReturnType<config, context> {
  const { mutation } = parameters
  const config = useConfig(parameters)
  return useMutation({
    ...mutation,
    async mutationFn(variables) {
      return Actions.token.revokeRolesSync(config, variables as never)
    },
    mutationKey: ['revokeRolesSync'],
  }) as never
}

export declare namespace useRevokeRolesSync {
  type Parameters<
    config extends Config = Config,
    context = unknown,
  > = ConfigParameter<config> & {
    mutation?:
      | UseMutationParameters<
          Actions.token.revokeRolesSync.ReturnValue,
          Actions.token.revokeRolesSync.ErrorType,
          Actions.token.revokeRolesSync.Parameters<config>,
          context
        >
      | undefined
  }

  type ReturnType<
    config extends Config = Config,
    context = unknown,
  > = UseMutationResult<
    Actions.token.revokeRolesSync.ReturnValue,
    Actions.token.revokeRolesSync.ErrorType,
    Actions.token.revokeRolesSync.Parameters<config>,
    context
  >
}

/**
 * Hook for setting the admin role for a specific role in a TIP20 token.
 *
 * @example
 * ```tsx
 * import { Hooks } from 'wagmi/tempo'
 *
 * function App() {
 *   const { mutate, isPending } = Hooks.token.useSetRoleAdmin()
 *
 *   return (
 *     <button
 *       onClick={() => mutate({ token: '0x...', role: 'issuer', adminRole: 'pause' })}
 *       disabled={isPending}
 *     >
 *       Set Role Admin
 *     </button>
 *   )
 * }
 * ```
 *
 * @param parameters - Parameters.
 * @returns Mutation result.
 */
export function useSetRoleAdmin<
  config extends Config = ResolvedRegister['config'],
  context = unknown,
>(
  parameters: useSetRoleAdmin.Parameters<config, context> = {},
): useSetRoleAdmin.ReturnType<config, context> {
  const { mutation } = parameters
  const config = useConfig(parameters)
  return useMutation({
    ...mutation,
    async mutationFn(variables) {
      return Actions.token.setRoleAdmin(config, variables as never)
    },
    mutationKey: ['setRoleAdmin'],
  }) as never
}

export declare namespace useSetRoleAdmin {
  type Parameters<
    config extends Config = Config,
    context = unknown,
  > = ConfigParameter<config> & {
    mutation?:
      | UseMutationParameters<
          Actions.token.setRoleAdmin.ReturnValue,
          Actions.token.setRoleAdmin.ErrorType,
          Actions.token.setRoleAdmin.Parameters<config>,
          context
        >
      | undefined
  }

  type ReturnType<
    config extends Config = Config,
    context = unknown,
  > = UseMutationResult<
    Actions.token.setRoleAdmin.ReturnValue,
    Actions.token.setRoleAdmin.ErrorType,
    Actions.token.setRoleAdmin.Parameters<config>,
    context
  >
}

/**
 * Hook for setting the admin role for a specific role in a TIP20 token.
 *
 * Note: This is a synchronous hook that waits for the transaction
 * to be included on a block before returning a response.
 *
 * @example
 * ```tsx
 * import { Hooks } from 'wagmi/tempo'
 *
 * function App() {
 *   const { mutate, isPending } = Hooks.token.useSetRoleAdminSync()
 *
 *   return (
 *     <button
 *       onClick={() => mutate({ token: '0x...', role: 'issuer', adminRole: 'pause' })}
 *       disabled={isPending}
 *     >
 *       Set Role Admin
 *     </button>
 *   )
 * }
 * ```
 *
 * @param parameters - Parameters.
 * @returns Mutation result.
 */
export function useSetRoleAdminSync<
  config extends Config = ResolvedRegister['config'],
  context = unknown,
>(
  parameters: useSetRoleAdminSync.Parameters<config, context> = {},
): useSetRoleAdminSync.ReturnType<config, context> {
  const { mutation } = parameters
  const config = useConfig(parameters)
  return useMutation({
    ...mutation,
    async mutationFn(variables) {
      return Actions.token.setRoleAdminSync(config, variables as never)
    },
    mutationKey: ['setRoleAdminSync'],
  }) as never
}

export declare namespace useSetRoleAdminSync {
  type Parameters<
    config extends Config = Config,
    context = unknown,
  > = ConfigParameter<config> & {
    mutation?:
      | UseMutationParameters<
          Actions.token.setRoleAdminSync.ReturnValue,
          Actions.token.setRoleAdminSync.ErrorType,
          Actions.token.setRoleAdminSync.Parameters<config>,
          context
        >
      | undefined
  }

  type ReturnType<
    config extends Config = Config,
    context = unknown,
  > = UseMutationResult<
    Actions.token.setRoleAdminSync.ReturnValue,
    Actions.token.setRoleAdminSync.ErrorType,
    Actions.token.setRoleAdminSync.Parameters<config>,
    context
  >
}

/**
 * Hook for setting the supply cap for a TIP20 token.
 *
 * @example
 * ```tsx
 * import { Hooks } from 'wagmi/tempo'
 *
 * function App() {
 *   const { mutate, isPending } = Hooks.token.useSetSupplyCap()
 *
 *   return (
 *     <button
 *       onClick={() => mutate({ token: '0x...', supplyCap: 1000000n })}
 *       disabled={isPending}
 *     >
 *       Set Supply Cap
 *     </button>
 *   )
 * }
 * ```
 *
 * @param parameters - Parameters.
 * @returns Mutation result.
 */
export function useSetSupplyCap<
  config extends Config = ResolvedRegister['config'],
  context = unknown,
>(
  parameters: useSetSupplyCap.Parameters<config, context