tempo.ts 0.1.5 → 0.2.1

package/src/wagmi/Hooks/faucet.ts

@@ -0,0 +1,76 @@
+import type { UseMutationResult } from '@tanstack/react-query'
+import type { Config, ResolvedRegister } from '@wagmi/core'
+import type { BaseErrorType } from 'viem'
+import { useConfig } from 'wagmi'
+import type { ConfigParameter } from 'wagmi/internal'
+import { type UseMutationParameters, useMutation } from 'wagmi/query'
+
+import { fund } from '../Actions/faucet.js'
+
+/**
+ * Hook for funding an account with an initial amount of set token(s)
+ * on Tempo's testnet.
+ *
+ * @example
+ * ```tsx
+ * import { Hooks } from 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   const { mutate, isPending } = Hooks.faucet.useFund()
+ *
+ *   return (
+ *     <button
+ *       onClick={() => mutate({ account: '0xdeadbeef...' })}
+ *       disabled={isPending}
+ *     >
+ *       Fund Account
+ *     </button>
+ *   )
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ * @returns Mutation result.
+ */
+export function useFund<
+  config extends Config = ResolvedRegister['config'],
+  context = unknown,
+>(
+  parameters: useFund.Parameters<config, context> = {},
+): useFund.ReturnType<config, context> {
+  const { mutation } = parameters
+  const config = useConfig(parameters)
+  return useMutation({
+    ...mutation,
+    async mutationFn(variables) {
+      return fund(config, variables)
+    },
+    mutationKey: ['fund'],
+  })
+}
+
+export declare namespace useFund {
+  type Parameters<
+    config extends Config = Config,
+    context = unknown,
+  > = ConfigParameter<config> & {
+    mutation?:
+      | UseMutationParameters<
+          fund.ReturnValue,
+          BaseErrorType,
+          fund.Parameters<config>,
+          context
+        >
+      | undefined
+  }
+
+  type ReturnType<
+    config extends Config = Config,
+    context = unknown,
+  > = UseMutationResult<
+    fund.ReturnValue,
+    BaseErrorType,
+    fund.Parameters<config>,
+    context
+  >
+}

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

@@ -0,0 +1,166 @@
+import type { Account } from 'viem'
+import { describe, expect, test, vi } from 'vitest'
+import { useConnect } from 'wagmi'
+import { accounts } from '../../../test/viem/config.js'
+import { config, renderHook } from '../../../test/wagmi/config.js'
+import { useSetUserToken, useSetUserTokenSync, useUserToken } from './fee.js'
+
+describe('useUserToken', () => {
+  test('default', async () => {
+    let account: Account | undefined
+
+    const { result, rerender } = await renderHook(() =>
+      useUserToken({ account }),
+    )
+
+    await vi.waitFor(() => result.current.fetchStatus === 'fetching')
+
+    expect(result.current).toMatchInlineSnapshot(`
+      {
+        "data": undefined,
+        "dataUpdatedAt": 0,
+        "error": null,
+        "errorUpdateCount": 0,
+        "errorUpdatedAt": 0,
+        "failureCount": 0,
+        "failureReason": null,
+        "fetchStatus": "idle",
+        "isEnabled": false,
+        "isError": false,
+        "isFetched": false,
+        "isFetchedAfterMount": false,
+        "isFetching": false,
+        "isInitialLoading": false,
+        "isLoading": false,
+        "isLoadingError": false,
+        "isPaused": false,
+        "isPending": true,
+        "isPlaceholderData": false,
+        "isRefetchError": false,
+        "isRefetching": false,
+        "isStale": false,
+        "isSuccess": false,
+        "promise": Promise {
+          "reason": [Error: experimental_prefetchInRender feature flag is not enabled],
+          "status": "rejected",
+        },
+        "queryKey": [
+          "getUserToken",
+          {
+            "account": undefined,
+            "chainId": 1337,
+          },
+        ],
+        "refetch": [Function],
+        "status": "pending",
+      }
+    `)
+
+    account = accounts[0]
+    rerender()
+
+    await vi.waitFor(() => expect(result.current.isSuccess).toBeTruthy(), {
+      timeout: 5_000,
+    })
+
+    expect(result.current).toMatchInlineSnapshot(`
+      {
+        "data": {
+          "address": "0x20C0000000000000000000000000000000000001",
+          "id": 1n,
+        },
+        "dataUpdatedAt": 1675209600000,
+        "error": null,
+        "errorUpdateCount": 0,
+        "errorUpdatedAt": 0,
+        "failureCount": 0,
+        "failureReason": null,
+        "fetchStatus": "idle",
+        "isEnabled": true,
+        "isError": false,
+        "isFetched": true,
+        "isFetchedAfterMount": true,
+        "isFetching": false,
+        "isInitialLoading": false,
+        "isLoading": false,
+        "isLoadingError": false,
+        "isPaused": false,
+        "isPending": false,
+        "isPlaceholderData": false,
+        "isRefetchError": false,
+        "isRefetching": false,
+        "isStale": true,
+        "isSuccess": true,
+        "promise": Promise {
+          "reason": [Error: experimental_prefetchInRender feature flag is not enabled],
+          "status": "rejected",
+        },
+        "queryKey": [
+          "getUserToken",
+          {
+            "account": {
+              "address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+              "getHdKey": [Function],
+              "nonceManager": undefined,
+              "publicKey": "0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5",
+              "sign": [Function],
+              "signAuthorization": [Function],
+              "signMessage": [Function],
+              "signTransaction": [Function],
+              "signTypedData": [Function],
+              "source": "hd",
+              "type": "local",
+            },
+            "chainId": 1337,
+          },
+        ],
+        "refetch": [Function],
+        "status": "success",
+      }
+    `)
+  })
+})
+
+describe.skip('useSetUserToken', () => {
+  test('default', async () => {
+    const { result } = await renderHook(() => ({
+      connect: useConnect(),
+      setUserToken: useSetUserToken(),
+    }))
+
+    await result.current.connect.connectAsync({
+      connector: config.connectors[0]!,
+    })
+
+    const hash = await result.current.setUserToken.mutateAsync({
+      token: '0x20C0000000000000000000000000000000000001',
+    })
+    expect(hash).toBeDefined()
+
+    await vi.waitFor(() =>
+      expect(result.current.setUserToken.isSuccess).toBeTruthy(),
+    )
+  })
+})
+
+describe('useSetUserTokenSync', () => {
+  test('default', async () => {
+    const { result } = await renderHook(() => ({
+      connect: useConnect(),
+      setUserToken: useSetUserTokenSync(),
+    }))
+
+    await result.current.connect.connectAsync({
+      connector: config.connectors[0]!,
+    })
+
+    const data = await result.current.setUserToken.mutateAsync({
+      token: '0x20C0000000000000000000000000000000000001',
+    })
+    expect(data).toBeDefined()
+
+    await vi.waitFor(() =>
+      expect(result.current.setUserToken.isSuccess).toBeTruthy(),
+    )
+  })
+})

