tempo.ts 0.1.5 → 0.2.0

package/src/wagmi/Hooks/dex.ts

@@ -0,0 +1,1685 @@
+import type { DefaultError, InfiniteData } from '@tanstack/query-core'
+import type { UseMutationResult } from '@tanstack/react-query'
+import type { Config, ResolvedRegister } from '@wagmi/core'
+import { useEffect } from 'react'
+import { useChainId, useConfig } from 'wagmi'
+import type { ConfigParameter, QueryParameter } from 'wagmi/internal'
+import {
+  type UseInfiniteQueryReturnType,
+  type UseMutationParameters,
+  type UseQueryReturnType,
+  useInfiniteQuery,
+  useMutation,
+  useQuery,
+} from 'wagmi/query'
+import type { ExactPartial, UnionCompute } from '../../internal/types.js'
+
+import {
+  buy,
+  buySync,
+  cancel,
+  cancelSync,
+  createPair,
+  createPairSync,
+  getBalance,
+  getBuyQuote,
+  getOrder,
+  getOrderbook,
+  getOrders,
+  getPriceLevel,
+  getSellQuote,
+  place,
+  placeFlip,
+  placeFlipSync,
+  placeSync,
+  sell,
+  sellSync,
+  watchFlipOrderPlaced,
+  watchOrderCancelled,
+  watchOrderFilled,
+  watchOrderPlaced,
+  withdraw,
+  withdrawSync,
+} from '../Actions/dex.js'
+
+/**
+ * Hook for buying a specific amount of tokens.
+ *
+ * @example
+ * ```tsx
+ * import { Hooks } from 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   const { mutate, isPending } = Hooks.dex.useBuy()
+ *
+ *   return (
+ *     <button
+ *       onClick={() => mutate({
+ *         tokenIn: '0x20c...11',
+ *         tokenOut: '0x20c...20',
+ *         amountOut: parseUnits('100', 6),
+ *         maxAmountIn: parseUnits('105', 6),
+ *       })}
+ *       disabled={isPending}
+ *     >
+ *       Buy Tokens
+ *     </button>
+ *   )
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ * @returns Mutation result.
+ */
+export function useBuy<
+  config extends Config = ResolvedRegister['config'],
+  context = unknown,
+>(
+  parameters: useBuy.Parameters<config, context> = {},
+): useBuy.ReturnType<config, context> {
+  const { mutation } = parameters
+  const config = useConfig(parameters)
+  return useMutation({
+    ...mutation,
+    async mutationFn(variables) {
+      return buy(config, variables)
+    },
+    mutationKey: ['buy'],
+  })
+}
+
+export declare namespace useBuy {
+  type Parameters<
+    config extends Config = Config,
+    context = unknown,
+  > = ConfigParameter<config> & {
+    mutation?:
+      | UseMutationParameters<
+          buy.ReturnValue,
+          buy.ErrorType,
+          buy.Parameters<config>,
+          context
+        >
+      | undefined
+  }
+
+  type ReturnType<
+    config extends Config = Config,
+    context = unknown,
+  > = UseMutationResult<
+    buy.ReturnValue,
+    buy.ErrorType,
+    buy.Parameters<config>,
+    context
+  >
+}
+
+/**
+ * Hook for buying a specific amount of 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 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   const { mutate, isPending } = Hooks.dex.useBuySync()
+ *
+ *   return (
+ *     <button
+ *       onClick={() => mutate({
+ *         tokenIn: '0x20c...11',
+ *         tokenOut: '0x20c...20',
+ *         amountOut: parseUnits('100', 6),
+ *         maxAmountIn: parseUnits('105', 6),
+ *       })}
+ *       disabled={isPending}
+ *     >
+ *       Buy Tokens
+ *     </button>
+ *   )
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ * @returns Mutation result.
+ */
+export function useBuySync<
+  config extends Config = ResolvedRegister['config'],
+  context = unknown,
+>(
+  parameters: useBuySync.Parameters<config, context> = {},
+): useBuySync.ReturnType<config, context> {
+  const { mutation } = parameters
+  const config = useConfig(parameters)
+  return useMutation({
+    ...mutation,
+    async mutationFn(variables) {
+      return buySync(config, variables)
+    },
+    mutationKey: ['buySync'],
+  })
+}
+
+export declare namespace useBuySync {
+  type Parameters<
+    config extends Config = Config,
+    context = unknown,
+  > = ConfigParameter<config> & {
+    mutation?:
+      | UseMutationParameters<
+          buySync.ReturnValue,
+          buySync.ErrorType,
+          buySync.Parameters<config>,
+          context
+        >
+      | undefined
+  }
+
+  type ReturnType<
+    config extends Config = Config,
+    context = unknown,
+  > = UseMutationResult<
+    buySync.ReturnValue,
+    buySync.ErrorType,
+    buySync.Parameters<config>,
+    context
+  >
+}
+
+/**
+ * Hook for canceling an order from the orderbook.
+ *
+ * @example
+ * ```tsx
+ * import { Hooks } from 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   const { mutate, isPending } = Hooks.dex.useCancel()
+ *
+ *   return (
+ *     <button
+ *       onClick={() => mutate({ orderId: 123n })}
+ *       disabled={isPending}
+ *     >
+ *       Cancel Order
+ *     </button>
+ *   )
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ * @returns Mutation result.
+ */
+export function useCancel<
+  config extends Config = ResolvedRegister['config'],
+  context = unknown,
+>(
+  parameters: useCancel.Parameters<config, context> = {},
+): useCancel.ReturnType<config, context> {
+  const { mutation } = parameters
+  const config = useConfig(parameters)
+  return useMutation({
+    ...mutation,
+    async mutationFn(variables) {
+      return cancel(config, variables)
+    },
+    mutationKey: ['cancel'],
+  })
+}
+
+export declare namespace useCancel {
+  type Parameters<
+    config extends Config = Config,
+    context = unknown,
+  > = ConfigParameter<config> & {
+    mutation?:
+      | UseMutationParameters<
+          cancel.ReturnValue,
+          cancel.ErrorType,
+          cancel.Parameters<config>,
+          context
+        >
+      | undefined
+  }
+
+  type ReturnType<
+    config extends Config = Config,
+    context = unknown,
+  > = UseMutationResult<
+    cancel.ReturnValue,
+    cancel.ErrorType,
+    cancel.Parameters<config>,
+    context
+  >
+}
+
+/**
+ * Hook for canceling an order from the orderbook.
+ *
+ * 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 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   const { mutate, isPending } = Hooks.dex.useCancelSync()
+ *
+ *   return (
+ *     <button
+ *       onClick={() => mutate({ orderId: 123n })}
+ *       disabled={isPending}
+ *     >
+ *       Cancel Order
+ *     </button>
+ *   )
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ * @returns Mutation result.
+ */
+export function useCancelSync<
+  config extends Config = ResolvedRegister['config'],
+  context = unknown,
+>(
+  parameters: useCancelSync.Parameters<config, context> = {},
+): useCancelSync.ReturnType<config, context> {
+  const { mutation } = parameters
+  const config = useConfig(parameters)
+  return useMutation({
+    ...mutation,
+    async mutationFn(variables) {
+      return cancelSync(config, variables)
+    },
+    mutationKey: ['cancelSync'],
+  })
+}
+
+export declare namespace useCancelSync {
+  type Parameters<
+    config extends Config = Config,
+    context = unknown,
+  > = ConfigParameter<config> & {
+    mutation?:
+      | UseMutationParameters<
+          cancelSync.ReturnValue,
+          cancelSync.ErrorType,
+          cancelSync.Parameters<config>,
+          context
+        >
+      | undefined
+  }
+
+  type ReturnType<
+    config extends Config = Config,
+    context = unknown,
+  > = UseMutationResult<
+    cancelSync.ReturnValue,
+    cancelSync.ErrorType,
+    cancelSync.Parameters<config>,
+    context
+  >
+}
+
+/**
+ * Hook for creating a new trading pair on the DEX.
+ *
+ * @example
+ * ```tsx
+ * import { Hooks } from 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   const { mutate, isPending } = Hooks.dex.useCreatePair()
+ *
+ *   return (
+ *     <button
+ *       onClick={() => mutate({ base: '0x20c...11' })}
+ *       disabled={isPending}
+ *     >
+ *       Create Pair
+ *     </button>
+ *   )
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ * @returns Mutation result.
+ */
+export function useCreatePair<
+  config extends Config = ResolvedRegister['config'],
+  context = unknown,
+>(
+  parameters: useCreatePair.Parameters<config, context> = {},
+): useCreatePair.ReturnType<config, context> {
+  const { mutation } = parameters
+  const config = useConfig(parameters)
+  return useMutation({
+    ...mutation,
+    async mutationFn(variables) {
+      return createPair(config, variables)
+    },
+    mutationKey: ['createPair'],
+  })
+}
+
+export declare namespace useCreatePair {
+  type Parameters<
+    config extends Config = Config,
+    context = unknown,
+  > = ConfigParameter<config> & {
+    mutation?:
+      | UseMutationParameters<
+          createPair.ReturnValue,
+          createPair.ErrorType,
+          createPair.Parameters<config>,
+          context
+        >
+      | undefined
+  }
+
+  type ReturnType<
+    config extends Config = Config,
+    context = unknown,
+  > = UseMutationResult<
+    createPair.ReturnValue,
+    createPair.ErrorType,
+    createPair.Parameters<config>,
+    context
+  >
+}
+
+/**
+ * Hook for creating a new trading pair on the DEX.
+ *
+ * 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 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   const { mutate, isPending } = Hooks.dex.useCreatePairSync()
+ *
+ *   return (
+ *     <button
+ *       onClick={() => mutate({ base: '0x20c...11' })}
+ *       disabled={isPending}
+ *     >
+ *       Create Pair
+ *     </button>
+ *   )
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ * @returns Mutation result.
+ */
+export function useCreatePairSync<
+  config extends Config = ResolvedRegister['config'],
+  context = unknown,
+>(
+  parameters: useCreatePairSync.Parameters<config, context> = {},
+): useCreatePairSync.ReturnType<config, context> {
+  const { mutation } = parameters
+  const config = useConfig(parameters)
+  return useMutation({
+    ...mutation,
+    async mutationFn(variables) {
+      return createPairSync(config, variables)
+    },
+    mutationKey: ['createPairSync'],
+  })
+}
+
+export declare namespace useCreatePairSync {
+  type Parameters<
+    config extends Config = Config,
+    context = unknown,
+  > = ConfigParameter<config> & {
+    mutation?:
+      | UseMutationParameters<
+          createPairSync.ReturnValue,
+          createPairSync.ErrorType,
+          createPairSync.Parameters<config>,
+          context
+        >
+      | undefined
+  }
+
+  type ReturnType<
+    config extends Config = Config,
+    context = unknown,
+  > = UseMutationResult<
+    createPairSync.ReturnValue,
+    createPairSync.ErrorType,
+    createPairSync.Parameters<config>,
+    context
+  >
+}
+
+/**
+ * Hook for getting a user's token balance on the DEX.
+ *
+ * @example
+ * ```tsx
+ * import { Hooks } from 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   const { data, isLoading } = Hooks.dex.useBalance({
+ *     account: '0x...',
+ *     token: '0x20c...11',
+ *   })
+ *
+ *   if (isLoading) return <div>Loading...</div>
+ *   return <div>Balance: {data}</div>
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ * @returns Query result with the user's token balance on the DEX.
+ */
+export function useBalance<
+  config extends Config = ResolvedRegister['config'],
+  selectData = getBalance.ReturnValue,
+>(parameters: useBalance.Parameters<config, selectData>) {
+  const { account, query = {} } = parameters
+
+  const config = useConfig(parameters)
+  const chainId = useChainId({ config })
+
+  const options = getBalance.queryOptions(config, {
+    ...parameters,
+    chainId: parameters.chainId ?? chainId,
+    query: undefined,
+  })
+  const enabled = Boolean(account && (query.enabled ?? true))
+
+  return useQuery({ ...query, ...options, enabled })
+}
+
+export declare namespace useBalance {
+  export type Parameters<
+    config extends Config = ResolvedRegister['config'],
+    selectData = getBalance.ReturnValue,
+  > = ConfigParameter<config> &
+    QueryParameter<
+      getBalance.ReturnValue,
+      DefaultError,
+      selectData,
+      getBalance.QueryKey<config>
+    > &
+    Omit<getBalance.queryOptions.Parameters<config, selectData>, 'query'>
+
+  export type ReturnValue<selectData = getBalance.ReturnValue> =
+    UseQueryReturnType<selectData, Error>
+}
+
+/**
+ * Hook for getting the quote for buying a specific amount of tokens.
+ *
+ * @example
+ * ```tsx
+ * import { Hooks } from 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   const { data, isLoading } = Hooks.dex.useBuyQuote({
+ *     amountOut: parseUnits('100', 6),
+ *     tokenIn: '0x20c...11',
+ *     tokenOut: '0x20c...20',
+ *   })
+ *
+ *   if (isLoading) return <div>Loading...</div>
+ *   return <div>Required Input: {data}</div>
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ * @returns Query result with the amount of tokenIn needed.
+ */
+export function useBuyQuote<
+  config extends Config = ResolvedRegister['config'],
+  selectData = getBuyQuote.ReturnValue,
+>(parameters: useBuyQuote.Parameters<config, selectData>) {
+  const { query = {} } = parameters
+
+  const config = useConfig(parameters)
+  const chainId = useChainId({ config })
+
+  const options = getBuyQuote.queryOptions(config, {
+    ...parameters,
+    chainId: parameters.chainId ?? chainId,
+    query: undefined,
+  })
+  const enabled = Boolean(
+    parameters.tokenIn &&
+      parameters.tokenOut &&
+      parameters.amountOut &&
+      (query.enabled ?? true),
+  )
+
+  return useQuery({ ...query, ...options, enabled })
+}
+
+export declare namespace useBuyQuote {
+  export type Parameters<
+    config extends Config = ResolvedRegister['config'],
+    selectData = getBuyQuote.ReturnValue,
+  > = ConfigParameter<config> &
+    QueryParameter<
+      getBuyQuote.ReturnValue,
+      DefaultError,
+      selectData,
+      getBuyQuote.QueryKey<config>
+    > &
+    Omit<getBuyQuote.queryOptions.Parameters<config, selectData>, 'query'>
+
+  export type ReturnValue<selectData = getBuyQuote.ReturnValue> =
+    UseQueryReturnType<selectData, Error>
+}
+
+/**
+ * Hook for getting an order's details from the orderbook.
+ *
+ * @example
+ * ```tsx
+ * import { Hooks } from 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   const { data, isLoading } = Hooks.dex.useOrder({
+ *     orderId: 123n,
+ *   })
+ *
+ *   if (isLoading) return <div>Loading...</div>
+ *   return <div>Order: {JSON.stringify(data)}</div>
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ * @returns Query result with the order details.
+ */
+export function useOrder<
+  config extends Config = ResolvedRegister['config'],
+  selectData = getOrder.ReturnValue,
+>(parameters: useOrder.Parameters<config, selectData>) {
+  const { query = {} } = parameters
+
+  const config = useConfig(parameters)
+  const chainId = useChainId({ config })
+
+  const options = getOrder.queryOptions(config, {
+    ...parameters,
+    chainId: parameters.chainId ?? chainId,
+    query: undefined,
+  })
+  const enabled = Boolean(
+    parameters.orderId !== undefined && (query.enabled ?? true),
+  )
+
+  return useQuery({ ...query, ...options, enabled })
+}
+
+export declare namespace useOrder {
+  export type Parameters<
+    config extends Config = ResolvedRegister['config'],
+    selectData = getOrder.ReturnValue,
+  > = ConfigParameter<config> &
+    QueryParameter<
+      getOrder.ReturnValue,
+      DefaultError,
+      selectData,
+      getOrder.QueryKey<config>
+    > &
+    Omit<getOrder.queryOptions.Parameters<config, selectData>, 'query'>
+
+  export type ReturnValue<selectData = getOrder.ReturnValue> =
+    UseQueryReturnType<selectData, Error>
+}
+
+/**
+ * Hook for getting paginated orders from the orderbook.
+ *
+ * @example
+ * ```tsx
+ * import { Hooks } from 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   const { data, fetchNextPage, hasNextPage, isFetchingNextPage } = Hooks.dex.useGetOrders({
+ *     limit: 10,
+ *     filters: {
+ *       baseToken: '0x20c0...',
+ *       isBid: true,
+ *     }
+ *   })
+ *
+ *   return (
+ *     <div>
+ *       {data?.pages.map((page, i) => (
+ *         <div key={i}>
+ *           {page.orders.map((order) => (
+ *             <div key={order.orderId.toString()}>{order.amount.toString()}</div>
+ *           ))}
+ *         </div>
+ *       ))}
+ *       {hasNextPage && (
+ *         <button onClick={() => fetchNextPage()} disabled={isFetchingNextPage}>
+ *           Load More
+ *         </button>
+ *       )}
+ *     </div>
+ *   )
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ * @returns Infinite query result with paginated orders.
+ */
+export function useGetOrders<
+  config extends Config = ResolvedRegister['config'],
+  selectData = getOrders.ReturnValue,
+>(parameters: useGetOrders.Parameters<config, selectData> = {}) {
+  const { query = {}, ...rest } = parameters
+
+  const config = useConfig(parameters)
+  const chainId = useChainId({ config })
+
+  const options = getOrders.infiniteQueryOptions(config, {
+    ...rest,
+    chainId: parameters.chainId ?? chainId,
+    query: undefined,
+  })
+
+  return useInfiniteQuery({
+    ...query,
+    ...options,
+  } as never) as useGetOrders.ReturnValue<selectData>
+}
+
+export declare namespace useGetOrders {
+  export type Parameters<
+    config extends Config = ResolvedRegister['config'],
+    selectData = getOrders.ReturnValue,
+  > = ConfigParameter<config> &
+    Omit<
+      QueryParameter<
+        getOrders.ReturnValue,
+        DefaultError,
+        selectData,
+        getOrders.QueryKey<config>
+      >,
+      'queryFn' | 'queryKey'
+    > &
+    ExactPartial<
+      Omit<
+        getOrders.infiniteQueryOptions.Parameters<config, selectData>,
+        'query'
+      >
+    >
+
+  export type ReturnValue<selectData = getOrders.ReturnValue> =
+    UseInfiniteQueryReturnType<InfiniteData<selectData>, Error>
+}
+
+/**
+ * Hook for getting orderbook information for a trading pair.
+ *
+ * @example
+ * ```tsx
+ * import { Hooks } from 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   const { data, isLoading } = Hooks.dex.useOrderbook({
+ *     base: '0x20c...11',
+ *     quote: '0x20c...20',
+ *   })
+ *
+ *   if (isLoading) return <div>Loading...</div>
+ *   return <div>Orderbook: {JSON.stringify(data)}</div>
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ * @returns Query result with the orderbook information.
+ */
+export function useOrderbook<
+  config extends Config = ResolvedRegister['config'],
+  selectData = getOrderbook.ReturnValue,
+>(parameters: useOrderbook.Parameters<config, selectData>) {
+  const { query = {} } = parameters
+
+  const config = useConfig(parameters)
+  const chainId = useChainId({ config })
+
+  const options = getOrderbook.queryOptions(config, {
+    ...parameters,
+    chainId: parameters.chainId ?? chainId,
+    query: undefined,
+  })
+  const enabled = Boolean(
+    parameters.base && parameters.quote && (query.enabled ?? true),
+  )
+
+  return useQuery({ ...query, ...options, enabled })
+}
+
+export declare namespace useOrderbook {
+  export type Parameters<
+    config extends Config = ResolvedRegister['config'],
+    selectData = getOrderbook.ReturnValue,
+  > = ConfigParameter<config> &
+    QueryParameter<
+      getOrderbook.ReturnValue,
+      DefaultError,
+      selectData,
+      getOrderbook.QueryKey<config>
+    > &
+    Omit<getOrderbook.queryOptions.Parameters<config, selectData>, 'query'>
+
+  export type ReturnValue<selectData = getOrderbook.ReturnValue> =
+    UseQueryReturnType<selectData, Error>
+}
+
+/**
+ * Hook for getting the price level information at a specific tick.
+ *
+ * @example
+ * ```tsx
+ * import { Hooks } from 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   const { data, isLoading } = Hooks.dex.usePriceLevel({
+ *     base: '0x20c...11',
+ *     tick: Tick.fromPrice('1.001'),
+ *     isBid: true,
+ *   })
+ *
+ *   if (isLoading) return <div>Loading...</div>
+ *   return <div>Price Level: {JSON.stringify(data)}</div>
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ * @returns Query result with the price level information.
+ */
+export function usePriceLevel<
+  config extends Config = ResolvedRegister['config'],
+  selectData = getPriceLevel.ReturnValue,
+>(parameters: usePriceLevel.Parameters<config, selectData>) {
+  const { query = {} } = parameters
+
+  const config = useConfig(parameters)
+  const chainId = useChainId({ config })
+
+  const options = getPriceLevel.queryOptions(config, {
+    ...parameters,
+    chainId: parameters.chainId ?? chainId,
+    query: undefined,
+  })
+  const enabled = Boolean(
+    parameters.base &&
+      parameters.tick !== undefined &&
+      parameters.isBid !== undefined &&
+      (query.enabled ?? true),
+  )
+
+  return useQuery({ ...query, ...options, enabled })
+}
+
+export declare namespace usePriceLevel {
+  export type Parameters<
+    config extends Config = ResolvedRegister['config'],
+    selectData = getPriceLevel.ReturnValue,
+  > = ConfigParameter<config> &
+    QueryParameter<
+      getPriceLevel.ReturnValue,
+      DefaultError,
+      selectData,
+      getPriceLevel.QueryKey<config>
+    > &
+    Omit<getPriceLevel.queryOptions.Parameters<config, selectData>, 'query'>
+
+  export type ReturnValue<selectData = getPriceLevel.ReturnValue> =
+    UseQueryReturnType<selectData, Error>
+}
+
+/**
+ * Hook for getting the quote for selling a specific amount of tokens.
+ *
+ * @example
+ * ```tsx
+ * import { Hooks } from 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   const { data, isLoading } = Hooks.dex.useSellQuote({
+ *     amountIn: parseUnits('100', 6),
+ *     tokenIn: '0x20c...11',
+ *     tokenOut: '0x20c...20',
+ *   })
+ *
+ *   if (isLoading) return <div>Loading...</div>
+ *   return <div>Expected Output: {data}</div>
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ * @returns Query result with the amount of tokenOut received.
+ */
+export function useSellQuote<
+  config extends Config = ResolvedRegister['config'],
+  selectData = getSellQuote.ReturnValue,
+>(parameters: useSellQuote.Parameters<config, selectData>) {
+  const { query = {} } = parameters
+
+  const config = useConfig(parameters)
+  const chainId = useChainId({ config })
+
+  const options = getSellQuote.queryOptions(config, {
+    ...parameters,
+    chainId: parameters.chainId ?? chainId,
+    query: undefined,
+  })
+  const enabled = Boolean(
+    parameters.tokenIn &&
+      parameters.tokenOut &&
+      parameters.amountIn &&
+      (query.enabled ?? true),
+  )
+
+  return useQuery({ ...query, ...options, enabled })
+}
+
+export declare namespace useSellQuote {
+  export type Parameters<
+    config extends Config = ResolvedRegister['config'],
+    selectData = getSellQuote.ReturnValue,
+  > = ConfigParameter<config> &
+    QueryParameter<
+      getSellQuote.ReturnValue,
+      DefaultError,
+      selectData,
+      getSellQuote.QueryKey<config>
+    > &
+    Omit<getSellQuote.queryOptions.Parameters<config, selectData>, 'query'>
+
+  export type ReturnValue<selectData = getSellQuote.ReturnValue> =
+    UseQueryReturnType<selectData, Error>
+}
+
+/**
+ * Hook for placing a limit order on the orderbook.
+ *
+ * @example
+ * ```tsx
+ * import { Hooks } from 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   const { mutate, isPending } = Hooks.dex.usePlace()
+ *
+ *   return (
+ *     <button
+ *       onClick={() => mutate({
+ *         amount: parseUnits('100', 6),
+ *         tick: Tick.fromPrice('0.99'),
+ *         token: '0x20c...11',
+ *         type: 'buy',
+ *       })}
+ *       disabled={isPending}
+ *     >
+ *       Place Order
+ *     </button>
+ *   )
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ * @returns Mutation result.
+ */
+export function usePlace<
+  config extends Config = ResolvedRegister['config'],
+  context = unknown,
+>(
+  parameters: usePlace.Parameters<config, context> = {},
+): usePlace.ReturnType<config, context> {
+  const { mutation } = parameters
+  const config = useConfig(parameters)
+  return useMutation({
+    ...mutation,
+    async mutationFn(variables) {
+      return place(config, variables)
+    },
+    mutationKey: ['place'],
+  })
+}
+
+export declare namespace usePlace {
+  type Parameters<
+    config extends Config = Config,
+    context = unknown,
+  > = ConfigParameter<config> & {
+    mutation?:
+      | UseMutationParameters<
+          place.ReturnValue,
+          place.ErrorType,
+          place.Parameters<config>,
+          context
+        >
+      | undefined
+  }
+
+  type ReturnType<
+    config extends Config = Config,
+    context = unknown,
+  > = UseMutationResult<
+    place.ReturnValue,
+    place.ErrorType,
+    place.Parameters<config>,
+    context
+  >
+}
+
+/**
+ * Hook for placing a flip order that automatically flips when filled.
+ *
+ * @example
+ * ```tsx
+ * import { Hooks } from 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   const { mutate, isPending } = Hooks.dex.usePlaceFlip()
+ *
+ *   return (
+ *     <button
+ *       onClick={() => mutate({
+ *         amount: parseUnits('100', 6),
+ *         flipTick: Tick.fromPrice('1.01'),
+ *         tick: Tick.fromPrice('0.99'),
+ *         token: '0x20c...11',
+ *         type: 'buy',
+ *       })}
+ *       disabled={isPending}
+ *     >
+ *       Place Flip Order
+ *     </button>
+ *   )
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ * @returns Mutation result.
+ */
+export function usePlaceFlip<
+  config extends Config = ResolvedRegister['config'],
+  context = unknown,
+>(
+  parameters: usePlaceFlip.Parameters<config, context> = {},
+): usePlaceFlip.ReturnType<config, context> {
+  const { mutation } = parameters
+  const config = useConfig(parameters)
+  return useMutation({
+    ...mutation,
+    async mutationFn(variables) {
+      return placeFlip(config, variables)
+    },
+    mutationKey: ['placeFlip'],
+  })
+}
+
+export declare namespace usePlaceFlip {
+  type Parameters<
+    config extends Config = Config,
+    context = unknown,
+  > = ConfigParameter<config> & {
+    mutation?:
+      | UseMutationParameters<
+          placeFlip.ReturnValue,
+          placeFlip.ErrorType,
+          placeFlip.Parameters<config>,
+          context
+        >
+      | undefined
+  }
+
+  type ReturnType<
+    config extends Config = Config,
+    context = unknown,
+  > = UseMutationResult<
+    placeFlip.ReturnValue,
+    placeFlip.ErrorType,
+    placeFlip.Parameters<config>,
+    context
+  >
+}
+
+/**
+ * Hook for placing a flip order that automatically flips when filled.
+ *
+ * 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 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   const { mutate, isPending } = Hooks.dex.usePlaceFlipSync()
+ *
+ *   return (
+ *     <button
+ *       onClick={() => mutate({
+ *         amount: parseUnits('100', 6),
+ *         flipTick: Tick.fromPrice('1.01'),
+ *         tick: Tick.fromPrice('0.99'),
+ *         token: '0x20c...11',
+ *         type: 'buy',
+ *       })}
+ *       disabled={isPending}
+ *     >
+ *       Place Flip Order
+ *     </button>
+ *   )
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ * @returns Mutation result.
+ */
+export function usePlaceFlipSync<
+  config extends Config = ResolvedRegister['config'],
+  context = unknown,
+>(
+  parameters: usePlaceFlipSync.Parameters<config, context> = {},
+): usePlaceFlipSync.ReturnType<config, context> {
+  const { mutation } = parameters
+  const config = useConfig(parameters)
+  return useMutation({
+    ...mutation,
+    async mutationFn(variables) {
+      return placeFlipSync(config, variables)
+    },
+    mutationKey: ['placeFlipSync'],
+  })
+}
+
+export declare namespace usePlaceFlipSync {
+  type Parameters<
+    config extends Config = Config,
+    context = unknown,
+  > = ConfigParameter<config> & {
+    mutation?:
+      | UseMutationParameters<
+          placeFlipSync.ReturnValue,
+          placeFlipSync.ErrorType,
+          placeFlipSync.Parameters<config>,
+          context
+        >
+      | undefined
+  }
+
+  type ReturnType<
+    config extends Config = Config,
+    context = unknown,
+  > = UseMutationResult<
+    placeFlipSync.ReturnValue,
+    placeFlipSync.ErrorType,
+    placeFlipSync.Parameters<config>,
+    context
+  >
+}
+
+/**
+ * Hook for placing a limit order on the orderbook.
+ *
+ * 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 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   const { mutate, isPending } = Hooks.dex.usePlaceSync()
+ *
+ *   return (
+ *     <button
+ *       onClick={() => mutate({
+ *         amount: parseUnits('100', 6),
+ *         tick: Tick.fromPrice('0.99'),
+ *         token: '0x20c...11',
+ *         type: 'buy',
+ *       })}
+ *       disabled={isPending}
+ *     >
+ *       Place Order
+ *     </button>
+ *   )
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ * @returns Mutation result.
+ */
+export function usePlaceSync<
+  config extends Config = ResolvedRegister['config'],
+  context = unknown,
+>(
+  parameters: usePlaceSync.Parameters<config, context> = {},
+): usePlaceSync.ReturnType<config, context> {
+  const { mutation } = parameters
+  const config = useConfig(parameters)
+  return useMutation({
+    ...mutation,
+    async mutationFn(variables) {
+      return placeSync(config, variables)
+    },
+    mutationKey: ['placeSync'],
+  })
+}
+
+export declare namespace usePlaceSync {
+  type Parameters<
+    config extends Config = Config,
+    context = unknown,
+  > = ConfigParameter<config> & {
+    mutation?:
+      | UseMutationParameters<
+          placeSync.ReturnValue,
+          placeSync.ErrorType,
+          placeSync.Parameters<config>,
+          context
+        >
+      | undefined
+  }
+
+  type ReturnType<
+    config extends Config = Config,
+    context = unknown,
+  > = UseMutationResult<
+    placeSync.ReturnValue,
+    placeSync.ErrorType,
+    placeSync.Parameters<config>,
+    context
+  >
+}
+
+/**
+ * Hook for selling a specific amount of tokens.
+ *
+ * @example
+ * ```tsx
+ * import { Hooks } from 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   const { mutate, isPending } = Hooks.dex.useSell()
+ *
+ *   return (
+ *     <button
+ *       onClick={() => mutate({
+ *         amountIn: parseUnits('100', 6),
+ *         minAmountOut: parseUnits('95', 6),
+ *         tokenIn: '0x20c...11',
+ *         tokenOut: '0x20c...20',
+ *       })}
+ *       disabled={isPending}
+ *     >
+ *       Sell Tokens
+ *     </button>
+ *   )
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ * @returns Mutation result.
+ */
+export function useSell<
+  config extends Config = ResolvedRegister['config'],
+  context = unknown,
+>(
+  parameters: useSell.Parameters<config, context> = {},
+): useSell.ReturnType<config, context> {
+  const { mutation } = parameters
+  const config = useConfig(parameters)
+  return useMutation({
+    ...mutation,
+    async mutationFn(variables) {
+      return sell(config, variables)
+    },
+    mutationKey: ['sell'],
+  })
+}
+
+export declare namespace useSell {
+  type Parameters<
+    config extends Config = Config,
+    context = unknown,
+  > = ConfigParameter<config> & {
+    mutation?:
+      | UseMutationParameters<
+          sell.ReturnValue,
+          sell.ErrorType,
+          sell.Parameters<config>,
+          context
+        >
+      | undefined
+  }
+
+  type ReturnType<
+    config extends Config = Config,
+    context = unknown,
+  > = UseMutationResult<
+    sell.ReturnValue,
+    sell.ErrorType,
+    sell.Parameters<config>,
+    context
+  >
+}
+
+/**
+ * Hook for selling a specific amount of 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 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   const { mutate, isPending } = Hooks.dex.useSellSync()
+ *
+ *   return (
+ *     <button
+ *       onClick={() => mutate({
+ *         amountIn: parseUnits('100', 6),
+ *         minAmountOut: parseUnits('95', 6),
+ *         tokenIn: '0x20c...11',
+ *         tokenOut: '0x20c...20',
+ *       })}
+ *       disabled={isPending}
+ *     >
+ *       Sell Tokens
+ *     </button>
+ *   )
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ * @returns Mutation result.
+ */
+export function useSellSync<
+  config extends Config = ResolvedRegister['config'],
+  context = unknown,
+>(
+  parameters: useSellSync.Parameters<config, context> = {},
+): useSellSync.ReturnType<config, context> {
+  const { mutation } = parameters
+  const config = useConfig(parameters)
+  return useMutation({
+    ...mutation,
+    async mutationFn(variables) {
+      return sellSync(config, variables)
+    },
+    mutationKey: ['sellSync'],
+  })
+}
+
+export declare namespace useSellSync {
+  type Parameters<
+    config extends Config = Config,
+    context = unknown,
+  > = ConfigParameter<config> & {
+    mutation?:
+      | UseMutationParameters<
+          sellSync.ReturnValue,
+          sellSync.ErrorType,
+          sellSync.Parameters<config>,
+          context
+        >
+      | undefined
+  }
+
+  type ReturnType<
+    config extends Config = Config,
+    context = unknown,
+  > = UseMutationResult<
+    sellSync.ReturnValue,
+    sellSync.ErrorType,
+    sellSync.Parameters<config>,
+    context
+  >
+}
+
+/**
+ * Hook for withdrawing tokens from the DEX to the caller's wallet.
+ *
+ * @example
+ * ```tsx
+ * import { Hooks } from 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   const { mutate, isPending } = Hooks.dex.useWithdraw()
+ *
+ *   return (
+ *     <button
+ *       onClick={() => mutate({
+ *         amount: 100n,
+ *         token: '0x20c...11',
+ *       })}
+ *       disabled={isPending}
+ *     >
+ *       Withdraw
+ *     </button>
+ *   )
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ * @returns Mutation result.
+ */
+export function useWithdraw<
+  config extends Config = ResolvedRegister['config'],
+  context = unknown,
+>(
+  parameters: useWithdraw.Parameters<config, context> = {},
+): useWithdraw.ReturnType<config, context> {
+  const { mutation } = parameters
+  const config = useConfig(parameters)
+  return useMutation({
+    ...mutation,
+    async mutationFn(variables) {
+      return withdraw(config, variables)
+    },
+    mutationKey: ['withdraw'],
+  })
+}
+
+export declare namespace useWithdraw {
+  type Parameters<
+    config extends Config = Config,
+    context = unknown,
+  > = ConfigParameter<config> & {
+    mutation?:
+      | UseMutationParameters<
+          withdraw.ReturnValue,
+          withdraw.ErrorType,
+          withdraw.Parameters<config>,
+          context
+        >
+      | undefined
+  }
+
+  type ReturnType<
+    config extends Config = Config,
+    context = unknown,
+  > = UseMutationResult<
+    withdraw.ReturnValue,
+    withdraw.ErrorType,
+    withdraw.Parameters<config>,
+    context
+  >
+}
+
+/**
+ * Hook for withdrawing tokens from the DEX to the caller's wallet.
+ *
+ * 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 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   const { mutate, isPending } = Hooks.dex.useWithdrawSync()
+ *
+ *   return (
+ *     <button
+ *       onClick={() => mutate({
+ *         amount: 100n,
+ *         token: '0x20c...11',
+ *       })}
+ *       disabled={isPending}
+ *     >
+ *       Withdraw
+ *     </button>
+ *   )
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ * @returns Mutation result.
+ */
+export function useWithdrawSync<
+  config extends Config = ResolvedRegister['config'],
+  context = unknown,
+>(
+  parameters: useWithdrawSync.Parameters<config, context> = {},
+): useWithdrawSync.ReturnType<config, context> {
+  const { mutation } = parameters
+  const config = useConfig(parameters)
+  return useMutation({
+    ...mutation,
+    async mutationFn(variables) {
+      return withdrawSync(config, variables)
+    },
+    mutationKey: ['withdrawSync'],
+  })
+}
+
+export declare namespace useWithdrawSync {
+  type Parameters<
+    config extends Config = Config,
+    context = unknown,
+  > = ConfigParameter<config> & {
+    mutation?:
+      | UseMutationParameters<
+          withdrawSync.ReturnValue,
+          withdrawSync.ErrorType,
+          withdrawSync.Parameters<config>,
+          context
+        >
+      | undefined
+  }
+
+  type ReturnType<
+    config extends Config = Config,
+    context = unknown,
+  > = UseMutationResult<
+    withdrawSync.ReturnValue,
+    withdrawSync.ErrorType,
+    withdrawSync.Parameters<config>,
+    context
+  >
+}
+
+/**
+ * Hook for watching flip order placement events on the DEX.
+ *
+ * @example
+ * ```tsx
+ * import { Hooks } from 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   Hooks.dex.useWatchFlipOrderPlaced({
+ *     onFlipOrderPlaced(args) {
+ *       console.log('Flip order placed:', args)
+ *     },
+ *   })
+ *
+ *   return <div>Watching for flip order placements...</div>
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ */
+export function useWatchFlipOrderPlaced<
+  config extends Config = ResolvedRegister['config'],
+>(parameters: useWatchFlipOrderPlaced.Parameters<config> = {}) {
+  const { enabled = true, onFlipOrderPlaced, ...rest } = parameters
+
+  const config = useConfig({ config: parameters.config })
+  const configChainId = useChainId({ config })
+  const chainId = parameters.chainId ?? configChainId
+
+  useEffect(() => {
+    if (!enabled) return
+    if (!onFlipOrderPlaced) return
+    return watchFlipOrderPlaced(config, {
+      ...rest,
+      chainId,
+      onFlipOrderPlaced,
+    })
+  }, [config, enabled, onFlipOrderPlaced, rest, chainId])
+}
+
+export declare namespace useWatchFlipOrderPlaced {
+  type Parameters<config extends Config = Config> = UnionCompute<
+    ExactPartial<watchFlipOrderPlaced.Parameters<config>> &
+      ConfigParameter<config> & { enabled?: boolean | undefined }
+  >
+}
+
+/**
+ * Hook for watching order cancellation events on the DEX.
+ *
+ * @example
+ * ```tsx
+ * import { Hooks } from 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   Hooks.dex.useWatchOrderCancelled({
+ *     onOrderCancelled(args) {
+ *       console.log('Order cancelled:', args)
+ *     },
+ *   })
+ *
+ *   return <div>Watching for order cancellations...</div>
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ */
+export function useWatchOrderCancelled<
+  config extends Config = ResolvedRegister['config'],
+>(parameters: useWatchOrderCancelled.Parameters<config> = {}) {
+  const { enabled = true, onOrderCancelled, ...rest } = parameters
+
+  const config = useConfig({ config: parameters.config })
+  const configChainId = useChainId({ config })
+  const chainId = parameters.chainId ?? configChainId
+
+  useEffect(() => {
+    if (!enabled) return
+    if (!onOrderCancelled) return
+    return watchOrderCancelled(config, {
+      ...rest,
+      chainId,
+      onOrderCancelled,
+    })
+  }, [config, enabled, onOrderCancelled, rest, chainId])
+}
+
+export declare namespace useWatchOrderCancelled {
+  type Parameters<config extends Config = Config> = UnionCompute<
+    ExactPartial<watchOrderCancelled.Parameters<config>> &
+      ConfigParameter<config> & { enabled?: boolean | undefined }
+  >
+}
+
+/**
+ * Hook for watching order filled events on the DEX.
+ *
+ * @example
+ * ```tsx
+ * import { Hooks } from 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   Hooks.dex.useWatchOrderFilled({
+ *     onOrderFilled(args) {
+ *       console.log('Order filled:', args)
+ *     },
+ *   })
+ *
+ *   return <div>Watching for order fills...</div>
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ */
+export function useWatchOrderFilled<
+  config extends Config = ResolvedRegister['config'],
+>(parameters: useWatchOrderFilled.Parameters<config> = {}) {
+  const { enabled = true, onOrderFilled, ...rest } = parameters
+
+  const config = useConfig({ config: parameters.config })
+  const configChainId = useChainId({ config })
+  const chainId = parameters.chainId ?? configChainId
+
+  useEffect(() => {
+    if (!enabled) return
+    if (!onOrderFilled) return
+    return watchOrderFilled(config, {
+      ...rest,
+      chainId,
+      onOrderFilled,
+    })
+  }, [config, enabled, onOrderFilled, rest, chainId])
+}
+
+export declare namespace useWatchOrderFilled {
+  type Parameters<config extends Config = Config> = UnionCompute<
+    ExactPartial<watchOrderFilled.Parameters<config>> &
+      ConfigParameter<config> & { enabled?: boolean | undefined }
+  >
+}
+
+/**
+ * Hook for watching order placement events on the DEX.
+ *
+ * @example
+ * ```tsx
+ * import { Hooks } from 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   Hooks.dex.useWatchOrderPlaced({
+ *     onOrderPlaced(args) {
+ *       console.log('Order placed:', args)
+ *     },
+ *   })
+ *
+ *   return <div>Watching for order placements...</div>
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ */
+export function useWatchOrderPlaced<
+  config extends Config = ResolvedRegister['config'],
+>(parameters: useWatchOrderPlaced.Parameters<config> = {}) {
+  const { enabled = true, onOrderPlaced, ...rest } = parameters
+
+  const config = useConfig({ config: parameters.config })
+  const configChainId = useChainId({ config })
+  const chainId = parameters.chainId ?? configChainId
+
+  useEffect(() => {
+    if (!enabled) return
+    if (!onOrderPlaced) return
+    return watchOrderPlaced(config, {
+      ...rest,
+      chainId,
+      onOrderPlaced,
+    })
+  }, [config, enabled, onOrderPlaced, rest, chainId])
+}
+
+export declare namespace useWatchOrderPlaced {
+  type Parameters<config extends Config = Config> = UnionCompute<
+    ExactPartial<watchOrderPlaced.Parameters<config>> &
+      ConfigParameter<config> & { enabled?: boolean | undefined }
+  >
+}