tempo.ts 0.4.3 → 0.5.0

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

@@ -1,17 +1,17 @@
 import { parseEther, parseUnits } from 'viem'
 import { describe, expect, test } from 'vitest'
-import { client, setupToken } from '../../../test/viem/config.js'
+import { clientWithAccount, setupToken } from '../../../test/viem/config.js'
 import * as actions from './index.js'
 
-const account = client.account
+const account = clientWithAccount.account
 
 describe('cancelSync', () => {
   test('default', async () => {
-    const { token } = await setupToken(client)
+    const { token } = await setupToken(clientWithAccount)
 
     // Start a reward stream with longer duration
     const rewardAmount = parseUnits('100', 6)
-    const { id: streamId } = await actions.reward.startSync(client, {
+    const { id: streamId } = await actions.reward.startSync(clientWithAccount, {
       amount: rewardAmount,
       seconds: 3600, // 1 hour to avoid stream ending during test
       token,
@@ -19,7 +19,7 @@ describe('cancelSync', () => {
 
     // Cancel the reward
     const { receipt, refund, ...result } = await actions.reward.cancelSync(
-      client,
+      clientWithAccount,
       {
         id: streamId,
         token,
@@ -40,46 +40,46 @@ describe('cancelSync', () => {
 // TODO: unskip
 describe.skip('claimSync', () => {
   test('default', async () => {
-    const { token } = await setupToken(client)
+    const { token } = await setupToken(clientWithAccount)
 
-    const balanceBefore = await actions.token.getBalance(client, {
+    const balanceBefore = await actions.token.getBalance(clientWithAccount, {
       token,
     })
 
     // Opt in to rewards
-    await actions.reward.setRecipientSync(client, {
+    await actions.reward.setRecipientSync(clientWithAccount, {
       recipient: account.address,
       token,
     })
 
     // Mint reward tokens
     const rewardAmount = parseUnits('100', 6)
-    await actions.token.mintSync(client, {
+    await actions.token.mintSync(clientWithAccount, {
       amount: rewardAmount,
       to: account.address,
       token,
     })
 
     // Start immediate reward to distribute rewards
-    await actions.reward.startSync(client, {
+    await actions.reward.startSync(clientWithAccount, {
       amount: rewardAmount,
       seconds: 0,
       token,
     })
 
     // Trigger reward accrual by transferring
-    await actions.token.transferSync(client, {
+    await actions.token.transferSync(clientWithAccount, {
       amount: 1n,
       to: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
       token,
     })
 
     // Claim rewards
-    await actions.reward.claimSync(client, {
+    await actions.reward.claimSync(clientWithAccount, {
       token,
     })
 
-    const balanceAfter = await actions.token.getBalance(client, {
+    const balanceAfter = await actions.token.getBalance(clientWithAccount, {
       token,
     })
 
@@ -89,36 +89,36 @@ describe.skip('claimSync', () => {
   })
 
   test('behavior: claiming from streaming reward', async () => {
-    const { token } = await setupToken(client)
+    const { token } = await setupToken(clientWithAccount)
 
-    const balanceBefore = await actions.token.getBalance(client, {
+    const balanceBefore = await actions.token.getBalance(clientWithAccount, {
       token,
     })
 
     // Mint tokens to have balance
     const mintAmount = parseUnits('1000', 6)
-    await actions.token.mintSync(client, {
+    await actions.token.mintSync(clientWithAccount, {
       amount: mintAmount,
       to: account.address,
       token,
     })
 
     // Opt in to rewards
-    await actions.reward.setRecipientSync(client, {
+    await actions.reward.setRecipientSync(clientWithAccount, {
       recipient: account.address,
       token,
     })
 
     // Mint reward tokens
     const rewardAmount = parseUnits('100', 6)
-    await actions.token.mintSync(client, {
+    await actions.token.mintSync(clientWithAccount, {
       amount: rewardAmount,
       to: account.address,
       token,
     })
 
     // Start a streaming reward (not immediate)
-    await actions.reward.startSync(client, {
+    await actions.reward.startSync(clientWithAccount, {
       amount: rewardAmount,
       seconds: 10,
       token,
@@ -126,18 +126,18 @@ describe.skip('claimSync', () => {
 
     // Wait a bit and trigger accrual by transferring
     await new Promise((resolve) => setTimeout(resolve, 2000))
-    await actions.token.transferSync(client, {
+    await actions.token.transferSync(clientWithAccount, {
       amount: 1n,
       to: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
       token,
     })
 
     // Claim accumulated rewards from the stream
-    await actions.reward.claimSync(client, {
+    await actions.reward.claimSync(clientWithAccount, {
       token,
     })
 
-    const balanceAfter = await actions.token.getBalance(client, {
+    const balanceAfter = await actions.token.getBalance(clientWithAccount, {
       token,
     })
 
@@ -148,12 +148,12 @@ describe.skip('claimSync', () => {
 
 describe('getStream', () => {
   test('default', async () => {
-    const { token } = await setupToken(client)
+    const { token } = await setupToken(clientWithAccount)
 
     // Start a reward stream
     const rewardAmount = parseUnits('100', 6)
     const duration = 10
-    const { id: streamId } = await actions.reward.startSync(client, {
+    const { id: streamId } = await actions.reward.startSync(clientWithAccount, {
       amount: rewardAmount,
       seconds: duration,
       token,
@@ -161,7 +161,7 @@ describe('getStream', () => {
 
     // Get the stream
     const { endTime, startTime, ...stream } = await actions.reward.getStream(
-      client,
+      clientWithAccount,
       {
         id: streamId,
         token,
@@ -180,23 +180,23 @@ describe('getStream', () => {
   })
 
   test('behavior: canceled stream has zero funder', async () => {
-    const { token } = await setupToken(client)
+    const { token } = await setupToken(clientWithAccount)
 
     // Start and cancel a reward stream
     const rewardAmount = parseUnits('100', 6)
-    const { id: streamId } = await actions.reward.startSync(client, {
+    const { id: streamId } = await actions.reward.startSync(clientWithAccount, {
       amount: rewardAmount,
       seconds: 3600, // 1 hour to avoid stream ending during test
       token,
     })
 
-    await actions.reward.cancelSync(client, {
+    await actions.reward.cancelSync(clientWithAccount, {
       id: streamId,
       token,
     })
 
     // Get the canceled stream
-    const stream = await actions.reward.getStream(client, {
+    const stream = await actions.reward.getStream(clientWithAccount, {
       id: streamId,
       token,
     })
@@ -215,9 +215,9 @@ describe('getStream', () => {
 
 describe('getTotalPerSecond', () => {
   test('default', async () => {
-    const { token } = await setupToken(client)
+    const { token } = await setupToken(clientWithAccount)
 
-    const rate = await actions.reward.getTotalPerSecond(client, {
+    const rate = await actions.reward.getTotalPerSecond(clientWithAccount, {
       token,
     })
 
@@ -225,19 +225,19 @@ describe('getTotalPerSecond', () => {
   })
 
   test('behavior: increases after starting stream', async () => {
-    const { token } = await setupToken(client)
+    const { token } = await setupToken(clientWithAccount)
 
     // Start a reward stream
     const rewardAmount = parseUnits('100', 6)
     const duration = 100
-    await actions.reward.startSync(client, {
+    await actions.reward.startSync(clientWithAccount, {
       amount: rewardAmount,
       seconds: duration,
       token,
     })
 
     // Check total reward per second
-    const rate = await actions.reward.getTotalPerSecond(client, {
+    const rate = await actions.reward.getTotalPerSecond(clientWithAccount, {
       token,
     })
 
@@ -250,11 +250,11 @@ describe('getTotalPerSecond', () => {
 
 describe('setRecipientSync', () => {
   test('default', async () => {
-    const { token } = await setupToken(client)
+    const { token } = await setupToken(clientWithAccount)
 
     // Set reward recipient to self
     const { holder, receipt, recipient } =
-      await actions.reward.setRecipientSync(client, {
+      await actions.reward.setRecipientSync(clientWithAccount, {
         recipient: account.address,
         token,
       })
@@ -265,17 +265,17 @@ describe('setRecipientSync', () => {
   })
 
   test('behavior: opt out with zero address', async () => {
-    const { token } = await setupToken(client)
+    const { token } = await setupToken(clientWithAccount)
 
     // First opt in
-    await actions.reward.setRecipientSync(client, {
+    await actions.reward.setRecipientSync(clientWithAccount, {
       recipient: account.address,
       token,
     })
 
     // Then opt out
     const { holder, recipient } = await actions.reward.setRecipientSync(
-      client,
+      clientWithAccount,
       {
         recipient: '0x0000000000000000000000000000000000000000',
         token,
@@ -289,16 +289,19 @@ describe('setRecipientSync', () => {
 
 describe('startSync', () => {
   test('default', async () => {
-    const { token } = await setupToken(client)
+    const { token } = await setupToken(clientWithAccount)
 
     // Start a reward stream
     const duration = 10
     const rewardAmount = parseUnits('100', 6)
-    const { id, receipt, ...result } = await actions.reward.startSync(client, {
-      amount: rewardAmount,
-      seconds: duration,
-      token,
-    })
+    const { id, receipt, ...result } = await actions.reward.startSync(
+      clientWithAccount,
+      {
+        amount: rewardAmount,
+        seconds: duration,
+        token,
+      },
+    )
 
     expect(receipt).toBeDefined()
     expect(result).toMatchInlineSnapshot(`
@@ -311,7 +314,7 @@ describe('startSync', () => {
 
     // Verify the stream was created
     const { endTime, startTime, ...stream } = await actions.reward.getStream(
-      client,
+      clientWithAccount,
       {
         id,
         token,
@@ -329,20 +332,23 @@ describe('startSync', () => {
     `)
 
     // Verify total reward per second
-    const totalRate = await actions.reward.getTotalPerSecond(client, {
-      token,
-    })
+    const totalRate = await actions.reward.getTotalPerSecond(
+      clientWithAccount,
+      {
+        token,
+      },
+    )
     const expectedRate = (rewardAmount * parseEther('1')) / BigInt(duration)
     expect(totalRate).toBe(expectedRate)
   })
 
   test('behavior: streaming distribution', async () => {
-    const { token } = await setupToken(client)
+    const { token } = await setupToken(clientWithAccount)
 
     // Start a streaming reward
     const duration = 3600
     const rewardAmount = parseUnits('100', 6)
-    const { id } = await actions.reward.startSync(client, {
+    const { id } = await actions.reward.startSync(clientWithAccount, {
       amount: rewardAmount,
       seconds: duration,
       token,
@@ -351,9 +357,12 @@ describe('startSync', () => {
     expect(id).toBeGreaterThan(0n) // Streaming distributions return ID > 0
 
     // Verify the stream was created with correct rate
-    const totalRate = await actions.reward.getTotalPerSecond(client, {
-      token,
-    })
+    const totalRate = await actions.reward.getTotalPerSecond(
+      clientWithAccount,
+      {
+        token,
+      },
+    )
 
     const expectedRate = (rewardAmount * parseEther('1')) / BigInt(duration)
     expect(totalRate).toBe(expectedRate)
@@ -361,28 +370,31 @@ describe('startSync', () => {
 
   // TODO: unskip
   test.skip('behavior: immediate distribution (seconds = 0)', async () => {
-    const { token } = await setupToken(client)
+    const { token } = await setupToken(clientWithAccount)
 
     // Opt in to rewards
-    await actions.reward.setRecipientSync(client, {
+    await actions.reward.setRecipientSync(clientWithAccount, {
       recipient: account.address,
       token,
     })
 
-    const balanceBeforeReward = await actions.token.getBalance(client, {
-      token,
-    })
+    const balanceBeforeReward = await actions.token.getBalance(
+      clientWithAccount,
+      {
+        token,
+      },
+    )
 
     // Mint reward tokens
     const rewardAmount = parseUnits('100', 6)
-    await actions.token.mintSync(client, {
+    await actions.token.mintSync(clientWithAccount, {
       amount: rewardAmount,
       to: account.address,
       token,
     })
 
     // Start immediate reward (seconds = 0)
-    const { id } = await actions.reward.startSync(client, {
+    const { id } = await actions.reward.startSync(clientWithAccount, {
       amount: rewardAmount,
       seconds: 0,
       token,
@@ -391,18 +403,18 @@ describe('startSync', () => {
     expect(id).toBe(0n) // Immediate distributions return ID 0
 
     // Trigger reward distribution by transferring
-    await actions.token.transferSync(client, {
+    await actions.token.transferSync(clientWithAccount, {
       amount: 1n,
       to: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
       token,
     })
 
     // Claim the accumulated rewards
-    await actions.reward.claimSync(client, {
+    await actions.reward.claimSync(clientWithAccount, {
       token,
     })
 
-    const balanceAfter = await actions.token.getBalance(client, {
+    const balanceAfter = await actions.token.getBalance(clientWithAccount, {
       token,
     })
 
@@ -412,24 +424,27 @@ describe('startSync', () => {
     )
 
     // Total reward per second should be zero for immediate distributions
-    const totalRate = await actions.reward.getTotalPerSecond(client, {
-      token,
-    })
+    const totalRate = await actions.reward.getTotalPerSecond(
+      clientWithAccount,
+      {
+        token,
+      },
+    )
     expect(totalRate).toBe(0n)
   })
 
   test('behavior: immediate distribution with opted-in holders', async () => {
-    const { token } = await setupToken(client)
+    const { token } = await setupToken(clientWithAccount)
 
     // Opt in to rewards
-    await actions.reward.setRecipientSync(client, {
+    await actions.reward.setRecipientSync(clientWithAccount, {
       recipient: account.address,
       token,
     })
 
     // Mint reward tokens
     const rewardAmount = parseUnits('100', 6)
-    await actions.token.mintSync(client, {
+    await actions.token.mintSync(clientWithAccount, {
       amount: rewardAmount,
       to: account.address,
       token,
@@ -437,7 +452,7 @@ describe('startSync', () => {
 
     // Start immediate reward
     const { amount, durationSeconds, funder, id } =
-      await actions.reward.startSync(client, {
+      await actions.reward.startSync(clientWithAccount, {
         amount: rewardAmount,
         seconds: 0,
         token,
@@ -449,9 +464,12 @@ describe('startSync', () => {
     expect(durationSeconds).toBe(0)
 
     // Total reward per second should be zero for immediate distributions
-    const totalRate = await actions.reward.getTotalPerSecond(client, {
-      token,
-    })
+    const totalRate = await actions.reward.getTotalPerSecond(
+      clientWithAccount,
+      {
+        token,
+      },
+    )
     expect(totalRate).toBe(0n)
   })
 })