tempo.ts 0.1.5 → 0.2.0

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

@@ -1,91 +1,22 @@
-import { Actions, Addresses, createTempoClient, Tick } from 'tempo.ts/viem'
-import { parseEther, publicActions } from 'viem'
-import { mnemonicToAccount } from 'viem/accounts'
-import { describe, expect, test } from 'vitest'
-import { tempoTest } from '../../../test/viem/config.js'
-
-const account = mnemonicToAccount(
-  'test test test test test test test test test test test junk',
-)
-
-const client = createTempoClient({
-  account,
-  chain: tempoTest,
-  pollingInterval: 100,
-}).extend(publicActions)
-
-async function setupTokenPair() {
-  // Create quote token
-  const { token: quoteToken } = await Actions.token.createSync(client, {
-    name: 'Test Quote Token',
-    symbol: 'QUOTE',
-    currency: 'USD',
-  })
-
-  // Create base token
-  const { token: baseToken } = await Actions.token.createSync(client, {
-    name: 'Test Base Token',
-    symbol: 'BASE',
-    currency: 'USD',
-    quoteToken,
-  })
-
-  // Grant issuer role to mint base tokens
-  await Actions.token.grantRolesSync(client, {
-    token: baseToken,
-    roles: ['issuer'],
-    to: client.account.address,
-  })
-
-  // Grant issuer role to mint quote tokens
-  await Actions.token.grantRolesSync(client, {
-    token: quoteToken,
-    roles: ['issuer'],
-    to: client.account.address,
-  })
-
-  // Mint base tokens
-  await Actions.token.mintSync(client, {
-    token: baseToken,
-    to: account.address,
-    amount: parseEther('10000'),
-  })
-
-  // Mint quote tokens
-  await Actions.token.mintSync(client, {
-    token: quoteToken,
-    to: account.address,
-    amount: parseEther('10000'),
-  })
-
-  // Approve DEX to spend base tokens
-  await Actions.token.approveSync(client, {
-    token: baseToken,
-    spender: Addresses.stablecoinExchange,
-    amount: parseEther('10000'),
-  })
-
-  // Approve DEX to spend quote tokens
-  await Actions.token.approveSync(client, {
-    token: quoteToken,
-    spender: Addresses.stablecoinExchange,
-    amount: parseEther('10000'),
-  })
-
-  // Create the pair on the DEX
-  return await Actions.dex.createPairSync(client, {
-    base: baseToken,
-  })
-}
+import * as Address from 'ox/Address'
+import { Actions, Tick } from 'tempo.ts/viem'
+import { parseUnits } from 'viem'
+import { beforeAll, describe, expect, test } from 'vitest'
+import {
+  accounts,
+  client,
+  setupOrders,
+  setupTokenPair,
+} from '../../../test/viem/config.js'
 
 describe('buy', () => {
   test('default', async () => {
-    const { base, quote } = await setupTokenPair()
+    const { base, quote } = await setupTokenPair(client)
 
     // Place ask order to create liquidity
     await Actions.dex.placeSync(client, {
       token: base,
-      amount: parseEther('500'),
+      amount: parseUnits('500', 6),
       type: 'sell',
       tick: Tick.fromPrice('1.001'),
     })
@@ -99,8 +30,8 @@ describe('buy', () => {
     const { receipt } = await Actions.dex.buySync(client, {
       tokenIn: quote,
       tokenOut: base,
-      amountOut: parseEther('100'),
-      maxAmountIn: parseEther('150'),
+      amountOut: parseUnits('100', 6),
+      maxAmountIn: parseUnits('150', 6),
     })
 
     expect(receipt).toBeDefined()
@@ -116,12 +47,12 @@ describe('buy', () => {
   })
 
   test('behavior: respects maxAmountIn', async () => {
-    const { base, quote } = await setupTokenPair()
+    const { base, quote } = await setupTokenPair(client)
 
     // Place ask order at high price
     await Actions.dex.placeSync(client, {
       token: base,
-      amount: parseEther('500'),
+      amount: parseUnits('500', 6),
       type: 'sell',
       tick: Tick.fromPrice('1.01'), // 1% above peg
     })
@@ -131,27 +62,14 @@ describe('buy', () => {
       Actions.dex.buySync(client, {
         tokenIn: quote,
         tokenOut: base,
-        amountOut: parseEther('100'),
-        maxAmountIn: parseEther('50'), // Way too low for 1% premium
+        amountOut: parseUnits('100', 6),
+        maxAmountIn: parseUnits('50', 6), // Way too low for 1% premium
       }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(`
-      [ContractFunctionExecutionError: The contract function "swapExactAmountOut" reverted.
-
-      Error: MaxInputExceeded()
-       
-      Contract Call:
-        address:   0xdec0000000000000000000000000000000000000
-        function:  swapExactAmountOut(address tokenIn, address tokenOut, uint128 amountOut, uint128 maxAmountIn)
-        args:                        (0x20C0000000000000000000000000000000000004, 0x20c0000000000000000000000000000000000005, 100000000000000000000, 50000000000000000000)
-        sender:    0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266
-
-      Docs: https://viem.sh/docs/contract/writeContract
-      Version: viem@2.38.3]
-    `)
+    ).rejects.toThrow('The contract function "swapExactAmountOut" reverted')
   })
 
   test('behavior: fails with insufficient liquidity', async () => {
-    const { base, quote } = await setupTokenPair()
+    const { base, quote } = await setupTokenPair(client)
 
     // Don't place any orders - no liquidity
 
@@ -160,89 +78,71 @@ describe('buy', () => {
       Actions.dex.buySync(client, {
         tokenIn: quote,
         tokenOut: base,
-        amountOut: parseEther('100'),
-        maxAmountIn: parseEther('150'),
+        amountOut: parseUnits('100', 6),
+        maxAmountIn: parseUnits('150', 6),
       }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(`
-      [ContractFunctionExecutionError: The contract function "swapExactAmountOut" reverted.
-
-      Error: InsufficientLiquidity()
-       
-      Contract Call:
-        address:   0xdec0000000000000000000000000000000000000
-        function:  swapExactAmountOut(address tokenIn, address tokenOut, uint128 amountOut, uint128 maxAmountIn)
-        args:                        (0x20C0000000000000000000000000000000000004, 0x20c0000000000000000000000000000000000005, 100000000000000000000, 150000000000000000000)
-        sender:    0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266
-
-      Docs: https://viem.sh/docs/contract/writeContract
-      Version: viem@2.38.3]
-    `)
+    ).rejects.toThrow('The contract function "swapExactAmountOut" reverted')
   })
 })
 
 describe('cancel', () => {
   test('default', async () => {
-    const { base, quote } = await setupTokenPair()
+    const { base, quote } = await setupTokenPair(client)
 
     // Place a bid order
     const { orderId } = await Actions.dex.placeSync(client, {
       token: base,
-      amount: parseEther('100'),
+      amount: parseUnits('100', 6),
       type: 'buy',
       tick: Tick.fromPrice('1.001'),
     })
 
     // Check initial DEX balance (should be 0)
     const dexBalanceBefore = await Actions.dex.getBalance(client, {
-      account: account.address,
+      account: client.account.address,
       token: quote,
     })
     expect(dexBalanceBefore).toBe(0n)
 
     // Cancel the order
-    const { receipt, ...result } = await Actions.dex.cancelSync(client, {
-      orderId,
-    })
+    const { receipt, orderId: returnedOrderId } = await Actions.dex.cancelSync(
+      client,
+      {
+        orderId,
+      },
+    )
 
     expect(receipt).toBeDefined()
     expect(receipt.status).toBe('success')
-    expect(result.orderId).toBe(orderId)
-    expect(result).toMatchInlineSnapshot(`
-      {
-        "orderId": 1n,
-      }
-    `)
+    expect(returnedOrderId).toBe(orderId)
 
     // Check DEX balance after cancel - tokens should be refunded to internal balance
     const dexBalanceAfter = await Actions.dex.getBalance(client, {
-      account: account.address,
+      account: client.account.address,
       token: quote,
     })
     expect(dexBalanceAfter).toBeGreaterThan(0n)
   })
 
   test('behavior: only maker can cancel', async () => {
-    const { base } = await setupTokenPair()
+    const { base } = await setupTokenPair(client)
 
     // Account places order
     const { orderId } = await Actions.dex.placeSync(client, {
       token: base,
-      amount: parseEther('100'),
+      amount: parseUnits('100', 6),
       type: 'buy',
       tick: Tick.fromPrice('1.001'),
     })
 
     // Create another account
-    const account2 = mnemonicToAccount(
-      'test test test test test test test test test test test junk',
-      { accountIndex: 1 },
-    )
+    const account2 = accounts[1]
 
     // Transfer gas to account2
     await Actions.token.transferSync(client, {
       to: account2.address,
-      amount: parseEther('1'),
-      token: Addresses.defaultFeeToken,
+      amount: parseUnits('1', 6),
+      token: 1n,
     })
 
     // Account2 tries to cancel - should fail
@@ -251,44 +151,18 @@ describe('cancel', () => {
         account: account2,
         orderId,
       }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(`
-      [ContractFunctionExecutionError: The contract function "cancel" reverted.
-
-      Error: Unauthorized()
-       
-      Contract Call:
-        address:   0xdec0000000000000000000000000000000000000
-        function:  cancel(uint128 orderId)
-        args:            (1)
-        sender:    0x8C8d35429F74ec245F8Ef2f4Fd1e551cFF97d650
-
-      Docs: https://viem.sh/docs/contract/writeContract
-      Version: viem@2.38.3]
-    `)
+    ).rejects.toThrow('The contract function "cancel" reverted')
   })
 
   test('behavior: cannot cancel non-existent order', async () => {
-    await setupTokenPair()
+    await setupTokenPair(client)
 
     // Try to cancel an order that doesn't exist
     await expect(
       Actions.dex.cancelSync(client, {
         orderId: 999n,
       }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(`
-      [ContractFunctionExecutionError: The contract function "cancel" reverted.
-
-      Error: OrderDoesNotExist()
-       
-      Contract Call:
-        address:   0xdec0000000000000000000000000000000000000
-        function:  cancel(uint128 orderId)
-        args:            (999)
-        sender:    0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266
-
-      Docs: https://viem.sh/docs/contract/writeContract
-      Version: viem@2.38.3]
-    `)
+    ).rejects.toThrow('The contract function "cancel" reverted')
   })
 })
 
@@ -300,31 +174,28 @@ describe('createPair', () => {
       currency: 'USD',
     })
 
-    const { receipt, ...result } = await Actions.dex.createPairSync(client, {
-      base: baseToken,
-    })
+    const { receipt, key, base, quote } = await Actions.dex.createPairSync(
+      client,
+      {
+        base: baseToken,
+      },
+    )
 
     expect(receipt).toBeDefined()
     expect(receipt.status).toBe('success')
-
-    const { key, ...rest } = result
     expect(key).toBeDefined()
-    expect(rest).toMatchInlineSnapshot(`
-      {
-        "base": "0x20C0000000000000000000000000000000000004",
-        "quote": "0x20C0000000000000000000000000000000000000",
-      }
-    `)
+    expect(base).toBe(baseToken)
+    expect(quote).toBeDefined()
   })
 })
 
 describe('getBalance', () => {
   test('default', async () => {
-    const { base, quote } = await setupTokenPair()
+    const { base, quote } = await setupTokenPair(client)
 
     // Initial balance should be 0
     const initialBalance = await Actions.dex.getBalance(client, {
-      account: account.address,
+      account: client.account.address,
       token: quote,
     })
     expect(initialBalance).toBe(0n)
@@ -332,7 +203,7 @@ describe('getBalance', () => {
     // Place and cancel order to create internal balance
     const { orderId } = await Actions.dex.placeSync(client, {
       token: base,
-      amount: parseEther('50'),
+      amount: parseUnits('50', 6),
       type: 'buy',
       tick: Tick.fromPrice('1.0005'),
     })
@@ -343,19 +214,16 @@ describe('getBalance', () => {
 
     // Now balance should be > 0 (refunded quote tokens)
     const balance = await Actions.dex.getBalance(client, {
-      account: account.address,
+      account: client.account.address,
       token: quote,
     })
     expect(balance).toBeGreaterThan(0n)
   })
 
   test('behavior: check different account', async () => {
-    const { quote } = await setupTokenPair()
+    const { quote } = await setupTokenPair(client)
 
-    const account2 = mnemonicToAccount(
-      'test test test test test test test test test test test junk',
-      { accountIndex: 1 },
-    )
+    const account2 = accounts[1]
 
     // Check account2's balance (should be 0)
     const balance = await Actions.dex.getBalance(client, {
@@ -366,12 +234,12 @@ describe('getBalance', () => {
   })
 
   test('behavior: balances are per-token', async () => {
-    const { base, quote } = await setupTokenPair()
+    const { base, quote } = await setupTokenPair(client)
 
     // Create balance in quote token
     const { orderId } = await Actions.dex.placeSync(client, {
       token: base,
-      amount: parseEther('100'),
+      amount: parseUnits('100', 6),
       type: 'buy',
       tick: Tick.fromPrice('1.001'),
     })
@@ -379,14 +247,14 @@ describe('getBalance', () => {
 
     // Check quote balance (should have refunded tokens)
     const quoteBalance = await Actions.dex.getBalance(client, {
-      account: account.address,
+      account: client.account.address,
       token: quote,
     })
     expect(quoteBalance).toBeGreaterThan(0n)
 
     // Check base balance (should still be 0)
     const baseBalance = await Actions.dex.getBalance(client, {
-      account: account.address,
+      account: client.account.address,
       token: base,
     })
     expect(baseBalance).toBe(0n)
@@ -395,12 +263,12 @@ describe('getBalance', () => {
 
 describe('getBuyQuote', () => {
   test('default', async () => {
-    const { base, quote } = await setupTokenPair()
+    const { base, quote } = await setupTokenPair(client)
 
     // Place ask orders to create liquidity
     await Actions.dex.placeSync(client, {
       token: base,
-      amount: parseEther('500'),
+      amount: parseUnits('500', 6),
       type: 'sell',
       tick: Tick.fromPrice('1.001'),
     })
@@ -409,16 +277,16 @@ describe('getBuyQuote', () => {
     const amountIn = await Actions.dex.getBuyQuote(client, {
       tokenIn: quote,
       tokenOut: base,
-      amountOut: parseEther('100'),
+      amountOut: parseUnits('100', 6),
     })
 
     expect(amountIn).toBeGreaterThan(0n)
     // Should be approximately 100 * 1.001 = 100.1
-    expect(amountIn).toBeGreaterThan(parseEther('100'))
+    expect(amountIn).toBeGreaterThan(parseUnits('100', 6))
   })
 
   test('behavior: fails with no liquidity', async () => {
-    const { base, quote } = await setupTokenPair()
+    const { base, quote } = await setupTokenPair(client)
 
     // No orders placed - no liquidity
 
@@ -427,32 +295,22 @@ describe('getBuyQuote', () => {
       Actions.dex.getBuyQuote(client, {
         tokenIn: quote,
         tokenOut: base,
-        amountOut: parseEther('100'),
+        amountOut: parseUnits('100', 6),
       }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(`
-      [ContractFunctionExecutionError: The contract function "quoteSwapExactAmountOut" reverted.
-
-      Error: InsufficientLiquidity()
-       
-      Contract Call:
-        address:   0xdec0000000000000000000000000000000000000
-        function:  quoteSwapExactAmountOut(address tokenIn, address tokenOut, uint128 amountOut)
-        args:                             (0x20C0000000000000000000000000000000000004, 0x20c0000000000000000000000000000000000005, 100000000000000000000)
-
-      Docs: https://viem.sh/docs/contract/readContract
-      Version: viem@2.38.3]
-    `)
+    ).rejects.toThrow(
+      'The contract function "quoteSwapExactAmountOut" reverted',
+    )
   })
 })
 
 describe('getOrder', () => {
   test('default', async () => {
-    const { base } = await setupTokenPair()
+    const { base } = await setupTokenPair(client)
 
     // Place an order to get an order ID
     const { orderId } = await Actions.dex.placeSync(client, {
       token: base,
-      amount: parseEther('100'),
+      amount: parseUnits('100', 6),
       type: 'buy',
       tick: Tick.fromPrice('1.001'),
     })
@@ -466,18 +324,18 @@ describe('getOrder', () => {
     expect(order.maker).toBe(client.account.address)
     expect(order.isBid).toBe(true)
     expect(order.tick).toBe(Tick.fromPrice('1.001'))
-    expect(order.amount).toBe(parseEther('100'))
-    expect(order.remaining).toBe(parseEther('100'))
+    expect(order.amount).toBe(parseUnits('100', 6))
+    expect(order.remaining).toBe(parseUnits('100', 6))
     expect(order.isFlip).toBe(false)
   })
 
   test('behavior: returns flip order details', async () => {
-    const { base } = await setupTokenPair()
+    const { base } = await setupTokenPair(client)
 
     // Place a flip order
     const { orderId } = await Actions.dex.placeFlipSync(client, {
       token: base,
-      amount: parseEther('50'),
+      amount: parseUnits('50', 6),
       type: 'buy',
       tick: Tick.fromPrice('1.001'),
       flipTick: Tick.fromPrice('1.002'),
@@ -492,41 +350,29 @@ describe('getOrder', () => {
     expect(order.maker).toBe(client.account.address)
     expect(order.isBid).toBe(true)
     expect(order.tick).toBe(Tick.fromPrice('1.001'))
-    expect(order.amount).toBe(parseEther('50'))
+    expect(order.amount).toBe(parseUnits('50', 6))
     expect(order.isFlip).toBe(true)
     expect(order.flipTick).toBe(Tick.fromPrice('1.002'))
   })
 
   test('behavior: fails for non-existent order', async () => {
-    await setupTokenPair()
+    await setupTokenPair(client)
 
     // Try to get an order that doesn't exist
     await expect(
       Actions.dex.getOrder(client, {
         orderId: 999n,
       }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(`
-      [ContractFunctionExecutionError: The contract function "getOrder" reverted.
-
-      Error: OrderDoesNotExist()
-       
-      Contract Call:
-        address:   0xdec0000000000000000000000000000000000000
-        function:  getOrder(uint128 orderId)
-        args:              (999)
-
-      Docs: https://viem.sh/docs/contract/readContract
-      Version: viem@2.38.3]
-    `)
+    ).rejects.toThrow('The contract function "getOrder" reverted')
   })
 
   test('behavior: reflects order state after partial fill', async () => {
-    const { base, quote } = await setupTokenPair()
+    const { base, quote } = await setupTokenPair(client)
 
     // Place a large sell order
     const { orderId } = await Actions.dex.placeSync(client, {
       token: base,
-      amount: parseEther('500'),
+      amount: parseUnits('500', 6),
       type: 'sell',
       tick: Tick.fromPrice('1.001'),
     })
@@ -535,34 +381,34 @@ describe('getOrder', () => {
     const orderBefore = await Actions.dex.getOrder(client, {
       orderId,
     })
-    expect(orderBefore.amount).toBe(parseEther('500'))
-    expect(orderBefore.remaining).toBe(parseEther('500'))
+    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, {
       tokenIn: quote,
       tokenOut: base,
-      amountOut: parseEther('100'),
-      maxAmountIn: parseEther('150'),
+      amountOut: parseUnits('100', 6),
+      maxAmountIn: parseUnits('150', 6),
     })
 
     // Get order state after partial fill
     const orderAfter = await Actions.dex.getOrder(client, {
       orderId,
     })
-    expect(orderAfter.amount).toBe(parseEther('500')) // amount unchanged
-    expect(orderAfter.remaining).toBeLessThan(parseEther('500')) // remaining decreased
+    expect(orderAfter.amount).toBe(parseUnits('500', 6)) // amount unchanged
+    expect(orderAfter.remaining).toBeLessThan(parseUnits('500', 6)) // remaining decreased
   })
 
   test('behavior: linked list pointers for multiple orders at same tick', async () => {
-    const { base } = await setupTokenPair()
+    const { base } = await setupTokenPair(client)
 
     const tick = Tick.fromPrice('1.001')
 
     // Place first order
     const { orderId: orderId1 } = await Actions.dex.placeSync(client, {
       token: base,
-      amount: parseEther('100'),
+      amount: parseUnits('100', 6),
       type: 'buy',
       tick,
     })
@@ -570,7 +416,7 @@ describe('getOrder', () => {
     // Place second order at same tick
     const { orderId: orderId2 } = await Actions.dex.placeSync(client, {
       token: base,
-      amount: parseEther('50'),
+      amount: parseUnits('50', 6),
       type: 'buy',
       tick,
     })
@@ -591,16 +437,364 @@ describe('getOrder', () => {
   })
 })
 
+describe('getOrders', () => {
+  let bases: Address.Address[] = []
+  beforeAll(async () => {
+    ;({ bases } = await setupOrders(client))
+  })
+
+  test('default', async () => {
+    // Get orders with default pagination
+    const response = await Actions.dex.getOrders(client, {
+      limit: 10,
+    })
+
+    expect(response).matchSnapshot()
+
+    // Get orders with cursor
+    const response2 = await Actions.dex.getOrders(client, {
+      cursor: response.nextCursor!,
+      limit: 10,
+    })
+
+    expect(response2).matchSnapshot()
+  })
+
+  test.skip('behavior: filter by baseToken', async () => {
+    // Get orders filtered by base1
+    const response = await Actions.dex.getOrders(client, {
+      filters: {
+        baseToken: bases[0],
+      },
+      limit: 5,
+    })
+
+    // Verify all orders match the filter
+    expect(response.orders.length).toBeGreaterThan(0)
+    expect(response.orders.every((order) => order.baseToken === bases[0])).toBe(
+      true,
+    )
+
+    expect(response).matchSnapshot()
+  })
+
+  test('behavior: filter by isBid', async () => {
+    // Get only buy orders
+    const buyOrders = await Actions.dex.getOrders(client, {
+      filters: {
+        isBid: true,
+      },
+      limit: 5,
+    })
+
+    // Verify all orders are buy orders
+    expect(buyOrders.orders.length).toBeGreaterThan(0)
+    expect(buyOrders.orders.every((order) => order.isBid === true)).toBe(true)
+
+    expect(buyOrders).matchSnapshot()
+
+    // Get only sell orders
+    const sellOrders = await Actions.dex.getOrders(client, {
+      filters: {
+        isBid: false,
+      },
+      limit: 5,
+    })
+
+    // Verify all orders are sell orders
+    expect(sellOrders.orders.length).toBeGreaterThan(0)
+    expect(sellOrders.orders.every((order) => order.isBid === false)).toBe(true)
+
+    expect(sellOrders).matchSnapshot()
+  })
+
+  test('behavior: filter by maker', async () => {
+    // Filter by account's address
+    const response = await Actions.dex.getOrders(client, {
+      filters: {
+        maker: client.account.address,
+      },
+      limit: 5,
+    })
+
+    // Verify all orders are from the maker
+    expect(response.orders.length).toBeGreaterThan(0)
+    expect(
+      response.orders.every((order) =>
+        Address.isEqual(order.maker, client.account.address),
+      ),
+    ).toBe(true)
+
+    expect(response).matchSnapshot()
+  })
+
+  test('behavior: filter by isFlip', async () => {
+    // Get only non-flip orders (setupOrders creates non-flip orders)
+    const response = await Actions.dex.getOrders(client, {
+      filters: {
+        isFlip: false,
+      },
+      limit: 5,
+    })
+
+    // Verify all orders are non-flip orders
+    expect(response.orders.length).toBeGreaterThan(0)
+    expect(response.orders.every((order) => order.isFlip === false)).toBe(true)
+
+    expect(response).matchSnapshot()
+  })
+
+  test('behavior: filter by remaining range', async () => {
+    // Get orders with remaining between 100 and 300
+    const response = await Actions.dex.getOrders(client, {
+      filters: {
+        remaining: {
+          min: parseUnits('100', 6),
+          max: parseUnits('300', 6),
+        },
+      },
+      limit: 5,
+    })
+
+    // Verify all orders are within the range
+    expect(response.orders.length).toBeGreaterThan(0)
+    expect(
+      response.orders.every(
+        (order) =>
+          order.remaining >= parseUnits('100', 6) &&
+          order.remaining <= parseUnits('300', 6),
+      ),
+    ).toBe(true)
+
+    expect(response).matchSnapshot()
+  })
+
+  test('behavior: filter by tick range', async () => {
+    // Get orders with tick between -100 and 100
+    const response = await Actions.dex.getOrders(client, {
+      filters: {
+        tick: {
+          min: -100,
+          max: 100,
+        },
+      },
+      limit: 5,
+    })
+
+    // Verify all orders are within the tick range
+    expect(response.orders.length).toBeGreaterThan(0)
+    expect(
+      response.orders.every((order) => order.tick >= -100 && order.tick <= 100),
+    ).toBe(true)
+
+    expect(response).matchSnapshot()
+  })
+
+  test('behavior: multiple filters combined', async () => {
+    // Filter by multiple conditions
+    const response = await Actions.dex.getOrders(client, {
+      filters: {
+        baseToken: bases[0],
+        isBid: true,
+      },
+      limit: 5,
+    })
+
+    // Verify all orders match all filters
+    expect(response.orders.length).toBeGreaterThan(0)
+    expect(
+      response.orders.every(
+        (order) => order.baseToken === bases[0] && order.isBid === true,
+      ),
+    ).toBe(true)
+
+    expect(response).matchSnapshot()
+  })
+
+  test('behavior: empty result', async () => {
+    await setupTokenPair(client)
+
+    // Get orders with filter that matches nothing
+    const response = await Actions.dex.getOrders(client, {
+      filters: {
+        maker: '0x0000000000000000000000000000000000000001',
+      },
+    })
+
+    // Verify empty result
+    expect(response.orders).toHaveLength(0)
+    expect(response.nextCursor).toBeNull()
+
+    expect(response).matchSnapshot()
+  })
+})
+
+describe('getOrderbook', () => {
+  test('default', async () => {
+    const { base, quote } = await setupTokenPair(client)
+
+    // Get orderbook information
+    const book = await Actions.dex.getOrderbook(client, {
+      base,
+      quote,
+    })
+
+    expect(book).toBeDefined()
+    expect(book.base).toBe(base)
+    expect(book.quote).toBe(quote)
+    expect(book.bestBidTick).toBeDefined()
+    expect(book.bestAskTick).toBeDefined()
+  })
+
+  test('behavior: shows best bid and ask after orders placed', async () => {
+    const { base, quote } = await setupTokenPair(client)
+
+    const bidTick = Tick.fromPrice('0.999')
+    const askTick = Tick.fromPrice('1.001')
+
+    // Place a bid order
+    await Actions.dex.placeSync(client, {
+      token: base,
+      amount: parseUnits('100', 6),
+      type: 'buy',
+      tick: bidTick,
+    })
+
+    // Place an ask order
+    await Actions.dex.placeSync(client, {
+      token: base,
+      amount: parseUnits('100', 6),
+      type: 'sell',
+      tick: askTick,
+    })
+
+    // Get orderbook
+    const book = await Actions.dex.getOrderbook(client, {
+      base,
+      quote,
+    })
+
+    expect(book.bestBidTick).toBe(bidTick)
+    expect(book.bestAskTick).toBe(askTick)
+  })
+
+  test('behavior: best ticks update after better orders placed', async () => {
+    const { base, quote } = await setupTokenPair(client)
+
+    // Place initial bid at 0.999
+    await Actions.dex.placeSync(client, {
+      token: base,
+      amount: parseUnits('100', 6),
+      type: 'buy',
+      tick: Tick.fromPrice('0.999'),
+    })
+
+    // Get orderbook
+    const bookBefore = await Actions.dex.getOrderbook(client, {
+      base,
+      quote,
+    })
+    expect(bookBefore.bestBidTick).toBe(Tick.fromPrice('0.999'))
+
+    // Place better bid at 1.0
+    await Actions.dex.placeSync(client, {
+      token: base,
+      amount: parseUnits('100', 6),
+      type: 'buy',
+      tick: Tick.fromPrice('1.0'),
+    })
+
+    // Get orderbook again
+    const bookAfter = await Actions.dex.getOrderbook(client, {
+      base,
+      quote,
+    })
+    expect(bookAfter.bestBidTick).toBe(Tick.fromPrice('1.0'))
+  })
+
+  test.skip('behavior: best ticks update after order cancellation', async () => {
+    const { base, quote } = await setupTokenPair(client)
+
+    // Place two bid orders at different ticks
+    await Actions.dex.placeSync(client, {
+      token: base,
+      amount: parseUnits('50', 6),
+      type: 'buy',
+      tick: Tick.fromPrice('0.999'),
+    })
+
+    const { orderId } = await Actions.dex.placeSync(client, {
+      token: base,
+      amount: parseUnits('100', 6),
+      type: 'buy',
+      tick: Tick.fromPrice('1.0'),
+    })
+
+    // Get orderbook - best bid should be 1.0
+    const bookBefore = await Actions.dex.getOrderbook(client, {
+      base,
+      quote,
+    })
+    expect(bookBefore.bestBidTick).toBe(Tick.fromPrice('1.0'))
+
+    // Cancel the better order
+    await Actions.dex.cancelSync(client, { orderId })
+
+    // Get orderbook again - best bid should fall back to 0.999
+    const bookAfter = await Actions.dex.getOrderbook(client, {
+      base,
+      quote,
+    })
+    expect(bookAfter.bestBidTick).toBe(Tick.fromPrice('0.999'))
+  })
+
+  test('behavior: multiple pairs have independent orderbooks', async () => {
+    const { base: base1, quote: quote1 } = await setupTokenPair(client)
+    const { base: base2, quote: quote2 } = await setupTokenPair(client)
+
+    // Place order on first pair
+    await Actions.dex.placeSync(client, {
+      token: base1,
+      amount: parseUnits('100', 6),
+      type: 'buy',
+      tick: Tick.fromPrice('1.001'),
+    })
+
+    // Place order on second pair at different tick
+    await Actions.dex.placeSync(client, {
+      token: base2,
+      amount: parseUnits('100', 6),
+      type: 'buy',
+      tick: Tick.fromPrice('0.999'),
+    })
+
+    // Get orderbooks
+    const book1 = await Actions.dex.getOrderbook(client, {
+      base: base1,
+      quote: quote1,
+    })
+
+    const book2 = await Actions.dex.getOrderbook(client, {
+      base: base2,
+      quote: quote2,
+    })
+
+    // Each pair should have its own best tick
+    expect(book1.bestBidTick).toBe(Tick.fromPrice('1.001'))
+    expect(book2.bestBidTick).toBe(Tick.fromPrice('0.999'))
+  })
+})
+
 describe('getPriceLevel', () => {
   test('default', async () => {
-    const { base } = await setupTokenPair()
+    const { base } = await setupTokenPair(client)
 
     const tick = Tick.fromPrice('1.001')
 
     // Place an order to create liquidity at this tick
     const { orderId } = await Actions.dex.placeSync(client, {
       token: base,
-      amount: parseEther('100'),
+      amount: parseUnits('100', 6),
       type: 'buy',
       tick,
     })
@@ -619,7 +813,7 @@ describe('getPriceLevel', () => {
   })
 
   test('behavior: empty price level', async () => {
-    const { base } = await setupTokenPair()
+    const { base } = await setupTokenPair(client)
 
     const tick = Tick.fromPrice('1.001')
 
@@ -637,14 +831,14 @@ describe('getPriceLevel', () => {
   })
 
   test('behavior: multiple orders at same tick', async () => {
-    const { base } = await setupTokenPair()
+    const { base } = await setupTokenPair(client)
 
     const tick = Tick.fromPrice('1.001')
 
     // Place first order
     const { orderId: orderId1 } = await Actions.dex.placeSync(client, {
       token: base,
-      amount: parseEther('100'),
+      amount: parseUnits('100', 6),
       type: 'buy',
       tick,
     })
@@ -652,7 +846,7 @@ describe('getPriceLevel', () => {
     // Place second order at same tick
     const { orderId: orderId2 } = await Actions.dex.placeSync(client, {
       token: base,
-      amount: parseEther('50'),
+      amount: parseUnits('50', 6),
       type: 'buy',
       tick,
     })
@@ -667,18 +861,18 @@ describe('getPriceLevel', () => {
     expect(level.head).toBe(orderId1) // head should be first order
     expect(level.tail).toBe(orderId2) // tail should be last order
     // Total liquidity should be sum of both orders (approximately)
-    expect(level.totalLiquidity).toBeGreaterThan(parseEther('145'))
+    expect(level.totalLiquidity).toBeGreaterThan(parseUnits('145', 6))
   })
 
   test('behavior: bid vs ask sides', async () => {
-    const { base } = await setupTokenPair()
+    const { base } = await setupTokenPair(client)
 
     const tick = Tick.fromPrice('1.001')
 
     // Place a buy order (bid)
     await Actions.dex.placeSync(client, {
       token: base,
-      amount: parseEther('100'),
+      amount: parseUnits('100', 6),
       type: 'buy',
       tick,
     })
@@ -686,7 +880,7 @@ describe('getPriceLevel', () => {
     // Place a sell order (ask) at same tick
     await Actions.dex.placeSync(client, {
       token: base,
-      amount: parseEther('50'),
+      amount: parseUnits('50', 6),
       type: 'sell',
       tick,
     })
@@ -712,21 +906,21 @@ describe('getPriceLevel', () => {
   })
 
   test('behavior: liquidity changes after order cancellation', async () => {
-    const { base } = await setupTokenPair()
+    const { base } = await setupTokenPair(client)
 
     const tick = Tick.fromPrice('1.001')
 
     // Place orders
     const { orderId: orderId1 } = await Actions.dex.placeSync(client, {
       token: base,
-      amount: parseEther('100'),
+      amount: parseUnits('100', 6),
       type: 'buy',
       tick,
     })
 
     await Actions.dex.placeSync(client, {
       token: base,
-      amount: parseEther('50'),
+      amount: parseUnits('50', 6),
       type: 'buy',
       tick,
     })
@@ -755,14 +949,14 @@ describe('getPriceLevel', () => {
   })
 
   test('behavior: liquidity changes after partial fill', async () => {
-    const { base, quote } = await setupTokenPair()
+    const { base, quote } = await setupTokenPair(client)
 
     const tick = Tick.fromPrice('1.001')
 
     // Place sell order
     await Actions.dex.placeSync(client, {
       token: base,
-      amount: parseEther('500'),
+      amount: parseUnits('500', 6),
       type: 'sell',
       tick,
     })
@@ -778,8 +972,8 @@ describe('getPriceLevel', () => {
     await Actions.dex.buySync(client, {
       tokenIn: quote,
       tokenOut: base,
-      amountOut: parseEther('100'),
-      maxAmountIn: parseEther('150'),
+      amountOut: parseUnits('100', 6),
+      maxAmountIn: parseUnits('150', 6),
     })
 
     // Get level after fill
@@ -794,12 +988,12 @@ describe('getPriceLevel', () => {
   })
 
   test('behavior: tick at boundaries', async () => {
-    const { base } = await setupTokenPair()
+    const { base } = await setupTokenPair(client)
 
     // Place order at min tick
     await Actions.dex.placeSync(client, {
       token: base,
-      amount: parseEther('10'),
+      amount: parseUnits('10', 6),
       type: 'sell',
       tick: Tick.minTick,
     })
@@ -815,7 +1009,7 @@ describe('getPriceLevel', () => {
     // Place order at max tick
     await Actions.dex.placeSync(client, {
       token: base,
-      amount: parseEther('10'),
+      amount: parseUnits('10', 6),
       type: 'buy',
       tick: Tick.maxTick,
     })
@@ -832,12 +1026,12 @@ describe('getPriceLevel', () => {
 
 describe('getSellQuote', () => {
   test('default', async () => {
-    const { base, quote } = await setupTokenPair()
+    const { base, quote } = await setupTokenPair(client)
 
     // Place bid orders to create liquidity
     await Actions.dex.placeSync(client, {
       token: base,
-      amount: parseEther('500'),
+      amount: parseUnits('500', 6),
       type: 'buy',
       tick: Tick.fromPrice('0.999'),
     })
@@ -846,100 +1040,91 @@ describe('getSellQuote', () => {
     const amountOut = await Actions.dex.getSellQuote(client, {
       tokenIn: base,
       tokenOut: quote,
-      amountIn: parseEther('100'),
+      amountIn: parseUnits('100', 6),
     })
 
     expect(amountOut).toBeGreaterThan(0n)
     // Should be approximately 100 * 0.999 = 99.9
-    expect(amountOut).toBeLessThan(parseEther('100'))
+    expect(amountOut).toBeLessThan(parseUnits('100', 6))
   })
 
   test('behavior: fails with no liquidity', async () => {
-    const { base, quote } = await setupTokenPair()
+    const { base, quote } = await setupTokenPair(client)
 
     // Quote should fail with no liquidity
     await expect(
       Actions.dex.getSellQuote(client, {
         tokenIn: base,
         tokenOut: quote,
-        amountIn: parseEther('100'),
+        amountIn: parseUnits('100', 6),
       }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(`
-      [ContractFunctionExecutionError: The contract function "quoteSwapExactAmountIn" reverted.
-
-      Error: InsufficientLiquidity()
-       
-      Contract Call:
-        address:   0xdec0000000000000000000000000000000000000
-        function:  quoteSwapExactAmountIn(address tokenIn, address tokenOut, uint128 amountIn)
-        args:                            (0x20c0000000000000000000000000000000000005, 0x20C0000000000000000000000000000000000004, 100000000000000000000)
-
-      Docs: https://viem.sh/docs/contract/readContract
-      Version: viem@2.38.3]
-    `)
+    ).rejects.toThrow('The contract function "quoteSwapExactAmountIn" reverted')
   })
 })
 
 describe('place', () => {
   test('default', async () => {
     // Setup token pair
-    const { base } = await setupTokenPair()
+    const { base } = await setupTokenPair(client)
 
     // Place a sell order
-    const { receipt, ...result } = await Actions.dex.placeSync(client, {
-      token: base,
-      amount: parseEther('100'),
-      type: 'sell',
-      tick: Tick.fromPrice('1.001'),
-    })
+    const { receipt, orderId, token, ...result } = await Actions.dex.placeSync(
+      client,
+      {
+        token: base,
+        amount: parseUnits('100', 6),
+        type: 'sell',
+        tick: Tick.fromPrice('1.001'),
+      },
+    )
 
     expect(receipt).toBeDefined()
     expect(receipt.status).toBe('success')
-    expect(result.orderId).toBeGreaterThan(0n)
+    expect(orderId).toBeGreaterThan(0n)
+    expect(token).toBe(base)
     expect(result).toMatchInlineSnapshot(`
       {
-        "amount": 100000000000000000000n,
+        "amount": 100000000n,
         "isBid": false,
         "maker": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-        "orderId": 1n,
         "tick": 100,
-        "token": "0x20c0000000000000000000000000000000000005",
       }
     `)
 
     // Place a buy order
-    const { receipt: receipt2, ...result2 } = await Actions.dex.placeSync(
-      client,
-      {
-        token: base,
-        amount: parseEther('100'),
-        type: 'buy',
-        tick: Tick.fromPrice('1.001'),
-      },
-    )
+    const {
+      receipt: receipt2,
+      orderId: orderId2,
+      token: token2,
+      ...result2
+    } = await Actions.dex.placeSync(client, {
+      token: base,
+      amount: parseUnits('100', 6),
+      type: 'buy',
+      tick: Tick.fromPrice('1.001'),
+    })
     expect(receipt2.status).toBe('success')
-    expect(result2.orderId).toBeGreaterThan(0n)
+    expect(orderId2).toBeGreaterThan(0n)
+    expect(token2).toBe(base)
     expect(result2).toMatchInlineSnapshot(`
       {
-        "amount": 100000000000000000000n,
+        "amount": 100000000n,
         "isBid": true,
         "maker": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-        "orderId": 2n,
         "tick": 100,
-        "token": "0x20c0000000000000000000000000000000000005",
       }
     `)
   })
 
   test('behavior: tick at boundaries', async () => {
-    const { base } = await setupTokenPair()
+    const { base } = await setupTokenPair(client)
 
     // Test at min tick (-2000)
     const { receipt: receipt1, ...result1 } = await Actions.dex.placeSync(
       client,
       {
         token: base,
-        amount: parseEther('10'),
+        amount: parseUnits('10', 6),
         type: 'sell',
         tick: Tick.minTick,
       },
@@ -952,7 +1137,7 @@ describe('place', () => {
       client,
       {
         token: base,
-        amount: parseEther('10'),
+        amount: parseUnits('10', 6),
         type: 'buy',
         tick: Tick.maxTick,
       },
@@ -962,59 +1147,31 @@ describe('place', () => {
   })
 
   test('behavior: tick validation fails outside bounds', async () => {
-    const { base } = await setupTokenPair()
+    const { base } = await setupTokenPair(client)
 
     // Test tick above max tix should fail
     await expect(
       Actions.dex.placeSync(client, {
         token: base,
-        amount: parseEther('10'),
+        amount: parseUnits('10', 6),
         type: 'buy',
         tick: Tick.maxTick + 1,
       }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(`
-      [ContractFunctionExecutionError: The contract function "place" reverted.
-
-      Error: TickOutOfBounds(int16 tick)
-                            (2001)
-       
-      Contract Call:
-        address:   0xdec0000000000000000000000000000000000000
-        function:  place(address token, uint128 amount, bool isBid, int16 tick)
-        args:           (0x20c0000000000000000000000000000000000005, 10000000000000000000, true, 2001)
-        sender:    0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266
-
-      Docs: https://viem.sh/docs/contract/writeContract
-      Version: viem@2.38.3]
-    `)
+    ).rejects.toThrow('The contract function "place" reverted')
 
     // Test tick below min tick should fail
     await expect(
       Actions.dex.placeSync(client, {
         token: base,
-        amount: parseEther('10'),
+        amount: parseUnits('10', 6),
         type: 'sell',
         tick: Tick.minTick - 1,
       }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(`
-      [ContractFunctionExecutionError: The contract function "place" reverted.
-
-      Error: TickOutOfBounds(int16 tick)
-                            (-2001)
-       
-      Contract Call:
-        address:   0xdec0000000000000000000000000000000000000
-        function:  place(address token, uint128 amount, bool isBid, int16 tick)
-        args:           (0x20c0000000000000000000000000000000000005, 10000000000000000000, false, -2001)
-        sender:    0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266
-
-      Docs: https://viem.sh/docs/contract/writeContract
-      Version: viem@2.38.3]
-    `)
+    ).rejects.toThrow('The contract function "place" reverted')
   })
 
   test('behavior: transfers from wallet', async () => {
-    const { base, quote } = await setupTokenPair()
+    const { base, quote } = await setupTokenPair(client)
 
     // Get balances before placing order
     const baseBalanceBefore = await Actions.token.getBalance(client, {
@@ -1025,7 +1182,7 @@ describe('place', () => {
     })
 
     // Place a buy order - should transfer quote tokens to escrow
-    const orderAmount = parseEther('100')
+    const orderAmount = parseUnits('100', 6)
     const tick = Tick.fromPrice('1.001')
     await Actions.dex.placeSync(client, {
       token: base,
@@ -1055,14 +1212,14 @@ describe('place', () => {
   })
 
   test('behavior: multiple orders at same tick', async () => {
-    const { base } = await setupTokenPair()
+    const { base } = await setupTokenPair(client)
 
     const tick = Tick.fromPrice('1.0005')
 
     // Place first order
     const { orderId: orderId1 } = await Actions.dex.placeSync(client, {
       token: base,
-      amount: parseEther('100'),
+      amount: parseUnits('100', 6),
       type: 'buy',
       tick,
     })
@@ -1070,7 +1227,7 @@ describe('place', () => {
     // Place second order at same tick
     const { orderId: orderId2 } = await Actions.dex.placeSync(client, {
       token: base,
-      amount: parseEther('50'),
+      amount: parseUnits('50', 6),
       type: 'buy',
       tick,
     })
@@ -1082,41 +1239,41 @@ describe('place', () => {
 
 describe('placeFlip', () => {
   test('default', async () => {
-    const { base } = await setupTokenPair()
+    const { base } = await setupTokenPair(client)
 
     // Place a flip bid order
-    const { receipt, ...result } = await Actions.dex.placeFlipSync(client, {
-      token: base,
-      amount: parseEther('100'),
-      type: 'buy',
-      tick: Tick.fromPrice('1.001'),
-      flipTick: Tick.fromPrice('1.002'),
-    })
+    const { receipt, orderId, token, ...result } =
+      await Actions.dex.placeFlipSync(client, {
+        token: base,
+        amount: parseUnits('100', 6),
+        type: 'buy',
+        tick: Tick.fromPrice('1.001'),
+        flipTick: Tick.fromPrice('1.002'),
+      })
 
     expect(receipt).toBeDefined()
     expect(receipt.status).toBe('success')
-    expect(result.orderId).toBeGreaterThan(0n)
+    expect(orderId).toBeGreaterThan(0n)
+    expect(token).toBe(base)
     expect(result.flipTick).toBe(Tick.fromPrice('1.002'))
     expect(result).toMatchInlineSnapshot(`
       {
-        "amount": 100000000000000000000n,
+        "amount": 100000000n,
         "flipTick": 200,
         "isBid": true,
         "maker": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-        "orderId": 1n,
         "tick": 100,
-        "token": "0x20c0000000000000000000000000000000000005",
       }
     `)
   })
 
   test('behavior: flip bid requires flipTick > tick', async () => {
-    const { base } = await setupTokenPair()
+    const { base } = await setupTokenPair(client)
 
     // Valid: flipTick > tick for bid
     const { receipt: receipt1 } = await Actions.dex.placeFlipSync(client, {
       token: base,
-      amount: parseEther('10'),
+      amount: parseUnits('10', 6),
       type: 'buy',
       tick: Tick.fromPrice('1.0005'),
       flipTick: Tick.fromPrice('1.001'),
@@ -1127,57 +1284,31 @@ describe('placeFlip', () => {
     await expect(
       Actions.dex.placeFlipSync(client, {
         token: base,
-        amount: parseEther('10'),
+        amount: parseUnits('10', 6),
         type: 'buy',
         tick: Tick.fromPrice('1.001'),
         flipTick: Tick.fromPrice('1.001'), // Equal
       }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(`
-      [ContractFunctionExecutionError: The contract function "placeFlip" reverted.
-
-      Error: InvalidFlipTick()
-       
-      Contract Call:
-        address:   0xdec0000000000000000000000000000000000000
-        function:  placeFlip(address token, uint128 amount, bool isBid, int16 tick, int16 flipTick)
-        args:               (0x20c0000000000000000000000000000000000005, 10000000000000000000, true, 100, 100)
-        sender:    0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266
-
-      Docs: https://viem.sh/docs/contract/writeContract
-      Version: viem@2.38.3]
-    `)
+    ).rejects.toThrow('The contract function "placeFlip" reverted')
 
     await expect(
       Actions.dex.placeFlipSync(client, {
         token: base,
-        amount: parseEther('10'),
+        amount: parseUnits('10', 6),
         type: 'buy',
         tick: Tick.fromPrice('1.001'),
         flipTick: Tick.fromPrice('1.0005'), // Less than
       }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(`
-      [ContractFunctionExecutionError: The contract function "placeFlip" reverted.
-
-      Error: InvalidFlipTick()
-       
-      Contract Call:
-        address:   0xdec0000000000000000000000000000000000000
-        function:  placeFlip(address token, uint128 amount, bool isBid, int16 tick, int16 flipTick)
-        args:               (0x20c0000000000000000000000000000000000005, 10000000000000000000, true, 100, 50)
-        sender:    0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266
-
-      Docs: https://viem.sh/docs/contract/writeContract
-      Version: viem@2.38.3]
-    `)
+    ).rejects.toThrow('The contract function "placeFlip" reverted')
   })
 
   test('behavior: flip ask requires flipTick < tick', async () => {
-    const { base } = await setupTokenPair()
+    const { base } = await setupTokenPair(client)
 
     // Valid: flipTick < tick for ask
     const { receipt: receipt1 } = await Actions.dex.placeFlipSync(client, {
       token: base,
-      amount: parseEther('10'),
+      amount: parseUnits('10', 6),
       type: 'sell',
       tick: Tick.fromPrice('1.001'),
       flipTick: Tick.fromPrice('1.0005'),
@@ -1188,57 +1319,31 @@ describe('placeFlip', () => {
     await expect(
       Actions.dex.placeFlipSync(client, {
         token: base,
-        amount: parseEther('10'),
+        amount: parseUnits('10', 6),
         type: 'sell',
         tick: Tick.fromPrice('1.0005'),
         flipTick: Tick.fromPrice('1.0005'), // Equal
       }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(`
-      [ContractFunctionExecutionError: The contract function "placeFlip" reverted.
-
-      Error: InvalidFlipTick()
-       
-      Contract Call:
-        address:   0xdec0000000000000000000000000000000000000
-        function:  placeFlip(address token, uint128 amount, bool isBid, int16 tick, int16 flipTick)
-        args:               (0x20c0000000000000000000000000000000000005, 10000000000000000000, false, 50, 50)
-        sender:    0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266
-
-      Docs: https://viem.sh/docs/contract/writeContract
-      Version: viem@2.38.3]
-    `)
+    ).rejects.toThrow('The contract function "placeFlip" reverted')
 
     await expect(
       Actions.dex.placeFlipSync(client, {
         token: base,
-        amount: parseEther('10'),
+        amount: parseUnits('10', 6),
         type: 'sell',
         tick: Tick.fromPrice('1.0005'),
         flipTick: Tick.fromPrice('1.001'), // Greater than
       }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(`
-      [ContractFunctionExecutionError: The contract function "placeFlip" reverted.
-
-      Error: InvalidFlipTick()
-       
-      Contract Call:
-        address:   0xdec0000000000000000000000000000000000000
-        function:  placeFlip(address token, uint128 amount, bool isBid, int16 tick, int16 flipTick)
-        args:               (0x20c0000000000000000000000000000000000005, 10000000000000000000, false, 50, 100)
-        sender:    0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266
-
-      Docs: https://viem.sh/docs/contract/writeContract
-      Version: viem@2.38.3]
-    `)
+    ).rejects.toThrow('The contract function "placeFlip" reverted')
   })
 
   test('behavior: flip ticks at boundaries', async () => {
-    const { base } = await setupTokenPair()
+    const { base } = await setupTokenPair(client)
 
     // Flip order with ticks at extreme boundaries
     const { receipt } = await Actions.dex.placeFlipSync(client, {
       token: base,
-      amount: parseEther('10'),
+      amount: parseUnits('10', 6),
       type: 'buy',
       tick: Tick.minTick,
       flipTick: Tick.maxTick,
@@ -1249,12 +1354,12 @@ describe('placeFlip', () => {
 
 describe('sell', () => {
   test('default', async () => {
-    const { base, quote } = await setupTokenPair()
+    const { base, quote } = await setupTokenPair(client)
 
     // Place bid order to create liquidity
     await Actions.dex.placeSync(client, {
       token: base,
-      amount: parseEther('500'),
+      amount: parseUnits('500', 6),
       type: 'buy',
       tick: Tick.fromPrice('0.999'),
     })
@@ -1263,8 +1368,8 @@ describe('sell', () => {
     const { receipt } = await Actions.dex.sellSync(client, {
       tokenIn: base,
       tokenOut: quote,
-      amountIn: parseEther('100'),
-      minAmountOut: parseEther('50'),
+      amountIn: parseUnits('100', 6),
+      minAmountOut: parseUnits('50', 6),
     })
 
     expect(receipt).toBeDefined()
@@ -1272,12 +1377,12 @@ describe('sell', () => {
   })
 
   test('behavior: respects minAmountOut', async () => {
-    const { base, quote } = await setupTokenPair()
+    const { base, quote } = await setupTokenPair(client)
 
     // Place bid order at low price
     await Actions.dex.placeSync(client, {
       token: base,
-      amount: parseEther('500'),
+      amount: parseUnits('500', 6),
       type: 'buy',
       tick: Tick.fromPrice('0.99'), // 1% below peg
     })
@@ -1287,27 +1392,14 @@ describe('sell', () => {
       Actions.dex.sellSync(client, {
         tokenIn: base,
         tokenOut: quote,
-        amountIn: parseEther('100'),
-        minAmountOut: parseEther('150'), // Way too high
+        amountIn: parseUnits('100', 6),
+        minAmountOut: parseUnits('150', 6), // Way too high
       }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(`
-      [ContractFunctionExecutionError: The contract function "swapExactAmountIn" reverted.
-
-      Error: InsufficientOutput()
-       
-      Contract Call:
-        address:   0xdec0000000000000000000000000000000000000
-        function:  swapExactAmountIn(address tokenIn, address tokenOut, uint128 amountIn, uint128 minAmountOut)
-        args:                       (0x20c0000000000000000000000000000000000005, 0x20C0000000000000000000000000000000000004, 100000000000000000000, 150000000000000000000)
-        sender:    0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266
-
-      Docs: https://viem.sh/docs/contract/writeContract
-      Version: viem@2.38.3]
-    `)
+    ).rejects.toThrow('The contract function "swapExactAmountIn" reverted')
   })
 
   test('behavior: fails with insufficient liquidity', async () => {
-    const { base, quote } = await setupTokenPair()
+    const { base, quote } = await setupTokenPair(client)
 
     // No orders - no liquidity
 
@@ -1316,29 +1408,16 @@ describe('sell', () => {
       Actions.dex.sellSync(client, {
         tokenIn: base,
         tokenOut: quote,
-        amountIn: parseEther('100'),
-        minAmountOut: parseEther('50'),
+        amountIn: parseUnits('100', 6),
+        minAmountOut: parseUnits('50', 6),
       }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(`
-      [ContractFunctionExecutionError: The contract function "swapExactAmountIn" reverted.
-
-      Error: InsufficientLiquidity()
-       
-      Contract Call:
-        address:   0xdec0000000000000000000000000000000000000
-        function:  swapExactAmountIn(address tokenIn, address tokenOut, uint128 amountIn, uint128 minAmountOut)
-        args:                       (0x20c0000000000000000000000000000000000005, 0x20C0000000000000000000000000000000000004, 100000000000000000000, 50000000000000000000)
-        sender:    0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266
-
-      Docs: https://viem.sh/docs/contract/writeContract
-      Version: viem@2.38.3]
-    `)
+    ).rejects.toThrow('The contract function "swapExactAmountIn" reverted')
   })
 })
 
 describe('watchFlipOrderPlaced', () => {
   test('default', async () => {
-    const { base } = await setupTokenPair()
+    const { base } = await setupTokenPair(client)
 
     const receivedOrders: Array<{
       args: Actions.dex.watchFlipOrderPlaced.Args
@@ -1355,7 +1434,7 @@ describe('watchFlipOrderPlaced', () => {
       // Place flip order
       await Actions.dex.placeFlipSync(client, {
         token: base,
-        amount: parseEther('100'),
+        amount: parseUnits('100', 6),
         type: 'buy',
         tick: Tick.fromPrice('1.001'),
         flipTick: Tick.fromPrice('1.002'),
@@ -1374,7 +1453,7 @@ describe('watchFlipOrderPlaced', () => {
 
 describe('watchOrderCancelled', () => {
   test('default', async () => {
-    const { base } = await setupTokenPair()
+    const { base } = await setupTokenPair(client)
 
     const receivedCancellations: Array<{
       args: Actions.dex.watchOrderCancelled.Args
@@ -1391,7 +1470,7 @@ describe('watchOrderCancelled', () => {
       // Place order
       const { orderId } = await Actions.dex.placeSync(client, {
         token: base,
-        amount: parseEther('100'),
+        amount: parseUnits('100', 6),
         type: 'buy',
         tick: Tick.fromPrice('1.001'),
       })
@@ -1411,19 +1490,19 @@ describe('watchOrderCancelled', () => {
   })
 
   test('behavior: filter by orderId', async () => {
-    const { base } = await setupTokenPair()
+    const { base } = await setupTokenPair(client)
 
     // Place two orders
     const { orderId: orderId1 } = await Actions.dex.placeSync(client, {
       token: base,
-      amount: parseEther('100'),
+      amount: parseUnits('100', 6),
       type: 'buy',
       tick: Tick.fromPrice('1.001'),
     })
 
     const { orderId: orderId2 } = await Actions.dex.placeSync(client, {
       token: base,
-      amount: parseEther('50'),
+      amount: parseUnits('50', 6),
       type: 'buy',
       tick: Tick.fromPrice('1.001'),
     })
@@ -1467,7 +1546,7 @@ describe.todo('watchOrderFilled')
 
 describe('watchOrderPlaced', () => {
   test('default', async () => {
-    const { base } = await setupTokenPair()
+    const { base } = await setupTokenPair(client)
 
     const receivedOrders: Array<{
       args: Actions.dex.watchOrderPlaced.Args
@@ -1484,7 +1563,7 @@ describe('watchOrderPlaced', () => {
       // Place first order
       await Actions.dex.placeSync(client, {
         token: base,
-        amount: parseEther('100'),
+        amount: parseUnits('100', 6),
         type: 'buy',
         tick: Tick.fromPrice('1.001'),
       })
@@ -1492,7 +1571,7 @@ describe('watchOrderPlaced', () => {
       // Place second order
       await Actions.dex.placeSync(client, {
         token: base,
-        amount: parseEther('50'),
+        amount: parseUnits('50', 6),
         type: 'sell',
         tick: Tick.fromPrice('0.999'),
       })
@@ -1502,17 +1581,17 @@ describe('watchOrderPlaced', () => {
 
       expect(receivedOrders).toHaveLength(2)
       expect(receivedOrders[0]?.args.isBid).toBe(true)
-      expect(receivedOrders[0]?.args.amount).toBe(parseEther('100'))
+      expect(receivedOrders[0]?.args.amount).toBe(parseUnits('100', 6))
       expect(receivedOrders[1]?.args.isBid).toBe(false)
-      expect(receivedOrders[1]?.args.amount).toBe(parseEther('50'))
+      expect(receivedOrders[1]?.args.amount).toBe(parseUnits('50', 6))
     } finally {
       unwatch()
     }
   })
 
   test('behavior: filter by token', async () => {
-    const { base } = await setupTokenPair()
-    const { base: base2 } = await setupTokenPair()
+    const { base } = await setupTokenPair(client)
+    const { base: base2 } = await setupTokenPair(client)
 
     const receivedOrders: Array<{
       args: Actions.dex.watchOrderPlaced.Args
@@ -1531,7 +1610,7 @@ describe('watchOrderPlaced', () => {
       // Place order on base (should be captured)
       await Actions.dex.placeSync(client, {
         token: base,
-        amount: parseEther('100'),
+        amount: parseUnits('100', 6),
         type: 'buy',
         tick: Tick.fromPrice('1.001'),
       })
@@ -1539,7 +1618,7 @@ describe('watchOrderPlaced', () => {
       // Place order on base2 (should NOT be captured)
       await Actions.dex.placeSync(client, {
         token: base2,
-        amount: parseEther('50'),
+        amount: parseUnits('50', 6),
         type: 'buy',
         tick: Tick.fromPrice('1.001'),
       })
@@ -1559,12 +1638,12 @@ describe('watchOrderPlaced', () => {
 
 describe('withdraw', () => {
   test('default', async () => {
-    const { base, quote } = await setupTokenPair()
+    const { base, quote } = await setupTokenPair(client)
 
     // Create internal balance
     const { orderId } = await Actions.dex.placeSync(client, {
       token: base,
-      amount: parseEther('100'),
+      amount: parseUnits('100', 6),
       type: 'buy',
       tick: Tick.fromPrice('1.001'),
     })
@@ -1573,7 +1652,7 @@ describe('withdraw', () => {
 
     // Get DEX balance
     const dexBalance = await Actions.dex.getBalance(client, {
-      account: account.address,
+      account: client.account.address,
       token: quote,
     })
     expect(dexBalance).toBeGreaterThan(0n)
@@ -1594,7 +1673,7 @@ describe('withdraw', () => {
 
     // Check DEX balance is now 0
     const dexBalanceAfter = await Actions.dex.getBalance(client, {
-      account: account.address,
+      account: client.account.address,
       token: quote,
     })
     expect(dexBalanceAfter).toBe(0n)