tempo.ts 0.12.0 → 0.13.0

package/src/wagmi/Hooks/faucet.ts

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

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

@@ -1,166 +0,0 @@
-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",
-              "keyType": "secp256k1",
-              "publicKey": "0x8318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5",
-              "sign": [Function],
-              "signAuthorization": [Function],
-              "signKeyAuthorization": [Function],
-              "signMessage": [Function],
-              "signTransaction": [Function],
-              "signTypedData": [Function],
-              "source": "root",
-              "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

@@ -1,206 +0,0 @@
-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 as never)
-    },
-    mutationKey: ['setUserTokenSync'],
-  }) as never
-}
-
-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 as never)
-    },
-    mutationKey: ['setUserTokenSync'],
-  }) as never
-}
-
-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

@@ -1,8 +0,0 @@
-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 nonce from './nonce.js'
-export * as policy from './policy.js'
-export * as reward from './reward.js'
-export * as token from './token.js'

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

@@ -1,142 +0,0 @@
-import type { Address } 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 * as hooks from './nonce.js'
-import * as tokenHooks from './token.js'
-
-const { useNonce } = hooks
-
-const account = accounts[0]
-const account2 = accounts[1]
-
-describe('useNonce', () => {
-  test('default', async () => {
-    let testAccount: Address | undefined
-    let testNonceKey: bigint | undefined
-
-    const { result, rerender } = await renderHook(() =>
-      useNonce({ account: testAccount, nonceKey: testNonceKey }),
-    )
-
-    await vi.waitFor(() => result.current.fetchStatus === 'fetching')
-
-    // Should be disabled when account is undefined
-    expect(result.current.data).toBeUndefined()
-    expect(result.current.isPending).toBe(true)
-    expect(result.current.isEnabled).toBe(false)
-
-    // Set account and nonceKey
-    testAccount = account.address
-    testNonceKey = 1n
-    rerender()
-
-    await vi.waitFor(() => expect(result.current.isSuccess).toBeTruthy(), {
-      timeout: 5_000,
-    })
-
-    // Should now be enabled and have data
-    expect(result.current.isEnabled).toBe(true)
-    expect(result.current.data).toBe(0n)
-  })
-
-  test('reactivity: account parameter', async () => {
-    let testAccount: Address | undefined
-
-    const { result, rerender } = await renderHook(() =>
-      useNonce({ account: testAccount, nonceKey: 1n }),
-    )
-
-    await vi.waitFor(() => result.current.fetchStatus === 'fetching')
-
-    // Should be disabled when account is undefined
-    expect(result.current.isEnabled).toBe(false)
-
-    // Set account
-    testAccount = account.address
-    rerender()
-
-    await vi.waitFor(() => expect(result.current.isSuccess).toBeTruthy(), {
-      timeout: 5_000,
-    })
-
-    expect(result.current.isEnabled).toBe(true)
-    expect(result.current.data).toBe(0n)
-  })
-
-  test('reactivity: nonceKey parameter', async () => {
-    let testNonceKey: bigint | undefined
-
-    const { result, rerender } = await renderHook(() =>
-      useNonce({ account: account.address, nonceKey: testNonceKey }),
-    )
-
-    await vi.waitFor(() => result.current.fetchStatus === 'fetching')
-
-    // Should be disabled when nonceKey is undefined
-    expect(result.current.isEnabled).toBe(false)
-
-    // Set nonceKey
-    testNonceKey = 1n
-    rerender()
-
-    await vi.waitFor(() => expect(result.current.isSuccess).toBeTruthy(), {
-      timeout: 5_000,
-    })
-
-    expect(result.current.isEnabled).toBe(true)
-    expect(result.current.data).toBe(0n)
-  })
-})
-
-describe('useWatchNonceIncremented', () => {
-  test('default', async () => {
-    const { result: connectResult } = await renderHook(() => ({
-      connect: useConnect(),
-      transferSync: tokenHooks.useTransferSync(),
-    }))
-
-    await connectResult.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    const events: any[] = []
-    await renderHook(() =>
-      hooks.useWatchNonceIncremented({
-        onNonceIncremented(args) {
-          events.push(args)
-        },
-        args: {
-          account: account.address,
-          nonceKey: 5n,
-        },
-      }),
-    )
-
-    // Have to manually set nonce because eth_FillTransaction does not support nonce keys
-    await connectResult.current.transferSync.mutateAsync({
-      to: account2.address,
-      amount: 1n,
-      token: 1n,
-      nonceKey: 5n,
-      nonce: 0,
-    })
-
-    await connectResult.current.transferSync.mutateAsync({
-      to: account2.address,
-      amount: 1n,
-      token: 1n,
-      nonceKey: 5n,
-      nonce: 1,
-    })
-
-    await vi.waitUntil(() => events.length >= 2)
-
-    expect(events).toHaveLength(2)
-    expect(events[0]?.account).toBe(account.address)
-    expect(events[0]?.nonceKey).toBe(5n)
-    expect(events[0]?.newNonce).toBe(1n)
-    expect(events[1]?.newNonce).toBe(2n)
-  })
-})