package/src/wagmi/Hooks/fee.ts

@@ -0,0 +1,206 @@
+import type { DefaultError } from '@tanstack/query-core'
+import type { UseMutationResult } from '@tanstack/react-query'
+import type { Config, ResolvedRegister } from '@wagmi/core'
+import { useChainId, useConfig } from 'wagmi'
+import type { ConfigParameter, QueryParameter } from 'wagmi/internal'
+import {
+  type UseMutationParameters,
+  type UseQueryReturnType,
+  useMutation,
+  useQuery,
+} from 'wagmi/query'
+
+import { getUserToken, setUserToken, setUserTokenSync } from '../Actions/fee.js'
+
+/**
+ * Hook for getting the user's default fee token.
+ *
+ * @example
+ * ```tsx
+ * import { Hooks } from 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   const { data, isLoading } = Hooks.fee.useUserToken({
+ *     account: '0x20c...0055',
+ *   })
+ *
+ *   if (isLoading) return <div>Loading...</div>
+ *   return <div>Token: {data?.address}</div>
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ * @returns Query result with token address and ID.
+ */
+export function useUserToken<
+  config extends Config = ResolvedRegister['config'],
+  selectData = getUserToken.ReturnValue,
+>(parameters: useUserToken.Parameters<config, selectData>) {
+  const { account, query = {} } = parameters
+
+  const config = useConfig(parameters)
+  const chainId = useChainId({ config })
+
+  const options = getUserToken.queryOptions(config, {
+    ...parameters,
+    chainId: parameters.chainId ?? chainId,
+    query: undefined,
+  })
+  const enabled = Boolean(account && (query.enabled ?? true))
+
+  return useQuery({ ...query, ...options, enabled })
+}
+
+export declare namespace useUserToken {
+  export type Parameters<
+    config extends Config = ResolvedRegister['config'],
+    selectData = getUserToken.ReturnValue,
+  > = ConfigParameter<config> &
+    QueryParameter<
+      getUserToken.ReturnValue,
+      DefaultError,
+      selectData,
+      getUserToken.QueryKey<config>
+    > &
+    Omit<getUserToken.queryOptions.Parameters<config, selectData>, 'query'>
+
+  export type ReturnValue<selectData = getUserToken.ReturnValue> =
+    UseQueryReturnType<selectData, Error>
+}
+
+/**
+ * Hook for setting the user's default fee token.
+ *
+ * @example
+ * ```tsx
+ * import { Hooks } from 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   const { mutate, isPending } = Hooks.fee.useSetUserToken()
+ *
+ *   return (
+ *     <button
+ *       onClick={() => mutate({ token: '0x20c...0055' })}
+ *       disabled={isPending}
+ *     >
+ *       Set Token
+ *     </button>
+ *   )
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ * @returns Mutation result.
+ */
+export function useSetUserToken<
+  config extends Config = ResolvedRegister['config'],
+  context = unknown,
+>(
+  parameters: useSetUserToken.Parameters<config, context> = {},
+): useSetUserToken.ReturnType<config, context> {
+  const { mutation } = parameters
+  const config = useConfig(parameters)
+  return useMutation({
+    ...mutation,
+    async mutationFn(variables) {
+      return setUserToken(config, variables)
+    },
+    mutationKey: ['setUserTokenSync'],
+  })
+}
+
+export declare namespace useSetUserToken {
+  type Parameters<
+    config extends Config = Config,
+    context = unknown,
+  > = ConfigParameter<config> & {
+    mutation?:
+      | UseMutationParameters<
+          setUserToken.ReturnValue,
+          setUserToken.ErrorType,
+          setUserToken.Parameters<config>,
+          context
+        >
+      | undefined
+  }
+
+  type ReturnType<
+    config extends Config = Config,
+    context = unknown,
+  > = UseMutationResult<
+    setUserToken.ReturnValue,
+    setUserToken.ErrorType,
+    setUserToken.Parameters<config>,
+    context
+  >
+}
+
+/**
+ * Hook for setting the user's default fee 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.fee.useSetUserTokenSync()
+ *
+ *   return (
+ *     <button
+ *       onClick={() => mutate({ token: '0x20c...0055' })}
+ *       disabled={isPending}
+ *     >
+ *       Set Token
+ *     </button>
+ *   )
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ * @returns Mutation result.
+ */
+export function useSetUserTokenSync<
+  config extends Config = ResolvedRegister['config'],
+  context = unknown,
+>(
+  parameters: useSetUserTokenSync.Parameters<config, context> = {},
+): useSetUserTokenSync.ReturnType<config, context> {
+  const { mutation } = parameters
+  const config = useConfig(parameters)
+  return useMutation({
+    ...mutation,
+    async mutationFn(variables) {
+      return setUserTokenSync(config, variables)
+    },
+    mutationKey: ['setUserTokenSync'],
+  })
+}
+
+export declare namespace useSetUserTokenSync {
+  type Parameters<
+    config extends Config = Config,
+    context = unknown,
+  > = ConfigParameter<config> & {
+    mutation?:
+      | UseMutationParameters<
+          setUserTokenSync.ReturnValue,
+          setUserTokenSync.ErrorType,
+          setUserTokenSync.Parameters<config>,
+          context
+        >
+      | undefined
+  }
+
+  type ReturnType<
+    config extends Config = Config,
+    context = unknown,
+  > = UseMutationResult<
+    setUserTokenSync.ReturnValue,
+    setUserTokenSync.ErrorType,
+    setUserTokenSync.Parameters<config>,
+    context
+  >
+}

