tempo.ts 0.4.3 → 0.5.0

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

@@ -5,12 +5,8 @@ import { Abis, Addresses, TokenIds } from 'tempo.ts/viem'
 import { parseUnits } from 'viem'
 import { getCode, writeContractSync } from 'viem/actions'
 import { beforeAll, describe, expect, test } from 'vitest'
-import {
-  accounts,
-  addresses,
-  client,
-  rpcUrl,
-} from '../../../test/viem/config.js'
+import { addresses, rpcUrl } from '../../../test/config.js'
+import { accounts, clientWithAccount } from '../../../test/viem/config.js'
 import * as actions from './index.js'
 
 const account = accounts[0]
@@ -21,11 +17,14 @@ describe('approve', () => {
   test('default', async () => {
     {
       // approve
-      const { receipt, ...result } = await actions.token.approveSync(client, {
-        spender: account2.address,
-        amount: parseUnits('100', 6),
-        token: addresses.alphaUsd,
-      })
+      const { receipt, ...result } = await actions.token.approveSync(
+        clientWithAccount,
+        {
+          spender: account2.address,
+          amount: parseUnits('100', 6),
+          token: addresses.alphaUsd,
+        },
+      )
       expect(receipt).toBeDefined()
       expect(result).toMatchInlineSnapshot(`
         {
@@ -38,7 +37,7 @@ describe('approve', () => {
 
     {
       // check allowance
-      const allowance = await actions.token.getAllowance(client, {
+      const allowance = await actions.token.getAllowance(clientWithAccount, {
         spender: account2.address,
         token: addresses.alphaUsd,
       })
@@ -46,7 +45,7 @@ describe('approve', () => {
     }
 
     // transfer tokens for gas
-    await writeContractSync(client, {
+    await writeContractSync(clientWithAccount, {
       abi: Abis.tip20,
       address: addresses.alphaUsd,
       functionName: 'transfer',
@@ -54,7 +53,7 @@ describe('approve', () => {
     })
 
     // transfer tokens from approved account
-    await actions.token.transferSync(client, {
+    await actions.token.transferSync(clientWithAccount, {
       amount: parseUnits('50', 6),
       account: account2,
       from: account.address,
@@ -64,7 +63,7 @@ describe('approve', () => {
 
     {
       // verify updated allowance
-      const allowance = await actions.token.getAllowance(client, {
+      const allowance = await actions.token.getAllowance(clientWithAccount, {
         spender: account2.address,
         token: addresses.alphaUsd,
       })
@@ -72,7 +71,7 @@ describe('approve', () => {
     }
 
     // verify balance
-    const balance = await actions.token.getBalance(client, {
+    const balance = await actions.token.getBalance(clientWithAccount, {
       account: '0x0000000000000000000000000000000000000001',
       token: addresses.alphaUsd,
     })
@@ -80,18 +79,21 @@ describe('approve', () => {
   })
 
   test('behavior: token address', async () => {
-    const balanceBefore = await actions.token.getBalance(client, {
+    const balanceBefore = await actions.token.getBalance(clientWithAccount, {
       account: '0x0000000000000000000000000000000000000001',
       token: addresses.alphaUsd,
     })
 
     {
       // approve
-      const { receipt, ...result } = await actions.token.approveSync(client, {
-        amount: parseUnits('100', 6),
-        token: addresses.alphaUsd,
-        spender: account2.address,
-      })
+      const { receipt, ...result } = await actions.token.approveSync(
+        clientWithAccount,
+        {
+          amount: parseUnits('100', 6),
+          token: addresses.alphaUsd,
+          spender: account2.address,
+        },
+      )
       expect(receipt).toBeDefined()
       expect(result).toMatchInlineSnapshot(`
         {
@@ -104,7 +106,7 @@ describe('approve', () => {
 
     {
       // check allowance
-      const allowance = await actions.token.getAllowance(client, {
+      const allowance = await actions.token.getAllowance(clientWithAccount, {
         token: addresses.alphaUsd,
         spender: account2.address,
       })
@@ -112,7 +114,7 @@ describe('approve', () => {
     }
 
     // transfer tokens for gas
-    await writeContractSync(client, {
+    await writeContractSync(clientWithAccount, {
       abi: Abis.tip20,
       address: addresses.alphaUsd,
       functionName: 'transfer',
@@ -120,7 +122,7 @@ describe('approve', () => {
     })
 
     // transfer tokens from approved account
-    await actions.token.transferSync(client, {
+    await actions.token.transferSync(clientWithAccount, {
       amount: parseUnits('50', 6),
       account: account2,
       from: account.address,
@@ -130,7 +132,7 @@ describe('approve', () => {
 
     {
       // verify updated allowance
-      const allowance = await actions.token.getAllowance(client, {
+      const allowance = await actions.token.getAllowance(clientWithAccount, {
         spender: account2.address,
         token: addresses.alphaUsd,
       })
@@ -138,7 +140,7 @@ describe('approve', () => {
     }
 
     // verify balance
-    const balance = await actions.token.getBalance(client, {
+    const balance = await actions.token.getBalance(clientWithAccount, {
       account: '0x0000000000000000000000000000000000000001',
       token: addresses.alphaUsd,
     })
@@ -146,18 +148,21 @@ describe('approve', () => {
   })
 
   test('behavior: token address', async () => {
-    const balanceBefore = await actions.token.getBalance(client, {
+    const balanceBefore = await actions.token.getBalance(clientWithAccount, {
       account: '0x0000000000000000000000000000000000000001',
       token: addresses.alphaUsd,
     })
 
     {
       // approve
-      const { receipt, ...result } = await actions.token.approveSync(client, {
-        amount: parseUnits('100', 6),
-        token: addresses.alphaUsd,
-        spender: account2.address,
-      })
+      const { receipt, ...result } = await actions.token.approveSync(
+        clientWithAccount,
+        {
+          amount: parseUnits('100', 6),
+          token: addresses.alphaUsd,
+          spender: account2.address,
+        },
+      )
       expect(receipt).toBeDefined()
       expect(result).toMatchInlineSnapshot(`
         {
@@ -170,7 +175,7 @@ describe('approve', () => {
 
     {
       // check allowance
-      const allowance = await actions.token.getAllowance(client, {
+      const allowance = await actions.token.getAllowance(clientWithAccount, {
         token: addresses.alphaUsd,
         spender: account2.address,
       })
@@ -178,7 +183,7 @@ describe('approve', () => {
     }
 
     // transfer tokens for gas
-    await writeContractSync(client, {
+    await writeContractSync(clientWithAccount, {
       abi: Abis.tip20,
       address: addresses.alphaUsd,
       functionName: 'transfer',
@@ -186,7 +191,7 @@ describe('approve', () => {
     })
 
     // transfer tokens from approved account
-    await actions.token.transferSync(client, {
+    await actions.token.transferSync(clientWithAccount, {
       amount: parseUnits('50', 6),
       account: account2,
       from: account.address,
@@ -196,7 +201,7 @@ describe('approve', () => {
 
     {
       // verify updated allowance
-      const allowance = await actions.token.getAllowance(client, {
+      const allowance = await actions.token.getAllowance(clientWithAccount, {
         spender: account2.address,
         token: addresses.alphaUsd,
       })
@@ -204,7 +209,7 @@ describe('approve', () => {
     }
 
     // verify balance
-    const balance = await actions.token.getBalance(client, {
+    const balance = await actions.token.getBalance(clientWithAccount, {
       account: '0x0000000000000000000000000000000000000001',
       token: addresses.alphaUsd,
     })
@@ -215,7 +220,7 @@ describe('approve', () => {
 describe('create', () => {
   test('default', async () => {
     const { receipt, token, tokenId, ...result } =
-      await actions.token.createSync(client, {
+      await actions.token.createSync(clientWithAccount, {
         currency: 'USD',
         name: 'Test USD',
         symbol: 'TUSD',
@@ -234,7 +239,7 @@ describe('create', () => {
     expect(tokenId).toBeDefined()
     expect(receipt).toBeDefined()
 
-    const code = await getCode(client, {
+    const code = await getCode(clientWithAccount, {
       address: token,
     })
     expect(code).toBe('0xef')
@@ -244,7 +249,7 @@ describe('create', () => {
 describe('getAllowance', () => {
   test('default', async () => {
     // First, approve some allowance
-    await writeContractSync(client, {
+    await writeContractSync(clientWithAccount, {
       abi: Abis.tip20,
       address: addresses.alphaUsd,
       functionName: 'approve',
@@ -253,7 +258,7 @@ describe('getAllowance', () => {
 
     {
       // Test with default token
-      const allowance = await actions.token.getAllowance(client, {
+      const allowance = await actions.token.getAllowance(clientWithAccount, {
         spender: account2.address,
         token: addresses.alphaUsd,
       })
@@ -262,7 +267,7 @@ describe('getAllowance', () => {
 
     {
       // Test with token address
-      const allowance = await actions.token.getAllowance(client, {
+      const allowance = await actions.token.getAllowance(clientWithAccount, {
         token: addresses.alphaUsd,
         spender: account2.address,
       })
@@ -272,7 +277,7 @@ describe('getAllowance', () => {
 
     {
       // Test with token ID
-      const allowance = await actions.token.getAllowance(client, {
+      const allowance = await actions.token.getAllowance(clientWithAccount, {
         token: addresses.alphaUsd,
         spender: account2.address,
       })
@@ -286,7 +291,7 @@ describe('getBalance', () => {
   test('default', async () => {
     {
       // Test with token address
-      const balance = await actions.token.getBalance(client, {
+      const balance = await actions.token.getBalance(clientWithAccount, {
         token: addresses.alphaUsd,
       })
 
@@ -295,7 +300,7 @@ describe('getBalance', () => {
 
     {
       // Test with token ID & different account
-      const balance = await actions.token.getBalance(client, {
+      const balance = await actions.token.getBalance(clientWithAccount, {
         token: addresses.alphaUsd,
         account: Hex.random(20),
       })
@@ -307,7 +312,7 @@ describe('getBalance', () => {
 
 describe('getMetadata', () => {
   test('default', async () => {
-    const metadata = await actions.token.getMetadata(client, {
+    const metadata = await actions.token.getMetadata(clientWithAccount, {
       token: addresses.alphaUsd,
     })
 
@@ -327,13 +332,13 @@ describe('getMetadata', () => {
   })
 
   test('behavior: custom token (address)', async () => {
-    const { token } = await actions.token.createSync(client, {
+    const { token } = await actions.token.createSync(clientWithAccount, {
       currency: 'USD',
       name: 'Test USD',
       symbol: 'TUSD',
     })
 
-    const metadata = await actions.token.getMetadata(client, {
+    const metadata = await actions.token.getMetadata(clientWithAccount, {
       token,
     })
 
@@ -354,7 +359,7 @@ describe('getMetadata', () => {
 
   test('behavior: quote token', async () => {
     {
-      const metadata = await actions.token.getMetadata(client, {
+      const metadata = await actions.token.getMetadata(clientWithAccount, {
         token: TokenIds.linkingUsd,
       })
 
@@ -370,7 +375,7 @@ describe('getMetadata', () => {
     }
 
     {
-      const metadata = await actions.token.getMetadata(client, {
+      const metadata = await actions.token.getMetadata(clientWithAccount, {
         token: Addresses.linkingUsd,
       })
 
@@ -387,13 +392,13 @@ describe('getMetadata', () => {
   })
 
   test('behavior: custom token (id)', async () => {
-    const token = await actions.token.createSync(client, {
+    const token = await actions.token.createSync(clientWithAccount, {
       currency: 'USD',
       name: 'Test USD',
       symbol: 'TUSD',
     })
 
-    const metadata = await actions.token.getMetadata(client, {
+    const metadata = await actions.token.getMetadata(clientWithAccount, {
       token: token.tokenId,
     })
 
@@ -416,21 +421,21 @@ describe('getMetadata', () => {
 describe('mint', () => {
   test('default', async () => {
     // Create a new token where we're the admin
-    const { token } = await actions.token.createSync(client, {
+    const { token } = await actions.token.createSync(clientWithAccount, {
       currency: 'USD',
       name: 'Mintable Token',
       symbol: 'MINT',
     })
 
     // Grant issuer role
-    await actions.token.grantRolesSync(client, {
+    await actions.token.grantRolesSync(clientWithAccount, {
       token,
       roles: ['issuer'],
-      to: client.account.address,
+      to: clientWithAccount.account.address,
     })
 
     // Check initial balance
-    const balanceBefore = await actions.token.getBalance(client, {
+    const balanceBefore = await actions.token.getBalance(clientWithAccount, {
       token,
       account: account2.address,
     })
@@ -438,7 +443,7 @@ describe('mint', () => {
 
     // Mint tokens
     const { receipt: mintReceipt, ...mintResult } =
-      await actions.token.mintSync(client, {
+      await actions.token.mintSync(clientWithAccount, {
         token,
         to: account2.address,
         amount: parseUnits('1000', 6),
@@ -452,14 +457,14 @@ describe('mint', () => {
     `)
 
     // Check balance after mint
-    const balanceAfter = await actions.token.getBalance(client, {
+    const balanceAfter = await actions.token.getBalance(clientWithAccount, {
       token,
       account: account2.address,
     })
     expect(balanceAfter).toBe(parseUnits('1000', 6))
 
     // Check total supply
-    const metadata = await actions.token.getMetadata(client, {
+    const metadata = await actions.token.getMetadata(clientWithAccount, {
       token,
     })
     expect(metadata.totalSupply).toBe(parseUnits('1000', 6))
@@ -468,23 +473,23 @@ describe('mint', () => {
   // TODO: fix
   test.skip('with memo', async () => {
     // Create a new token
-    const { token } = await actions.token.createSync(client, {
-      admin: client.account,
+    const { token } = await actions.token.createSync(clientWithAccount, {
+      admin: clientWithAccount.account,
       currency: 'USD',
       name: 'Mintable Token 2',
       symbol: 'MINT2',
     })
 
     // Grant issuer role
-    await actions.token.grantRolesSync(client, {
+    await actions.token.grantRolesSync(clientWithAccount, {
       token,
       roles: ['issuer'],
-      to: client.account.address,
+      to: clientWithAccount.account.address,
     })
 
     // Mint tokens with memo
     const { receipt: mintMemoReceipt, ...mintMemoResult } =
-      await actions.token.mintSync(client, {
+      await actions.token.mintSync(clientWithAccount, {
         token,
         to: account2.address,
         amount: parseUnits('500', 6),
@@ -499,7 +504,7 @@ describe('mint', () => {
     `)
 
     // Verify balance
-    const balance = await actions.token.getBalance(client, {
+    const balance = await actions.token.getBalance(clientWithAccount, {
       token,
       account: account2.address,
     })
@@ -510,18 +515,24 @@ describe('mint', () => {
 describe('transfer', () => {
   test('default', async () => {
     // Get initial balances
-    const senderBalanceBefore = await actions.token.getBalance(client, {
-      account: account.address,
-      token: addresses.alphaUsd,
-    })
-    const receiverBalanceBefore = await actions.token.getBalance(client, {
-      account: account2.address,
-      token: addresses.alphaUsd,
-    })
+    const senderBalanceBefore = await actions.token.getBalance(
+      clientWithAccount,
+      {
+        account: account.address,
+        token: addresses.alphaUsd,
+      },
+    )
+    const receiverBalanceBefore = await actions.token.getBalance(
+      clientWithAccount,
+      {
+        account: account2.address,
+        token: addresses.alphaUsd,
+      },
+    )
 
     // Transfer tokens
     const { receipt: transferReceipt, ...transferResult } =
-      await actions.token.transferSync(client, {
+      await actions.token.transferSync(clientWithAccount, {
         to: account2.address,
         amount: parseUnits('10', 6),
         token: addresses.alphaUsd,
@@ -536,14 +547,20 @@ describe('transfer', () => {
     `)
 
     // Verify balances
-    const senderBalanceAfter = await actions.token.getBalance(client, {
-      account: account.address,
-      token: addresses.alphaUsd,
-    })
-    const receiverBalanceAfter = await actions.token.getBalance(client, {
-      account: account2.address,
-      token: addresses.alphaUsd,
-    })
+    const senderBalanceAfter = await actions.token.getBalance(
+      clientWithAccount,
+      {
+        account: account.address,
+        token: addresses.alphaUsd,
+      },
+    )
+    const receiverBalanceAfter = await actions.token.getBalance(
+      clientWithAccount,
+      {
+        account: account2.address,
+        token: addresses.alphaUsd,
+      },
+    )
 
     expect(senderBalanceAfter - senderBalanceBefore).toBeLessThan(
       parseUnits('10', 6),
@@ -555,34 +572,34 @@ describe('transfer', () => {
 
   test('behavior: with custom token', async () => {
     // Create a new token
-    const { token } = await actions.token.createSync(client, {
+    const { token } = await actions.token.createSync(clientWithAccount, {
       currency: 'USD',
       name: 'Transfer Token',
       symbol: 'XFER',
     })
 
     // Grant issuer role and mint tokens
-    await actions.token.grantRolesSync(client, {
+    await actions.token.grantRolesSync(clientWithAccount, {
       token,
       roles: ['issuer'],
-      to: client.account.address,
+      to: clientWithAccount.account.address,
     })
 
-    await actions.token.mintSync(client, {
+    await actions.token.mintSync(clientWithAccount, {
       token,
-      to: client.account.address,
+      to: clientWithAccount.account.address,
       amount: parseUnits('1000', 6),
     })
 
     // Transfer custom tokens
-    await actions.token.transferSync(client, {
+    await actions.token.transferSync(clientWithAccount, {
       token,
       to: account2.address,
       amount: parseUnits('100', 6),
     })
 
     // Verify balance
-    const balance = await actions.token.getBalance(client, {
+    const balance = await actions.token.getBalance(clientWithAccount, {
       token,
       account: account2.address,
     })
@@ -593,7 +610,7 @@ describe('transfer', () => {
     const memo = Hex.fromString('Payment for services')
 
     const { receipt: transferMemoReceipt, ...transferMemoResult } =
-      await actions.token.transferSync(client, {
+      await actions.token.transferSync(clientWithAccount, {
         to: account2.address,
         amount: parseUnits('5', 6),
         memo,
@@ -612,14 +629,14 @@ describe('transfer', () => {
 
   test('behavior: from another account (transferFrom)', async () => {
     // First approve account2 to spend tokens
-    await actions.token.approveSync(client, {
+    await actions.token.approveSync(clientWithAccount, {
       spender: account2.address,
       amount: parseUnits('50', 6),
       token: addresses.alphaUsd,
     })
 
     // Transfer tokens for gas
-    await writeContractSync(client, {
+    await writeContractSync(clientWithAccount, {
       abi: Abis.tip20,
       address: addresses.alphaUsd,
       functionName: 'transfer',
@@ -627,13 +644,13 @@ describe('transfer', () => {
     })
 
     // Get initial balance
-    const balanceBefore = await actions.token.getBalance(client, {
+    const balanceBefore = await actions.token.getBalance(clientWithAccount, {
       account: account3.address,
       token: addresses.alphaUsd,
     })
 
     // Account2 transfers from account to account3
-    await actions.token.transferSync(client, {
+    await actions.token.transferSync(clientWithAccount, {
       account: account2,
       from: account.address,
       to: account3.address,
@@ -642,14 +659,14 @@ describe('transfer', () => {
     })
 
     // Verify balance
-    const balanceAfter = await actions.token.getBalance(client, {
+    const balanceAfter = await actions.token.getBalance(clientWithAccount, {
       account: account3.address,
       token: addresses.alphaUsd,
     })
     expect(balanceAfter - balanceBefore).toBe(parseUnits('25', 6))
 
     // Verify allowance was reduced
-    const allowance = await actions.token.getAllowance(client, {
+    const allowance = await actions.token.getAllowance(clientWithAccount, {
       spender: account2.address,
       token: addresses.alphaUsd,
     })
@@ -660,43 +677,46 @@ describe('transfer', () => {
 describe('burn', () => {
   test('default', async () => {
     // Create a new token where we have issuer role
-    const { token } = await actions.token.createSync(client, {
+    const { token } = await actions.token.createSync(clientWithAccount, {
       currency: 'USD',
       name: 'Burnable Token',
       symbol: 'BURN',
     })
 
     // Grant issuer role
-    await actions.token.grantRolesSync(client, {
+    await actions.token.grantRolesSync(clientWithAccount, {
       token,
       roles: ['issuer'],
-      to: client.account.address,
+      to: clientWithAccount.account.address,
     })
 
     // Mint some tokens
-    await actions.token.mintSync(client, {
+    await actions.token.mintSync(clientWithAccount, {
       token,
-      to: client.account.address,
+      to: clientWithAccount.account.address,
       amount: parseUnits('1000', 6),
     })
 
     // Check balance before burn
-    const balanceBefore = await actions.token.getBalance(client, {
+    const balanceBefore = await actions.token.getBalance(clientWithAccount, {
       token,
     })
     expect(balanceBefore).toBe(parseUnits('1000', 6))
 
     // Check total supply before
-    const metadataBefore = await actions.token.getMetadata(client, {
+    const metadataBefore = await actions.token.getMetadata(clientWithAccount, {
       token,
     })
     expect(metadataBefore.totalSupply).toBe(parseUnits('1000', 6))
 
     // Burn tokens
-    const { receipt, ...result } = await actions.token.burnSync(client, {
-      token,
-      amount: parseUnits('100', 6),
-    })
+    const { receipt, ...result } = await actions.token.burnSync(
+      clientWithAccount,
+      {
+        token,
+        amount: parseUnits('100', 6),
+      },
+    )
     expect(receipt).toBeDefined()
     expect(result).toMatchInlineSnapshot(`
       {
@@ -706,13 +726,13 @@ describe('burn', () => {
     `)
 
     // Check balance after burn
-    const balanceAfter = await actions.token.getBalance(client, {
+    const balanceAfter = await actions.token.getBalance(clientWithAccount, {
       token,
     })
     expect(balanceAfter).toBe(parseUnits('900', 6))
 
     // Check total supply after
-    const metadataAfter = await actions.token.getMetadata(client, {
+    const metadataAfter = await actions.token.getMetadata(clientWithAccount, {
       token,
     })
     expect(metadataAfter.totalSupply).toBe(parseUnits('900', 6))
@@ -720,38 +740,38 @@ describe('burn', () => {
 
   test('behavior: requires issuer role', async () => {
     // Create a new token
-    const { token } = await actions.token.createSync(client, {
+    const { token } = await actions.token.createSync(clientWithAccount, {
       currency: 'USD',
       name: 'Restricted Burn Token',
       symbol: 'RBURN',
     })
 
     // Grant issuer role to account2 (not us)
-    await actions.token.grantRolesSync(client, {
+    await actions.token.grantRolesSync(clientWithAccount, {
       token,
       roles: ['issuer'],
       to: account2.address,
     })
 
     // Transfer gas to account2
-    await writeContractSync(client, {
+    await writeContractSync(clientWithAccount, {
       abi: Abis.tip20,
       address: addresses.alphaUsd,
       functionName: 'transfer',
       args: [account2.address, parseUnits('1', 6)],
     })
 
-    await actions.token.mintSync(client, {
+    await actions.token.mintSync(clientWithAccount, {
       account: account2,
       feeToken: addresses.alphaUsd,
       token,
-      to: client.account.address,
+      to: clientWithAccount.account.address,
       amount: parseUnits('100', 6),
     })
 
     // Try to burn without issuer role - should fail
     await expect(
-      actions.token.burnSync(client, {
+      actions.token.burnSync(clientWithAccount, {
         token,
         amount: parseUnits('10', 6),
       }),
@@ -766,47 +786,47 @@ describe.todo('changeTokenTransferPolicy')
 describe('pause', () => {
   test('default', async () => {
     // Create a new token
-    const { token } = await actions.token.createSync(client, {
+    const { token } = await actions.token.createSync(clientWithAccount, {
       currency: 'USD',
       name: 'Pausable Token',
       symbol: 'PAUSE',
     })
 
     // Grant pause role
-    await actions.token.grantRolesSync(client, {
+    await actions.token.grantRolesSync(clientWithAccount, {
       token,
       roles: ['pause'],
-      to: client.account.address,
+      to: clientWithAccount.account.address,
     })
 
     // Grant issuer role and mint tokens
-    await actions.token.grantRolesSync(client, {
+    await actions.token.grantRolesSync(clientWithAccount, {
       token,
       roles: ['issuer'],
-      to: client.account.address,
+      to: clientWithAccount.account.address,
     })
 
-    await actions.token.mintSync(client, {
+    await actions.token.mintSync(clientWithAccount, {
       token,
       to: account2.address,
       amount: parseUnits('1000', 6),
     })
 
     // Verify token is not paused
-    let metadata = await actions.token.getMetadata(client, {
+    let metadata = await actions.token.getMetadata(clientWithAccount, {
       token,
     })
     expect(metadata.paused).toBe(false)
 
     // Transfer gas
-    await writeContractSync(client, {
+    await writeContractSync(clientWithAccount, {
       abi: Abis.tip20,
       address: addresses.alphaUsd,
       functionName: 'transfer',
       args: [account2.address, parseUnits('1', 6)],
     })
 
-    await actions.token.transferSync(client, {
+    await actions.token.transferSync(clientWithAccount, {
       account: account2,
       token,
       to: account3.address,
@@ -815,7 +835,7 @@ describe('pause', () => {
 
     // Pause the token
     const { receipt: pauseReceipt, ...pauseResult } =
-      await actions.token.pauseSync(client, {
+      await actions.token.pauseSync(clientWithAccount, {
         token,
       })
     expect(pauseReceipt).toBeDefined()
@@ -827,14 +847,14 @@ describe('pause', () => {
     `)
 
     // Verify token is paused
-    metadata = await actions.token.getMetadata(client, {
+    metadata = await actions.token.getMetadata(clientWithAccount, {
       token,
     })
     expect(metadata.paused).toBe(true)
 
     // Transfers should now fail
     await expect(
-      actions.token.transferSync(client, {
+      actions.token.transferSync(clientWithAccount, {
         account: account2,
         token,
         to: account3.address,
@@ -845,7 +865,7 @@ describe('pause', () => {
 
   test('behavior: requires pause role', async () => {
     // Create a new token
-    const { token } = await actions.token.createSync(client, {
+    const { token } = await actions.token.createSync(clientWithAccount, {
       currency: 'USD',
       name: 'Restricted Pause Token',
       symbol: 'RPAUSE',
@@ -853,34 +873,34 @@ describe('pause', () => {
 
     // Try to pause without pause role - should fail
     await expect(
-      actions.token.pauseSync(client, {
+      actions.token.pauseSync(clientWithAccount, {
         token,
       }),
     ).rejects.toThrow()
 
     // Grant pause role to account2
-    await actions.token.grantRolesSync(client, {
+    await actions.token.grantRolesSync(clientWithAccount, {
       token,
       roles: ['pause'],
       to: account2.address,
     })
 
     // Transfer gas to account2
-    await writeContractSync(client, {
+    await writeContractSync(clientWithAccount, {
       abi: Abis.tip20,
       address: addresses.alphaUsd,
       functionName: 'transfer',
       args: [account2.address, parseUnits('1', 6)],
     })
 
-    await actions.token.pauseSync(client, {
+    await actions.token.pauseSync(clientWithAccount, {
       account: account2,
       feeToken: addresses.alphaUsd,
       token,
     })
 
     // Verify token is paused
-    const metadata = await actions.token.getMetadata(client, {
+    const metadata = await actions.token.getMetadata(clientWithAccount, {
       token,
     })
     expect(metadata.paused).toBe(true)
@@ -888,27 +908,30 @@ describe('pause', () => {
 
   test('behavior: cannot pause already paused token', async () => {
     // Create a new token
-    const { token: address } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'Double Pause Token',
-      symbol: 'DPAUSE',
-    })
+    const { token: address } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'Double Pause Token',
+        symbol: 'DPAUSE',
+      },
+    )
 
     // Grant pause role
-    await actions.token.grantRolesSync(client, {
+    await actions.token.grantRolesSync(clientWithAccount, {
       token: address,
       roles: ['pause'],
-      to: client.account.address,
+      to: clientWithAccount.account.address,
     })
 
     // Pause the token
-    await actions.token.pauseSync(client, {
+    await actions.token.pauseSync(clientWithAccount, {
       token: address,
     })
 
     // Try to pause again - implementation may vary, but typically this succeeds without error
     const { receipt: doublePauseReceipt, ...doublePauseResult } =
-      await actions.token.pauseSync(client, {
+      await actions.token.pauseSync(clientWithAccount, {
         token: address,
       })
     expect(doublePauseReceipt.status).toBe('success')
@@ -924,51 +947,54 @@ describe('pause', () => {
 describe('unpause', () => {
   test('default', async () => {
     // Create a new token
-    const { token: address } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'Unpausable Token',
-      symbol: 'UNPAUSE',
-    })
+    const { token: address } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'Unpausable Token',
+        symbol: 'UNPAUSE',
+      },
+    )
 
     // Grant pause and unpause roles
-    await actions.token.grantRolesSync(client, {
+    await actions.token.grantRolesSync(clientWithAccount, {
       token: address,
       roles: ['pause'],
-      to: client.account.address,
+      to: clientWithAccount.account.address,
     })
 
-    await actions.token.grantRolesSync(client, {
+    await actions.token.grantRolesSync(clientWithAccount, {
       token: address,
       roles: ['unpause'],
-      to: client.account.address,
+      to: clientWithAccount.account.address,
     })
 
     // Grant issuer role and mint tokens
-    await actions.token.grantRolesSync(client, {
+    await actions.token.grantRolesSync(clientWithAccount, {
       token: address,
       roles: ['issuer'],
-      to: client.account.address,
+      to: clientWithAccount.account.address,
     })
 
-    await actions.token.mintSync(client, {
+    await actions.token.mintSync(clientWithAccount, {
       token: address,
       to: account2.address,
       amount: parseUnits('1000', 6),
     })
 
     // First pause the token
-    await actions.token.pauseSync(client, {
+    await actions.token.pauseSync(clientWithAccount, {
       token: address,
     })
 
     // Verify token is paused
-    let metadata = await actions.token.getMetadata(client, {
+    let metadata = await actions.token.getMetadata(clientWithAccount, {
       token: address,
     })
     expect(metadata.paused).toBe(true)
 
     // Transfer gas to account2
-    await writeContractSync(client, {
+    await writeContractSync(clientWithAccount, {
       abi: Abis.tip20,
       address: addresses.alphaUsd,
       functionName: 'transfer',
@@ -977,7 +1003,7 @@ describe('unpause', () => {
 
     // Verify transfers fail when paused
     await expect(
-      actions.token.transferSync(client, {
+      actions.token.transferSync(clientWithAccount, {
         account: account2,
         token: address,
         to: account3.address,
@@ -987,7 +1013,7 @@ describe('unpause', () => {
 
     // Unpause the token
     const { receipt: unpauseReceipt, ...unpauseResult } =
-      await actions.token.unpauseSync(client, {
+      await actions.token.unpauseSync(clientWithAccount, {
         token: address,
       })
     expect(unpauseReceipt).toBeDefined()
@@ -999,20 +1025,20 @@ describe('unpause', () => {
     `)
 
     // Verify token is unpaused
-    metadata = await actions.token.getMetadata(client, {
+    metadata = await actions.token.getMetadata(clientWithAccount, {
       token: address,
     })
     expect(metadata.paused).toBe(false)
 
     // Transfers should work again
-    await actions.token.transferSync(client, {
+    await actions.token.transferSync(clientWithAccount, {
       account: account2,
       token: address,
       to: account3.address,
       amount: parseUnits('100', 6),
     })
 
-    const balance = await actions.token.getBalance(client, {
+    const balance = await actions.token.getBalance(clientWithAccount, {
       token: address,
       account: account3.address,
     })
@@ -1021,39 +1047,42 @@ describe('unpause', () => {
 
   test('behavior: requires unpause role', async () => {
     // Create a new token
-    const { token: address } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'Restricted Unpause Token',
-      symbol: 'RUNPAUSE',
-    })
+    const { token: address } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'Restricted Unpause Token',
+        symbol: 'RUNPAUSE',
+      },
+    )
 
     // Grant pause role and pause the token
-    await actions.token.grantRolesSync(client, {
+    await actions.token.grantRolesSync(clientWithAccount, {
       token: address,
       roles: ['pause'],
-      to: client.account.address,
+      to: clientWithAccount.account.address,
     })
 
-    await actions.token.pauseSync(client, {
+    await actions.token.pauseSync(clientWithAccount, {
       token: address,
     })
 
     // Try to unpause without unpause role - should fail
     await expect(
-      actions.token.unpauseSync(client, {
+      actions.token.unpauseSync(clientWithAccount, {
         token: address,
       }),
     ).rejects.toThrow()
 
     // Grant unpause role to account2
-    await actions.token.grantRolesSync(client, {
+    await actions.token.grantRolesSync(clientWithAccount, {
       token: address,
       roles: ['unpause'],
       to: account2.address,
     })
 
     // Transfer gas to account2
-    await writeContractSync(client, {
+    await writeContractSync(clientWithAccount, {
       abi: Abis.tip20,
       address: addresses.alphaUsd,
       functionName: 'transfer',
@@ -1061,14 +1090,14 @@ describe('unpause', () => {
     })
 
     // Now account2 should be able to unpause
-    await actions.token.unpauseSync(client, {
+    await actions.token.unpauseSync(clientWithAccount, {
       account: account2,
       feeToken: addresses.alphaUsd,
       token: address,
     })
 
     // Verify token is unpaused
-    const metadata = await actions.token.getMetadata(client, {
+    const metadata = await actions.token.getMetadata(clientWithAccount, {
       token: address,
     })
     expect(metadata.paused).toBe(false)
@@ -1076,35 +1105,38 @@ describe('unpause', () => {
 
   test('behavior: different roles for pause and unpause', async () => {
     // Create a new token
-    const { token: address } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'Split Role Token',
-      symbol: 'SPLIT',
-    })
+    const { token: address } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'Split Role Token',
+        symbol: 'SPLIT',
+      },
+    )
 
     // Grant pause role to account2
-    await actions.token.grantRolesSync(client, {
+    await actions.token.grantRolesSync(clientWithAccount, {
       token: address,
       roles: ['pause'],
       to: account2.address,
     })
 
     // Grant unpause role to account3
-    await actions.token.grantRolesSync(client, {
+    await actions.token.grantRolesSync(clientWithAccount, {
       token: address,
       roles: ['unpause'],
       to: account3.address,
     })
 
     // Transfer gas to both accounts
-    await writeContractSync(client, {
+    await writeContractSync(clientWithAccount, {
       abi: Abis.tip20,
       address: addresses.alphaUsd,
       functionName: 'transfer',
       args: [account2.address, parseUnits('1', 6)],
     })
 
-    await writeContractSync(client, {
+    await writeContractSync(clientWithAccount, {
       abi: Abis.tip20,
       address: addresses.alphaUsd,
       functionName: 'transfer',
@@ -1112,7 +1144,7 @@ describe('unpause', () => {
     })
 
     // Account2 can pause
-    await actions.token.pauseSync(client, {
+    await actions.token.pauseSync(clientWithAccount, {
       account: account2,
       feeToken: addresses.alphaUsd,
       token: address,
@@ -1120,21 +1152,21 @@ describe('unpause', () => {
 
     // Account2 cannot unpause
     await expect(
-      actions.token.unpauseSync(client, {
+      actions.token.unpauseSync(clientWithAccount, {
         account: account2,
         token: address,
       }),
     ).rejects.toThrow()
 
     // Account3 can unpause
-    await actions.token.unpauseSync(client, {
+    await actions.token.unpauseSync(clientWithAccount, {
       account: account3,
       feeToken: addresses.alphaUsd,
       token: address,
     })
 
     // Verify token is unpaused
-    const metadata = await actions.token.getMetadata(client, {
+    const metadata = await actions.token.getMetadata(clientWithAccount, {
       token: address,
     })
     expect(metadata.paused).toBe(false)
@@ -1145,7 +1177,7 @@ describe('prepareUpdateQuoteToken', () => {
   test('default', async () => {
     // Create two tokens - one to be the new quote token
     const { token: quoteTokenAddress } = await actions.token.createSync(
-      client,
+      clientWithAccount,
       {
         currency: 'USD',
         name: 'Quote Token',
@@ -1153,18 +1185,21 @@ describe('prepareUpdateQuoteToken', () => {
       },
     )
 
-    const { token: address } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'Main Token',
-      symbol: 'MAIN',
-    })
+    const { token: address } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'Main Token',
+        symbol: 'MAIN',
+      },
+    )
 
     // Update quote token
     const {
       receipt: updateReceipt,
       nextQuoteToken,
       ...updateResult
-    } = await actions.token.prepareUpdateQuoteTokenSync(client, {
+    } = await actions.token.prepareUpdateQuoteTokenSync(clientWithAccount, {
       token: address,
       quoteToken: quoteTokenAddress,
     })
@@ -1183,7 +1218,7 @@ describe('prepareUpdateQuoteToken', () => {
   test('behavior: requires admin role', async () => {
     // Create quote token
     const { token: quoteTokenAddress } = await actions.token.createSync(
-      client,
+      clientWithAccount,
       {
         currency: 'USD',
         name: 'Quote Token 2',
@@ -1191,15 +1226,18 @@ describe('prepareUpdateQuoteToken', () => {
       },
     )
 
-    // Create main token where client.account is admin
-    const { token: address } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'Restricted Token',
-      symbol: 'RESTR',
-    })
+    // Create main token where clientWithAccount.account is admin
+    const { token: address } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'Restricted Token',
+        symbol: 'RESTR',
+      },
+    )
 
     // Transfer gas to account2
-    await writeContractSync(client, {
+    await writeContractSync(clientWithAccount, {
       abi: Abis.tip20,
       address: addresses.alphaUsd,
       functionName: 'transfer',
@@ -1208,7 +1246,7 @@ describe('prepareUpdateQuoteToken', () => {
 
     // Try to update quote token from account2 (not admin) - should fail
     await expect(
-      actions.token.prepareUpdateQuoteTokenSync(client, {
+      actions.token.prepareUpdateQuoteTokenSync(clientWithAccount, {
         account: account2,
         token: address,
         quoteToken: quoteTokenAddress,
@@ -1219,7 +1257,7 @@ describe('prepareUpdateQuoteToken', () => {
   test('behavior: with token ID', async () => {
     // Create quote token
     const { token: quoteTokenAddress } = await actions.token.createSync(
-      client,
+      clientWithAccount,
       {
         currency: 'USD',
         name: 'Quote Token 3',
@@ -1228,18 +1266,21 @@ describe('prepareUpdateQuoteToken', () => {
     )
 
     // Create main token using token ID
-    const { tokenId: mainTokenId } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'Main Token ID',
-      symbol: 'MAINID',
-    })
+    const { tokenId: mainTokenId } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'Main Token ID',
+        symbol: 'MAINID',
+      },
+    )
 
     // Update quote token using token ID for main token, address for quote token
     const {
       receipt: updateReceipt,
       nextQuoteToken,
       ...updateResult
-    } = await actions.token.prepareUpdateQuoteTokenSync(client, {
+    } = await actions.token.prepareUpdateQuoteTokenSync(clientWithAccount, {
       token: mainTokenId,
       quoteToken: quoteTokenAddress,
     })
@@ -1258,7 +1299,7 @@ describe('finalizeUpdateQuoteToken', () => {
   test('default', async () => {
     // Create quote token
     const { token: quoteTokenAddress } = await actions.token.createSync(
-      client,
+      clientWithAccount,
       {
         currency: 'USD',
         name: 'Quote Token',
@@ -1267,14 +1308,17 @@ describe('finalizeUpdateQuoteToken', () => {
     )
 
     // Create main token
-    const { token: address } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'Main Token',
-      symbol: 'MAIN',
-    })
+    const { token: address } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'Main Token',
+        symbol: 'MAIN',
+      },
+    )
 
     // Prepare update quote token (step 1)
-    await actions.token.prepareUpdateQuoteTokenSync(client, {
+    await actions.token.prepareUpdateQuoteTokenSync(clientWithAccount, {
       token: address,
       quoteToken: quoteTokenAddress,
     })
@@ -1284,7 +1328,7 @@ describe('finalizeUpdateQuoteToken', () => {
       receipt: finalizeReceipt,
       newQuoteToken,
       ...finalizeResult
-    } = await actions.token.updateQuoteTokenSync(client, {
+    } = await actions.token.updateQuoteTokenSync(clientWithAccount, {
       token: address,
     })
 
@@ -1299,7 +1343,7 @@ describe('finalizeUpdateQuoteToken', () => {
     expect(newQuoteToken).toBe(quoteTokenAddress)
 
     // Verify it's reflected in metadata
-    const metadata = await actions.token.getMetadata(client, {
+    const metadata = await actions.token.getMetadata(clientWithAccount, {
       token: address,
     })
     expect(metadata.quoteToken).toBe(quoteTokenAddress)
@@ -1308,7 +1352,7 @@ describe('finalizeUpdateQuoteToken', () => {
   test('behavior: requires admin role', async () => {
     // Create quote token
     const { token: quoteTokenAddress } = await actions.token.createSync(
-      client,
+      clientWithAccount,
       {
         currency: 'USD',
         name: 'Quote Token 2',
@@ -1317,20 +1361,23 @@ describe('finalizeUpdateQuoteToken', () => {
     )
 
     // Create main token
-    const { token: address } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'Restricted Token',
-      symbol: 'RESTR',
-    })
+    const { token: address } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'Restricted Token',
+        symbol: 'RESTR',
+      },
+    )
 
     // Update quote token as admin
-    await actions.token.prepareUpdateQuoteTokenSync(client, {
+    await actions.token.prepareUpdateQuoteTokenSync(clientWithAccount, {
       token: address,
       quoteToken: quoteTokenAddress,
     })
 
     // Transfer gas to account2
-    await writeContractSync(client, {
+    await writeContractSync(clientWithAccount, {
       abi: Abis.tip20,
       address: addresses.alphaUsd,
       functionName: 'transfer',
@@ -1339,7 +1386,7 @@ describe('finalizeUpdateQuoteToken', () => {
 
     // Try to finalize as non-admin - should fail
     await expect(
-      actions.token.updateQuoteTokenSync(client, {
+      actions.token.updateQuoteTokenSync(clientWithAccount, {
         account: account2,
         token: address,
       }),
@@ -1348,29 +1395,35 @@ describe('finalizeUpdateQuoteToken', () => {
 
   test('behavior: prevents circular references', async () => {
     // Create token B
-    const { token: tokenBAddress } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'Token B',
-      symbol: 'TKB',
-    })
+    const { token: tokenBAddress } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'Token B',
+        symbol: 'TKB',
+      },
+    )
 
     // Create token A that links to token B
-    const { token: tokenAAddress } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'Token A',
-      symbol: 'TKA',
-      quoteToken: tokenBAddress,
-    })
+    const { token: tokenAAddress } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'Token A',
+        symbol: 'TKA',
+        quoteToken: tokenBAddress,
+      },
+    )
 
     // Try to make token B link to token A (would create A -> B -> A loop)
-    await actions.token.prepareUpdateQuoteTokenSync(client, {
+    await actions.token.prepareUpdateQuoteTokenSync(clientWithAccount, {
       token: tokenBAddress,
       quoteToken: tokenAAddress,
     })
 
     // Finalize should fail due to circular reference detection
     await expect(
-      actions.token.updateQuoteTokenSync(client, {
+      actions.token.updateQuoteTokenSync(clientWithAccount, {
         token: tokenBAddress,
       }),
     ).rejects.toThrow()
@@ -1382,51 +1435,60 @@ describe.todo('setTokenSupplyCap')
 describe('hasRole', () => {
   test('default', async () => {
     // Create a new token where we're the admin
-    const { token: address } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'HasRole Test Token',
-      symbol: 'HRTEST',
-    })
+    const { token: address } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'HasRole Test Token',
+        symbol: 'HRTEST',
+      },
+    )
 
     // Client account should have defaultAdmin role on the new token
-    const hasDefaultAdminRole = await actions.token.hasRole(client, {
+    const hasDefaultAdminRole = await actions.token.hasRole(clientWithAccount, {
       token: address,
       role: 'defaultAdmin',
     })
     expect(hasDefaultAdminRole).toBe(true)
 
     // Client account should not have issuer role initially on the new token
-    const hasIssuerRole = await actions.token.hasRole(client, {
+    const hasIssuerRole = await actions.token.hasRole(clientWithAccount, {
       token: address,
       role: 'issuer',
     })
     expect(hasIssuerRole).toBe(false)
 
     // Grant issuer role
-    await actions.token.grantRolesSync(client, {
+    await actions.token.grantRolesSync(clientWithAccount, {
       token: address,
       roles: ['issuer'],
-      to: client.account.address,
+      to: clientWithAccount.account.address,
     })
 
     // Now should have issuer role
-    const hasIssuerRoleAfterGrant = await actions.token.hasRole(client, {
-      token: address,
-      role: 'issuer',
-    })
+    const hasIssuerRoleAfterGrant = await actions.token.hasRole(
+      clientWithAccount,
+      {
+        token: address,
+        role: 'issuer',
+      },
+    )
     expect(hasIssuerRoleAfterGrant).toBe(true)
   })
 
   test('behavior: check other account', async () => {
     // Create a new token
-    const { token: address } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'HasRole Other Account',
-      symbol: 'HROAC',
-    })
+    const { token: address } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'HasRole Other Account',
+        symbol: 'HROAC',
+      },
+    )
 
     // Account2 should not have issuer role
-    const hasIssuerBefore = await actions.token.hasRole(client, {
+    const hasIssuerBefore = await actions.token.hasRole(clientWithAccount, {
       token: address,
       account: account2.address,
       role: 'issuer',
@@ -1434,14 +1496,14 @@ describe('hasRole', () => {
     expect(hasIssuerBefore).toBe(false)
 
     // Grant issuer role to account2
-    await actions.token.grantRolesSync(client, {
+    await actions.token.grantRolesSync(clientWithAccount, {
       token: address,
       roles: ['issuer'],
       to: account2.address,
     })
 
     // Account2 should now have issuer role
-    const hasIssuerAfter = await actions.token.hasRole(client, {
+    const hasIssuerAfter = await actions.token.hasRole(clientWithAccount, {
       token: address,
       account: account2.address,
       role: 'issuer',
@@ -1449,7 +1511,7 @@ describe('hasRole', () => {
     expect(hasIssuerAfter).toBe(true)
 
     // Account3 should still not have issuer role
-    const account3HasIssuer = await actions.token.hasRole(client, {
+    const account3HasIssuer = await actions.token.hasRole(clientWithAccount, {
       token: address,
       account: account3.address,
       role: 'issuer',
@@ -1459,21 +1521,24 @@ describe('hasRole', () => {
 
   test('behavior: multiple roles', async () => {
     // Create a new token
-    const { token: address } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'HasRole Multiple',
-      symbol: 'HRMULTI',
-    })
+    const { token: address } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'HasRole Multiple',
+        symbol: 'HRMULTI',
+      },
+    )
 
     // Grant multiple roles to account2
-    await actions.token.grantRolesSync(client, {
+    await actions.token.grantRolesSync(clientWithAccount, {
       token: address,
       roles: ['issuer', 'pause'],
       to: account2.address,
     })
 
     // Check issuer role
-    const hasIssuer = await actions.token.hasRole(client, {
+    const hasIssuer = await actions.token.hasRole(clientWithAccount, {
       token: address,
       account: account2.address,
       role: 'issuer',
@@ -1481,7 +1546,7 @@ describe('hasRole', () => {
     expect(hasIssuer).toBe(true)
 
     // Check pause role
-    const hasPause = await actions.token.hasRole(client, {
+    const hasPause = await actions.token.hasRole(clientWithAccount, {
       token: address,
       account: account2.address,
       role: 'pause',
@@ -1489,7 +1554,7 @@ describe('hasRole', () => {
     expect(hasPause).toBe(true)
 
     // Check unpause role (not granted)
-    const hasUnpause = await actions.token.hasRole(client, {
+    const hasUnpause = await actions.token.hasRole(clientWithAccount, {
       token: address,
       account: account2.address,
       role: 'unpause',
@@ -1499,21 +1564,24 @@ describe('hasRole', () => {
 
   test('behavior: after revoke', async () => {
     // Create a new token
-    const { token: address } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'HasRole Revoke',
-      symbol: 'HRREV',
-    })
+    const { token: address } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'HasRole Revoke',
+        symbol: 'HRREV',
+      },
+    )
 
     // Grant issuer role to account2
-    await actions.token.grantRolesSync(client, {
+    await actions.token.grantRolesSync(clientWithAccount, {
       token: address,
       roles: ['issuer'],
       to: account2.address,
     })
 
     // Verify has role
-    const hasRoleBefore = await actions.token.hasRole(client, {
+    const hasRoleBefore = await actions.token.hasRole(clientWithAccount, {
       token: address,
       account: account2.address,
       role: 'issuer',
@@ -1521,14 +1589,14 @@ describe('hasRole', () => {
     expect(hasRoleBefore).toBe(true)
 
     // Revoke the role
-    await actions.token.revokeRolesSync(client, {
+    await actions.token.revokeRolesSync(clientWithAccount, {
       token: address,
       roles: ['issuer'],
       from: account2.address,
     })
 
     // Verify no longer has role
-    const hasRoleAfter = await actions.token.hasRole(client, {
+    const hasRoleAfter = await actions.token.hasRole(clientWithAccount, {
       token: address,
       account: account2.address,
       role: 'issuer',
@@ -1538,21 +1606,24 @@ describe('hasRole', () => {
 
   test('behavior: with token ID', async () => {
     // Create a new token
-    const { token: address, tokenId } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'HasRole Token ID',
-      symbol: 'HRTID',
-    })
+    const { token: address, tokenId } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'HasRole Token ID',
+        symbol: 'HRTID',
+      },
+    )
 
     // Grant issuer role
-    await actions.token.grantRolesSync(client, {
+    await actions.token.grantRolesSync(clientWithAccount, {
       token: tokenId,
       roles: ['issuer'],
       to: account2.address,
     })
 
     // Check using token ID
-    const hasRole = await actions.token.hasRole(client, {
+    const hasRole = await actions.token.hasRole(clientWithAccount, {
       token: tokenId,
       account: account2.address,
       role: 'issuer',
@@ -1560,7 +1631,7 @@ describe('hasRole', () => {
     expect(hasRole).toBe(true)
 
     // Verify same result with address
-    const hasRoleWithAddress = await actions.token.hasRole(client, {
+    const hasRoleWithAddress = await actions.token.hasRole(clientWithAccount, {
       token: address,
       account: account2.address,
       role: 'issuer',
@@ -1572,23 +1643,29 @@ describe('hasRole', () => {
 describe('getRoleAdmin', () => {
   test('default', async () => {
     // Create a new token where we're the admin
-    const { token: address } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'GetRoleAdmin Test Token',
-      symbol: 'GRATEST',
-    })
+    const { token: address } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'GetRoleAdmin Test Token',
+        symbol: 'GRATEST',
+      },
+    )
 
     // Get admin role for issuer role (should be defaultAdmin)
-    const issuerAdminRole = await actions.token.getRoleAdmin(client, {
-      token: address,
-      role: 'issuer',
-    })
+    const issuerAdminRole = await actions.token.getRoleAdmin(
+      clientWithAccount,
+      {
+        token: address,
+        role: 'issuer',
+      },
+    )
     expect(issuerAdminRole).toBe(
       '0x0000000000000000000000000000000000000000000000000000000000000000',
     )
 
     // Get admin role for pause role (should be defaultAdmin)
-    const pauseAdminRole = await actions.token.getRoleAdmin(client, {
+    const pauseAdminRole = await actions.token.getRoleAdmin(clientWithAccount, {
       token: address,
       role: 'pause',
     })
@@ -1597,10 +1674,13 @@ describe('getRoleAdmin', () => {
     )
 
     // Get admin role for unpause role (should be defaultAdmin)
-    const unpauseAdminRole = await actions.token.getRoleAdmin(client, {
-      token: address,
-      role: 'unpause',
-    })
+    const unpauseAdminRole = await actions.token.getRoleAdmin(
+      clientWithAccount,
+      {
+        token: address,
+        role: 'unpause',
+      },
+    )
     expect(unpauseAdminRole).toBe(
       '0x0000000000000000000000000000000000000000000000000000000000000000',
     )
@@ -1608,74 +1688,98 @@ describe('getRoleAdmin', () => {
 
   test('behavior: after setting role admin', async () => {
     // Create a new token
-    const { token: address } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'GetRoleAdmin After Set',
-      symbol: 'GRASET',
-    })
+    const { token: address } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'GetRoleAdmin After Set',
+        symbol: 'GRASET',
+      },
+    )
 
     // Get initial admin role for issuer
-    const initialAdminRole = await actions.token.getRoleAdmin(client, {
-      token: address,
-      role: 'issuer',
-    })
+    const initialAdminRole = await actions.token.getRoleAdmin(
+      clientWithAccount,
+      {
+        token: address,
+        role: 'issuer',
+      },
+    )
     expect(initialAdminRole).toBe(
       '0x0000000000000000000000000000000000000000000000000000000000000000',
     )
 
     // Set pause as admin role for issuer
-    await actions.token.setRoleAdminSync(client, {
+    await actions.token.setRoleAdminSync(clientWithAccount, {
       token: address,
       role: 'issuer',
       adminRole: 'pause',
     })
 
     // Get updated admin role for issuer
-    const updatedAdminRole = await actions.token.getRoleAdmin(client, {
-      token: address,
-      role: 'issuer',
-    })
+    const updatedAdminRole = await actions.token.getRoleAdmin(
+      clientWithAccount,
+      {
+        token: address,
+        role: 'issuer',
+      },
+    )
     expect(updatedAdminRole).toBe(TokenRole.serialize('pause'))
   })
 
   test('behavior: with token ID', async () => {
     // Create a new token
-    const { token: address, tokenId } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'GetRoleAdmin Token ID',
-      symbol: 'GRATID',
-    })
+    const { token: address, tokenId } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'GetRoleAdmin Token ID',
+        symbol: 'GRATID',
+      },
+    )
 
     // Get admin role using token ID
-    const adminRoleWithId = await actions.token.getRoleAdmin(client, {
-      token: tokenId,
-      role: 'issuer',
-    })
+    const adminRoleWithId = await actions.token.getRoleAdmin(
+      clientWithAccount,
+      {
+        token: tokenId,
+        role: 'issuer',
+      },
+    )
     expect(adminRoleWithId).toBe(
       '0x0000000000000000000000000000000000000000000000000000000000000000',
     )
 
     // Get admin role using address
-    const adminRoleWithAddress = await actions.token.getRoleAdmin(client, {
-      token: address,
-      role: 'issuer',
-    })
+    const adminRoleWithAddress = await actions.token.getRoleAdmin(
+      clientWithAccount,
+      {
+        token: address,
+        role: 'issuer',
+      },
+    )
     expect(adminRoleWithAddress).toBe(adminRoleWithId)
   })
 
   test('behavior: defaultAdmin role admin', async () => {
     // Create a new token
-    const { token: address } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'GetRoleAdmin DefaultAdmin',
-      symbol: 'GRADMIN',
-    })
+    const { token: address } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'GetRoleAdmin DefaultAdmin',
+        symbol: 'GRADMIN',
+      },
+    )
 
     // Get admin role for defaultAdmin role (should be itself - 0x00)
-    const defaultAdminAdminRole = await actions.token.getRoleAdmin(client, {
-      token: address,
-      role: 'defaultAdmin',
-    })
+    const defaultAdminAdminRole = await actions.token.getRoleAdmin(
+      clientWithAccount,
+      {
+        token: address,
+        role: 'defaultAdmin',
+      },
+    )
     expect(defaultAdminAdminRole).toBe(
       '0x0000000000000000000000000000000000000000000000000000000000000000',
     )
@@ -1685,16 +1789,19 @@ describe('getRoleAdmin', () => {
 describe('grantRoles', () => {
   test('default', async () => {
     // Create a new token where we're the admin
-    const { token: address } = await actions.token.createSync(client, {
-      admin: client.account,
-      currency: 'USD',
-      name: 'Test Token',
-      symbol: 'TEST',
-    })
+    const { token: address } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        admin: clientWithAccount.account,
+        currency: 'USD',
+        name: 'Test Token',
+        symbol: 'TEST',
+      },
+    )
 
     // Grant issuer role to account2
     const { receipt: grantReceipt, value: grantValue } =
-      await actions.token.grantRolesSync(client, {
+      await actions.token.grantRolesSync(clientWithAccount, {
         token: address,
         roles: ['issuer'],
         to: account2.address,
@@ -1716,21 +1823,24 @@ describe('grantRoles', () => {
 
 describe('revokeTokenRole', async () => {
   test('default', async () => {
-    const { token: address } = await actions.token.createSync(client, {
-      admin: client.account,
-      currency: 'USD',
-      name: 'Test Token 2',
-      symbol: 'TEST2',
-    })
+    const { token: address } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        admin: clientWithAccount.account,
+        currency: 'USD',
+        name: 'Test Token 2',
+        symbol: 'TEST2',
+      },
+    )
 
-    await actions.token.grantRolesSync(client, {
+    await actions.token.grantRolesSync(clientWithAccount, {
       token: address,
       roles: ['issuer'],
       to: account2.address,
     })
 
     const { receipt: revokeReceipt, value: revokeValue } =
-      await actions.token.revokeRolesSync(client, {
+      await actions.token.revokeRolesSync(clientWithAccount, {
         from: account2.address,
         token: address,
         roles: ['issuer'],
@@ -1752,25 +1862,28 @@ describe('revokeTokenRole', async () => {
 
 describe('renounceTokenRole', async () => {
   test('default', async () => {
-    const { token: address } = await actions.token.createSync(client, {
-      admin: client.account,
-      currency: 'USD',
-      name: 'Test Token 3',
-      symbol: 'TEST3',
-    })
+    const { token: address } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        admin: clientWithAccount.account,
+        currency: 'USD',
+        name: 'Test Token 3',
+        symbol: 'TEST3',
+      },
+    )
 
     const { receipt: grantReceipt } = await actions.token.grantRolesSync(
-      client,
+      clientWithAccount,
       {
         token: address,
         roles: ['issuer'],
-        to: client.account.address,
+        to: clientWithAccount.account.address,
       },
     )
     expect(grantReceipt.status).toBe('success')
 
     const { receipt: renounceReceipt, value: renounceValue } =
-      await actions.token.renounceRolesSync(client, {
+      await actions.token.renounceRolesSync(clientWithAccount, {
         token: address,
         roles: ['issuer'],
       })
@@ -1798,20 +1911,20 @@ describe('watchCreate', () => {
       log: actions.token.watchCreate.Log
     }> = []
 
-    const unwatch = actions.token.watchCreate(client, {
+    const unwatch = actions.token.watchCreate(clientWithAccount, {
       onTokenCreated: (args, log) => {
         receivedTokens.push({ args, log })
       },
     })
 
     try {
-      await actions.token.createSync(client, {
+      await actions.token.createSync(clientWithAccount, {
         currency: 'USD',
         name: 'Watch Test Token 1',
         symbol: 'WATCH1',
       })
 
-      await actions.token.createSync(client, {
+      await actions.token.createSync(clientWithAccount, {
         currency: 'USD',
         name: 'Watch Test Token 2',
         symbol: 'WATCH2',
@@ -1862,11 +1975,14 @@ describe('watchCreate', () => {
 
   test('behavior: filter by tokenId', async () => {
     // First, create a token to know what ID we're at
-    const { tokenId: firstId } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'Setup Token',
-      symbol: 'SETUP',
-    })
+    const { tokenId: firstId } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'Setup Token',
+        symbol: 'SETUP',
+      },
+    )
 
     // We want to watch for the token with ID = firstId + 2
     const targetTokenId = firstId + 2n
@@ -1877,7 +1993,7 @@ describe('watchCreate', () => {
     }> = []
 
     // Start watching for token creation events only for targetTokenId
-    const unwatch = actions.token.watchCreate(client, {
+    const unwatch = actions.token.watchCreate(clientWithAccount, {
       args: {
         tokenId: targetTokenId,
       },
@@ -1888,21 +2004,24 @@ describe('watchCreate', () => {
 
     try {
       // Create first token (should NOT be captured - ID will be firstId + 1)
-      await actions.token.createSync(client, {
+      await actions.token.createSync(clientWithAccount, {
         currency: 'USD',
         name: 'Filtered Watch Token 1',
         symbol: 'FWATCH1',
       })
 
       // Create second token (should be captured - ID will be firstId + 2 = targetTokenId)
-      const { tokenId: id2 } = await actions.token.createSync(client, {
-        currency: 'USD',
-        name: 'Filtered Watch Token 2',
-        symbol: 'FWATCH2',
-      })
+      const { tokenId: id2 } = await actions.token.createSync(
+        clientWithAccount,
+        {
+          currency: 'USD',
+          name: 'Filtered Watch Token 2',
+          symbol: 'FWATCH2',
+        },
+      )
 
       // Create third token (should NOT be captured - ID will be firstId + 3)
-      await actions.token.createSync(client, {
+      await actions.token.createSync(clientWithAccount, {
         currency: 'USD',
         name: 'Filtered Watch Token 3',
         symbol: 'FWATCH3',
@@ -1937,17 +2056,20 @@ describe('watchCreate', () => {
 describe('watchMint', () => {
   test('default', async () => {
     // Create a new token for testing
-    const { token: address } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'Mint Watch Token',
-      symbol: 'MINT',
-    })
+    const { token: address } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'Mint Watch Token',
+        symbol: 'MINT',
+      },
+    )
 
     // Grant issuer role
-    await actions.token.grantRolesSync(client, {
+    await actions.token.grantRolesSync(clientWithAccount, {
       token: address,
       roles: ['issuer'],
-      to: client.account.address,
+      to: clientWithAccount.account.address,
     })
 
     const receivedMints: Array<{
@@ -1956,7 +2078,7 @@ describe('watchMint', () => {
     }> = []
 
     // Start watching for mint events
-    const unwatch = actions.token.watchMint(client, {
+    const unwatch = actions.token.watchMint(clientWithAccount, {
       token: address,
       onMint: (args, log) => {
         receivedMints.push({ args, log })
@@ -1965,14 +2087,14 @@ describe('watchMint', () => {
 
     try {
       // Mint first batch
-      await actions.token.mintSync(client, {
+      await actions.token.mintSync(clientWithAccount, {
         token: address,
         to: account2.address,
         amount: parseUnits('100', 6),
       })
 
       // Mint second batch
-      await actions.token.mintSync(client, {
+      await actions.token.mintSync(clientWithAccount, {
         token: address,
         to: account3.address,
         amount: parseUnits('50', 6),
@@ -2001,17 +2123,20 @@ describe('watchMint', () => {
 
   test('behavior: filter by to address', async () => {
     // Create a new token for testing
-    const { token: address } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'Filtered Mint Token',
-      symbol: 'FMINT',
-    })
+    const { token: address } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'Filtered Mint Token',
+        symbol: 'FMINT',
+      },
+    )
 
     // Grant issuer role
-    await actions.token.grantRolesSync(client, {
+    await actions.token.grantRolesSync(clientWithAccount, {
       token: address,
       roles: ['issuer'],
-      to: client.account.address,
+      to: clientWithAccount.account.address,
     })
 
     const receivedMints: Array<{
@@ -2020,7 +2145,7 @@ describe('watchMint', () => {
     }> = []
 
     // Start watching for mint events only to account2
-    const unwatch = actions.token.watchMint(client, {
+    const unwatch = actions.token.watchMint(clientWithAccount, {
       token: address,
       args: {
         to: account2.address,
@@ -2032,21 +2157,21 @@ describe('watchMint', () => {
 
     try {
       // Mint to account2 (should be captured)
-      await actions.token.mintSync(client, {
+      await actions.token.mintSync(clientWithAccount, {
         token: address,
         to: account2.address,
         amount: parseUnits('100', 6),
       })
 
       // Mint to account3 (should NOT be captured)
-      await actions.token.mintSync(client, {
+      await actions.token.mintSync(clientWithAccount, {
         token: address,
         to: account3.address,
         amount: parseUnits('50', 6),
       })
 
       // Mint to account2 again (should be captured)
-      await actions.token.mintSync(client, {
+      await actions.token.mintSync(clientWithAccount, {
         token: address,
         to: account2.address,
         amount: parseUnits('75', 6),
@@ -2083,11 +2208,14 @@ describe('watchMint', () => {
 describe('watchApprove', () => {
   test('default', async () => {
     // Create a new token for testing
-    const { token: address } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'Approval Watch Token',
-      symbol: 'APPR',
-    })
+    const { token: address } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'Approval Watch Token',
+        symbol: 'APPR',
+      },
+    )
 
     const receivedApprovals: Array<{
       args: actions.token.watchApprove.Args
@@ -2095,7 +2223,7 @@ describe('watchApprove', () => {
     }> = []
 
     // Start watching for approval events
-    const unwatch = actions.token.watchApprove(client, {
+    const unwatch = actions.token.watchApprove(clientWithAccount, {
       token: address,
       onApproval: (args, log) => {
         receivedApprovals.push({ args, log })
@@ -2104,14 +2232,14 @@ describe('watchApprove', () => {
 
     try {
       // Approve account2
-      await actions.token.approveSync(client, {
+      await actions.token.approveSync(clientWithAccount, {
         token: address,
         spender: account2.address,
         amount: parseUnits('100', 6),
       })
 
       // Approve account3
-      await actions.token.approveSync(client, {
+      await actions.token.approveSync(clientWithAccount, {
         token: address,
         spender: account3.address,
         amount: parseUnits('50', 6),
@@ -2142,11 +2270,14 @@ describe('watchApprove', () => {
 
   test('behavior: filter by spender address', async () => {
     // Create a new token for testing
-    const { token: address } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'Filtered Approval Token',
-      symbol: 'FAPPR',
-    })
+    const { token: address } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'Filtered Approval Token',
+        symbol: 'FAPPR',
+      },
+    )
 
     const receivedApprovals: Array<{
       args: actions.token.watchApprove.Args
@@ -2154,7 +2285,7 @@ describe('watchApprove', () => {
     }> = []
 
     // Start watching for approval events only to account2
-    const unwatch = actions.token.watchApprove(client, {
+    const unwatch = actions.token.watchApprove(clientWithAccount, {
       token: address,
       args: {
         spender: account2.address,
@@ -2166,21 +2297,21 @@ describe('watchApprove', () => {
 
     try {
       // Approve account2 (should be captured)
-      await actions.token.approveSync(client, {
+      await actions.token.approveSync(clientWithAccount, {
         token: address,
         spender: account2.address,
         amount: parseUnits('100', 6),
       })
 
       // Approve account3 (should NOT be captured)
-      await actions.token.approveSync(client, {
+      await actions.token.approveSync(clientWithAccount, {
         token: address,
         spender: account3.address,
         amount: parseUnits('50', 6),
       })
 
       // Approve account2 again (should be captured)
-      await actions.token.approveSync(client, {
+      await actions.token.approveSync(clientWithAccount, {
         token: address,
         spender: account2.address,
         amount: parseUnits('75', 6),
@@ -2219,34 +2350,37 @@ describe('watchApprove', () => {
 describe('watchBurn', () => {
   test('default', async () => {
     // Create a new token for testing
-    const { token: address } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'Burn Watch Token',
-      symbol: 'BURN',
-    })
+    const { token: address } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'Burn Watch Token',
+        symbol: 'BURN',
+      },
+    )
 
     // Grant issuer role to mint/burn tokens
-    await actions.token.grantRolesSync(client, {
+    await actions.token.grantRolesSync(clientWithAccount, {
       token: address,
       roles: ['issuer'],
-      to: client.account.address,
+      to: clientWithAccount.account.address,
     })
 
     // Grant issuer role to mint/burn tokens
-    await actions.token.grantRolesSync(client, {
+    await actions.token.grantRolesSync(clientWithAccount, {
       token: address,
       roles: ['issuer'],
       to: account2.address,
     })
 
     // Mint tokens to burn later
-    await actions.token.mintSync(client, {
+    await actions.token.mintSync(clientWithAccount, {
       token: address,
-      to: client.account.address,
+      to: clientWithAccount.account.address,
       amount: parseUnits('200', 6),
     })
 
-    await actions.token.mintSync(client, {
+    await actions.token.mintSync(clientWithAccount, {
       token: address,
       to: account2.address,
       amount: parseUnits('100', 6),
@@ -2258,7 +2392,7 @@ describe('watchBurn', () => {
     }> = []
 
     // Start watching for burn events
-    const unwatch = actions.token.watchBurn(client, {
+    const unwatch = actions.token.watchBurn(clientWithAccount, {
       token: address,
       onBurn: (args, log) => {
         receivedBurns.push({ args, log })
@@ -2267,13 +2401,13 @@ describe('watchBurn', () => {
 
     try {
       // Burn first batch
-      await actions.token.burnSync(client, {
+      await actions.token.burnSync(clientWithAccount, {
         token: address,
         amount: parseUnits('50', 6),
       })
 
       // Transfer gas to account2
-      await writeContractSync(client, {
+      await writeContractSync(clientWithAccount, {
         abi: Abis.tip20,
         address: addresses.alphaUsd,
         functionName: 'transfer',
@@ -2281,7 +2415,7 @@ describe('watchBurn', () => {
       })
 
       // Burn second batch from account2
-      await actions.token.burnSync(client, {
+      await actions.token.burnSync(clientWithAccount, {
         account: account2,
         token: address,
         amount: parseUnits('25', 6),
@@ -2310,34 +2444,37 @@ describe('watchBurn', () => {
 
   test('behavior: filter by from address', async () => {
     // Create a new token for testing
-    const { token: address } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'Filtered Burn Token',
-      symbol: 'FBURN',
-    })
+    const { token: address } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'Filtered Burn Token',
+        symbol: 'FBURN',
+      },
+    )
 
     // Grant issuer role
-    await actions.token.grantRolesSync(client, {
+    await actions.token.grantRolesSync(clientWithAccount, {
       token: address,
       roles: ['issuer'],
-      to: client.account.address,
+      to: clientWithAccount.account.address,
     })
 
     // Grant issuer role
-    await actions.token.grantRolesSync(client, {
+    await actions.token.grantRolesSync(clientWithAccount, {
       token: address,
       roles: ['issuer'],
       to: account2.address,
     })
 
     // Mint tokens to multiple accounts
-    await actions.token.mintSync(client, {
+    await actions.token.mintSync(clientWithAccount, {
       token: address,
-      to: client.account.address,
+      to: clientWithAccount.account.address,
       amount: parseUnits('200', 6),
     })
 
-    await actions.token.mintSync(client, {
+    await actions.token.mintSync(clientWithAccount, {
       token: address,
       to: account2.address,
       amount: parseUnits('200', 6),
@@ -2348,11 +2485,11 @@ describe('watchBurn', () => {
       log: actions.token.watchBurn.Log
     }> = []
 
-    // Start watching for burn events only from client.account
-    const unwatch = actions.token.watchBurn(client, {
+    // Start watching for burn events only from clientWithAccount.account
+    const unwatch = actions.token.watchBurn(clientWithAccount, {
       token: address,
       args: {
-        from: client.account.address,
+        from: clientWithAccount.account.address,
       },
       onBurn: (args, log) => {
         receivedBurns.push({ args, log })
@@ -2360,14 +2497,14 @@ describe('watchBurn', () => {
     })
 
     try {
-      // Burn from client.account (should be captured)
-      await actions.token.burnSync(client, {
+      // Burn from clientWithAccount.account (should be captured)
+      await actions.token.burnSync(clientWithAccount, {
         token: address,
         amount: parseUnits('50', 6),
       })
 
       // Transfer gas to account2
-      await writeContractSync(client, {
+      await writeContractSync(clientWithAccount, {
         abi: Abis.tip20,
         address: addresses.alphaUsd,
         functionName: 'transfer',
@@ -2375,21 +2512,21 @@ describe('watchBurn', () => {
       })
 
       // Burn from account2 (should NOT be captured)
-      await actions.token.burnSync(client, {
+      await actions.token.burnSync(clientWithAccount, {
         account: account2,
         token: address,
         amount: parseUnits('25', 6),
       })
 
-      // Burn from client.account again (should be captured)
-      await actions.token.burnSync(client, {
+      // Burn from clientWithAccount.account again (should be captured)
+      await actions.token.burnSync(clientWithAccount, {
         token: address,
         amount: parseUnits('75', 6),
       })
 
       await setTimeout(100)
 
-      // Should only receive 2 events (from client.account)
+      // Should only receive 2 events (from clientWithAccount.account)
       expect(receivedBurns).toHaveLength(2)
 
       expect(receivedBurns.at(0)!.args).toMatchInlineSnapshot(`
@@ -2405,9 +2542,9 @@ describe('watchBurn', () => {
         }
       `)
 
-      // Verify all received burns are from client.account
+      // Verify all received burns are from clientWithAccount.account
       for (const burn of receivedBurns) {
-        expect(burn.args.from).toBe(client.account.address)
+        expect(burn.args.from).toBe(clientWithAccount.account.address)
       }
     } finally {
       if (unwatch) unwatch()
@@ -2418,11 +2555,14 @@ describe('watchBurn', () => {
 describe('watchAdminRole', () => {
   test('default', async () => {
     // Create a new token for testing
-    const { token: address } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'Admin Role Watch Token',
-      symbol: 'ADMIN',
-    })
+    const { token: address } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'Admin Role Watch Token',
+        symbol: 'ADMIN',
+      },
+    )
 
     const receivedAdminUpdates: Array<{
       args: actions.token.watchAdminRole.Args
@@ -2430,7 +2570,7 @@ describe('watchAdminRole', () => {
     }> = []
 
     // Start watching for role admin updates
-    const unwatch = actions.token.watchAdminRole(client, {
+    const unwatch = actions.token.watchAdminRole(clientWithAccount, {
       token: address,
       onRoleAdminUpdated: (args, log) => {
         receivedAdminUpdates.push({ args, log })
@@ -2444,7 +2584,7 @@ describe('watchAdminRole', () => {
         role,
         newAdminRole,
         ...setRoleAdmin1Result
-      } = await actions.token.setRoleAdminSync(client, {
+      } = await actions.token.setRoleAdminSync(clientWithAccount, {
         token: address,
         role: 'issuer',
         adminRole: 'pause',
@@ -2459,7 +2599,7 @@ describe('watchAdminRole', () => {
       expect(newAdminRole).toBeDefined()
 
       // Set role admin for pause role
-      await actions.token.setRoleAdminSync(client, {
+      await actions.token.setRoleAdminSync(clientWithAccount, {
         token: address,
         role: 'pause',
         adminRole: 'unpause',
@@ -2470,10 +2610,10 @@ describe('watchAdminRole', () => {
       expect(receivedAdminUpdates).toHaveLength(2)
 
       expect(receivedAdminUpdates.at(0)!.args.sender).toBe(
-        client.account.address,
+        clientWithAccount.account.address,
       )
       expect(receivedAdminUpdates.at(1)!.args.sender).toBe(
-        client.account.address,
+        clientWithAccount.account.address,
       )
     } finally {
       if (unwatch) unwatch()
@@ -2484,11 +2624,14 @@ describe('watchAdminRole', () => {
 describe('watchRole', () => {
   test('default', async () => {
     // Create a new token for testing
-    const { token: address } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'Role Watch Token',
-      symbol: 'ROLE',
-    })
+    const { token: address } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'Role Watch Token',
+        symbol: 'ROLE',
+      },
+    )
 
     const receivedRoleUpdates: Array<{
       args: actions.token.watchRole.Args
@@ -2496,7 +2639,7 @@ describe('watchRole', () => {
     }> = []
 
     // Start watching for role membership updates
-    const unwatch = actions.token.watchRole(client, {
+    const unwatch = actions.token.watchRole(clientWithAccount, {
       token: address,
       onRoleUpdated: (args, log) => {
         receivedRoleUpdates.push({ args, log })
@@ -2505,21 +2648,21 @@ describe('watchRole', () => {
 
     try {
       // Grant issuer role to account2
-      await actions.token.grantRolesSync(client, {
+      await actions.token.grantRolesSync(clientWithAccount, {
         token: address,
         roles: ['issuer'],
         to: account2.address,
       })
 
       // Grant pause role to account3
-      await actions.token.grantRolesSync(client, {
+      await actions.token.grantRolesSync(clientWithAccount, {
         token: address,
         roles: ['pause'],
         to: account3.address,
       })
 
       // Revoke issuer role from account2
-      await actions.token.revokeRolesSync(client, {
+      await actions.token.revokeRolesSync(clientWithAccount, {
         token: address,
         roles: ['issuer'],
         from: account2.address,
@@ -2550,11 +2693,14 @@ describe('watchRole', () => {
 
   test('behavior: filter by account address', async () => {
     // Create a new token for testing
-    const { token: address } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'Filtered Role Token',
-      symbol: 'FROLE',
-    })
+    const { token: address } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'Filtered Role Token',
+        symbol: 'FROLE',
+      },
+    )
 
     const receivedRoleUpdates: Array<{
       args: actions.token.watchRole.Args
@@ -2562,7 +2708,7 @@ describe('watchRole', () => {
     }> = []
 
     // Start watching for role updates only for account2
-    const unwatch = actions.token.watchRole(client, {
+    const unwatch = actions.token.watchRole(clientWithAccount, {
       token: address,
       args: {
         account: account2.address,
@@ -2574,21 +2720,21 @@ describe('watchRole', () => {
 
     try {
       // Grant issuer role to account2 (should be captured)
-      await actions.token.grantRolesSync(client, {
+      await actions.token.grantRolesSync(clientWithAccount, {
         token: address,
         roles: ['issuer'],
         to: account2.address,
       })
 
       // Grant pause role to account3 (should NOT be captured)
-      await actions.token.grantRolesSync(client, {
+      await actions.token.grantRolesSync(clientWithAccount, {
         token: address,
         roles: ['pause'],
         to: account3.address,
       })
 
       // Revoke issuer role from account2 (should be captured)
-      await actions.token.revokeRolesSync(client, {
+      await actions.token.revokeRolesSync(clientWithAccount, {
         token: address,
         roles: ['issuer'],
         from: account2.address,
@@ -2626,23 +2772,26 @@ describe('watchTransfer', () => {
 
   test('default', async () => {
     // Create a new token for testing
-    const { token: address } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'Transfer Watch Token',
-      symbol: 'XFER',
-    })
+    const { token: address } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'Transfer Watch Token',
+        symbol: 'XFER',
+      },
+    )
 
     // Grant issuer role to mint tokens
-    await actions.token.grantRolesSync(client, {
+    await actions.token.grantRolesSync(clientWithAccount, {
       token: address,
       roles: ['issuer'],
-      to: client.account.address,
+      to: clientWithAccount.account.address,
     })
 
     // Mint tokens to transfer
-    await actions.token.mintSync(client, {
+    await actions.token.mintSync(clientWithAccount, {
       token: address,
-      to: client.account.address,
+      to: clientWithAccount.account.address,
       amount: parseUnits('500', 6),
     })
 
@@ -2652,7 +2801,7 @@ describe('watchTransfer', () => {
     }> = []
 
     // Start watching for transfer events
-    const unwatch = actions.token.watchTransfer(client, {
+    const unwatch = actions.token.watchTransfer(clientWithAccount, {
       token: address,
       onTransfer: (args, log) => {
         receivedTransfers.push({ args, log })
@@ -2661,14 +2810,14 @@ describe('watchTransfer', () => {
 
     try {
       // Transfer to account2
-      await actions.token.transferSync(client, {
+      await actions.token.transferSync(clientWithAccount, {
         token: address,
         to: account2.address,
         amount: parseUnits('100', 6),
       })
 
       // Transfer to account3
-      await actions.token.transferSync(client, {
+      await actions.token.transferSync(clientWithAccount, {
         token: address,
         to: account3.address,
         amount: parseUnits('50', 6),
@@ -2699,23 +2848,26 @@ describe('watchTransfer', () => {
 
   test('behavior: filter by to address', async () => {
     // Create a new token for testing
-    const { token: address } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'Filtered Transfer Token',
-      symbol: 'FXFER',
-    })
+    const { token: address } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'Filtered Transfer Token',
+        symbol: 'FXFER',
+      },
+    )
 
     // Grant issuer role
-    await actions.token.grantRolesSync(client, {
+    await actions.token.grantRolesSync(clientWithAccount, {
       token: address,
       roles: ['issuer'],
-      to: client.account.address,
+      to: clientWithAccount.account.address,
     })
 
     // Mint tokens
-    await actions.token.mintSync(client, {
+    await actions.token.mintSync(clientWithAccount, {
       token: address,
-      to: client.account.address,
+      to: clientWithAccount.account.address,
       amount: parseUnits('500', 6),
     })
 
@@ -2725,7 +2877,7 @@ describe('watchTransfer', () => {
     }> = []
 
     // Start watching for transfer events only to account2
-    const unwatch = actions.token.watchTransfer(client, {
+    const unwatch = actions.token.watchTransfer(clientWithAccount, {
       token: address,
       args: {
         to: account2.address,
@@ -2737,21 +2889,21 @@ describe('watchTransfer', () => {
 
     try {
       // Transfer to account2 (should be captured)
-      await actions.token.transferSync(client, {
+      await actions.token.transferSync(clientWithAccount, {
         token: address,
         to: account2.address,
         amount: parseUnits('100', 6),
       })
 
       // Transfer to account3 (should NOT be captured)
-      await actions.token.transferSync(client, {
+      await actions.token.transferSync(clientWithAccount, {
         token: address,
         to: account3.address,
         amount: parseUnits('50', 6),
       })
 
       // Transfer to account2 again (should be captured)
-      await actions.token.transferSync(client, {
+      await actions.token.transferSync(clientWithAccount, {
         token: address,
         to: account2.address,
         amount: parseUnits('75', 6),
@@ -2791,7 +2943,7 @@ describe('watchUpdateQuoteToken', () => {
   test('default', async () => {
     // Create quote token
     const { token: quoteTokenAddress } = await actions.token.createSync(
-      client,
+      clientWithAccount,
       {
         currency: 'USD',
         name: 'Watch Quote Token',
@@ -2800,11 +2952,14 @@ describe('watchUpdateQuoteToken', () => {
     )
 
     // Create main token
-    const { token: address } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'Watch Main Token',
-      symbol: 'WMAIN',
-    })
+    const { token: address } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'Watch Main Token',
+        symbol: 'WMAIN',
+      },
+    )
 
     const receivedUpdates: Array<{
       args: actions.token.watchUpdateQuoteToken.Args
@@ -2812,7 +2967,7 @@ describe('watchUpdateQuoteToken', () => {
     }> = []
 
     // Start watching for quote token update events
-    const unwatch = actions.token.watchUpdateQuoteToken(client, {
+    const unwatch = actions.token.watchUpdateQuoteToken(clientWithAccount, {
       token: address,
       onUpdateQuoteToken: (args, log) => {
         receivedUpdates.push({ args, log })
@@ -2821,13 +2976,13 @@ describe('watchUpdateQuoteToken', () => {
 
     try {
       // Step 1: Prepare update quote token (should emit NextQuoteTokenSet)
-      await actions.token.prepareUpdateQuoteTokenSync(client, {
+      await actions.token.prepareUpdateQuoteTokenSync(clientWithAccount, {
         token: address,
         quoteToken: quoteTokenAddress,
       })
 
       // Step 2: Finalize the update (should emit QuoteTokenUpdateFinalized)
-      await actions.token.updateQuoteTokenSync(client, {
+      await actions.token.updateQuoteTokenSync(clientWithAccount, {
         token: address,
       })
 
@@ -2839,12 +2994,16 @@ describe('watchUpdateQuoteToken', () => {
       // First event: update proposed (not finalized)
       expect(receivedUpdates.at(0)!.args.completed).toBe(false)
       expect(receivedUpdates.at(0)!.args.nextQuoteToken).toBe(quoteTokenAddress)
-      expect(receivedUpdates.at(0)!.args.updater).toBe(client.account.address)
+      expect(receivedUpdates.at(0)!.args.updater).toBe(
+        clientWithAccount.account.address,
+      )
 
       // Second event: update finalized
       expect(receivedUpdates.at(1)!.args.completed).toBe(true)
       expect(receivedUpdates.at(1)!.args.newQuoteToken).toBe(quoteTokenAddress)
-      expect(receivedUpdates.at(1)!.args.updater).toBe(client.account.address)
+      expect(receivedUpdates.at(1)!.args.updater).toBe(
+        clientWithAccount.account.address,
+      )
     } finally {
       if (unwatch) unwatch()
     }
@@ -2853,7 +3012,7 @@ describe('watchUpdateQuoteToken', () => {
   test('behavior: only proposed updates', async () => {
     // Create quote token
     const { token: quoteTokenAddress } = await actions.token.createSync(
-      client,
+      clientWithAccount,
       {
         currency: 'USD',
         name: 'Proposed Quote Token',
@@ -2862,11 +3021,14 @@ describe('watchUpdateQuoteToken', () => {
     )
 
     // Create main token
-    const { token: address } = await actions.token.createSync(client, {
-      currency: 'USD',
-      name: 'Proposed Main Token',
-      symbol: 'PMAIN',
-    })
+    const { token: address } = await actions.token.createSync(
+      clientWithAccount,
+      {
+        currency: 'USD',
+        name: 'Proposed Main Token',
+        symbol: 'PMAIN',
+      },
+    )
 
     const receivedUpdates: Array<{
       args: actions.token.watchUpdateQuoteToken.Args
@@ -2874,7 +3036,7 @@ describe('watchUpdateQuoteToken', () => {
     }> = []
 
     // Start watching
-    const unwatch = actions.token.watchUpdateQuoteToken(client, {
+    const unwatch = actions.token.watchUpdateQuoteToken(clientWithAccount, {
       token: address,
       onUpdateQuoteToken: (args, log) => {
         receivedUpdates.push({ args, log })
@@ -2883,7 +3045,7 @@ describe('watchUpdateQuoteToken', () => {
 
     try {
       // Only update (don't finalize)
-      await actions.token.prepareUpdateQuoteTokenSync(client, {
+      await actions.token.prepareUpdateQuoteTokenSync(clientWithAccount, {
         token: address,
         quoteToken: quoteTokenAddress,
       })