tempo.ts 0.8.1 → 0.8.2

package/src/viem/Decorator.ts

@@ -1810,6 +1810,62 @@ export type Decorator<
     startSync: (
       parameters: rewardActions.startSync.Parameters<chain, account>,
     ) => Promise<rewardActions.startSync.ReturnValue>
+    /**
+     * Watches for reward recipient set events.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'tempo.ts/chains'
+     * import { tempoActions } from 'tempo.ts/viem'
+     *
+     * const client = createClient({
+     *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+     *   transport: http(),
+     * }).extend(tempoActions())
+     *
+     * const unwatch = client.reward.watchRewardRecipientSet({
+     *   token: '0x20c0000000000000000000000000000000000001',
+     *   onRewardRecipientSet: (args, log) => {
+     *     console.log('Reward recipient set:', args)
+     *   },
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns A function to unsubscribe from the event.
+     */
+    watchRewardRecipientSet: (
+      parameters: rewardActions.watchRewardRecipientSet.Parameters,
+    ) => () => void
+    /**
+     * Watches for reward scheduled events.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'tempo.ts/chains'
+     * import { tempoActions } from 'tempo.ts/viem'
+     *
+     * const client = createClient({
+     *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+     *   transport: http(),
+     * }).extend(tempoActions())
+     *
+     * const unwatch = client.reward.watchRewardScheduled({
+     *   token: '0x20c0000000000000000000000000000000000001',
+     *   onRewardScheduled: (args, log) => {
+     *     console.log('Reward scheduled:', args)
+     *   },
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns A function to unsubscribe from the event.
+     */
+    watchRewardScheduled: (
+      parameters: rewardActions.watchRewardScheduled.Parameters,
+    ) => () => void
   }
   token: {
     /**
@@ -3078,6 +3134,10 @@ export function decorator() {
           rewardActions.setRecipientSync(client, parameters),
         start: (parameters) => rewardActions.start(client, parameters),
         startSync: (parameters) => rewardActions.startSync(client, parameters),
+        watchRewardRecipientSet: (parameters) =>
+          rewardActions.watchRewardRecipientSet(client, parameters),
+        watchRewardScheduled: (parameters) =>
+          rewardActions.watchRewardScheduled(client, parameters),
       },
       token: {
         approve: (parameters) => tokenActions.approve(client, parameters),

package/src/viem/Transaction.ts

@@ -216,9 +216,6 @@ export async function serialize(
     | OneOf<SignatureEnvelope.SignatureEnvelope | viem_Signature>
     | undefined,
 ) {
-  // Convert EIP-1559 transactions to AA transactions.
-  if (transaction.type === 'eip1559') (transaction as any).type = 'aa'
-
   // If the transaction is not a Tempo transaction, route to Viem serializer.
   if (!isTempo(transaction)) {
     if (signature && 'type' in signature && signature.type !== 'secp256k1')

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

@@ -145,3 +145,72 @@ describe('setRecipientSync', () => {
     expect(recipient).toBe(account.address)
   })
 })
+
+describe('watchRewardScheduled', () => {
+  test('default', async () => {
+    const { token } = await setupToken()
+
+    const account = getAccount(config)
+
+    // Setup rewards
+    await actions.setRecipientSync(config, {
+      recipient: account.address!,
+      token,
+    })
+
+    const rewardAmount = parseUnits('100', 6)
+    await tokenActions.mintSync(config, {
+      amount: rewardAmount,
+      to: account.address!,
+      token,
+    })
+
+    const events: any[] = []
+    const unwatch = actions.watchRewardScheduled(config, {
+      token,
+      onRewardScheduled: (args) => {
+        events.push(args)
+      },
+    })
+
+    await actions.startSync(config, {
+      amount: rewardAmount,
+      token,
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 500))
+
+    expect(events.length).toBeGreaterThan(0)
+    expect(events[0]?.amount).toBe(rewardAmount)
+    expect(events[0]?.funder).toBe(account.address)
+    unwatch()
+  })
+})
+
+describe('watchRewardRecipientSet', () => {
+  test('default', async () => {
+    const { token } = await setupToken()
+
+    const account = getAccount(config)
+
+    const events: any[] = []
+    const unwatch = actions.watchRewardRecipientSet(config, {
+      token,
+      onRewardRecipientSet: (args) => {
+        events.push(args)
+      },
+    })
+
+    await actions.setRecipientSync(config, {
+      recipient: account.address!,
+      token,
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 500))
+
+    expect(events.length).toBeGreaterThan(0)
+    expect(events[0]?.holder).toBe(account.address)
+    expect(events[0]?.recipient).toBe(account.address)
+    unwatch()
+  })
+})

package/src/wagmi/Actions/reward.ts

@@ -524,3 +524,87 @@ export declare namespace startSync {
 
   export type ErrorType = viem_Actions.startSync.ErrorType
 }
+
+/**
+ * Watches for reward scheduled 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.reward.watchRewardScheduled(config, {
+ *   token: '0x20c0000000000000000000000000000000000001',
+ *   onRewardScheduled: (args, log) => {
+ *     console.log('Reward scheduled:', args)
+ *   },
+ * })
+ * ```
+ *
+ * @param config - Config.
+ * @param parameters - Parameters.
+ * @returns A function to unsubscribe from the event.
+ */
+export function watchRewardScheduled<config extends Config>(
+  config: config,
+  parameters: watchRewardScheduled.Parameters<config>,
+) {
+  const { chainId, ...rest } = parameters
+  const client = config.getClient({ chainId })
+  return viem_Actions.watchRewardScheduled(client, rest)
+}
+
+export declare namespace watchRewardScheduled {
+  export type Parameters<config extends Config> = ChainIdParameter<config> &
+    viem_Actions.watchRewardScheduled.Parameters
+}
+
+/**
+ * Watches for reward recipient set 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.reward.watchRewardRecipientSet(config, {
+ *   token: '0x20c0000000000000000000000000000000000001',
+ *   onRewardRecipientSet: (args, log) => {
+ *     console.log('Reward recipient set:', args)
+ *   },
+ * })
+ * ```
+ *
+ * @param config - Config.
+ * @param parameters - Parameters.
+ * @returns A function to unsubscribe from the event.
+ */
+export function watchRewardRecipientSet<config extends Config>(
+  config: config,
+  parameters: watchRewardRecipientSet.Parameters<config>,
+) {
+  const { chainId, ...rest } = parameters
+  const client = config.getClient({ chainId })
+  return viem_Actions.watchRewardRecipientSet(client, rest)
+}
+
+export declare namespace watchRewardRecipientSet {
+  export type Parameters<config extends Config> = ChainIdParameter<config> &
+    viem_Actions.watchRewardRecipientSet.Parameters
+}

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

@@ -1,9 +1,11 @@
 import { getAccount } from '@wagmi/core'
 import type { Address } from 'viem'
+import { 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'
+import * as tokenHooks from './token.js'
 
 describe('useGetTotalPerSecond', () => {
   test('default', async () => {
@@ -148,3 +150,100 @@ describe('useSetRecipientSync', () => {
     )
   })
 })
+
+describe('useWatchRewardScheduled', () => {
+  test('default', async () => {
+    const { result: connectResult } = await renderHook(() => ({
+      connect: useConnect(),
+      grantRolesSync: tokenHooks.useGrantRolesSync(),
+      mintSync: tokenHooks.useMintSync(),
+      setRecipientSync: hooks.useSetRecipientSync(),
+      startSync: hooks.useStartSync(),
+    }))
+
+    await connectResult.current.connect.connectAsync({
+      connector: config.connectors[0]!,
+    })
+
+    const { token: tokenAddr } = await setupToken()
+
+    const account = getAccount(config).address
+
+    await connectResult.current.grantRolesSync.mutateAsync({
+      token: tokenAddr,
+      roles: ['issuer'],
+      to: account!,
+    })
+
+    const rewardAmount = parseUnits('100', 6)
+    await connectResult.current.mintSync.mutateAsync({
+      token: tokenAddr,
+      to: account!,
+      amount: rewardAmount,
+    })
+
+    await connectResult.current.setRecipientSync.mutateAsync({
+      token: tokenAddr,
+      recipient: account!,
+    })
+
+    const events: any[] = []
+    await renderHook(() =>
+      hooks.useWatchRewardScheduled({
+        token: tokenAddr,
+        onRewardScheduled(args) {
+          events.push(args)
+        },
+      }),
+    )
+
+    await connectResult.current.startSync.mutateAsync({
+      token: tokenAddr,
+      amount: rewardAmount,
+    })
+
+    await vi.waitUntil(() => events.length >= 1)
+
+    expect(events.length).toBeGreaterThanOrEqual(1)
+    expect(events[0]?.amount).toBe(rewardAmount)
+    expect(events[0]?.funder).toBe(account)
+  })
+})
+
+describe('useWatchRewardRecipientSet', () => {
+  test('default', async () => {
+    const { result: connectResult } = await renderHook(() => ({
+      connect: useConnect(),
+      setRecipientSync: hooks.useSetRecipientSync(),
+    }))
+
+    await connectResult.current.connect.connectAsync({
+      connector: config.connectors[0]!,
+    })
+
+    const { token: tokenAddr } = await setupToken()
+
+    const account = getAccount(config).address
+
+    const events: any[] = []
+    await renderHook(() =>
+      hooks.useWatchRewardRecipientSet({
+        token: tokenAddr,
+        onRewardRecipientSet(args) {
+          events.push(args)
+        },
+      }),
+    )
+
+    await connectResult.current.setRecipientSync.mutateAsync({
+      token: tokenAddr,
+      recipient: account!,
+    })
+
+    await vi.waitUntil(() => events.length >= 1)
+
+    expect(events.length).toBeGreaterThanOrEqual(1)
+    expect(events[0]?.holder).toBe(account)
+    expect(events[0]?.recipient).toBe(account)
+  })
+})

package/src/wagmi/Hooks/reward.ts

@@ -1,6 +1,7 @@
 import type { DefaultError } from '@tanstack/query-core'
 import type { UseMutationResult } from '@tanstack/react-query'
 import type { Config, ResolvedRegister } from '@wagmi/core'
+import { useEffect } from 'react'
 import { useChainId, useConfig } from 'wagmi'
 import type { ConfigParameter, QueryParameter } from 'wagmi/internal'
 import {
@@ -9,7 +10,7 @@ import {
   useMutation,
   useQuery,
 } from 'wagmi/query'
-import type { ExactPartial } from '../../internal/types.js'
+import type { ExactPartial, UnionCompute } from '../../internal/types.js'
 import * as Actions from '../Actions/reward.js'
 
 /**
@@ -542,3 +543,103 @@ export declare namespace useStartSync {
     context
   >
 }
+
+/**
+ * Hook for watching reward scheduled events.
+ *
+ * @example
+ * ```tsx
+ * import { Hooks } from 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   Hooks.reward.useWatchRewardScheduled({
+ *     token: '0x20c0000000000000000000000000000000000001',
+ *     onRewardScheduled(args) {
+ *       console.log('Reward scheduled:', args)
+ *     },
+ *   })
+ *
+ *   return <div>Watching for reward scheduled events...</div>
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ */
+export function useWatchRewardScheduled<
+  config extends Config = ResolvedRegister['config'],
+>(parameters: useWatchRewardScheduled.Parameters<config> = {}) {
+  const { enabled = true, onRewardScheduled, token, ...rest } = parameters
+
+  const config = useConfig({ config: parameters.config })
+  const configChainId = useChainId({ config })
+  const chainId = parameters.chainId ?? configChainId
+
+  useEffect(() => {
+    if (!enabled) return
+    if (!onRewardScheduled) return
+    if (!token) return
+    return Actions.watchRewardScheduled(config, {
+      ...rest,
+      chainId,
+      onRewardScheduled,
+      token,
+    })
+  }, [config, enabled, onRewardScheduled, rest, chainId, token])
+}
+
+export declare namespace useWatchRewardScheduled {
+  type Parameters<config extends Config = Config> = UnionCompute<
+    ExactPartial<Actions.watchRewardScheduled.Parameters<config>> &
+      ConfigParameter<config> & { enabled?: boolean | undefined }
+  >
+}
+
+/**
+ * Hook for watching reward recipient set events.
+ *
+ * @example
+ * ```tsx
+ * import { Hooks } from 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   Hooks.reward.useWatchRewardRecipientSet({
+ *     token: '0x20c0000000000000000000000000000000000001',
+ *     onRewardRecipientSet(args) {
+ *       console.log('Reward recipient set:', args)
+ *     },
+ *   })
+ *
+ *   return <div>Watching for reward recipient set events...</div>
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ */
+export function useWatchRewardRecipientSet<
+  config extends Config = ResolvedRegister['config'],
+>(parameters: useWatchRewardRecipientSet.Parameters<config> = {}) {
+  const { enabled = true, onRewardRecipientSet, token, ...rest } = parameters
+
+  const config = useConfig({ config: parameters.config })
+  const configChainId = useChainId({ config })
+  const chainId = parameters.chainId ?? configChainId
+
+  useEffect(() => {
+    if (!enabled) return
+    if (!onRewardRecipientSet) return
+    if (!token) return
+    return Actions.watchRewardRecipientSet(config, {
+      ...rest,
+      chainId,
+      onRewardRecipientSet,
+      token,
+    })
+  }, [config, enabled, onRewardRecipientSet, rest, chainId, token])
+}
+
+export declare namespace useWatchRewardRecipientSet {
+  type Parameters<config extends Config = Config> = UnionCompute<
+    ExactPartial<Actions.watchRewardRecipientSet.Parameters<config>> &
+      ConfigParameter<config> & { enabled?: boolean | undefined }
+  >
+}