package/src/wagmi/Hooks/index.ts

@@ -0,0 +1,6 @@
+export * as amm from './amm.js'
+export * as dex from './dex.js'
+export * as faucet from './faucet.js'
+export * as fee from './fee.js'
+export * as reward from './reward.js'
+export * as token from './token.js'

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

@@ -0,0 +1,219 @@
+import { type Address, parseUnits } 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()
+
+    const { result } = await renderHook(() =>
+      hooks.useGetTotalPerSecond({
+        token,
+      }),
+    )
+
+    await vi.waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+
+    expect(result.current.data).toBe(0n)
+  })
+
+  test('reactivity: token parameter', async () => {
+    const { result, rerender } = await renderHook(
+      (props) =>
+        hooks.useGetTotalPerSecond({
+          token: props?.token,
+        }),
+      {
+        initialProps: {
+          token: undefined as Address | undefined,
+        },
+      },
+    )
+
+    await vi.waitFor(() => result.current.fetchStatus === 'idle')
+
+    // Should be disabled when token is undefined
+    expect(result.current.data).toBeUndefined()
+    expect(result.current.isPending).toBe(true)
+    expect(result.current.isEnabled).toBe(false)
+
+    // Setup token
+    const { token } = await setupToken()
+
+    // Set token
+    rerender({ 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).toBe(0n)
+  })
+})
+
+describe('useSetRecipientSync', () => {
+  test('default', async () => {
+    const { result } = await renderHook(() => ({
+      connect: useConnect(),
+      setRecipient: hooks.useSetRecipientSync(),
+    }))
+
+    await result.current.connect.connectAsync({
+      connector: config.connectors[0]!,
+    })
+
+    const { token } = await setupToken()
+
+    await result.current.setRecipient.mutateAsync({
+      recipient: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+      token,
+    })
+
+    await vi.waitFor(() =>
+      expect(result.current.setRecipient.isSuccess).toBeTruthy(),
+    )
+  })
+})
+
+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())
+  })
+})