tempo.ts 0.8.0 → 0.8.2

package/src/viem/Decorator.ts

@@ -1591,6 +1591,60 @@ export type Decorator<
     ) => () => void
   }
   reward: {
+    /**
+     * Claims accumulated rewards for a recipient.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { privateKeyToAccount } from 'viem/accounts'
+     * import { tempo } from 'tempo.ts/chains'
+     * import { tempoActions } from 'tempo.ts/viem'
+     *
+     * const client = createClient({
+     *   account: privateKeyToAccount('0x...'),
+     *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+     *   transport: http(),
+     * }).extend(tempoActions())
+     *
+     * const hash = await client.reward.claim({
+     *   token: '0x20c0000000000000000000000000000000000001',
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The transaction hash.
+     */
+    claim: (
+      parameters: rewardActions.claim.Parameters<chain, account>,
+    ) => Promise<rewardActions.claim.ReturnValue>
+    /**
+     * Claims accumulated rewards for a recipient and waits for confirmation.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { privateKeyToAccount } from 'viem/accounts'
+     * import { tempo } from 'tempo.ts/chains'
+     * import { tempoActions } from 'tempo.ts/viem'
+     *
+     * const client = createClient({
+     *   account: privateKeyToAccount('0x...'),
+     *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+     *   transport: http(),
+     * }).extend(tempoActions())
+     *
+     * const result = await client.reward.claimSync({
+     *   token: '0x20c0000000000000000000000000000000000001',
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The amount claimed and transaction receipt.
+     */
+    claimSync: (
+      parameters: rewardActions.claimSync.Parameters<chain, account>,
+    ) => Promise<rewardActions.claimSync.ReturnValue>
     /**
      * Gets the total reward per second rate for all active streams.
      *
@@ -1616,6 +1670,32 @@ export type Decorator<
     getTotalPerSecond: (
       parameters: rewardActions.getTotalPerSecond.Parameters,
     ) => Promise<rewardActions.getTotalPerSecond.ReturnValue>
+    /**
+     * Gets the reward information for a specific account.
+     *
+     * @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 info = await client.reward.getUserRewardInfo({
+     *   token: '0x20c0000000000000000000000000000000000001',
+     *   account: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The user's reward information (recipient, rewardPerToken, rewardBalance).
+     */
+    getUserRewardInfo: (
+      parameters: rewardActions.getUserRewardInfo.Parameters,
+    ) => Promise<rewardActions.getUserRewardInfo.ReturnValue>
     /**
      * Sets or changes the reward recipient for a token holder.
      *
@@ -1730,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: {
     /**
@@ -2986,14 +3122,22 @@ export function decorator() {
           policyActions.watchBlacklistUpdated(client, parameters),
       },
       reward: {
+        claim: (parameters) => rewardActions.claim(client, parameters),
+        claimSync: (parameters) => rewardActions.claimSync(client, parameters),
         getTotalPerSecond: (parameters) =>
           rewardActions.getTotalPerSecond(client, parameters),
+        getUserRewardInfo: (parameters) =>
+          rewardActions.getUserRewardInfo(client, parameters),
         setRecipient: (parameters) =>
           rewardActions.setRecipient(client, parameters),
         setRecipientSync: (parameters) =>
           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

@@ -89,6 +89,42 @@ describe('getTotalPerSecond', () => {
   })
 })
 
+describe('getUserRewardInfo', () => {
+  test('default', async () => {
+    const { token } = await setupToken()
+
+    const account = getAccount(config)
+
+    const info = await actions.getUserRewardInfo(config, {
+      token,
+      account: account.address!,
+    })
+
+    expect(info.rewardRecipient).toBeDefined()
+    expect(info.rewardPerToken).toBeDefined()
+    expect(info.rewardBalance).toBeDefined()
+  })
+
+  describe('queryOptions', () => {
+    test('default', async () => {
+      const { token } = await setupToken()
+
+      const account = getAccount(config)
+
+      const options = actions.getUserRewardInfo.queryOptions(config, {
+        token,
+        account: account.address!,
+      })
+
+      const info = await queryClient.fetchQuery(options)
+
+      expect(info.rewardRecipient).toBeDefined()
+      expect(info.rewardPerToken).toBeDefined()
+      expect(info.rewardBalance).toBeDefined()
+    })
+  })
+})
+
 describe('setRecipientSync', () => {
   test('default', async () => {
     const { token } = await setupToken()
@@ -109,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

@@ -205,6 +205,97 @@ export namespace getTotalPerSecond {
   }
 }
 
+/**
+ * Gets the reward information for a specific 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 info = await Actions.reward.getUserRewardInfo(config, {
+ *   token: '0x20c0000000000000000000000000000000000001',
+ *   account: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+ * })
+ * ```
+ *
+ * @param config - Config.
+ * @param parameters - Parameters.
+ * @returns The user's reward information (recipient, rewardPerToken, rewardBalance).
+ */
+export function getUserRewardInfo<config extends Config>(
+  config: config,
+  parameters: getUserRewardInfo.Parameters<config>,
+) {
+  const { chainId, ...rest } = parameters
+  const client = config.getClient({ chainId })
+  return viem_Actions.getUserRewardInfo(client, rest)
+}
+
+export namespace getUserRewardInfo {
+  export type Parameters<config extends Config> = ChainIdParameter<config> &
+    viem_Actions.getUserRewardInfo.Parameters
+
+  export type ReturnValue = viem_Actions.getUserRewardInfo.ReturnValue
+
+  export function queryKey<config extends Config>(
+    parameters: Parameters<config>,
+  ) {
+    return ['getUserRewardInfo', 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 [, parameters] = queryKey
+        return await getUserRewardInfo(config, parameters)
+      },
+    }
+  }
+
+  export declare namespace queryOptions {
+    export type Parameters<
+      config extends Config,
+      selectData = getUserRewardInfo.ReturnValue,
+    > = getUserRewardInfo.Parameters<config> & {
+      query?:
+        | Omit<ReturnValue<config, selectData>, 'queryKey' | 'queryFn'>
+        | undefined
+    }
+
+    export type ReturnValue<
+      config extends Config,
+      selectData = getUserRewardInfo.ReturnValue,
+    > = RequiredBy<
+      Query.QueryOptions<
+        getUserRewardInfo.ReturnValue,
+        Query.DefaultError,
+        selectData,
+        getUserRewardInfo.QueryKey<config>
+      >,
+      'queryKey' | 'queryFn'
+    >
+  }
+}
+
 /**
  * Sets or changes the reward recipient for a token holder.
  *
@@ -433,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,8 +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 () => {
@@ -53,6 +56,77 @@ describe('useGetTotalPerSecond', () => {
   })
 })
 
+describe('useUserRewardInfo', () => {
+  test('default', async () => {
+    const { token } = await setupToken()
+
+    const account = getAccount(config).address
+
+    const { result } = await renderHook(() =>
+      hooks.useUserRewardInfo({
+        token,
+        account,
+      }),
+    )
+
+    await vi.waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+
+    expect(result.current.data?.rewardRecipient).toBeDefined()
+    expect(result.current.data?.rewardPerToken).toBeDefined()
+    expect(result.current.data?.rewardBalance).toBeDefined()
+  })
+
+  test('reactivity: account and token parameters', async () => {
+    const { result, rerender } = await renderHook(
+      (props) =>
+        hooks.useUserRewardInfo({
+          token: props?.token,
+          account: props?.account,
+        }),
+      {
+        initialProps: {
+          token: undefined as Address | undefined,
+          account: undefined as Address | undefined,
+        },
+      },
+    )
+
+    await vi.waitFor(() => result.current.fetchStatus === 'idle')
+
+    // Should be disabled when both token and account are undefined
+    expect(result.current.data).toBeUndefined()
+    expect(result.current.isPending).toBe(true)
+    expect(result.current.isEnabled).toBe(false)
+
+    // Setup token (this also connects the account)
+    const { token } = await setupToken()
+
+    // Set token only (account still undefined)
+    rerender({ token, account: undefined })
+
+    await vi.waitFor(() => result.current.fetchStatus === 'idle')
+
+    // Should still be disabled when account is undefined
+    expect(result.current.data).toBeUndefined()
+    expect(result.current.isPending).toBe(true)
+    expect(result.current.isEnabled).toBe(false)
+
+    // Get account from config (already connected by setupToken)
+    const account = getAccount(config).address
+
+    // Set both token and account
+    rerender({ token, account })
+
+    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?.rewardRecipient).toBeDefined()
+    expect(result.current.data?.rewardPerToken).toBeDefined()
+    expect(result.current.data?.rewardBalance).toBeDefined()
+  })
+})
+
 describe('useSetRecipientSync', () => {
   test('default', async () => {
     const { result } = await renderHook(() => ({
@@ -76,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)
+  })
+})