tempo.ts 0.6.1 → 0.7.0

package/src/wagmi/Hooks/amm.ts

@@ -154,157 +154,6 @@ export declare namespace useLiquidityBalance {
   > = UseQueryReturnType<selectData, Error>
 }
 
-/**
- * Hook for performing a rebalance swap from validator token to user token.
- *
- * @example
- * ```tsx
- * import { Hooks } from 'tempo.ts/wagmi'
- *
- * function App() {
- *   const { mutate, isPending } = Hooks.amm.useRebalanceSwap()
- *
- *   return (
- *     <button
- *       onClick={() =>
- *         mutate({
- *           userToken: '0x...',
- *           validatorToken: '0x...',
- *           amountOut: 100n,
- *           to: '0x...',
- *         })
- *       }
- *       disabled={isPending}
- *     >
- *       Rebalance Swap
- *     </button>
- *   )
- * }
- * ```
- *
- * @param parameters - Parameters.
- * @returns Mutation result.
- */
-export function useRebalanceSwap<
-  config extends Config = ResolvedRegister['config'],
-  context = unknown,
->(
-  parameters: useRebalanceSwap.Parameters<config, context> = {},
-): useRebalanceSwap.ReturnType<config, context> {
-  const { mutation } = parameters
-  const config = useConfig(parameters)
-  return useMutation({
-    ...mutation,
-    async mutationFn(variables) {
-      return Actions.rebalanceSwap(config, variables as never)
-    },
-    mutationKey: ['rebalanceSwap'],
-  }) as never
-}
-
-export declare namespace useRebalanceSwap {
-  type Parameters<
-    config extends Config = Config,
-    context = unknown,
-  > = ConfigParameter<config> & {
-    mutation?:
-      | UseMutationParameters<
-          Actions.rebalanceSwap.ReturnValue,
-          DefaultError,
-          Actions.rebalanceSwap.Parameters<config>,
-          context
-        >
-      | undefined
-  }
-
-  type ReturnType<
-    config extends Config = Config,
-    context = unknown,
-  > = UseMutationResult<
-    Actions.rebalanceSwap.ReturnValue,
-    DefaultError,
-    Actions.rebalanceSwap.Parameters<config>,
-    context
-  >
-}
-
-/**
- * Hook for performing a rebalance swap from validator token to user 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 'tempo.ts/wagmi'
- *
- * function App() {
- *   const { mutate, isPending } = Hooks.amm.useRebalanceSwapSync()
- *
- *   return (
- *     <button
- *       onClick={() =>
- *         mutate({
- *           userToken: '0x...',
- *           validatorToken: '0x...',
- *           amountOut: 100n,
- *           to: '0x...',
- *         })
- *       }
- *       disabled={isPending}
- *     >
- *       Rebalance Swap
- *     </button>
- *   )
- * }
- * ```
- *
- * @param parameters - Parameters.
- * @returns Mutation result.
- */
-export function useRebalanceSwapSync<
-  config extends Config = ResolvedRegister['config'],
-  context = unknown,
->(
-  parameters: useRebalanceSwapSync.Parameters<config, context> = {},
-): useRebalanceSwapSync.ReturnType<config, context> {
-  const { mutation } = parameters
-  const config = useConfig(parameters)
-  return useMutation({
-    ...mutation,
-    async mutationFn(variables) {
-      return Actions.rebalanceSwapSync(config, variables as never)
-    },
-    mutationKey: ['rebalanceSwapSync'],
-  }) as never
-}
-
-export declare namespace useRebalanceSwapSync {
-  type Parameters<
-    config extends Config = Config,
-    context = unknown,
-  > = ConfigParameter<config> & {
-    mutation?:
-      | UseMutationParameters<
-          Actions.rebalanceSwapSync.ReturnValue,
-          DefaultError,
-          Actions.rebalanceSwapSync.Parameters<config>,
-          context
-        >
-      | undefined
-  }
-
-  type ReturnType<
-    config extends Config = Config,
-    context = unknown,
-  > = UseMutationResult<
-    Actions.rebalanceSwapSync.ReturnValue,
-    DefaultError,
-    Actions.rebalanceSwapSync.Parameters<config>,
-    context
-  >
-}
-
 /**
  * Hook for adding liquidity to a pool.
  *
@@ -466,251 +315,6 @@ export declare namespace useMintSync {
   >
 }
 
-/**
- * Hook for removing liquidity from a pool.
- *
- * @example
- * ```tsx
- * import { Hooks } from 'tempo.ts/wagmi'
- *
- * function App() {
- *   const { mutate, isPending } = Hooks.amm.useBurn()
- *
- *   return (
- *     <button
- *       onClick={() =>
- *         mutate({
- *           userToken: '0x20c0...beef',
- *           validatorToken: '0x20c0...babe',
- *           liquidity: 50n,
- *           to: '0xfeed...fede',
- *         })
- *       }
- *       disabled={isPending}
- *     >
- *       Remove Liquidity
- *     </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.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.burn.ReturnValue,
-          DefaultError,
-          Actions.burn.Parameters<config>,
-          context
-        >
-      | undefined
-  }
-
-  type ReturnType<
-    config extends Config = Config,
-    context = unknown,
-  > = UseMutationResult<
-    Actions.burn.ReturnValue,
-    DefaultError,
-    Actions.burn.Parameters<config>,
-    context
-  >
-}
-
-/**
- * Hook for removing liquidity from a pool.
- *
- * 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.amm.useBurnSync()
- *
- *   return (
- *     <button
- *       onClick={() =>
- *         mutate({
- *           userToken: '0x20c0...beef',
- *           validatorToken: '0x20c0...babe',
- *           liquidity: 50n,
- *           to: '0xfeed...fede',
- *         })
- *       }
- *       disabled={isPending}
- *     >
- *       Remove Liquidity
- *     </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.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.burnSync.ReturnValue,
-          DefaultError,
-          Actions.burnSync.Parameters<config>,
-          context
-        >
-      | undefined
-  }
-
-  type ReturnType<
-    config extends Config = Config,
-    context = unknown,
-  > = UseMutationResult<
-    Actions.burnSync.ReturnValue,
-    DefaultError,
-    Actions.burnSync.Parameters<config>,
-    context
-  >
-}
-
-/**
- * Hook for watching rebalance swap events.
- *
- * @example
- * ```tsx
- * import { Hooks } from 'tempo.ts/wagmi'
- *
- * function App() {
- *   Hooks.amm.useWatchRebalanceSwap({
- *     onRebalanceSwap(args) {
- *       console.log('Rebalance swap:', args)
- *     },
- *   })
- *
- *   return <div>Watching for rebalance swaps...</div>
- * }
- * ```
- *
- * @param parameters - Parameters.
- */
-export function useWatchRebalanceSwap<
-  config extends Config = ResolvedRegister['config'],
->(parameters: useWatchRebalanceSwap.Parameters<config> = {}) {
-  const { enabled = true, onRebalanceSwap, ...rest } = parameters
-
-  const config = useConfig({ config: parameters.config })
-  const configChainId = useChainId({ config })
-  const chainId = parameters.chainId ?? configChainId
-
-  useEffect(() => {
-    if (!enabled) return
-    if (!onRebalanceSwap) return
-    return Actions.watchRebalanceSwap(config, {
-      ...rest,
-      chainId,
-      onRebalanceSwap,
-    })
-  }, [config, enabled, onRebalanceSwap, rest, chainId])
-}
-
-export declare namespace useWatchRebalanceSwap {
-  type Parameters<config extends Config = Config> = UnionCompute<
-    ExactPartial<Actions.watchRebalanceSwap.Parameters<config>> &
-      ConfigParameter<config> & { enabled?: boolean | undefined }
-  >
-}
-
-/**
- * Hook for watching fee swap events.
- *
- * @example
- * ```tsx
- * import { Hooks } from 'tempo.ts/wagmi'
- *
- * function App() {
- *   Hooks.amm.useWatchFeeSwap({
- *     onFeeSwap(args) {
- *       console.log('Fee swap:', args)
- *     },
- *   })
- *
- *   return <div>Watching for fee swaps...</div>
- * }
- * ```
- *
- * @param parameters - Parameters.
- */
-export function useWatchFeeSwap<
-  config extends Config = ResolvedRegister['config'],
->(parameters: useWatchFeeSwap.Parameters<config> = {}) {
-  const { enabled = true, onFeeSwap, ...rest } = parameters
-
-  const config = useConfig({ config: parameters.config })
-  const configChainId = useChainId({ config })
-  const chainId = parameters.chainId ?? configChainId
-
-  useEffect(() => {
-    if (!enabled) return
-    if (!onFeeSwap) return
-    return Actions.watchFeeSwap(config, {
-      ...rest,
-      chainId,
-      onFeeSwap,
-    })
-  }, [config, enabled, onFeeSwap, rest, chainId])
-}
-
-export declare namespace useWatchFeeSwap {
-  type Parameters<config extends Config = Config> = UnionCompute<
-    ExactPartial<Actions.watchFeeSwap.Parameters<config>> &
-      ConfigParameter<config> & { enabled?: boolean | undefined }
-  >
-}
-
 /**
  * Hook for watching liquidity mint events.
  *
@@ -757,50 +361,3 @@ export declare namespace useWatchMint {
       ConfigParameter<config> & { enabled?: boolean | undefined }
   >
 }
-
-/**
- * Hook for watching liquidity burn events.
- *
- * @example
- * ```tsx
- * import { Hooks } from 'tempo.ts/wagmi'
- *
- * function App() {
- *   Hooks.amm.useWatchBurn({
- *     onBurn(args) {
- *       console.log('Liquidity removed:', args)
- *     },
- *   })
- *
- *   return <div>Watching for liquidity removals...</div>
- * }
- * ```
- *
- * @param parameters - Parameters.
- */
-export function useWatchBurn<
-  config extends Config = ResolvedRegister['config'],
->(parameters: useWatchBurn.Parameters<config> = {}) {
-  const { enabled = true, onBurn, ...rest } = parameters
-
-  const config = useConfig({ config: parameters.config })
-  const configChainId = useChainId({ config })
-  const chainId = parameters.chainId ?? configChainId
-
-  useEffect(() => {
-    if (!enabled) return
-    if (!onBurn) return
-    return Actions.watchBurn(config, {
-      ...rest,
-      chainId,
-      onBurn,
-    })
-  }, [config, enabled, onBurn, rest, chainId])
-}
-
-export declare namespace useWatchBurn {
-  type Parameters<config extends Config = Config> = UnionCompute<
-    ExactPartial<Actions.watchBurn.Parameters<config>> &
-      ConfigParameter<config> & { enabled?: boolean | undefined }
-  >
-}

