tempo.ts 0.1.5 → 0.2.1

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

@@ -0,0 +1,1507 @@
+import { connect } from '@wagmi/core'
+import { Tick } from 'tempo.ts/viem'
+import { Actions } from 'tempo.ts/wagmi'
+import { isAddress, parseUnits } from 'viem'
+import { beforeAll, describe, expect, test } from 'vitest'
+import { accounts, addresses } from '../../../test/viem/config.js'
+import {
+  config,
+  queryClient,
+  setupOrders,
+  setupTokenPair,
+} from '../../../test/wagmi/config.js'
+
+const account = accounts[0]
+const account2 = accounts[1]
+
+beforeAll(async () => {
+  await setupOrders()
+})
+
+describe('buy', () => {
+  test('default', async () => {
+    const { base, quote } = await setupTokenPair()
+
+    // Place ask order to create liquidity
+    await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('500', 6),
+      type: 'sell',
+      tick: Tick.fromPrice('1.001'),
+    })
+
+    // Get initial balances
+    const baseBalanceBefore = await Actions.token.getBalance(config, {
+      token: base,
+      account: account.address,
+    })
+
+    // Buy base tokens with quote tokens
+    const { receipt } = await Actions.dex.buySync(config, {
+      tokenIn: quote,
+      tokenOut: base,
+      amountOut: parseUnits('100', 6),
+      maxAmountIn: parseUnits('150', 6),
+    })
+
+    expect(receipt).toBeDefined()
+    expect(receipt.status).toBe('success')
+
+    // Verify balances changed
+    const baseBalanceAfter = await Actions.token.getBalance(config, {
+      token: base,
+      account: account.address,
+    })
+
+    // Should have received base tokens
+    expect(baseBalanceAfter).toBeGreaterThan(baseBalanceBefore)
+  })
+
+  test('behavior: respects maxAmountIn', async () => {
+    const { base, quote } = await setupTokenPair()
+
+    // Place ask order at high price
+    await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('500', 6),
+      type: 'sell',
+      tick: Tick.fromPrice('1.01'), // 1% above peg
+    })
+
+    // Try to buy with insufficient maxAmountIn - should fail
+    await expect(
+      Actions.dex.buySync(config, {
+        tokenIn: quote,
+        tokenOut: base,
+        amountOut: parseUnits('100', 6),
+        maxAmountIn: parseUnits('50', 6), // Way too low for 1% premium
+      }),
+    ).rejects.toThrow('The contract function "swapExactAmountOut" reverted')
+  })
+
+  test('behavior: fails with insufficient liquidity', async () => {
+    const { base, quote } = await setupTokenPair()
+
+    // Don't place any orders - no liquidity
+
+    // Try to buy - should fail due to no liquidity
+    await expect(
+      Actions.dex.buySync(config, {
+        tokenIn: quote,
+        tokenOut: base,
+        amountOut: parseUnits('100', 6),
+        maxAmountIn: parseUnits('150', 6),
+      }),
+    ).rejects.toThrow('The contract function "swapExactAmountOut" reverted')
+  })
+})
+
+describe('cancel', () => {
+  test('default', async () => {
+    const { base, quote } = await setupTokenPair()
+
+    // Place a bid order
+    const { orderId } = await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('100', 6),
+      type: 'buy',
+      tick: Tick.fromPrice('1.001'),
+    })
+
+    // Check initial DEX balance (should be 0)
+    const dexBalanceBefore = await Actions.dex.getBalance(config, {
+      account: account.address,
+      token: quote,
+    })
+    expect(dexBalanceBefore).toBe(0n)
+
+    // Cancel the order
+    const { receipt, ...result } = await Actions.dex.cancelSync(config, {
+      orderId,
+    })
+
+    expect(receipt).toBeDefined()
+    expect(receipt.status).toBe('success')
+    expect(result.orderId).toBe(orderId)
+
+    // Check DEX balance after cancel - tokens should be refunded to internal balance
+    const dexBalanceAfter = await Actions.dex.getBalance(config, {
+      account: account.address,
+      token: quote,
+    })
+    expect(dexBalanceAfter).toBeGreaterThan(0n)
+  })
+
+  test('behavior: only maker can cancel', async () => {
+    const { base } = await setupTokenPair()
+
+    // Account places order
+    const { orderId } = await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('100', 6),
+      type: 'buy',
+      tick: Tick.fromPrice('1.001'),
+    })
+
+    // Transfer gas to account2
+    await Actions.token.transferSync(config, {
+      to: account2.address,
+      amount: parseUnits('1', 6),
+      token: addresses.alphaUsd,
+    })
+
+    // Use a different account via the connector
+    await connect(config, {
+      connector: config.connectors[1]!,
+    })
+
+    // Account2 tries to cancel - should fail
+    await expect(
+      Actions.dex.cancelSync(config, {
+        orderId,
+      }),
+    ).rejects.toThrow('The contract function "cancel" reverted')
+  })
+
+  test('behavior: cannot cancel non-existent order', async () => {
+    await setupTokenPair()
+
+    // Try to cancel an order that doesn't exist
+    await expect(
+      Actions.dex.cancelSync(config, {
+        orderId: 999n,
+      }),
+    ).rejects.toThrow('The contract function "cancel" reverted')
+  })
+})
+
+describe('createPair', () => {
+  test('default', async () => {
+    await connect(config, {
+      connector: config.connectors[0]!,
+    })
+
+    const { token: baseToken } = await Actions.token.createSync(config, {
+      name: 'Test Base Token',
+      symbol: 'BASE',
+      currency: 'USD',
+      admin: account,
+    })
+
+    const { receipt, ...result } = await Actions.dex.createPairSync(config, {
+      base: baseToken,
+    })
+
+    expect(receipt).toBeDefined()
+    expect(receipt.status).toBe('success')
+
+    const { key, ...rest } = result
+    expect(key).toBeDefined()
+    expect(rest).toEqual(
+      expect.objectContaining({
+        base: expect.toSatisfy(isAddress),
+        quote: expect.toSatisfy(isAddress),
+      }),
+    )
+  })
+})
+
+describe('getBalance', () => {
+  test('default', async () => {
+    const { base, quote } = await setupTokenPair()
+
+    // Initial balance should be 0
+    const initialBalance = await Actions.dex.getBalance(config, {
+      account: account.address,
+      token: quote,
+    })
+    expect(initialBalance).toBe(0n)
+
+    // Place and cancel order to create internal balance
+    const { orderId } = await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('50', 6),
+      type: 'buy',
+      tick: Tick.fromPrice('1.0005'),
+    })
+
+    await Actions.dex.cancelSync(config, {
+      orderId,
+    })
+
+    // Now balance should be > 0 (refunded quote tokens)
+    const balance = await Actions.dex.getBalance(config, {
+      account: account.address,
+      token: quote,
+    })
+    expect(balance).toBeGreaterThan(0n)
+  })
+
+  test('behavior: check different account', async () => {
+    const { quote } = await setupTokenPair()
+
+    // Check account2's balance (should be 0)
+    const balance = await Actions.dex.getBalance(config, {
+      account: account2.address,
+      token: quote,
+    })
+    expect(balance).toBe(0n)
+  })
+
+  test('behavior: balances are per-token', async () => {
+    const { base, quote } = await setupTokenPair()
+
+    // Create balance in quote token
+    const { orderId } = await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('100', 6),
+      type: 'buy',
+      tick: Tick.fromPrice('1.001'),
+    })
+    await Actions.dex.cancelSync(config, { orderId })
+
+    // Check quote balance (should have refunded tokens)
+    const quoteBalance = await Actions.dex.getBalance(config, {
+      account: account.address,
+      token: quote,
+    })
+    expect(quoteBalance).toBeGreaterThan(0n)
+
+    // Check base balance (should still be 0)
+    const baseBalance = await Actions.dex.getBalance(config, {
+      account: account.address,
+      token: base,
+    })
+    expect(baseBalance).toBe(0n)
+  })
+})
+
+describe('getBuyQuote', () => {
+  test('default', async () => {
+    const { base, quote } = await setupTokenPair()
+
+    // Place ask orders to create liquidity
+    await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('500', 6),
+      type: 'sell',
+      tick: Tick.fromPrice('1.001'),
+    })
+
+    // Get quote for buying base tokens
+    const amountIn = await Actions.dex.getBuyQuote(config, {
+      tokenIn: quote,
+      tokenOut: base,
+      amountOut: parseUnits('100', 6),
+    })
+
+    expect(amountIn).toBeGreaterThan(0n)
+    // Should be approximately 100 * 1.001 = 100.1
+    expect(amountIn).toBeGreaterThan(parseUnits('100', 6))
+  })
+
+  test('behavior: fails with no liquidity', async () => {
+    const { base, quote } = await setupTokenPair()
+
+    // No orders placed - no liquidity
+
+    // Quote should fail
+    await expect(
+      Actions.dex.getBuyQuote(config, {
+        tokenIn: quote,
+        tokenOut: base,
+        amountOut: parseUnits('100', 6),
+      }),
+    ).rejects.toThrow(
+      'The contract function "quoteSwapExactAmountOut" reverted',
+    )
+  })
+})
+
+describe('getOrder', () => {
+  test('default', async () => {
+    const { base } = await setupTokenPair()
+
+    // Place an order to get an order ID
+    const { orderId } = await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('100', 6),
+      type: 'buy',
+      tick: Tick.fromPrice('1.001'),
+    })
+
+    // Get the order details
+    const order = await Actions.dex.getOrder(config, {
+      orderId,
+    })
+
+    expect(order).toBeDefined()
+    expect(order.maker).toBe(account.address)
+    expect(order.isBid).toBe(true)
+    expect(order.tick).toBe(Tick.fromPrice('1.001'))
+    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()
+
+    // Place a flip order
+    const { orderId } = await Actions.dex.placeFlipSync(config, {
+      token: base,
+      amount: parseUnits('50', 6),
+      type: 'buy',
+      tick: Tick.fromPrice('1.001'),
+      flipTick: Tick.fromPrice('1.002'),
+    })
+
+    // Get the order details
+    const order = await Actions.dex.getOrder(config, {
+      orderId,
+    })
+
+    expect(order).toBeDefined()
+    expect(order.maker).toBe(account.address)
+    expect(order.isBid).toBe(true)
+    expect(order.tick).toBe(Tick.fromPrice('1.001'))
+    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()
+
+    // Try to get an order that doesn't exist
+    await expect(
+      Actions.dex.getOrder(config, {
+        orderId: 999n,
+      }),
+    ).rejects.toThrow('The contract function "getOrder" reverted')
+  })
+
+  test('behavior: reflects order state after partial fill', async () => {
+    const { base, quote } = await setupTokenPair()
+
+    // Place a large sell order
+    const { orderId } = await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('500', 6),
+      type: 'sell',
+      tick: Tick.fromPrice('1.001'),
+    })
+
+    // Get initial order state
+    const orderBefore = await Actions.dex.getOrder(config, {
+      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(config, {
+      tokenIn: quote,
+      tokenOut: base,
+      amountOut: parseUnits('100', 6),
+      maxAmountIn: parseUnits('150', 6),
+    })
+
+    // Get order state after partial fill
+    const orderAfter = await Actions.dex.getOrder(config, {
+      orderId,
+    })
+    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 tick = Tick.fromPrice('1.001')
+
+    // Place first order
+    const { orderId: orderId1 } = await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('100', 6),
+      type: 'buy',
+      tick,
+    })
+
+    // Place second order at same tick
+    const { orderId: orderId2 } = await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('50', 6),
+      type: 'buy',
+      tick,
+    })
+
+    // Get first order
+    const order1 = await Actions.dex.getOrder(config, {
+      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(config, {
+      orderId: orderId2,
+    })
+    expect(order2.prev).toBe(orderId1) // should point to first order
+    expect(order2.next).toBe(0n) // should be 0 as it's last
+  })
+})
+
+describe('getOrders', () => {
+  test('default', async () => {
+    const response = await Actions.dex.getOrders(config, {
+      limit: 10,
+    })
+
+    expect(response).matchSnapshot()
+  })
+
+  describe('infiniteQueryOptions', () => {
+    test('default', async () => {
+      const options = Actions.dex.getOrders.infiniteQueryOptions(config, {
+        limit: 5,
+        query: {
+          pages: 2,
+        },
+      })
+
+      const result = await queryClient.fetchInfiniteQuery(options)
+
+      expect(result).matchSnapshot()
+    })
+  })
+})
+
+describe('getOrderbook', () => {
+  test('default', async () => {
+    const { base, quote } = await setupTokenPair()
+
+    // Get orderbook information
+    const book = await Actions.dex.getOrderbook(config, {
+      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()
+
+    const bidTick = Tick.fromPrice('0.999')
+    const askTick = Tick.fromPrice('1.001')
+
+    // Place a bid order
+    await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('100', 6),
+      type: 'buy',
+      tick: bidTick,
+    })
+
+    // Place an ask order
+    await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('100', 6),
+      type: 'sell',
+      tick: askTick,
+    })
+
+    // Get orderbook
+    const book = await Actions.dex.getOrderbook(config, {
+      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()
+
+    // Place initial bid at 0.999
+    await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('100', 6),
+      type: 'buy',
+      tick: Tick.fromPrice('0.999'),
+    })
+
+    // Get orderbook
+    const bookBefore = await Actions.dex.getOrderbook(config, {
+      base,
+      quote,
+    })
+    expect(bookBefore.bestBidTick).toBe(Tick.fromPrice('0.999'))
+
+    // Place better bid at 1.0
+    await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('100', 6),
+      type: 'buy',
+      tick: Tick.fromPrice('1.0'),
+    })
+
+    // Get orderbook again
+    const bookAfter = await Actions.dex.getOrderbook(config, {
+      base,
+      quote,
+    })
+    expect(bookAfter.bestBidTick).toBe(Tick.fromPrice('1.0'))
+  })
+
+  test.todo('behavior: best ticks update after order cancellation')
+
+  test('behavior: multiple pairs have independent orderbooks', async () => {
+    const { base: base1, quote: quote1 } = await setupTokenPair()
+    const { base: base2, quote: quote2 } = await setupTokenPair()
+
+    // Place order on first pair
+    await Actions.dex.placeSync(config, {
+      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(config, {
+      token: base2,
+      amount: parseUnits('100', 6),
+      type: 'buy',
+      tick: Tick.fromPrice('0.999'),
+    })
+
+    // Get orderbooks
+    const book1 = await Actions.dex.getOrderbook(config, {
+      base: base1,
+      quote: quote1,
+    })
+
+    const book2 = await Actions.dex.getOrderbook(config, {
+      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 tick = Tick.fromPrice('1.001')
+
+    // Place an order to create liquidity at this tick
+    const { orderId } = await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('100', 6),
+      type: 'buy',
+      tick,
+    })
+
+    // Get the price level
+    const level = await Actions.dex.getPriceLevel(config, {
+      base,
+      tick,
+      isBid: true,
+    })
+
+    expect(level).toBeDefined()
+    expect(level.head).toBe(orderId) // head should be our order
+    expect(level.tail).toBe(orderId) // tail should also be our order (only one)
+    expect(level.totalLiquidity).toBeGreaterThan(0n)
+  })
+
+  test('behavior: empty price level', async () => {
+    const { base } = await setupTokenPair()
+
+    const tick = Tick.fromPrice('1.001')
+
+    // Query a tick with no orders
+    const level = await Actions.dex.getPriceLevel(config, {
+      base,
+      tick,
+      isBid: true,
+    })
+
+    expect(level).toBeDefined()
+    expect(level.head).toBe(0n)
+    expect(level.tail).toBe(0n)
+    expect(level.totalLiquidity).toBe(0n)
+  })
+
+  test('behavior: multiple orders at same tick', async () => {
+    const { base } = await setupTokenPair()
+
+    const tick = Tick.fromPrice('1.001')
+
+    // Place first order
+    const { orderId: orderId1 } = await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('100', 6),
+      type: 'buy',
+      tick,
+    })
+
+    // Place second order at same tick
+    const { orderId: orderId2 } = await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('50', 6),
+      type: 'buy',
+      tick,
+    })
+
+    // Get the price level
+    const level = await Actions.dex.getPriceLevel(config, {
+      base,
+      tick,
+      isBid: true,
+    })
+
+    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(parseUnits('145', 6))
+  })
+
+  test('behavior: bid vs ask sides', async () => {
+    const { base } = await setupTokenPair()
+
+    const tick = Tick.fromPrice('1.001')
+
+    // Place a buy order (bid)
+    await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('100', 6),
+      type: 'buy',
+      tick,
+    })
+
+    // Place a sell order (ask) at same tick
+    await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('50', 6),
+      type: 'sell',
+      tick,
+    })
+
+    // Get bid side
+    const bidLevel = await Actions.dex.getPriceLevel(config, {
+      base,
+      tick,
+      isBid: true,
+    })
+
+    // Get ask side
+    const askLevel = await Actions.dex.getPriceLevel(config, {
+      base,
+      tick,
+      isBid: false,
+    })
+
+    // Both should have liquidity but different amounts
+    expect(bidLevel.totalLiquidity).toBeGreaterThan(0n)
+    expect(askLevel.totalLiquidity).toBeGreaterThan(0n)
+    expect(bidLevel.head).not.toBe(askLevel.head)
+  })
+
+  test('behavior: liquidity changes after order cancellation', async () => {
+    const { base } = await setupTokenPair()
+
+    const tick = Tick.fromPrice('1.001')
+
+    // Place orders
+    const { orderId: orderId1 } = await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('100', 6),
+      type: 'buy',
+      tick,
+    })
+
+    await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('50', 6),
+      type: 'buy',
+      tick,
+    })
+
+    // Get level before cancellation
+    const levelBefore = await Actions.dex.getPriceLevel(config, {
+      base,
+      tick,
+      isBid: true,
+    })
+
+    // Cancel first order
+    await Actions.dex.cancelSync(config, {
+      orderId: orderId1,
+    })
+
+    // Get level after cancellation
+    const levelAfter = await Actions.dex.getPriceLevel(config, {
+      base,
+      tick,
+      isBid: true,
+    })
+
+    // Total liquidity should decrease
+    expect(levelAfter.totalLiquidity).toBeLessThan(levelBefore.totalLiquidity)
+  })
+
+  test('behavior: liquidity changes after partial fill', async () => {
+    const { base, quote } = await setupTokenPair()
+
+    const tick = Tick.fromPrice('1.001')
+
+    // Place sell order
+    await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('500', 6),
+      type: 'sell',
+      tick,
+    })
+
+    // Get level before fill
+    const levelBefore = await Actions.dex.getPriceLevel(config, {
+      base,
+      tick,
+      isBid: false,
+    })
+
+    // Partially fill the order
+    await Actions.dex.buySync(config, {
+      tokenIn: quote,
+      tokenOut: base,
+      amountOut: parseUnits('100', 6),
+      maxAmountIn: parseUnits('150', 6),
+    })
+
+    // Get level after fill
+    const levelAfter = await Actions.dex.getPriceLevel(config, {
+      base,
+      tick,
+      isBid: false,
+    })
+
+    // Total liquidity should decrease
+    expect(levelAfter.totalLiquidity).toBeLessThan(levelBefore.totalLiquidity)
+  })
+
+  test('behavior: tick at boundaries', async () => {
+    const { base } = await setupTokenPair()
+
+    // Place order at min tick
+    await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('10', 6),
+      type: 'sell',
+      tick: Tick.minTick,
+    })
+
+    // Query min tick
+    const minLevel = await Actions.dex.getPriceLevel(config, {
+      base,
+      tick: Tick.minTick,
+      isBid: false,
+    })
+    expect(minLevel.totalLiquidity).toBeGreaterThan(0n)
+
+    // Place order at max tick
+    await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('10', 6),
+      type: 'buy',
+      tick: Tick.maxTick,
+    })
+
+    // Query max tick
+    const maxLevel = await Actions.dex.getPriceLevel(config, {
+      base,
+      tick: Tick.maxTick,
+      isBid: true,
+    })
+    expect(maxLevel.totalLiquidity).toBeGreaterThan(0n)
+  })
+})
+
+describe('getSellQuote', () => {
+  test('default', async () => {
+    const { base, quote } = await setupTokenPair()
+
+    // Place bid orders to create liquidity
+    await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('500', 6),
+      type: 'buy',
+      tick: Tick.fromPrice('0.999'),
+    })
+
+    // Get quote for selling base tokens
+    const amountOut = await Actions.dex.getSellQuote(config, {
+      tokenIn: base,
+      tokenOut: quote,
+      amountIn: parseUnits('100', 6),
+    })
+
+    expect(amountOut).toBeGreaterThan(0n)
+    // Should be approximately 100 * 0.999 = 99.9
+    expect(amountOut).toBeLessThan(parseUnits('100', 6))
+  })
+
+  test('behavior: fails with no liquidity', async () => {
+    const { base, quote } = await setupTokenPair()
+
+    // Quote should fail with no liquidity
+    await expect(
+      Actions.dex.getSellQuote(config, {
+        tokenIn: base,
+        tokenOut: quote,
+        amountIn: parseUnits('100', 6),
+      }),
+    ).rejects.toThrow('The contract function "quoteSwapExactAmountIn" reverted')
+  })
+})
+
+describe('place', () => {
+  test('default', async () => {
+    // Setup token pair
+    const { base } = await setupTokenPair()
+
+    // Place a sell order
+    const { receipt, orderId, token, ...result } = await Actions.dex.placeSync(
+      config,
+      {
+        token: base,
+        amount: parseUnits('100', 6),
+        type: 'sell',
+        tick: Tick.fromPrice('1.001'),
+      },
+    )
+
+    expect(receipt).toBeDefined()
+    expect(receipt.status).toBe('success')
+    expect(orderId).toBeGreaterThan(0n)
+    expect(token).toBe(base)
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "amount": 100000000n,
+        "isBid": false,
+        "maker": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+        "tick": 100,
+      }
+    `)
+
+    // Place a buy order
+    const {
+      receipt: receipt2,
+      orderId: orderId2,
+      token: token2,
+      ...result2
+    } = await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('100', 6),
+      type: 'buy',
+      tick: Tick.fromPrice('1.001'),
+    })
+    expect(receipt2.status).toBe('success')
+    expect(orderId2).toBeGreaterThan(0n)
+    expect(token2).toBe(base)
+    expect(result2).toMatchInlineSnapshot(`
+      {
+        "amount": 100000000n,
+        "isBid": true,
+        "maker": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+        "tick": 100,
+      }
+    `)
+  })
+
+  test('behavior: tick at boundaries', async () => {
+    const { base } = await setupTokenPair()
+
+    // Test at min tick (-2000)
+    const { receipt: receipt1, ...result1 } = await Actions.dex.placeSync(
+      config,
+      {
+        token: base,
+        amount: parseUnits('10', 6),
+        type: 'sell',
+        tick: Tick.minTick,
+      },
+    )
+    expect(receipt1.status).toBe('success')
+    expect(result1.tick).toBe(-2000)
+
+    // Test at max tick (2000)
+    const { receipt: receipt2, ...result2 } = await Actions.dex.placeSync(
+      config,
+      {
+        token: base,
+        amount: parseUnits('10', 6),
+        type: 'buy',
+        tick: Tick.maxTick,
+      },
+    )
+    expect(receipt2.status).toBe('success')
+    expect(result2.tick).toBe(2000)
+  })
+
+  test('behavior: tick validation fails outside bounds', async () => {
+    const { base } = await setupTokenPair()
+
+    // Test tick above max tick should fail
+    await expect(
+      Actions.dex.placeSync(config, {
+        token: base,
+        amount: parseUnits('10', 6),
+        type: 'buy',
+        tick: Tick.maxTick + 1,
+      }),
+    ).rejects.toThrow('The contract function "place" reverted')
+
+    // Test tick below min tick should fail
+    await expect(
+      Actions.dex.placeSync(config, {
+        token: base,
+        amount: parseUnits('10', 6),
+        type: 'sell',
+        tick: Tick.minTick - 1,
+      }),
+    ).rejects.toThrow('The contract function "place" reverted')
+  })
+
+  test('behavior: transfers from wallet', async () => {
+    const { base, quote } = await setupTokenPair()
+
+    // Get balances before placing order
+    const baseBalanceBefore = await Actions.token.getBalance(config, {
+      token: base,
+      account: account.address,
+    })
+    const quoteBalanceBefore = await Actions.token.getBalance(config, {
+      token: quote,
+      account: account.address,
+    })
+
+    // 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(config, {
+      token: base,
+      amount: orderAmount,
+      type: 'buy',
+      tick,
+    })
+
+    // Get balances after placing order
+    const baseBalanceAfter = await Actions.token.getBalance(config, {
+      token: base,
+      account: account.address,
+    })
+    const quoteBalanceAfter = await Actions.token.getBalance(config, {
+      token: quote,
+      account: account.address,
+    })
+
+    // Base token balance should be unchanged (we're buying base, not selling)
+    expect(baseBalanceAfter).toBe(baseBalanceBefore)
+
+    // Quote token balance should decrease (escrowed for the bid)
+    // Amount = orderAmount * (1 + tick/1000) for bids
+    const expectedQuoteEscrowed =
+      (orderAmount * BigInt(100000 + tick)) / BigInt(100000)
+    expect(quoteBalanceBefore - quoteBalanceAfter).toBeGreaterThanOrEqual(
+      expectedQuoteEscrowed,
+    )
+  })
+
+  test('behavior: multiple orders at same tick', async () => {
+    const { base } = await setupTokenPair()
+
+    const tick = Tick.fromPrice('1.0005')
+
+    // Place first order
+    const { orderId: orderId1 } = await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('100', 6),
+      type: 'buy',
+      tick,
+    })
+
+    // Place second order at same tick
+    const { orderId: orderId2 } = await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('50', 6),
+      type: 'buy',
+      tick,
+    })
+
+    // Order IDs should be different and sequential
+    expect(orderId2).toBeGreaterThan(orderId1)
+  })
+})
+
+describe('placeFlip', () => {
+  test('default', async () => {
+    const { base } = await setupTokenPair()
+
+    // Place a flip bid order
+    const { receipt, orderId, token, ...result } =
+      await Actions.dex.placeFlipSync(config, {
+        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(orderId).toBeGreaterThan(0n)
+    expect(token).toBe(base)
+    expect(result.flipTick).toBe(Tick.fromPrice('1.002'))
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "amount": 100000000n,
+        "flipTick": 200,
+        "isBid": true,
+        "maker": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+        "tick": 100,
+      }
+    `)
+  })
+
+  test('behavior: flip bid requires flipTick > tick', async () => {
+    const { base } = await setupTokenPair()
+
+    // Valid: flipTick > tick for bid
+    const { receipt: receipt1 } = await Actions.dex.placeFlipSync(config, {
+      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(config, {
+        token: base,
+        amount: parseUnits('10', 6),
+        type: 'buy',
+        tick: Tick.fromPrice('1.001'),
+        flipTick: Tick.fromPrice('1.001'), // Equal
+      }),
+    ).rejects.toThrow('The contract function "placeFlip" reverted')
+
+    await expect(
+      Actions.dex.placeFlipSync(config, {
+        token: base,
+        amount: parseUnits('10', 6),
+        type: 'buy',
+        tick: Tick.fromPrice('1.001'),
+        flipTick: Tick.fromPrice('1.0005'), // Less than
+      }),
+    ).rejects.toThrow('The contract function "placeFlip" reverted')
+  })
+
+  test('behavior: flip ask requires flipTick < tick', async () => {
+    const { base } = await setupTokenPair()
+
+    // Valid: flipTick < tick for ask
+    const { receipt: receipt1 } = await Actions.dex.placeFlipSync(config, {
+      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(config, {
+        token: base,
+        amount: parseUnits('10', 6),
+        type: 'sell',
+        tick: Tick.fromPrice('1.0005'),
+        flipTick: Tick.fromPrice('1.0005'), // Equal
+      }),
+    ).rejects.toThrow('The contract function "placeFlip" reverted')
+
+    await expect(
+      Actions.dex.placeFlipSync(config, {
+        token: base,
+        amount: parseUnits('10', 6),
+        type: 'sell',
+        tick: Tick.fromPrice('1.0005'),
+        flipTick: Tick.fromPrice('1.001'), // Greater than
+      }),
+    ).rejects.toThrow('The contract function "placeFlip" reverted')
+  })
+
+  test('behavior: flip ticks at boundaries', async () => {
+    const { base } = await setupTokenPair()
+
+    // Flip order with ticks at extreme boundaries
+    const { receipt } = await Actions.dex.placeFlipSync(config, {
+      token: base,
+      amount: parseUnits('10', 6),
+      type: 'buy',
+      tick: Tick.minTick,
+      flipTick: Tick.maxTick,
+    })
+    expect(receipt.status).toBe('success')
+  })
+})
+
+describe('sell', () => {
+  test('default', async () => {
+    const { base, quote } = await setupTokenPair()
+
+    // Place bid order to create liquidity
+    await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('500', 6),
+      type: 'buy',
+      tick: Tick.fromPrice('0.999'),
+    })
+
+    // Sell base tokens
+    const { receipt } = await Actions.dex.sellSync(config, {
+      tokenIn: base,
+      tokenOut: quote,
+      amountIn: parseUnits('100', 6),
+      minAmountOut: parseUnits('50', 6),
+    })
+
+    expect(receipt).toBeDefined()
+    expect(receipt.status).toBe('success')
+  })
+
+  test('behavior: respects minAmountOut', async () => {
+    const { base, quote } = await setupTokenPair()
+
+    // Place bid order at low price
+    await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('500', 6),
+      type: 'buy',
+      tick: Tick.fromPrice('0.99'), // 1% below peg
+    })
+
+    // Try to sell with too high minAmountOut - should fail
+    await expect(
+      Actions.dex.sellSync(config, {
+        tokenIn: base,
+        tokenOut: quote,
+        amountIn: parseUnits('100', 6),
+        minAmountOut: parseUnits('150', 6), // Way too high
+      }),
+    ).rejects.toThrow('The contract function "swapExactAmountIn" reverted')
+  })
+
+  test('behavior: fails with insufficient liquidity', async () => {
+    const { base, quote } = await setupTokenPair()
+
+    // No orders - no liquidity
+
+    // Try to sell - should fail
+    await expect(
+      Actions.dex.sellSync(config, {
+        tokenIn: base,
+        tokenOut: quote,
+        amountIn: parseUnits('100', 6),
+        minAmountOut: parseUnits('50', 6),
+      }),
+    ).rejects.toThrow('The contract function "swapExactAmountIn" reverted')
+  })
+})
+
+describe('watchFlipOrderPlaced', () => {
+  test('default', async () => {
+    const { base } = await setupTokenPair()
+
+    const receivedOrders: Array<{
+      args: Actions.dex.watchFlipOrderPlaced.Args
+      log: Actions.dex.watchFlipOrderPlaced.Log
+    }> = []
+
+    const unwatch = Actions.dex.watchFlipOrderPlaced(config, {
+      onFlipOrderPlaced: (args, log) => {
+        receivedOrders.push({ args, log })
+      },
+    })
+
+    try {
+      // Place flip order
+      await Actions.dex.placeFlipSync(config, {
+        token: base,
+        amount: parseUnits('100', 6),
+        type: 'buy',
+        tick: Tick.fromPrice('1.001'),
+        flipTick: Tick.fromPrice('1.002'),
+      })
+
+      await new Promise((resolve) => setTimeout(resolve, 200))
+
+      expect(receivedOrders).toHaveLength(1)
+      expect(receivedOrders[0]?.args.flipTick).toBe(Tick.fromPrice('1.002'))
+      expect(receivedOrders[0]?.args.tick).toBe(Tick.fromPrice('1.001'))
+    } finally {
+      unwatch()
+    }
+  })
+})
+
+describe('watchOrderCancelled', () => {
+  test('default', async () => {
+    const { base } = await setupTokenPair()
+
+    const receivedCancellations: Array<{
+      args: Actions.dex.watchOrderCancelled.Args
+      log: Actions.dex.watchOrderCancelled.Log
+    }> = []
+
+    const unwatch = Actions.dex.watchOrderCancelled(config, {
+      onOrderCancelled: (args, log) => {
+        receivedCancellations.push({ args, log })
+      },
+    })
+
+    try {
+      // Place order
+      const { orderId } = await Actions.dex.placeSync(config, {
+        token: base,
+        amount: parseUnits('100', 6),
+        type: 'buy',
+        tick: Tick.fromPrice('1.001'),
+      })
+
+      // Cancel order
+      await Actions.dex.cancelSync(config, {
+        orderId,
+      })
+
+      await new Promise((resolve) => setTimeout(resolve, 200))
+
+      expect(receivedCancellations).toHaveLength(1)
+      expect(receivedCancellations[0]?.args.orderId).toBe(orderId)
+    } finally {
+      unwatch()
+    }
+  })
+
+  test('behavior: filter by orderId', async () => {
+    const { base } = await setupTokenPair()
+
+    // Place two orders
+    const { orderId: orderId1 } = await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('100', 6),
+      type: 'buy',
+      tick: Tick.fromPrice('1.001'),
+    })
+
+    const { orderId: orderId2 } = await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('50', 6),
+      type: 'buy',
+      tick: Tick.fromPrice('1.001'),
+    })
+
+    const receivedCancellations: Array<{
+      args: Actions.dex.watchOrderCancelled.Args
+      log: Actions.dex.watchOrderCancelled.Log
+    }> = []
+
+    // Watch only for cancellation of orderId1
+    const unwatch = Actions.dex.watchOrderCancelled(config, {
+      orderId: orderId1,
+      onOrderCancelled: (args, log) => {
+        receivedCancellations.push({ args, log })
+      },
+    })
+
+    try {
+      // Cancel orderId1 (should be captured)
+      await Actions.dex.cancelSync(config, {
+        orderId: orderId1,
+      })
+
+      // Cancel orderId2 (should NOT be captured)
+      await Actions.dex.cancelSync(config, {
+        orderId: orderId2,
+      })
+
+      await new Promise((resolve) => setTimeout(resolve, 200))
+
+      // Should only receive 1 event
+      expect(receivedCancellations).toHaveLength(1)
+      expect(receivedCancellations[0]?.args.orderId).toBe(orderId1)
+    } finally {
+      unwatch()
+    }
+  })
+})
+
+describe.todo('watchOrderFilled')
+
+describe('watchOrderPlaced', () => {
+  test('default', async () => {
+    const { base } = await setupTokenPair()
+
+    const receivedOrders: Array<{
+      args: Actions.dex.watchOrderPlaced.Args
+      log: Actions.dex.watchOrderPlaced.Log
+    }> = []
+
+    const unwatch = Actions.dex.watchOrderPlaced(config, {
+      onOrderPlaced: (args, log) => {
+        receivedOrders.push({ args, log })
+      },
+    })
+
+    try {
+      // Place first order
+      await Actions.dex.placeSync(config, {
+        token: base,
+        amount: parseUnits('100', 6),
+        type: 'buy',
+        tick: Tick.fromPrice('1.001'),
+      })
+
+      // Place second order
+      await Actions.dex.placeSync(config, {
+        token: base,
+        amount: parseUnits('50', 6),
+        type: 'sell',
+        tick: Tick.fromPrice('0.999'),
+      })
+
+      // Wait for events
+      await new Promise((resolve) => setTimeout(resolve, 200))
+
+      expect(receivedOrders).toHaveLength(2)
+      expect(receivedOrders[0]?.args.isBid).toBe(true)
+      expect(receivedOrders[0]?.args.amount).toBe(parseUnits('100', 6))
+      expect(receivedOrders[1]?.args.isBid).toBe(false)
+      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 receivedOrders: Array<{
+      args: Actions.dex.watchOrderPlaced.Args
+      log: Actions.dex.watchOrderPlaced.Log
+    }> = []
+
+    // Watch only for orders on base
+    const unwatch = Actions.dex.watchOrderPlaced(config, {
+      token: base,
+      onOrderPlaced: (args, log) => {
+        receivedOrders.push({ args, log })
+      },
+    })
+
+    try {
+      // Place order on base (should be captured)
+      await Actions.dex.placeSync(config, {
+        token: base,
+        amount: parseUnits('100', 6),
+        type: 'buy',
+        tick: Tick.fromPrice('1.001'),
+      })
+
+      // Place order on base2 (should NOT be captured)
+      await Actions.dex.placeSync(config, {
+        token: base2,
+        amount: parseUnits('50', 6),
+        type: 'buy',
+        tick: Tick.fromPrice('1.001'),
+      })
+
+      await new Promise((resolve) => setTimeout(resolve, 200))
+
+      // Should only receive 1 event
+      expect(receivedOrders).toHaveLength(1)
+      expect(receivedOrders[0]?.args.token.toLowerCase()).toBe(
+        base.toLowerCase(),
+      )
+    } finally {
+      unwatch()
+    }
+  })
+})
+
+describe('withdraw', () => {
+  test('default', async () => {
+    const { base, quote } = await setupTokenPair()
+
+    // Create internal balance
+    const { orderId } = await Actions.dex.placeSync(config, {
+      token: base,
+      amount: parseUnits('100', 6),
+      type: 'buy',
+      tick: Tick.fromPrice('1.001'),
+    })
+
+    await Actions.dex.cancelSync(config, { orderId })
+
+    // Get DEX balance
+    const dexBalance = await Actions.dex.getBalance(config, {
+      account: account.address,
+      token: quote,
+    })
+    expect(dexBalance).toBeGreaterThan(0n)
+
+    // Get wallet balance before withdraw
+    const walletBalanceBefore = await Actions.token.getBalance(config, {
+      token: quote,
+      account: account.address,
+    })
+
+    // Withdraw from DEX
+    const { receipt } = await Actions.dex.withdrawSync(config, {
+      token: quote,
+      amount: dexBalance,
+    })
+
+    expect(receipt).toBeDefined()
+    expect(receipt.status).toBe('success')
+
+    // Check DEX balance is now 0
+    const dexBalanceAfter = await Actions.dex.getBalance(config, {
+      account: account.address,
+      token: quote,
+    })
+    expect(dexBalanceAfter).toBe(0n)
+
+    // Check wallet balance increased
+    const walletBalanceAfter = await Actions.token.getBalance(config, {
+      token: quote,
+      account: account.address,
+    })
+    expect(walletBalanceAfter).toBeGreaterThan(walletBalanceBefore)
+  })
+})