tempo.ts 0.4.4 → 0.5.0

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

@@ -4,17 +4,17 @@ import { parseUnits } from 'viem'
 import { beforeAll, describe, expect, test } from 'vitest'
 import {
   accounts,
-  client,
+  clientWithAccount,
   setupOrders,
   setupTokenPair,
 } from '../../../test/viem/config.js'
 
 describe('buy', () => {
   test('default', async () => {
-    const { base, quote } = await setupTokenPair(client)
+    const { base, quote } = await setupTokenPair(clientWithAccount)
 
     // Place ask order to create liquidity
-    await Actions.dex.placeSync(client, {
+    await Actions.dex.placeSync(clientWithAccount, {
       token: base,
       amount: parseUnits('500', 6),
       type: 'sell',
@@ -22,12 +22,15 @@ describe('buy', () => {
     })
 
     // Get initial balances
-    const baseBalanceBefore = await Actions.token.getBalance(client, {
-      token: base,
-    })
+    const baseBalanceBefore = await Actions.token.getBalance(
+      clientWithAccount,
+      {
+        token: base,
+      },
+    )
 
     // Buy base tokens with quote tokens
-    const { receipt } = await Actions.dex.buySync(client, {
+    const { receipt } = await Actions.dex.buySync(clientWithAccount, {
       tokenIn: quote,
       tokenOut: base,
       amountOut: parseUnits('100', 6),
@@ -38,7 +41,7 @@ describe('buy', () => {
     expect(receipt.status).toBe('success')
 
     // Verify balances changed
-    const baseBalanceAfter = await Actions.token.getBalance(client, {
+    const baseBalanceAfter = await Actions.token.getBalance(clientWithAccount, {
       token: base,
     })
 
@@ -47,10 +50,10 @@ describe('buy', () => {
   })
 
   test('behavior: respects maxAmountIn', async () => {
-    const { base, quote } = await setupTokenPair(client)
+    const { base, quote } = await setupTokenPair(clientWithAccount)
 
     // Place ask order at high price
-    await Actions.dex.placeSync(client, {
+    await Actions.dex.placeSync(clientWithAccount, {
       token: base,
       amount: parseUnits('500', 6),
       type: 'sell',
@@ -59,7 +62,7 @@ describe('buy', () => {
 
     // Try to buy with insufficient maxAmountIn - should fail
     await expect(
-      Actions.dex.buySync(client, {
+      Actions.dex.buySync(clientWithAccount, {
         tokenIn: quote,
         tokenOut: base,
         amountOut: parseUnits('100', 6),
@@ -69,13 +72,13 @@ describe('buy', () => {
   })
 
   test('behavior: fails with insufficient liquidity', async () => {
-    const { base, quote } = await setupTokenPair(client)
+    const { base, quote } = await setupTokenPair(clientWithAccount)
 
     // Don't place any orders - no liquidity
 
     // Try to buy - should fail due to no liquidity
     await expect(
-      Actions.dex.buySync(client, {
+      Actions.dex.buySync(clientWithAccount, {
         tokenIn: quote,
         tokenOut: base,
         amountOut: parseUnits('100', 6),
@@ -87,10 +90,10 @@ describe('buy', () => {
 
 describe('cancel', () => {
   test('default', async () => {
-    const { base, quote } = await setupTokenPair(client)
+    const { base, quote } = await setupTokenPair(clientWithAccount)
 
     // Place a bid order
-    const { orderId } = await Actions.dex.placeSync(client, {
+    const { orderId } = await Actions.dex.placeSync(clientWithAccount, {
       token: base,
       amount: parseUnits('100', 6),
       type: 'buy',
@@ -98,15 +101,15 @@ describe('cancel', () => {
     })
 
     // Check initial DEX balance (should be 0)
-    const dexBalanceBefore = await Actions.dex.getBalance(client, {
-      account: client.account.address,
+    const dexBalanceBefore = await Actions.dex.getBalance(clientWithAccount, {
+      account: clientWithAccount.account.address,
       token: quote,
     })
     expect(dexBalanceBefore).toBe(0n)
 
     // Cancel the order
     const { receipt, orderId: returnedOrderId } = await Actions.dex.cancelSync(
-      client,
+      clientWithAccount,
       {
         orderId,
       },
@@ -117,18 +120,18 @@ describe('cancel', () => {
     expect(returnedOrderId).toBe(orderId)
 
     // Check DEX balance after cancel - tokens should be refunded to internal balance
-    const dexBalanceAfter = await Actions.dex.getBalance(client, {
-      account: client.account.address,
+    const dexBalanceAfter = await Actions.dex.getBalance(clientWithAccount, {
+      account: clientWithAccount.account.address,
       token: quote,
     })
     expect(dexBalanceAfter).toBeGreaterThan(0n)
   })
 
   test('behavior: only maker can cancel', async () => {
-    const { base } = await setupTokenPair(client)
+    const { base } = await setupTokenPair(clientWithAccount)
 
     // Account places order
-    const { orderId } = await Actions.dex.placeSync(client, {
+    const { orderId } = await Actions.dex.placeSync(clientWithAccount, {
       token: base,
       amount: parseUnits('100', 6),
       type: 'buy',
@@ -139,7 +142,7 @@ describe('cancel', () => {
     const account2 = accounts[1]
 
     // Transfer gas to account2
-    await Actions.token.transferSync(client, {
+    await Actions.token.transferSync(clientWithAccount, {
       to: account2.address,
       amount: parseUnits('1', 6),
       token: 1n,
@@ -147,7 +150,7 @@ describe('cancel', () => {
 
     // Account2 tries to cancel - should fail
     await expect(
-      Actions.dex.cancelSync(client, {
+      Actions.dex.cancelSync(clientWithAccount, {
         account: account2,
         orderId,
       }),
@@ -155,11 +158,11 @@ describe('cancel', () => {
   })
 
   test('behavior: cannot cancel non-existent order', async () => {
-    await setupTokenPair(client)
+    await setupTokenPair(clientWithAccount)
 
     // Try to cancel an order that doesn't exist
     await expect(
-      Actions.dex.cancelSync(client, {
+      Actions.dex.cancelSync(clientWithAccount, {
         orderId: 999n,
       }),
     ).rejects.toThrow('The contract function "cancel" reverted')
@@ -168,14 +171,17 @@ describe('cancel', () => {
 
 describe('createPair', () => {
   test('default', async () => {
-    const { token: baseToken } = await Actions.token.createSync(client, {
-      name: 'Test Base Token',
-      symbol: 'BASE',
-      currency: 'USD',
-    })
+    const { token: baseToken } = await Actions.token.createSync(
+      clientWithAccount,
+      {
+        name: 'Test Base Token',
+        symbol: 'BASE',
+        currency: 'USD',
+      },
+    )
 
     const { receipt, key, base, quote } = await Actions.dex.createPairSync(
-      client,
+      clientWithAccount,
       {
         base: baseToken,
       },
@@ -191,42 +197,42 @@ describe('createPair', () => {
 
 describe('getBalance', () => {
   test('default', async () => {
-    const { base, quote } = await setupTokenPair(client)
+    const { base, quote } = await setupTokenPair(clientWithAccount)
 
     // Initial balance should be 0
-    const initialBalance = await Actions.dex.getBalance(client, {
-      account: client.account.address,
+    const initialBalance = await Actions.dex.getBalance(clientWithAccount, {
+      account: clientWithAccount.account.address,
       token: quote,
     })
     expect(initialBalance).toBe(0n)
 
     // Place and cancel order to create internal balance
-    const { orderId } = await Actions.dex.placeSync(client, {
+    const { orderId } = await Actions.dex.placeSync(clientWithAccount, {
       token: base,
       amount: parseUnits('50', 6),
       type: 'buy',
       tick: Tick.fromPrice('1.0005'),
     })
 
-    await Actions.dex.cancelSync(client, {
+    await Actions.dex.cancelSync(clientWithAccount, {
       orderId,
     })
 
     // Now balance should be > 0 (refunded quote tokens)
-    const balance = await Actions.dex.getBalance(client, {
-      account: client.account.address,
+    const balance = await Actions.dex.getBalance(clientWithAccount, {
+      account: clientWithAccount.account.address,
       token: quote,
     })
     expect(balance).toBeGreaterThan(0n)
   })
 
   test('behavior: check different account', async () => {
-    const { quote } = await setupTokenPair(client)
+    const { quote } = await setupTokenPair(clientWithAccount)
 
     const account2 = accounts[1]
 
     // Check account2's balance (should be 0)
-    const balance = await Actions.dex.getBalance(client, {
+    const balance = await Actions.dex.getBalance(clientWithAccount, {
       account: account2.address,
       token: quote,
     })
@@ -234,27 +240,27 @@ describe('getBalance', () => {
   })
 
   test('behavior: balances are per-token', async () => {
-    const { base, quote } = await setupTokenPair(client)
+    const { base, quote } = await setupTokenPair(clientWithAccount)
 
     // Create balance in quote token
-    const { orderId } = await Actions.dex.placeSync(client, {
+    const { orderId } = await Actions.dex.placeSync(clientWithAccount, {
       token: base,
       amount: parseUnits('100', 6),
       type: 'buy',
       tick: Tick.fromPrice('1.001'),
     })
-    await Actions.dex.cancelSync(client, { orderId })
+    await Actions.dex.cancelSync(clientWithAccount, { orderId })
 
     // Check quote balance (should have refunded tokens)
-    const quoteBalance = await Actions.dex.getBalance(client, {
-      account: client.account.address,
+    const quoteBalance = await Actions.dex.getBalance(clientWithAccount, {
+      account: clientWithAccount.account.address,
       token: quote,
     })
     expect(quoteBalance).toBeGreaterThan(0n)
 
     // Check base balance (should still be 0)
-    const baseBalance = await Actions.dex.getBalance(client, {
-      account: client.account.address,
+    const baseBalance = await Actions.dex.getBalance(clientWithAccount, {
+      account: clientWithAccount.account.address,
       token: base,
     })
     expect(baseBalance).toBe(0n)
@@ -263,10 +269,10 @@ describe('getBalance', () => {
 
 describe('getBuyQuote', () => {
   test('default', async () => {
-    const { base, quote } = await setupTokenPair(client)
+    const { base, quote } = await setupTokenPair(clientWithAccount)
 
     // Place ask orders to create liquidity
-    await Actions.dex.placeSync(client, {
+    await Actions.dex.placeSync(clientWithAccount, {
       token: base,
       amount: parseUnits('500', 6),
       type: 'sell',
@@ -274,7 +280,7 @@ describe('getBuyQuote', () => {
     })
 
     // Get quote for buying base tokens
-    const amountIn = await Actions.dex.getBuyQuote(client, {
+    const amountIn = await Actions.dex.getBuyQuote(clientWithAccount, {
       tokenIn: quote,
       tokenOut: base,
       amountOut: parseUnits('100', 6),
@@ -286,13 +292,13 @@ describe('getBuyQuote', () => {
   })
 
   test('behavior: fails with no liquidity', async () => {
-    const { base, quote } = await setupTokenPair(client)
+    const { base, quote } = await setupTokenPair(clientWithAccount)
 
     // No orders placed - no liquidity
 
     // Quote should fail
     await expect(
-      Actions.dex.getBuyQuote(client, {
+      Actions.dex.getBuyQuote(clientWithAccount, {
         tokenIn: quote,
         tokenOut: base,
         amountOut: parseUnits('100', 6),
@@ -305,10 +311,10 @@ describe('getBuyQuote', () => {
 
 describe('getOrder', () => {
   test('default', async () => {
-    const { base } = await setupTokenPair(client)
+    const { base } = await setupTokenPair(clientWithAccount)
 
     // Place an order to get an order ID
-    const { orderId } = await Actions.dex.placeSync(client, {
+    const { orderId } = await Actions.dex.placeSync(clientWithAccount, {
       token: base,
       amount: parseUnits('100', 6),
       type: 'buy',
@@ -316,12 +322,12 @@ describe('getOrder', () => {
     })
 
     // Get the order details
-    const order = await Actions.dex.getOrder(client, {
+    const order = await Actions.dex.getOrder(clientWithAccount, {
       orderId,
     })
 
     expect(order).toBeDefined()
-    expect(order.maker).toBe(client.account.address)
+    expect(order.maker).toBe(clientWithAccount.account.address)
     expect(order.isBid).toBe(true)
     expect(order.tick).toBe(Tick.fromPrice('1.001'))
     expect(order.amount).toBe(parseUnits('100', 6))
@@ -330,10 +336,10 @@ describe('getOrder', () => {
   })
 
   test('behavior: returns flip order details', async () => {
-    const { base } = await setupTokenPair(client)
+    const { base } = await setupTokenPair(clientWithAccount)
 
     // Place a flip order
-    const { orderId } = await Actions.dex.placeFlipSync(client, {
+    const { orderId } = await Actions.dex.placeFlipSync(clientWithAccount, {
       token: base,
       amount: parseUnits('50', 6),
       type: 'buy',
@@ -342,12 +348,12 @@ describe('getOrder', () => {
     })
 
     // Get the order details
-    const order = await Actions.dex.getOrder(client, {
+    const order = await Actions.dex.getOrder(clientWithAccount, {
       orderId,
     })
 
     expect(order).toBeDefined()
-    expect(order.maker).toBe(client.account.address)
+    expect(order.maker).toBe(clientWithAccount.account.address)
     expect(order.isBid).toBe(true)
     expect(order.tick).toBe(Tick.fromPrice('1.001'))
     expect(order.amount).toBe(parseUnits('50', 6))
@@ -356,21 +362,21 @@ describe('getOrder', () => {
   })
 
   test('behavior: fails for non-existent order', async () => {
-    await setupTokenPair(client)
+    await setupTokenPair(clientWithAccount)
 
     // Try to get an order that doesn't exist
     await expect(
-      Actions.dex.getOrder(client, {
+      Actions.dex.getOrder(clientWithAccount, {
         orderId: 999n,
       }),
     ).rejects.toThrow('The contract function "getOrder" reverted')
   })
 
   test('behavior: reflects order state after partial fill', async () => {
-    const { base, quote } = await setupTokenPair(client)
+    const { base, quote } = await setupTokenPair(clientWithAccount)
 
     // Place a large sell order
-    const { orderId } = await Actions.dex.placeSync(client, {
+    const { orderId } = await Actions.dex.placeSync(clientWithAccount, {
       token: base,
       amount: parseUnits('500', 6),
       type: 'sell',
@@ -378,14 +384,14 @@ describe('getOrder', () => {
     })
 
     // Get initial order state
-    const orderBefore = await Actions.dex.getOrder(client, {
+    const orderBefore = await Actions.dex.getOrder(clientWithAccount, {
       orderId,
     })
     expect(orderBefore.amount).toBe(parseUnits('500', 6))
     expect(orderBefore.remaining).toBe(parseUnits('500', 6))
 
     // Partially fill the order with a buy
-    await Actions.dex.buySync(client, {
+    await Actions.dex.buySync(clientWithAccount, {
       tokenIn: quote,
       tokenOut: base,
       amountOut: parseUnits('100', 6),
@@ -393,7 +399,7 @@ describe('getOrder', () => {
     })
 
     // Get order state after partial fill
-    const orderAfter = await Actions.dex.getOrder(client, {
+    const orderAfter = await Actions.dex.getOrder(clientWithAccount, {
       orderId,
     })
     expect(orderAfter.amount).toBe(parseUnits('500', 6)) // amount unchanged
@@ -401,35 +407,41 @@ describe('getOrder', () => {
   })
 
   test('behavior: linked list pointers for multiple orders at same tick', async () => {
-    const { base } = await setupTokenPair(client)
+    const { base } = await setupTokenPair(clientWithAccount)
 
     const tick = Tick.fromPrice('1.001')
 
     // Place first order
-    const { orderId: orderId1 } = await Actions.dex.placeSync(client, {
-      token: base,
-      amount: parseUnits('100', 6),
-      type: 'buy',
-      tick,
-    })
+    const { orderId: orderId1 } = await Actions.dex.placeSync(
+      clientWithAccount,
+      {
+        token: base,
+        amount: parseUnits('100', 6),
+        type: 'buy',
+        tick,
+      },
+    )
 
     // Place second order at same tick
-    const { orderId: orderId2 } = await Actions.dex.placeSync(client, {
-      token: base,
-      amount: parseUnits('50', 6),
-      type: 'buy',
-      tick,
-    })
+    const { orderId: orderId2 } = await Actions.dex.placeSync(
+      clientWithAccount,
+      {
+        token: base,
+        amount: parseUnits('50', 6),
+        type: 'buy',
+        tick,
+      },
+    )
 
     // Get first order
-    const order1 = await Actions.dex.getOrder(client, {
+    const order1 = await Actions.dex.getOrder(clientWithAccount, {
       orderId: orderId1,
     })
     expect(order1.prev).toBe(0n) // should be 0 as it's first
     expect(order1.next).toBe(orderId2) // should point to second order
 
     // Get second order
-    const order2 = await Actions.dex.getOrder(client, {
+    const order2 = await Actions.dex.getOrder(clientWithAccount, {
       orderId: orderId2,
     })
     expect(order2.prev).toBe(orderId1) // should point to first order
@@ -440,19 +452,19 @@ describe('getOrder', () => {
 describe('getOrders', () => {
   let bases: Address.Address[] = []
   beforeAll(async () => {
-    ;({ bases } = await setupOrders(client))
+    ;({ bases } = await setupOrders(clientWithAccount))
   })
 
   test('default', async () => {
     // Get orders with default pagination
-    const response = await Actions.dex.getOrders(client, {
+    const response = await Actions.dex.getOrders(clientWithAccount, {
       limit: 10,
     })
 
     expect(response).matchSnapshot()
 
     // Get orders with cursor
-    const response2 = await Actions.dex.getOrders(client, {
+    const response2 = await Actions.dex.getOrders(clientWithAccount, {
       cursor: response.nextCursor!,
       limit: 10,
     })
@@ -462,7 +474,7 @@ describe('getOrders', () => {
 
   test.skip('behavior: filter by baseToken', async () => {
     // Get orders filtered by base1
-    const response = await Actions.dex.getOrders(client, {
+    const response = await Actions.dex.getOrders(clientWithAccount, {
       filters: {
         baseToken: bases[0],
       },
@@ -480,7 +492,7 @@ describe('getOrders', () => {
 
   test('behavior: filter by isBid', async () => {
     // Get only buy orders
-    const buyOrders = await Actions.dex.getOrders(client, {
+    const buyOrders = await Actions.dex.getOrders(clientWithAccount, {
       filters: {
         isBid: true,
       },
@@ -494,7 +506,7 @@ describe('getOrders', () => {
     expect(buyOrders).matchSnapshot()
 
     // Get only sell orders
-    const sellOrders = await Actions.dex.getOrders(client, {
+    const sellOrders = await Actions.dex.getOrders(clientWithAccount, {
       filters: {
         isBid: false,
       },
@@ -510,9 +522,9 @@ describe('getOrders', () => {
 
   test('behavior: filter by maker', async () => {
     // Filter by account's address
-    const response = await Actions.dex.getOrders(client, {
+    const response = await Actions.dex.getOrders(clientWithAccount, {
       filters: {
-        maker: client.account.address,
+        maker: clientWithAccount.account.address,
       },
       limit: 5,
     })
@@ -521,7 +533,7 @@ describe('getOrders', () => {
     expect(response.orders.length).toBeGreaterThan(0)
     expect(
       response.orders.every((order) =>
-        Address.isEqual(order.maker, client.account.address),
+        Address.isEqual(order.maker, clientWithAccount.account.address),
       ),
     ).toBe(true)
 
@@ -530,7 +542,7 @@ describe('getOrders', () => {
 
   test('behavior: filter by isFlip', async () => {
     // Get only non-flip orders (setupOrders creates non-flip orders)
-    const response = await Actions.dex.getOrders(client, {
+    const response = await Actions.dex.getOrders(clientWithAccount, {
       filters: {
         isFlip: false,
       },
@@ -546,7 +558,7 @@ describe('getOrders', () => {
 
   test('behavior: filter by remaining range', async () => {
     // Get orders with remaining between 100 and 300
-    const response = await Actions.dex.getOrders(client, {
+    const response = await Actions.dex.getOrders(clientWithAccount, {
       filters: {
         remaining: {
           min: parseUnits('100', 6),
@@ -571,7 +583,7 @@ describe('getOrders', () => {
 
   test('behavior: filter by tick range', async () => {
     // Get orders with tick between -100 and 100
-    const response = await Actions.dex.getOrders(client, {
+    const response = await Actions.dex.getOrders(clientWithAccount, {
       filters: {
         tick: {
           min: -100,
@@ -592,7 +604,7 @@ describe('getOrders', () => {
 
   test('behavior: multiple filters combined', async () => {
     // Filter by multiple conditions
-    const response = await Actions.dex.getOrders(client, {
+    const response = await Actions.dex.getOrders(clientWithAccount, {
       filters: {
         baseToken: bases[0],
         isBid: true,
@@ -612,10 +624,10 @@ describe('getOrders', () => {
   })
 
   test('behavior: empty result', async () => {
-    await setupTokenPair(client)
+    await setupTokenPair(clientWithAccount)
 
     // Get orders with filter that matches nothing
-    const response = await Actions.dex.getOrders(client, {
+    const response = await Actions.dex.getOrders(clientWithAccount, {
       filters: {
         maker: '0x0000000000000000000000000000000000000001',
       },
@@ -631,10 +643,10 @@ describe('getOrders', () => {
 
 describe('getOrderbook', () => {
   test('default', async () => {
-    const { base, quote } = await setupTokenPair(client)
+    const { base, quote } = await setupTokenPair(clientWithAccount)
 
     // Get orderbook information
-    const book = await Actions.dex.getOrderbook(client, {
+    const book = await Actions.dex.getOrderbook(clientWithAccount, {
       base,
       quote,
     })
@@ -647,13 +659,13 @@ describe('getOrderbook', () => {
   })
 
   test('behavior: shows best bid and ask after orders placed', async () => {
-    const { base, quote } = await setupTokenPair(client)
+    const { base, quote } = await setupTokenPair(clientWithAccount)
 
     const bidTick = Tick.fromPrice('0.999')
     const askTick = Tick.fromPrice('1.001')
 
     // Place a bid order
-    await Actions.dex.placeSync(client, {
+    await Actions.dex.placeSync(clientWithAccount, {
       token: base,
       amount: parseUnits('100', 6),
       type: 'buy',
@@ -661,7 +673,7 @@ describe('getOrderbook', () => {
     })
 
     // Place an ask order
-    await Actions.dex.placeSync(client, {
+    await Actions.dex.placeSync(clientWithAccount, {
       token: base,
       amount: parseUnits('100', 6),
       type: 'sell',
@@ -669,7 +681,7 @@ describe('getOrderbook', () => {
     })
 
     // Get orderbook
-    const book = await Actions.dex.getOrderbook(client, {
+    const book = await Actions.dex.getOrderbook(clientWithAccount, {
       base,
       quote,
     })
@@ -679,10 +691,10 @@ describe('getOrderbook', () => {
   })
 
   test('behavior: best ticks update after better orders placed', async () => {
-    const { base, quote } = await setupTokenPair(client)
+    const { base, quote } = await setupTokenPair(clientWithAccount)
 
     // Place initial bid at 0.999
-    await Actions.dex.placeSync(client, {
+    await Actions.dex.placeSync(clientWithAccount, {
       token: base,
       amount: parseUnits('100', 6),
       type: 'buy',
@@ -690,14 +702,14 @@ describe('getOrderbook', () => {
     })
 
     // Get orderbook
-    const bookBefore = await Actions.dex.getOrderbook(client, {
+    const bookBefore = await Actions.dex.getOrderbook(clientWithAccount, {
       base,
       quote,
     })
     expect(bookBefore.bestBidTick).toBe(Tick.fromPrice('0.999'))
 
     // Place better bid at 1.0
-    await Actions.dex.placeSync(client, {
+    await Actions.dex.placeSync(clientWithAccount, {
       token: base,
       amount: parseUnits('100', 6),
       type: 'buy',
@@ -705,7 +717,7 @@ describe('getOrderbook', () => {
     })
 
     // Get orderbook again
-    const bookAfter = await Actions.dex.getOrderbook(client, {
+    const bookAfter = await Actions.dex.getOrderbook(clientWithAccount, {
       base,
       quote,
     })
@@ -713,17 +725,17 @@ describe('getOrderbook', () => {
   })
 
   test.skip('behavior: best ticks update after order cancellation', async () => {
-    const { base, quote } = await setupTokenPair(client)
+    const { base, quote } = await setupTokenPair(clientWithAccount)
 
     // Place two bid orders at different ticks
-    await Actions.dex.placeSync(client, {
+    await Actions.dex.placeSync(clientWithAccount, {
       token: base,
       amount: parseUnits('50', 6),
       type: 'buy',
       tick: Tick.fromPrice('0.999'),
     })
 
-    const { orderId } = await Actions.dex.placeSync(client, {
+    const { orderId } = await Actions.dex.placeSync(clientWithAccount, {
       token: base,
       amount: parseUnits('100', 6),
       type: 'buy',
@@ -731,17 +743,17 @@ describe('getOrderbook', () => {
     })
 
     // Get orderbook - best bid should be 1.0
-    const bookBefore = await Actions.dex.getOrderbook(client, {
+    const bookBefore = await Actions.dex.getOrderbook(clientWithAccount, {
       base,
       quote,
     })
     expect(bookBefore.bestBidTick).toBe(Tick.fromPrice('1.0'))
 
     // Cancel the better order
-    await Actions.dex.cancelSync(client, { orderId })
+    await Actions.dex.cancelSync(clientWithAccount, { orderId })
 
     // Get orderbook again - best bid should fall back to 0.999
-    const bookAfter = await Actions.dex.getOrderbook(client, {
+    const bookAfter = await Actions.dex.getOrderbook(clientWithAccount, {
       base,
       quote,
     })
@@ -749,11 +761,13 @@ describe('getOrderbook', () => {
   })
 
   test('behavior: multiple pairs have independent orderbooks', async () => {
-    const { base: base1, quote: quote1 } = await setupTokenPair(client)
-    const { base: base2, quote: quote2 } = await setupTokenPair(client)
+    const { base: base1, quote: quote1 } =
+      await setupTokenPair(clientWithAccount)
+    const { base: base2, quote: quote2 } =
+      await setupTokenPair(clientWithAccount)
 
     // Place order on first pair
-    await Actions.dex.placeSync(client, {
+    await Actions.dex.placeSync(clientWithAccount, {
       token: base1,
       amount: parseUnits('100', 6),
       type: 'buy',
@@ -761,7 +775,7 @@ describe('getOrderbook', () => {
     })
 
     // Place order on second pair at different tick
-    await Actions.dex.placeSync(client, {
+    await Actions.dex.placeSync(clientWithAccount, {
       token: base2,
       amount: parseUnits('100', 6),
       type: 'buy',
@@ -769,12 +783,12 @@ describe('getOrderbook', () => {
     })
 
     // Get orderbooks
-    const book1 = await Actions.dex.getOrderbook(client, {
+    const book1 = await Actions.dex.getOrderbook(clientWithAccount, {
       base: base1,
       quote: quote1,
     })
 
-    const book2 = await Actions.dex.getOrderbook(client, {
+    const book2 = await Actions.dex.getOrderbook(clientWithAccount, {
       base: base2,
       quote: quote2,
     })
@@ -787,12 +801,12 @@ describe('getOrderbook', () => {
 
 describe('getTickLevel', () => {
   test('default', async () => {
-    const { base } = await setupTokenPair(client)
+    const { base } = await setupTokenPair(clientWithAccount)
 
     const tick = Tick.fromPrice('1.001')
 
     // Place an order to create liquidity at this tick
-    const { orderId } = await Actions.dex.placeSync(client, {
+    const { orderId } = await Actions.dex.placeSync(clientWithAccount, {
       token: base,
       amount: parseUnits('100', 6),
       type: 'buy',
@@ -800,7 +814,7 @@ describe('getTickLevel', () => {
     })
 
     // Get the price level
-    const level = await Actions.dex.getTickLevel(client, {
+    const level = await Actions.dex.getTickLevel(clientWithAccount, {
       base,
       tick,
       isBid: true,
@@ -813,12 +827,12 @@ describe('getTickLevel', () => {
   })
 
   test('behavior: empty price level', async () => {
-    const { base } = await setupTokenPair(client)
+    const { base } = await setupTokenPair(clientWithAccount)
 
     const tick = Tick.fromPrice('1.001')
 
     // Query a tick with no orders
-    const level = await Actions.dex.getTickLevel(client, {
+    const level = await Actions.dex.getTickLevel(clientWithAccount, {
       base,
       tick,
       isBid: true,
@@ -831,28 +845,34 @@ describe('getTickLevel', () => {
   })
 
   test('behavior: multiple orders at same tick', async () => {
-    const { base } = await setupTokenPair(client)
+    const { base } = await setupTokenPair(clientWithAccount)
 
     const tick = Tick.fromPrice('1.001')
 
     // Place first order
-    const { orderId: orderId1 } = await Actions.dex.placeSync(client, {
-      token: base,
-      amount: parseUnits('100', 6),
-      type: 'buy',
-      tick,
-    })
+    const { orderId: orderId1 } = await Actions.dex.placeSync(
+      clientWithAccount,
+      {
+        token: base,
+        amount: parseUnits('100', 6),
+        type: 'buy',
+        tick,
+      },
+    )
 
     // Place second order at same tick
-    const { orderId: orderId2 } = await Actions.dex.placeSync(client, {
-      token: base,
-      amount: parseUnits('50', 6),
-      type: 'buy',
-      tick,
-    })
+    const { orderId: orderId2 } = await Actions.dex.placeSync(
+      clientWithAccount,
+      {
+        token: base,
+        amount: parseUnits('50', 6),
+        type: 'buy',
+        tick,
+      },
+    )
 
     // Get the price level
-    const level = await Actions.dex.getTickLevel(client, {
+    const level = await Actions.dex.getTickLevel(clientWithAccount, {
       base,
       tick,
       isBid: true,
@@ -865,12 +885,12 @@ describe('getTickLevel', () => {
   })
 
   test('behavior: bid vs ask sides', async () => {
-    const { base } = await setupTokenPair(client)
+    const { base } = await setupTokenPair(clientWithAccount)
 
     const tick = Tick.fromPrice('1.001')
 
     // Place a buy order (bid)
-    await Actions.dex.placeSync(client, {
+    await Actions.dex.placeSync(clientWithAccount, {
       token: base,
       amount: parseUnits('100', 6),
       type: 'buy',
@@ -878,7 +898,7 @@ describe('getTickLevel', () => {
     })
 
     // Place a sell order (ask) at same tick
-    await Actions.dex.placeSync(client, {
+    await Actions.dex.placeSync(clientWithAccount, {
       token: base,
       amount: parseUnits('50', 6),
       type: 'sell',
@@ -886,14 +906,14 @@ describe('getTickLevel', () => {
     })
 
     // Get bid side
-    const bidLevel = await Actions.dex.getTickLevel(client, {
+    const bidLevel = await Actions.dex.getTickLevel(clientWithAccount, {
       base,
       tick,
       isBid: true,
     })
 
     // Get ask side
-    const askLevel = await Actions.dex.getTickLevel(client, {
+    const askLevel = await Actions.dex.getTickLevel(clientWithAccount, {
       base,
       tick,
       isBid: false,
@@ -906,19 +926,22 @@ describe('getTickLevel', () => {
   })
 
   test('behavior: liquidity changes after order cancellation', async () => {
-    const { base } = await setupTokenPair(client)
+    const { base } = await setupTokenPair(clientWithAccount)
 
     const tick = Tick.fromPrice('1.001')
 
     // Place orders
-    const { orderId: orderId1 } = await Actions.dex.placeSync(client, {
-      token: base,
-      amount: parseUnits('100', 6),
-      type: 'buy',
-      tick,
-    })
+    const { orderId: orderId1 } = await Actions.dex.placeSync(
+      clientWithAccount,
+      {
+        token: base,
+        amount: parseUnits('100', 6),
+        type: 'buy',
+        tick,
+      },
+    )
 
-    await Actions.dex.placeSync(client, {
+    await Actions.dex.placeSync(clientWithAccount, {
       token: base,
       amount: parseUnits('50', 6),
       type: 'buy',
@@ -926,19 +949,19 @@ describe('getTickLevel', () => {
     })
 
     // Get level before cancellation
-    const levelBefore = await Actions.dex.getTickLevel(client, {
+    const levelBefore = await Actions.dex.getTickLevel(clientWithAccount, {
       base,
       tick,
       isBid: true,
     })
 
     // Cancel first order
-    await Actions.dex.cancelSync(client, {
+    await Actions.dex.cancelSync(clientWithAccount, {
       orderId: orderId1,
     })
 
     // Get level after cancellation
-    const levelAfter = await Actions.dex.getTickLevel(client, {
+    const levelAfter = await Actions.dex.getTickLevel(clientWithAccount, {
       base,
       tick,
       isBid: true,
@@ -949,12 +972,12 @@ describe('getTickLevel', () => {
   })
 
   test('behavior: liquidity changes after partial fill', async () => {
-    const { base, quote } = await setupTokenPair(client)
+    const { base, quote } = await setupTokenPair(clientWithAccount)
 
     const tick = Tick.fromPrice('1.001')
 
     // Place sell order
-    await Actions.dex.placeSync(client, {
+    await Actions.dex.placeSync(clientWithAccount, {
       token: base,
       amount: parseUnits('500', 6),
       type: 'sell',
@@ -962,14 +985,14 @@ describe('getTickLevel', () => {
     })
 
     // Get level before fill
-    const levelBefore = await Actions.dex.getTickLevel(client, {
+    const levelBefore = await Actions.dex.getTickLevel(clientWithAccount, {
       base,
       tick,
       isBid: false,
     })
 
     // Partially fill the order
-    await Actions.dex.buySync(client, {
+    await Actions.dex.buySync(clientWithAccount, {
       tokenIn: quote,
       tokenOut: base,
       amountOut: parseUnits('100', 6),
@@ -977,7 +1000,7 @@ describe('getTickLevel', () => {
     })
 
     // Get level after fill
-    const levelAfter = await Actions.dex.getTickLevel(client, {
+    const levelAfter = await Actions.dex.getTickLevel(clientWithAccount, {
       base,
       tick,
       isBid: false,
@@ -988,10 +1011,10 @@ describe('getTickLevel', () => {
   })
 
   test('behavior: tick at boundaries', async () => {
-    const { base } = await setupTokenPair(client)
+    const { base } = await setupTokenPair(clientWithAccount)
 
     // Place order at min tick
-    await Actions.dex.placeSync(client, {
+    await Actions.dex.placeSync(clientWithAccount, {
       token: base,
       amount: parseUnits('10', 6),
       type: 'sell',
@@ -999,7 +1022,7 @@ describe('getTickLevel', () => {
     })
 
     // Query min tick
-    const minLevel = await Actions.dex.getTickLevel(client, {
+    const minLevel = await Actions.dex.getTickLevel(clientWithAccount, {
       base,
       tick: Tick.minTick,
       isBid: false,
@@ -1007,7 +1030,7 @@ describe('getTickLevel', () => {
     expect(minLevel.totalLiquidity).toBeGreaterThan(0n)
 
     // Place order at max tick
-    await Actions.dex.placeSync(client, {
+    await Actions.dex.placeSync(clientWithAccount, {
       token: base,
       amount: parseUnits('10', 6),
       type: 'buy',
@@ -1015,7 +1038,7 @@ describe('getTickLevel', () => {
     })
 
     // Query max tick
-    const maxLevel = await Actions.dex.getTickLevel(client, {
+    const maxLevel = await Actions.dex.getTickLevel(clientWithAccount, {
       base,
       tick: Tick.maxTick,
       isBid: true,
@@ -1026,10 +1049,10 @@ describe('getTickLevel', () => {
 
 describe('getSellQuote', () => {
   test('default', async () => {
-    const { base, quote } = await setupTokenPair(client)
+    const { base, quote } = await setupTokenPair(clientWithAccount)
 
     // Place bid orders to create liquidity
-    await Actions.dex.placeSync(client, {
+    await Actions.dex.placeSync(clientWithAccount, {
       token: base,
       amount: parseUnits('500', 6),
       type: 'buy',
@@ -1037,7 +1060,7 @@ describe('getSellQuote', () => {
     })
 
     // Get quote for selling base tokens
-    const amountOut = await Actions.dex.getSellQuote(client, {
+    const amountOut = await Actions.dex.getSellQuote(clientWithAccount, {
       tokenIn: base,
       tokenOut: quote,
       amountIn: parseUnits('100', 6),
@@ -1049,11 +1072,11 @@ describe('getSellQuote', () => {
   })
 
   test('behavior: fails with no liquidity', async () => {
-    const { base, quote } = await setupTokenPair(client)
+    const { base, quote } = await setupTokenPair(clientWithAccount)
 
     // Quote should fail with no liquidity
     await expect(
-      Actions.dex.getSellQuote(client, {
+      Actions.dex.getSellQuote(clientWithAccount, {
         tokenIn: base,
         tokenOut: quote,
         amountIn: parseUnits('100', 6),
@@ -1065,11 +1088,11 @@ describe('getSellQuote', () => {
 describe('place', () => {
   test('default', async () => {
     // Setup token pair
-    const { base } = await setupTokenPair(client)
+    const { base } = await setupTokenPair(clientWithAccount)
 
     // Place a sell order
     const { receipt, orderId, token, ...result } = await Actions.dex.placeSync(
-      client,
+      clientWithAccount,
       {
         token: base,
         amount: parseUnits('100', 6),
@@ -1097,7 +1120,7 @@ describe('place', () => {
       orderId: orderId2,
       token: token2,
       ...result2
-    } = await Actions.dex.placeSync(client, {
+    } = await Actions.dex.placeSync(clientWithAccount, {
       token: base,
       amount: parseUnits('100', 6),
       type: 'buy',
@@ -1117,11 +1140,11 @@ describe('place', () => {
   })
 
   test('behavior: tick at boundaries', async () => {
-    const { base } = await setupTokenPair(client)
+    const { base } = await setupTokenPair(clientWithAccount)
 
     // Test at min tick (-2000)
     const { receipt: receipt1, ...result1 } = await Actions.dex.placeSync(
-      client,
+      clientWithAccount,
       {
         token: base,
         amount: parseUnits('10', 6),
@@ -1134,7 +1157,7 @@ describe('place', () => {
 
     // Test at max tick (2000)
     const { receipt: receipt2, ...result2 } = await Actions.dex.placeSync(
-      client,
+      clientWithAccount,
       {
         token: base,
         amount: parseUnits('10', 6),
@@ -1147,11 +1170,11 @@ describe('place', () => {
   })
 
   test('behavior: tick validation fails outside bounds', async () => {
-    const { base } = await setupTokenPair(client)
+    const { base } = await setupTokenPair(clientWithAccount)
 
     // Test tick above max tix should fail
     await expect(
-      Actions.dex.placeSync(client, {
+      Actions.dex.placeSync(clientWithAccount, {
         token: base,
         amount: parseUnits('10', 6),
         type: 'buy',
@@ -1161,7 +1184,7 @@ describe('place', () => {
 
     // Test tick below min tick should fail
     await expect(
-      Actions.dex.placeSync(client, {
+      Actions.dex.placeSync(clientWithAccount, {
         token: base,
         amount: parseUnits('10', 6),
         type: 'sell',
@@ -1171,20 +1194,26 @@ describe('place', () => {
   })
 
   test('behavior: transfers from wallet', async () => {
-    const { base, quote } = await setupTokenPair(client)
+    const { base, quote } = await setupTokenPair(clientWithAccount)
 
     // Get balances before placing order
-    const baseBalanceBefore = await Actions.token.getBalance(client, {
-      token: base,
-    })
-    const quoteBalanceBefore = await Actions.token.getBalance(client, {
-      token: quote,
-    })
+    const baseBalanceBefore = await Actions.token.getBalance(
+      clientWithAccount,
+      {
+        token: base,
+      },
+    )
+    const quoteBalanceBefore = await Actions.token.getBalance(
+      clientWithAccount,
+      {
+        token: quote,
+      },
+    )
 
     // Place a buy order - should transfer quote tokens to escrow
     const orderAmount = parseUnits('100', 6)
     const tick = Tick.fromPrice('1.001')
-    await Actions.dex.placeSync(client, {
+    await Actions.dex.placeSync(clientWithAccount, {
       token: base,
       amount: orderAmount,
       type: 'buy',
@@ -1192,12 +1221,15 @@ describe('place', () => {
     })
 
     // Get balances after placing order
-    const baseBalanceAfter = await Actions.token.getBalance(client, {
+    const baseBalanceAfter = await Actions.token.getBalance(clientWithAccount, {
       token: base,
     })
-    const quoteBalanceAfter = await Actions.token.getBalance(client, {
-      token: quote,
-    })
+    const quoteBalanceAfter = await Actions.token.getBalance(
+      clientWithAccount,
+      {
+        token: quote,
+      },
+    )
 
     // Base token balance should be unchanged (we're buying base, not selling)
     expect(baseBalanceAfter).toBe(baseBalanceBefore)
@@ -1212,25 +1244,31 @@ describe('place', () => {
   })
 
   test('behavior: multiple orders at same tick', async () => {
-    const { base } = await setupTokenPair(client)
+    const { base } = await setupTokenPair(clientWithAccount)
 
     const tick = Tick.fromPrice('1.0005')
 
     // Place first order
-    const { orderId: orderId1 } = await Actions.dex.placeSync(client, {
-      token: base,
-      amount: parseUnits('100', 6),
-      type: 'buy',
-      tick,
-    })
+    const { orderId: orderId1 } = await Actions.dex.placeSync(
+      clientWithAccount,
+      {
+        token: base,
+        amount: parseUnits('100', 6),
+        type: 'buy',
+        tick,
+      },
+    )
 
     // Place second order at same tick
-    const { orderId: orderId2 } = await Actions.dex.placeSync(client, {
-      token: base,
-      amount: parseUnits('50', 6),
-      type: 'buy',
-      tick,
-    })
+    const { orderId: orderId2 } = await Actions.dex.placeSync(
+      clientWithAccount,
+      {
+        token: base,
+        amount: parseUnits('50', 6),
+        type: 'buy',
+        tick,
+      },
+    )
 
     // Order IDs should be different and sequential
     expect(orderId2).toBeGreaterThan(orderId1)
@@ -1239,11 +1277,11 @@ describe('place', () => {
 
 describe('placeFlip', () => {
   test('default', async () => {
-    const { base } = await setupTokenPair(client)
+    const { base } = await setupTokenPair(clientWithAccount)
 
     // Place a flip bid order
     const { receipt, orderId, token, ...result } =
-      await Actions.dex.placeFlipSync(client, {
+      await Actions.dex.placeFlipSync(clientWithAccount, {
         token: base,
         amount: parseUnits('100', 6),
         type: 'buy',
@@ -1268,21 +1306,24 @@ describe('placeFlip', () => {
   })
 
   test('behavior: flip bid requires flipTick > tick', async () => {
-    const { base } = await setupTokenPair(client)
+    const { base } = await setupTokenPair(clientWithAccount)
 
     // Valid: flipTick > tick for bid
-    const { receipt: receipt1 } = await Actions.dex.placeFlipSync(client, {
-      token: base,
-      amount: parseUnits('10', 6),
-      type: 'buy',
-      tick: Tick.fromPrice('1.0005'),
-      flipTick: Tick.fromPrice('1.001'),
-    })
+    const { receipt: receipt1 } = await Actions.dex.placeFlipSync(
+      clientWithAccount,
+      {
+        token: base,
+        amount: parseUnits('10', 6),
+        type: 'buy',
+        tick: Tick.fromPrice('1.0005'),
+        flipTick: Tick.fromPrice('1.001'),
+      },
+    )
     expect(receipt1.status).toBe('success')
 
     // Invalid: flipTick <= tick for bid should fail
     await expect(
-      Actions.dex.placeFlipSync(client, {
+      Actions.dex.placeFlipSync(clientWithAccount, {
         token: base,
         amount: parseUnits('10', 6),
         type: 'buy',
@@ -1292,7 +1333,7 @@ describe('placeFlip', () => {
     ).rejects.toThrow('The contract function "placeFlip" reverted')
 
     await expect(
-      Actions.dex.placeFlipSync(client, {
+      Actions.dex.placeFlipSync(clientWithAccount, {
         token: base,
         amount: parseUnits('10', 6),
         type: 'buy',
@@ -1303,21 +1344,24 @@ describe('placeFlip', () => {
   })
 
   test('behavior: flip ask requires flipTick < tick', async () => {
-    const { base } = await setupTokenPair(client)
+    const { base } = await setupTokenPair(clientWithAccount)
 
     // Valid: flipTick < tick for ask
-    const { receipt: receipt1 } = await Actions.dex.placeFlipSync(client, {
-      token: base,
-      amount: parseUnits('10', 6),
-      type: 'sell',
-      tick: Tick.fromPrice('1.001'),
-      flipTick: Tick.fromPrice('1.0005'),
-    })
+    const { receipt: receipt1 } = await Actions.dex.placeFlipSync(
+      clientWithAccount,
+      {
+        token: base,
+        amount: parseUnits('10', 6),
+        type: 'sell',
+        tick: Tick.fromPrice('1.001'),
+        flipTick: Tick.fromPrice('1.0005'),
+      },
+    )
     expect(receipt1.status).toBe('success')
 
     // Invalid: flipTick >= tick for ask should fail
     await expect(
-      Actions.dex.placeFlipSync(client, {
+      Actions.dex.placeFlipSync(clientWithAccount, {
         token: base,
         amount: parseUnits('10', 6),
         type: 'sell',
@@ -1327,7 +1371,7 @@ describe('placeFlip', () => {
     ).rejects.toThrow('The contract function "placeFlip" reverted')
 
     await expect(
-      Actions.dex.placeFlipSync(client, {
+      Actions.dex.placeFlipSync(clientWithAccount, {
         token: base,
         amount: parseUnits('10', 6),
         type: 'sell',
@@ -1338,10 +1382,10 @@ describe('placeFlip', () => {
   })
 
   test('behavior: flip ticks at boundaries', async () => {
-    const { base } = await setupTokenPair(client)
+    const { base } = await setupTokenPair(clientWithAccount)
 
     // Flip order with ticks at extreme boundaries
-    const { receipt } = await Actions.dex.placeFlipSync(client, {
+    const { receipt } = await Actions.dex.placeFlipSync(clientWithAccount, {
       token: base,
       amount: parseUnits('10', 6),
       type: 'buy',
@@ -1354,10 +1398,10 @@ describe('placeFlip', () => {
 
 describe('sell', () => {
   test('default', async () => {
-    const { base, quote } = await setupTokenPair(client)
+    const { base, quote } = await setupTokenPair(clientWithAccount)
 
     // Place bid order to create liquidity
-    await Actions.dex.placeSync(client, {
+    await Actions.dex.placeSync(clientWithAccount, {
       token: base,
       amount: parseUnits('500', 6),
       type: 'buy',
@@ -1365,7 +1409,7 @@ describe('sell', () => {
     })
 
     // Sell base tokens
-    const { receipt } = await Actions.dex.sellSync(client, {
+    const { receipt } = await Actions.dex.sellSync(clientWithAccount, {
       tokenIn: base,
       tokenOut: quote,
       amountIn: parseUnits('100', 6),
@@ -1377,10 +1421,10 @@ describe('sell', () => {
   })
 
   test('behavior: respects minAmountOut', async () => {
-    const { base, quote } = await setupTokenPair(client)
+    const { base, quote } = await setupTokenPair(clientWithAccount)
 
     // Place bid order at low price
-    await Actions.dex.placeSync(client, {
+    await Actions.dex.placeSync(clientWithAccount, {
       token: base,
       amount: parseUnits('500', 6),
       type: 'buy',
@@ -1389,7 +1433,7 @@ describe('sell', () => {
 
     // Try to sell with too high minAmountOut - should fail
     await expect(
-      Actions.dex.sellSync(client, {
+      Actions.dex.sellSync(clientWithAccount, {
         tokenIn: base,
         tokenOut: quote,
         amountIn: parseUnits('100', 6),
@@ -1399,13 +1443,13 @@ describe('sell', () => {
   })
 
   test('behavior: fails with insufficient liquidity', async () => {
-    const { base, quote } = await setupTokenPair(client)
+    const { base, quote } = await setupTokenPair(clientWithAccount)
 
     // No orders - no liquidity
 
     // Try to sell - should fail
     await expect(
-      Actions.dex.sellSync(client, {
+      Actions.dex.sellSync(clientWithAccount, {
         tokenIn: base,
         tokenOut: quote,
         amountIn: parseUnits('100', 6),
@@ -1417,14 +1461,14 @@ describe('sell', () => {
 
 describe('watchFlipOrderPlaced', () => {
   test('default', async () => {
-    const { base } = await setupTokenPair(client)
+    const { base } = await setupTokenPair(clientWithAccount)
 
     const receivedOrders: Array<{
       args: Actions.dex.watchFlipOrderPlaced.Args
       log: Actions.dex.watchFlipOrderPlaced.Log
     }> = []
 
-    const unwatch = Actions.dex.watchFlipOrderPlaced(client, {
+    const unwatch = Actions.dex.watchFlipOrderPlaced(clientWithAccount, {
       onFlipOrderPlaced: (args, log) => {
         receivedOrders.push({ args, log })
       },
@@ -1432,7 +1476,7 @@ describe('watchFlipOrderPlaced', () => {
 
     try {
       // Place flip order
-      await Actions.dex.placeFlipSync(client, {
+      await Actions.dex.placeFlipSync(clientWithAccount, {
         token: base,
         amount: parseUnits('100', 6),
         type: 'buy',
@@ -1453,14 +1497,14 @@ describe('watchFlipOrderPlaced', () => {
 
 describe('watchOrderCancelled', () => {
   test('default', async () => {
-    const { base } = await setupTokenPair(client)
+    const { base } = await setupTokenPair(clientWithAccount)
 
     const receivedCancellations: Array<{
       args: Actions.dex.watchOrderCancelled.Args
       log: Actions.dex.watchOrderCancelled.Log
     }> = []
 
-    const unwatch = Actions.dex.watchOrderCancelled(client, {
+    const unwatch = Actions.dex.watchOrderCancelled(clientWithAccount, {
       onOrderCancelled: (args, log) => {
         receivedCancellations.push({ args, log })
       },
@@ -1468,7 +1512,7 @@ describe('watchOrderCancelled', () => {
 
     try {
       // Place order
-      const { orderId } = await Actions.dex.placeSync(client, {
+      const { orderId } = await Actions.dex.placeSync(clientWithAccount, {
         token: base,
         amount: parseUnits('100', 6),
         type: 'buy',
@@ -1476,7 +1520,7 @@ describe('watchOrderCancelled', () => {
       })
 
       // Cancel order
-      await Actions.dex.cancelSync(client, {
+      await Actions.dex.cancelSync(clientWithAccount, {
         orderId,
       })
 
@@ -1490,22 +1534,28 @@ describe('watchOrderCancelled', () => {
   })
 
   test('behavior: filter by orderId', async () => {
-    const { base } = await setupTokenPair(client)
+    const { base } = await setupTokenPair(clientWithAccount)
 
     // Place two orders
-    const { orderId: orderId1 } = await Actions.dex.placeSync(client, {
-      token: base,
-      amount: parseUnits('100', 6),
-      type: 'buy',
-      tick: Tick.fromPrice('1.001'),
-    })
+    const { orderId: orderId1 } = await Actions.dex.placeSync(
+      clientWithAccount,
+      {
+        token: base,
+        amount: parseUnits('100', 6),
+        type: 'buy',
+        tick: Tick.fromPrice('1.001'),
+      },
+    )
 
-    const { orderId: orderId2 } = await Actions.dex.placeSync(client, {
-      token: base,
-      amount: parseUnits('50', 6),
-      type: 'buy',
-      tick: Tick.fromPrice('1.001'),
-    })
+    const { orderId: orderId2 } = await Actions.dex.placeSync(
+      clientWithAccount,
+      {
+        token: base,
+        amount: parseUnits('50', 6),
+        type: 'buy',
+        tick: Tick.fromPrice('1.001'),
+      },
+    )
 
     const receivedCancellations: Array<{
       args: Actions.dex.watchOrderCancelled.Args
@@ -1513,7 +1563,7 @@ describe('watchOrderCancelled', () => {
     }> = []
 
     // Watch only for cancellation of orderId1
-    const unwatch = Actions.dex.watchOrderCancelled(client, {
+    const unwatch = Actions.dex.watchOrderCancelled(clientWithAccount, {
       orderId: orderId1,
       onOrderCancelled: (args, log) => {
         receivedCancellations.push({ args, log })
@@ -1522,12 +1572,12 @@ describe('watchOrderCancelled', () => {
 
     try {
       // Cancel orderId1 (should be captured)
-      await Actions.dex.cancelSync(client, {
+      await Actions.dex.cancelSync(clientWithAccount, {
         orderId: orderId1,
       })
 
       // Cancel orderId2 (should NOT be captured)
-      await Actions.dex.cancelSync(client, {
+      await Actions.dex.cancelSync(clientWithAccount, {
         orderId: orderId2,
       })
 
@@ -1546,14 +1596,14 @@ describe.todo('watchOrderFilled')
 
 describe('watchOrderPlaced', () => {
   test('default', async () => {
-    const { base } = await setupTokenPair(client)
+    const { base } = await setupTokenPair(clientWithAccount)
 
     const receivedOrders: Array<{
       args: Actions.dex.watchOrderPlaced.Args
       log: Actions.dex.watchOrderPlaced.Log
     }> = []
 
-    const unwatch = Actions.dex.watchOrderPlaced(client, {
+    const unwatch = Actions.dex.watchOrderPlaced(clientWithAccount, {
       onOrderPlaced: (args, log) => {
         receivedOrders.push({ args, log })
       },
@@ -1561,7 +1611,7 @@ describe('watchOrderPlaced', () => {
 
     try {
       // Place first order
-      await Actions.dex.placeSync(client, {
+      await Actions.dex.placeSync(clientWithAccount, {
         token: base,
         amount: parseUnits('100', 6),
         type: 'buy',
@@ -1569,7 +1619,7 @@ describe('watchOrderPlaced', () => {
       })
 
       // Place second order
-      await Actions.dex.placeSync(client, {
+      await Actions.dex.placeSync(clientWithAccount, {
         token: base,
         amount: parseUnits('50', 6),
         type: 'sell',
@@ -1590,8 +1640,8 @@ describe('watchOrderPlaced', () => {
   })
 
   test('behavior: filter by token', async () => {
-    const { base } = await setupTokenPair(client)
-    const { base: base2 } = await setupTokenPair(client)
+    const { base } = await setupTokenPair(clientWithAccount)
+    const { base: base2 } = await setupTokenPair(clientWithAccount)
 
     const receivedOrders: Array<{
       args: Actions.dex.watchOrderPlaced.Args
@@ -1599,7 +1649,7 @@ describe('watchOrderPlaced', () => {
     }> = []
 
     // Watch only for orders on base
-    const unwatch = Actions.dex.watchOrderPlaced(client, {
+    const unwatch = Actions.dex.watchOrderPlaced(clientWithAccount, {
       token: base,
       onOrderPlaced: (args, log) => {
         receivedOrders.push({ args, log })
@@ -1608,7 +1658,7 @@ describe('watchOrderPlaced', () => {
 
     try {
       // Place order on base (should be captured)
-      await Actions.dex.placeSync(client, {
+      await Actions.dex.placeSync(clientWithAccount, {
         token: base,
         amount: parseUnits('100', 6),
         type: 'buy',
@@ -1616,7 +1666,7 @@ describe('watchOrderPlaced', () => {
       })
 
       // Place order on base2 (should NOT be captured)
-      await Actions.dex.placeSync(client, {
+      await Actions.dex.placeSync(clientWithAccount, {
         token: base2,
         amount: parseUnits('50', 6),
         type: 'buy',
@@ -1638,32 +1688,35 @@ describe('watchOrderPlaced', () => {
 
 describe('withdraw', () => {
   test('default', async () => {
-    const { base, quote } = await setupTokenPair(client)
+    const { base, quote } = await setupTokenPair(clientWithAccount)
 
     // Create internal balance
-    const { orderId } = await Actions.dex.placeSync(client, {
+    const { orderId } = await Actions.dex.placeSync(clientWithAccount, {
       token: base,
       amount: parseUnits('100', 6),
       type: 'buy',
       tick: Tick.fromPrice('1.001'),
     })
 
-    await Actions.dex.cancelSync(client, { orderId })
+    await Actions.dex.cancelSync(clientWithAccount, { orderId })
 
     // Get DEX balance
-    const dexBalance = await Actions.dex.getBalance(client, {
-      account: client.account.address,
+    const dexBalance = await Actions.dex.getBalance(clientWithAccount, {
+      account: clientWithAccount.account.address,
       token: quote,
     })
     expect(dexBalance).toBeGreaterThan(0n)
 
     // Get wallet balance before withdraw
-    const walletBalanceBefore = await Actions.token.getBalance(client, {
-      token: quote,
-    })
+    const walletBalanceBefore = await Actions.token.getBalance(
+      clientWithAccount,
+      {
+        token: quote,
+      },
+    )
 
     // Withdraw from DEX
-    const { receipt } = await Actions.dex.withdrawSync(client, {
+    const { receipt } = await Actions.dex.withdrawSync(clientWithAccount, {
       token: quote,
       amount: dexBalance,
     })
@@ -1672,16 +1725,19 @@ describe('withdraw', () => {
     expect(receipt.status).toBe('success')
 
     // Check DEX balance is now 0
-    const dexBalanceAfter = await Actions.dex.getBalance(client, {
-      account: client.account.address,
+    const dexBalanceAfter = await Actions.dex.getBalance(clientWithAccount, {
+      account: clientWithAccount.account.address,
       token: quote,
     })
     expect(dexBalanceAfter).toBe(0n)
 
     // Check wallet balance increased
-    const walletBalanceAfter = await Actions.token.getBalance(client, {
-      token: quote,
-    })
+    const walletBalanceAfter = await Actions.token.getBalance(
+      clientWithAccount,
+      {
+        token: quote,
+      },
+    )
     expect(walletBalanceAfter).toBeGreaterThan(walletBalanceBefore)
   })
 })