tempo.ts 0.10.2 → 0.10.4

package/src/wagmi/Actions/nonce.ts

@@ -0,0 +1,271 @@
+import type * as Query from '@tanstack/query-core'
+import type { Config } from '@wagmi/core'
+import type { ChainIdParameter } from '@wagmi/core/internal'
+import type { PartialBy, RequiredBy } from '../../internal/types.js'
+import * as viem_Actions from '../../viem/Actions/nonce.js'
+
+/**
+ * Gets the nonce for an account and nonce key.
+ *
+ * @example
+ * ```ts
+ * import { createConfig, http } from '@wagmi/core'
+ * import { tempo } from 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/wagmi'
+ *
+ * const config = createConfig({
+ *   chains: [tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })],
+ *   transports: {
+ *     [tempo.id]: http(),
+ *   },
+ * })
+ *
+ * const nonce = await Actions.nonce.getNonce(config, {
+ *   account: '0x...',
+ *   nonceKey: 1n,
+ * })
+ * ```
+ *
+ * @param config - Config.
+ * @param parameters - Parameters.
+ * @returns The nonce value.
+ */
+export function getNonce<config extends Config>(
+  config: config,
+  parameters: getNonce.Parameters<config>,
+): Promise<getNonce.ReturnValue> {
+  const { chainId, ...rest } = parameters
+  const client = config.getClient({ chainId })
+  return viem_Actions.getNonce(client, rest)
+}
+
+export namespace getNonce {
+  export type Parameters<config extends Config> = ChainIdParameter<config> &
+    viem_Actions.getNonce.Parameters
+
+  export type ReturnValue = viem_Actions.getNonce.ReturnValue
+
+  export function queryKey<config extends Config>(
+    parameters: PartialBy<Parameters<config>, 'account' | 'nonceKey'>,
+  ) {
+    return ['getNonce', parameters] as const
+  }
+
+  export type QueryKey<config extends Config> = ReturnType<
+    typeof queryKey<config>
+  >
+
+  export function queryOptions<config extends Config, selectData = ReturnValue>(
+    config: Config,
+    parameters: queryOptions.Parameters<config, selectData>,
+  ): queryOptions.ReturnValue<config, selectData> {
+    const { query, ...rest } = parameters
+    return {
+      ...query,
+      queryKey: queryKey(rest),
+      async queryFn({ queryKey }) {
+        const [, { account, nonceKey, ...parameters }] = queryKey
+        if (!account) throw new Error('account is required.')
+        if (nonceKey === undefined) throw new Error('nonceKey is required.')
+        return await getNonce(config, { account, nonceKey, ...parameters })
+      },
+    }
+  }
+
+  export declare namespace queryOptions {
+    export type Parameters<
+      config extends Config,
+      selectData = getNonce.ReturnValue,
+    > = PartialBy<getNonce.Parameters<config>, 'account' | 'nonceKey'> & {
+      query?:
+        | Omit<ReturnValue<config, selectData>, 'queryKey' | 'queryFn'>
+        | undefined
+    }
+
+    export type ReturnValue<
+      config extends Config,
+      selectData = getNonce.ReturnValue,
+    > = RequiredBy<
+      Query.QueryOptions<
+        getNonce.ReturnValue,
+        Query.DefaultError,
+        selectData,
+        getNonce.QueryKey<config>
+      >,
+      'queryKey' | 'queryFn'
+    >
+  }
+}
+
+/**
+ * Gets the number of active nonce keys for an account.
+ *
+ * @example
+ * ```ts
+ * import { createConfig, http } from '@wagmi/core'
+ * import { tempo } from 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/wagmi'
+ *
+ * const config = createConfig({
+ *   chains: [tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })],
+ *   transports: {
+ *     [tempo.id]: http(),
+ *   },
+ * })
+ *
+ * const count = await Actions.nonce.getNonceKeyCount(config, {
+ *   account: '0x...',
+ * })
+ * ```
+ *
+ * @param config - Config.
+ * @param parameters - Parameters.
+ * @returns The number of active nonce keys.
+ */
+export function getNonceKeyCount<config extends Config>(
+  config: config,
+  parameters: getNonceKeyCount.Parameters<config>,
+): Promise<getNonceKeyCount.ReturnValue> {
+  const { chainId, ...rest } = parameters
+  const client = config.getClient({ chainId })
+  return viem_Actions.getNonceKeyCount(client, rest)
+}
+
+export namespace getNonceKeyCount {
+  export type Parameters<config extends Config> = ChainIdParameter<config> &
+    viem_Actions.getNonceKeyCount.Parameters
+
+  export type ReturnValue = viem_Actions.getNonceKeyCount.ReturnValue
+
+  export function queryKey<config extends Config>(
+    parameters: PartialBy<Parameters<config>, 'account'>,
+  ) {
+    return ['getNonceKeyCount', parameters] as const
+  }
+
+  export type QueryKey<config extends Config> = ReturnType<
+    typeof queryKey<config>
+  >
+
+  export function queryOptions<config extends Config, selectData = ReturnValue>(
+    config: Config,
+    parameters: queryOptions.Parameters<config, selectData>,
+  ): queryOptions.ReturnValue<config, selectData> {
+    const { query, ...rest } = parameters
+    return {
+      ...query,
+      queryKey: queryKey(rest),
+      async queryFn({ queryKey }) {
+        const [, { account, ...parameters }] = queryKey
+        if (!account) throw new Error('account is required.')
+        return await getNonceKeyCount(config, { account, ...parameters })
+      },
+    }
+  }
+
+  export declare namespace queryOptions {
+    export type Parameters<
+      config extends Config,
+      selectData = getNonceKeyCount.ReturnValue,
+    > = PartialBy<getNonceKeyCount.Parameters<config>, 'account'> & {
+      query?:
+        | Omit<ReturnValue<config, selectData>, 'queryKey' | 'queryFn'>
+        | undefined
+    }
+
+    export type ReturnValue<
+      config extends Config,
+      selectData = getNonceKeyCount.ReturnValue,
+    > = RequiredBy<
+      Query.QueryOptions<
+        getNonceKeyCount.ReturnValue,
+        Query.DefaultError,
+        selectData,
+        getNonceKeyCount.QueryKey<config>
+      >,
+      'queryKey' | 'queryFn'
+    >
+  }
+}
+
+/**
+ * Watches for nonce incremented events.
+ *
+ * @example
+ * ```ts
+ * import { createConfig, http } from '@wagmi/core'
+ * import { tempo } from 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/wagmi'
+ *
+ * const config = createConfig({
+ *   chains: [tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })],
+ *   transports: {
+ *     [tempo.id]: http(),
+ *   },
+ * })
+ *
+ * const unwatch = Actions.nonce.watchNonceIncremented(config, {
+ *   onNonceIncremented: (args, log) => {
+ *     console.log('Nonce incremented:', args)
+ *   },
+ * })
+ * ```
+ *
+ * @param config - Config.
+ * @param parameters - Parameters.
+ * @returns A function to unsubscribe from the event.
+ */
+export function watchNonceIncremented<config extends Config>(
+  config: config,
+  parameters: watchNonceIncremented.Parameters<config>,
+): () => void {
+  const { chainId, ...rest } = parameters
+  const client = config.getClient({ chainId })
+  return viem_Actions.watchNonceIncremented(client, rest)
+}
+
+export declare namespace watchNonceIncremented {
+  export type Parameters<config extends Config> = ChainIdParameter<config> &
+    viem_Actions.watchNonceIncremented.Parameters
+}
+
+/**
+ * Watches for active key count changed events.
+ *
+ * @example
+ * ```ts
+ * import { createConfig, http } from '@wagmi/core'
+ * import { tempo } from 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/wagmi'
+ *
+ * const config = createConfig({
+ *   chains: [tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })],
+ *   transports: {
+ *     [tempo.id]: http(),
+ *   },
+ * })
+ *
+ * const unwatch = Actions.nonce.watchActiveKeyCountChanged(config, {
+ *   onActiveKeyCountChanged: (args, log) => {
+ *     console.log('Active key count changed:', args)
+ *   },
+ * })
+ * ```
+ *
+ * @param config - Config.
+ * @param parameters - Parameters.
+ * @returns A function to unsubscribe from the event.
+ */
+export function watchActiveKeyCountChanged<config extends Config>(
+  config: config,
+  parameters: watchActiveKeyCountChanged.Parameters<config>,
+): () => void {
+  const { chainId, ...rest } = parameters
+  const client = config.getClient({ chainId })
+  return viem_Actions.watchActiveKeyCountChanged(client, rest)
+}
+
+export declare namespace watchActiveKeyCountChanged {
+  export type Parameters<config extends Config> = ChainIdParameter<config> &
+    viem_Actions.watchActiveKeyCountChanged.Parameters
+}