package/src/wagmi/Hooks/reward.test.ts

@@ -1,125 +1,9 @@
-import { type Address, parseUnits } from 'viem'
+import type { Address } from 'viem'
 import { describe, expect, test, vi } from 'vitest'
 import { useConnect } from 'wagmi'
 import { config, renderHook, setupToken } from '../../../test/wagmi/config.js'
 import * as hooks from './reward.js'
 
-describe('useCancelSync', () => {
-  test('default', async () => {
-    const { result } = await renderHook(() => ({
-      cancel: hooks.useCancelSync(),
-      connect: useConnect(),
-      start: hooks.useStartSync(),
-    }))
-
-    await result.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    const { token } = await setupToken()
-
-    // Start a reward stream
-    const { id: streamId } = await result.current.start.mutateAsync({
-      amount: parseUnits('100', 6),
-      seconds: 3600,
-      token,
-    })
-
-    // Cancel the stream
-    await result.current.cancel.mutateAsync({
-      id: streamId,
-      token,
-    })
-
-    await vi.waitFor(() => expect(result.current.cancel.isSuccess).toBeTruthy())
-  })
-})
-
-describe('useGetStream', () => {
-  test('default', async () => {
-    const { result } = await renderHook(() => ({
-      connect: useConnect(),
-      getStream: hooks.useGetStream(),
-      startSync: hooks.useStartSync(),
-    }))
-
-    await result.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    const { token } = await setupToken()
-
-    const { id: streamId } = await result.current.startSync.mutateAsync({
-      amount: parseUnits('100', 6),
-      seconds: 10,
-      token,
-    })
-
-    // Update the hook to query the stream
-    const { result: streamResult } = await renderHook(() =>
-      hooks.useGetStream({
-        id: streamId,
-        token,
-      }),
-    )
-
-    await vi.waitFor(() => expect(streamResult.current.isSuccess).toBeTruthy())
-
-    expect(streamResult.current.data?.funder).toBeDefined()
-    expect(streamResult.current.data?.amountTotal).toBe(parseUnits('100', 6))
-  })
-
-  test('reactivity: id and token parameters', async () => {
-    const { result: setupResult } = await renderHook(() => ({
-      connect: useConnect(),
-      startSync: hooks.useStartSync(),
-    }))
-
-    await setupResult.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    const { token } = await setupToken()
-
-    const { id } = await setupResult.current.startSync.mutateAsync({
-      amount: parseUnits('100', 6),
-      seconds: 10,
-      token,
-    })
-
-    const { result, rerender } = await renderHook(
-      (props) =>
-        hooks.useGetStream({
-          id: props?.id,
-          token: props?.token,
-        }),
-      {
-        initialProps: {
-          id: undefined as bigint | undefined,
-          token: undefined as Address | undefined,
-        },
-      },
-    )
-
-    await vi.waitFor(() => result.current.fetchStatus === 'idle')
-
-    // Should be disabled when parameters are undefined
-    expect(result.current.data).toBeUndefined()
-    expect(result.current.isPending).toBe(true)
-    expect(result.current.isEnabled).toBe(false)
-
-    // Set parameters
-    rerender({ id, token })
-
-    await vi.waitFor(() => expect(result.current.isSuccess).toBeTruthy())
-
-    // Should now be enabled and have data
-    expect(result.current.isEnabled).toBe(true)
-    expect(result.current.data).toBeDefined()
-    expect(result.current.data?.amountTotal).toBe(parseUnits('100', 6))
-  })
-})
-
 describe('useGetTotalPerSecond', () => {
   test('default', async () => {
     const { token } = await setupToken()
@@ -192,28 +76,3 @@ describe('useSetRecipientSync', () => {
     )
   })
 })
-
-describe('useStartSync', () => {
-  test('default', async () => {
-    const { result } = await renderHook(() => ({
-      connect: useConnect(),
-      start: hooks.useStartSync(),
-    }))
-
-    await result.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    const { token } = await setupToken()
-
-    const { id } = await result.current.start.mutateAsync({
-      amount: parseUnits('100', 6),
-      seconds: 10,
-      token,
-    })
-
-    expect(id).toBeGreaterThan(0n)
-
-    await vi.waitFor(() => expect(result.current.start.isSuccess).toBeTruthy())
-  })
-})