tempo.ts 0.10.2 → 0.10.3

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

@@ -0,0 +1,141 @@
+import { connect } from '@wagmi/core'
+import { afterEach, describe, expect, test } from 'vitest'
+import { rpcUrl } from '../../../test/config.js'
+import { accounts } from '../../../test/viem/config.js'
+import { config, queryClient } from '../../../test/wagmi/config.js'
+import * as nonce from './nonce.js'
+import * as token from './token.js'
+
+const { getNonceKeyCount, getNonce } = nonce
+
+const account = accounts[0]
+const account2 = accounts[1]
+
+afterEach(async () => {
+  await fetch(`${rpcUrl}/restart`)
+})
+
+describe('getNonce', () => {
+  test('default', async () => {
+    const result = await getNonce(config, {
+      account: account.address,
+      nonceKey: 1n,
+    })
+    expect(result).toBe(1n)
+  })
+
+  describe('queryOptions', () => {
+    test('default', async () => {
+      const options = getNonce.queryOptions(config, {
+        account: account.address,
+        nonceKey: 1n,
+      })
+      const result = await queryClient.fetchQuery(options)
+      expect(result).toBe(1n)
+    })
+  })
+})
+
+describe('getNonceKeyCount', () => {
+  test('default', async () => {
+    const result = await getNonceKeyCount(config, {
+      account: account.address,
+    })
+    expect(result).toBe(0n)
+  })
+
+  describe('queryOptions', () => {
+    test('default', async () => {
+      const options = getNonceKeyCount.queryOptions(config, {
+        account: account.address,
+      })
+      expect(await queryClient.fetchQuery(options)).toBe(0n)
+    })
+  })
+})
+
+describe('watchNonceIncremented', () => {
+  test('default', async () => {
+    await connect(config, {
+      connector: config.connectors[0]!,
+    })
+
+    const events: any[] = []
+    const unwatch = nonce.watchNonceIncremented(config, {
+      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 token.transferSync(config, {
+      to: account2.address,
+      amount: 1n,
+      token: 1n,
+      nonceKey: 5n,
+      nonce: 0,
+    })
+
+    await token.transferSync(config, {
+      to: account2.address,
+      amount: 1n,
+      token: 1n,
+      nonceKey: 5n,
+      nonce: 1,
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 1000))
+
+    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)
+    unwatch()
+  })
+})
+
+describe('watchActiveKeyCountChanged', () => {
+  test('default', async () => {
+    await connect(config, {
+      connector: config.connectors[0]!,
+    })
+
+    const events: any[] = []
+    const unwatch = nonce.watchActiveKeyCountChanged(config, {
+      onActiveKeyCountChanged: (args) => {
+        events.push(args)
+      },
+    })
+
+    // First use of nonceKey 10 should increment active key count
+    await token.transferSync(config, {
+      to: account2.address,
+      amount: 1n,
+      token: 1n,
+      nonceKey: 10n,
+      nonce: 0,
+    })
+
+    // First use of nonceKey 11 should increment again
+    await token.transferSync(config, {
+      to: account2.address,
+      amount: 1n,
+      token: 1n,
+      nonceKey: 11n,
+      nonce: 0,
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 1000))
+
+    expect(events).toHaveLength(2)
+    expect(events[0]?.account).toBe(account.address)
+    expect(events[0]?.newCount).toBe(1n)
+    expect(events[1]?.newCount).toBe(2n)
+    unwatch()
+  })
+})

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)
+  })
+})