package/src/wagmi/Hooks/index.ts

@@ -2,6 +2,7 @@ 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

@@ -0,0 +1,207 @@
+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 { useNonceKeyCount, 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(1n)
+  })
+
+  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(1n)
+  })
+
+  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(1n)
+  })
+})
+
+describe('useNonceKeyCount', () => {
+  test('default', async () => {
+    let testAccount: Address | undefined
+
+    const { result, rerender } = await renderHook(() =>
+      useNonceKeyCount({ account: testAccount }),
+    )
+
+    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
+    testAccount = account.address
+    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)
+  })
+})
+
+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)
+  })
+})
+
+describe('useWatchActiveKeyCountChanged', () => {
+  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.useWatchActiveKeyCountChanged({
+        onActiveKeyCountChanged(args) {
+          events.push(args)
+        },
+      }),
+    )
+
+    await connectResult.current.transferSync.mutateAsync({
+      to: account2.address,
+      amount: 1n,
+      token: 1n,
+      nonceKey: 10n,
+      nonce: 0,
+    })
+
+    await vi.waitUntil(() => events.length >= 1)
+
+    expect(events).toHaveLength(1)
+    expect(events[0]?.account).toBe(account.address)
+    expect(events[0]?.newCount).toBe(2n)
+  })
+})

