tempo.ts 0.8.1 → 0.8.3

package/src/viem/Actions/reward.ts

@@ -4,13 +4,24 @@ import {
   type BaseErrorType,
   type Chain,
   type Client,
+  type ExtractAbiItem,
+  type GetEventArgs,
   type Log,
   parseEventLogs,
   type ReadContractReturnType,
   type Transport,
+  type Log as viem_Log,
+  type WatchContractEventParameters,
+  type WatchContractEventReturnType,
   type WriteContractReturnType,
 } from 'viem'
-import { readContract, writeContract, writeContractSync } from 'viem/actions'
+import {
+  readContract,
+  watchContractEvent,
+  writeContract,
+  writeContractSync,
+} from 'viem/actions'
+import type { UnionOmit } from '../../internal/types.js'
 import * as Abis from '../Abis.js'
 import type { ReadParameters, WriteParameters } from '../internal/types.js'
 import { defineCall } from '../internal/utils.js'
@@ -783,3 +794,151 @@ export declare namespace startSync {
 
   export type ErrorType = start.ErrorType
 }
+
+/**
+ * Watches for reward scheduled events.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ *
+ * const client = createClient({
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+ *   transport: http(),
+ * })
+ *
+ * const unwatch = Actions.reward.watchRewardScheduled(client, {
+ *   token: '0x20c0000000000000000000000000000000000001',
+ *   onRewardScheduled: (args, log) => {
+ *     console.log('Reward scheduled:', args)
+ *   },
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns A function to unsubscribe from the event.
+ */
+export function watchRewardScheduled<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: watchRewardScheduled.Parameters,
+) {
+  const { onRewardScheduled, token, ...rest } = parameters
+  return watchContractEvent(client, {
+    ...rest,
+    address: token,
+    abi: Abis.tip20,
+    eventName: 'RewardScheduled',
+    onLogs: (logs) => {
+      for (const log of logs) onRewardScheduled(log.args, log)
+    },
+    strict: true,
+  })
+}
+
+export declare namespace watchRewardScheduled {
+  export type Args = GetEventArgs<
+    typeof Abis.tip20,
+    'RewardScheduled',
+    { IndexedOnly: false; Required: true }
+  >
+
+  export type Log = viem_Log<
+    bigint,
+    number,
+    false,
+    ExtractAbiItem<typeof Abis.tip20, 'RewardScheduled'>,
+    true
+  >
+
+  export type Parameters = UnionOmit<
+    WatchContractEventParameters<typeof Abis.tip20, 'RewardScheduled', true>,
+    'abi' | 'address' | 'batch' | 'eventName' | 'onLogs' | 'strict'
+  > & {
+    /** Callback to invoke when rewards are scheduled. */
+    onRewardScheduled: (args: Args, log: Log) => void
+    /** The TIP20 token address */
+    token: Address
+  }
+
+  export type ReturnValue = WatchContractEventReturnType
+}
+
+/**
+ * Watches for reward recipient set events.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'tempo.ts/chains'
+ * import { Actions } from 'tempo.ts/viem'
+ *
+ * const client = createClient({
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+ *   transport: http(),
+ * })
+ *
+ * const unwatch = Actions.reward.watchRewardRecipientSet(client, {
+ *   token: '0x20c0000000000000000000000000000000000001',
+ *   onRewardRecipientSet: (args, log) => {
+ *     console.log('Reward recipient set:', args)
+ *   },
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns A function to unsubscribe from the event.
+ */
+export function watchRewardRecipientSet<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: watchRewardRecipientSet.Parameters,
+) {
+  const { onRewardRecipientSet, token, ...rest } = parameters
+  return watchContractEvent(client, {
+    ...rest,
+    address: token,
+    abi: Abis.tip20,
+    eventName: 'RewardRecipientSet',
+    onLogs: (logs) => {
+      for (const log of logs) onRewardRecipientSet(log.args, log)
+    },
+    strict: true,
+  })
+}
+
+export declare namespace watchRewardRecipientSet {
+  export type Args = GetEventArgs<
+    typeof Abis.tip20,
+    'RewardRecipientSet',
+    { IndexedOnly: false; Required: true }
+  >
+
+  export type Log = viem_Log<
+    bigint,
+    number,
+    false,
+    ExtractAbiItem<typeof Abis.tip20, 'RewardRecipientSet'>,
+    true
+  >
+
+  export type Parameters = UnionOmit<
+    WatchContractEventParameters<typeof Abis.tip20, 'RewardRecipientSet', true>,
+    'abi' | 'address' | 'batch' | 'eventName' | 'onLogs' | 'strict'
+  > & {
+    /** Callback to invoke when a reward recipient is set. */
+    onRewardRecipientSet: (args: Args, log: Log) => void
+    /** The TIP20 token address */
+    token: Address
+  }
+
+  export type ReturnValue = WatchContractEventReturnType
+}

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/Formatters.ts

@@ -8,7 +8,7 @@ import {
   formatTransactionReceipt as viem_formatTransactionReceipt,
   formatTransactionRequest as viem_formatTransactionRequest,
 } from 'viem'
-import { parseAccount } from 'viem/accounts'
+import { type Address, parseAccount } from 'viem/accounts'
 import type { UnionOmit } from '../internal/types.js'
 import * as ox_Transaction from '../ox/Transaction.js'
 import * as ox_TransactionRequest from '../ox/TransactionRequest.js'
@@ -72,13 +72,17 @@ type Request<chain extends Chain | undefined> = UnionOmit<
   TransactionRequest,
   'feeToken'
 > &
-  GetFeeTokenParameter<chain> & { account?: viem_Account | undefined }
+  GetFeeTokenParameter<chain>
 export function formatTransactionRequest<chain extends Chain | undefined>(
   r: Request<chain>,
   action?: string | undefined,
 ): TransactionRequestRpc {
-  const request = r as Request<chain>
-  const account = request.account as Account | undefined
+  const request = r as Request<chain> & {
+    account?: viem_Account | Address | undefined
+  }
+  const account = request.account
+    ? parseAccount<Account | viem_Account | Address>(request.account)
+    : undefined
 
   // Convert EIP-1559 transactions to AA transactions.
   if (request.type === 'eip1559') (request as any).type = 'aa'
@@ -122,7 +126,7 @@ export function formatTransactionRequest<chain extends Chain | undefined>(
   // TODO: `calls` will not be supported by a lot of JSON-RPC accounts (wallet),
   // use `wallet_sendCalls` or sequential `eth_sendTransaction` to mimic the
   // behavior of `calls`.
-  if (request.account?.type === 'json-rpc') {
+  if (account?.type === 'json-rpc') {
     if (rpc.calls?.length && rpc.calls.length > 1)
       throw new Error(
         'Batch calls are not supported with JSON-RPC accounts yet.',
@@ -134,14 +138,15 @@ export function formatTransactionRequest<chain extends Chain | undefined>(
   // However, `calls` may not be supported by JSON-RPC accounts (wallets) yet,
   // so we will not remove the `data`, `to`, and `value` fields to make it
   // compatible with the base transaction structure.
-  if (request.account?.type !== 'json-rpc') {
+  if (account?.type !== 'json-rpc') {
     rpc.to = undefined
     rpc.data = undefined
     rpc.value = undefined
   }
 
   const [keyType, keyData] = (() => {
-    const type = account?.keyType || account?.source
+    const type =
+      account && 'keyType' in account ? account.keyType : account?.source
     if (!type) return [undefined, undefined]
     if (type === 'webAuthn')
       // TODO: derive correct bytes size of key data based on webauthn create metadata.

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