package/src/wagmi/Hooks/nonce.ts

@@ -0,0 +1,230 @@
+import type { DefaultError } from '@tanstack/query-core'
+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 UseQueryReturnType, useQuery } from 'wagmi/query'
+
+import type { ExactPartial, UnionCompute } from '../../internal/types.js'
+import {
+  getNonce,
+  getNonceKeyCount,
+  watchActiveKeyCountChanged,
+  watchNonceIncremented,
+} from '../Actions/nonce.js'
+
+/**
+ * Hook for getting the nonce for an account and nonce key.
+ *
+ * @example
+ * ```tsx
+ * import { Hooks } from 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   const { data, isLoading } = Hooks.nonce.useNonce({
+ *     account: '0x...',
+ *     nonceKey: 1n,
+ *   })
+ *
+ *   if (isLoading) return <div>Loading...</div>
+ *   return <div>Nonce: {data?.toString()}</div>
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ * @returns Query result with nonce value.
+ */
+export function useNonce<
+  config extends Config = ResolvedRegister['config'],
+  selectData = getNonce.ReturnValue,
+>(parameters: useNonce.Parameters<config, selectData> = {}) {
+  const { account, nonceKey, query = {} } = parameters
+
+  const config = useConfig(parameters)
+  const chainId = useChainId({ config })
+
+  const options = getNonce.queryOptions(config, {
+    ...parameters,
+    chainId: parameters.chainId ?? chainId,
+    query: undefined,
+  })
+  const enabled = Boolean(
+    account && nonceKey !== undefined && (query.enabled ?? true),
+  )
+
+  return useQuery({ ...query, ...options, enabled })
+}
+
+export declare namespace useNonce {
+  export type Parameters<
+    config extends Config = ResolvedRegister['config'],
+    selectData = getNonce.ReturnValue,
+  > = ConfigParameter<config> &
+    QueryParameter<
+      getNonce.ReturnValue,
+      DefaultError,
+      selectData,
+      getNonce.QueryKey<config>
+    > &
+    ExactPartial<
+      Omit<getNonce.queryOptions.Parameters<config, selectData>, 'query'>
+    >
+
+  export type ReturnValue<selectData = getNonce.ReturnValue> =
+    UseQueryReturnType<selectData, Error>
+}
+
+/**
+ * Hook for getting the number of active nonce keys for an account.
+ *
+ * @example
+ * ```tsx
+ * import { Hooks } from 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   const { data, isLoading } = Hooks.nonce.useNonceKeyCount({
+ *     account: '0x...',
+ *   })
+ *
+ *   if (isLoading) return <div>Loading...</div>
+ *   return <div>Active keys: {data?.toString()}</div>
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ * @returns Query result with active nonce key count.
+ */
+export function useNonceKeyCount<
+  config extends Config = ResolvedRegister['config'],
+  selectData = getNonceKeyCount.ReturnValue,
+>(parameters: useNonceKeyCount.Parameters<config, selectData> = {}) {
+  const { account, query = {} } = parameters
+
+  const config = useConfig(parameters)
+  const chainId = useChainId({ config })
+
+  const options = getNonceKeyCount.queryOptions(config, {
+    ...parameters,
+    chainId: parameters.chainId ?? chainId,
+    query: undefined,
+  })
+  const enabled = Boolean(account && (query.enabled ?? true))
+
+  return useQuery({ ...query, ...options, enabled })
+}
+
+export declare namespace useNonceKeyCount {
+  export type Parameters<
+    config extends Config = ResolvedRegister['config'],
+    selectData = getNonceKeyCount.ReturnValue,
+  > = ConfigParameter<config> &
+    QueryParameter<
+      getNonceKeyCount.ReturnValue,
+      DefaultError,
+      selectData,
+      getNonceKeyCount.QueryKey<config>
+    > &
+    ExactPartial<
+      Omit<
+        getNonceKeyCount.queryOptions.Parameters<config, selectData>,
+        'query'
+      >
+    >
+
+  export type ReturnValue<selectData = getNonceKeyCount.ReturnValue> =
+    UseQueryReturnType<selectData, Error>
+}
+
+/**
+ * Hook for watching nonce incremented events.
+ *
+ * @example
+ * ```tsx
+ * import { Hooks } from 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   Hooks.nonce.useWatchNonceIncremented({
+ *     onNonceIncremented(args, log) {
+ *       console.log('Nonce incremented:', args)
+ *     },
+ *   })
+ *
+ *   return <div>Watching for nonce increments...</div>
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ */
+export function useWatchNonceIncremented<
+  config extends Config = ResolvedRegister['config'],
+>(parameters: useWatchNonceIncremented.Parameters<config> = {}) {
+  const { enabled = true, onNonceIncremented, ...rest } = parameters
+
+  const config = useConfig({ config: parameters.config })
+  const configChainId = useChainId({ config })
+  const chainId = parameters.chainId ?? configChainId
+
+  useEffect(() => {
+    if (!enabled) return
+    if (!onNonceIncremented) return
+    return watchNonceIncremented(config, {
+      ...rest,
+      chainId,
+      onNonceIncremented,
+    })
+  }, [config, enabled, onNonceIncremented, chainId, rest])
+}
+
+export declare namespace useWatchNonceIncremented {
+  type Parameters<config extends Config = Config> = UnionCompute<
+    ExactPartial<watchNonceIncremented.Parameters<config>> &
+      ConfigParameter<config> & { enabled?: boolean | undefined }
+  >
+}
+
+/**
+ * Hook for watching active key count changed events.
+ *
+ * @example
+ * ```tsx
+ * import { Hooks } from 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   Hooks.nonce.useWatchActiveKeyCountChanged({
+ *     onActiveKeyCountChanged(args, log) {
+ *       console.log('Active key count changed:', args)
+ *     },
+ *   })
+ *
+ *   return <div>Watching for active key count changes...</div>
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ */
+export function useWatchActiveKeyCountChanged<
+  config extends Config = ResolvedRegister['config'],
+>(parameters: useWatchActiveKeyCountChanged.Parameters<config> = {}) {
+  const { enabled = true, onActiveKeyCountChanged, ...rest } = parameters
+
+  const config = useConfig({ config: parameters.config })
+  const configChainId = useChainId({ config })
+  const chainId = parameters.chainId ?? configChainId
+
+  useEffect(() => {
+    if (!enabled) return
+    if (!onActiveKeyCountChanged) return
+    return watchActiveKeyCountChanged(config, {
+      ...rest,
+      chainId,
+      onActiveKeyCountChanged,
+    })
+  }, [config, enabled, onActiveKeyCountChanged, chainId, rest])
+}
+
+export declare namespace useWatchActiveKeyCountChanged {
+  type Parameters<config extends Config = Config> = UnionCompute<
+    ExactPartial<watchActiveKeyCountChanged.Parameters<config>> &
+      ConfigParameter<config> & { enabled?: boolean | undefined }
+  >
+}