tempo.ts 0.12.1 → 0.13.0

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

@@ -1,992 +0,0 @@
-import { Actions, Hooks } from 'tempo.ts/wagmi'
-import { type Address, isAddress, parseUnits } from 'viem'
-import { Tick } from 'viem/tempo'
-import { describe, expect, test, vi } from 'vitest'
-import { useConnect } from 'wagmi'
-import { addresses } from '../../../test/config.js'
-import { accounts } from '../../../test/viem/config.js'
-import {
-  config,
-  renderHook,
-  setupTokenPair,
-} from '../../../test/wagmi/config.js'
-
-const account = accounts[0]
-const account2 = accounts[1]
-
-describe('useBuy', () => {
-  test('default', async () => {
-    const { base, quote } = await setupTokenPair()
-
-    const { result } = await renderHook(() => Hooks.dex.useBuySync())
-
-    // Place ask order to create liquidity
-    await Actions.dex.placeSync(config, {
-      token: base,
-      amount: parseUnits('500', 6),
-      type: 'sell',
-      tick: Tick.fromPrice('1.001'),
-    })
-
-    // Buy base tokens with quote tokens
-    const { receipt } = await result.current.mutateAsync({
-      tokenIn: quote,
-      tokenOut: base,
-      amountOut: parseUnits('100', 6),
-      maxAmountIn: parseUnits('150', 6),
-    })
-
-    expect(receipt).toBeDefined()
-    expect(receipt.status).toBe('success')
-
-    await vi.waitFor(() => expect(result.current.isSuccess).toBeTruthy())
-  })
-
-  test('behavior: respects maxAmountIn', async () => {
-    const { base, quote } = await setupTokenPair()
-
-    const { result } = await renderHook(() => Hooks.dex.useBuySync())
-
-    // 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(
-      result.current.mutateAsync({
-        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()
-
-    const { result } = await renderHook(() => Hooks.dex.useBuySync())
-
-    // Don't place any orders - no liquidity
-
-    // Try to buy - should fail due to no liquidity
-    await expect(
-      result.current.mutateAsync({
-        tokenIn: quote,
-        tokenOut: base,
-        amountOut: parseUnits('100', 6),
-        maxAmountIn: parseUnits('150', 6),
-      }),
-    ).rejects.toThrow('The contract function "swapExactAmountOut" reverted')
-  })
-})
-
-describe('useCancel', () => {
-  test('default', async () => {
-    const { base, quote } = await setupTokenPair()
-
-    const { result } = await renderHook(() => ({
-      place: Hooks.dex.usePlaceSync(),
-      cancel: Hooks.dex.useCancelSync(),
-    }))
-
-    // Place a bid order
-    const { orderId } = await result.current.place.mutateAsync({
-      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, orderId: returnedOrderId } =
-      await result.current.cancel.mutateAsync({
-        orderId,
-      })
-
-    expect(receipt).toBeDefined()
-    expect(receipt.status).toBe('success')
-    expect(returnedOrderId).toBe(orderId)
-
-    await vi.waitFor(() => expect(result.current.cancel.isSuccess).toBeTruthy())
-
-    // 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()
-
-    const { result } = await renderHook(() => ({
-      connect: useConnect(),
-      place: Hooks.dex.usePlaceSync(),
-      cancel: Hooks.dex.useCancelSync(),
-    }))
-
-    // Account places order
-    const { orderId } = await result.current.place.mutateAsync({
-      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 result.current.connect.connectAsync({
-      connector: config.connectors[1]!,
-    })
-
-    // Account2 tries to cancel - should fail
-    await expect(
-      result.current.cancel.mutateAsync({
-        orderId,
-      }),
-    ).rejects.toThrow('The contract function "cancel" reverted')
-  })
-
-  test('behavior: cannot cancel non-existent order', async () => {
-    await setupTokenPair()
-
-    const { result } = await renderHook(() => Hooks.dex.useCancelSync())
-
-    // Try to cancel an order that doesn't exist
-    await expect(
-      result.current.mutateAsync({
-        orderId: 999n,
-      }),
-    ).rejects.toThrow('The contract function "cancel" reverted')
-  })
-})
-
-describe('useCreatePair', () => {
-  test('default', async () => {
-    await setupTokenPair() // This ensures connection
-
-    const { result } = await renderHook(() => Hooks.dex.useCreatePairSync())
-
-    const { token: baseToken } = await Actions.token.createSync(config, {
-      name: 'Test Base Token',
-      symbol: 'BASE',
-      currency: 'USD',
-      admin: account,
-    })
-
-    const { receipt, ...resultData } = await result.current.mutateAsync({
-      base: baseToken,
-    })
-
-    expect(receipt).toBeDefined()
-    expect(receipt.status).toBe('success')
-
-    const { key, ...rest } = resultData
-    expect(key).toBeDefined()
-    expect(rest).toEqual(
-      expect.objectContaining({
-        base: expect.toSatisfy(isAddress),
-        quote: expect.toSatisfy(isAddress),
-      }),
-    )
-
-    await vi.waitFor(() => expect(result.current.isSuccess).toBeTruthy())
-  })
-})
-
-describe('useBalance', () => {
-  test('default', async () => {
-    const { base, quote } = await setupTokenPair()
-
-    const { result, rerender } = await renderHook(
-      (props) =>
-        Hooks.dex.useBalance({ account: props?.account, token: quote }),
-      { initialProps: { account: undefined as Address | undefined } },
-    )
-
-    await vi.waitFor(() => result.current.fetchStatus === 'fetching')
-
-    // Verify initial state (disabled/pending when account missing)
-    expect(result.current.status).toBe('pending')
-
-    // Set account and rerender
-    rerender({ account: accounts[0].address })
-
-    await vi.waitFor(() => expect(result.current.isSuccess).toBeTruthy())
-
-    // Initial balance should be 0
-    expect(result.current.data).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,
-    })
-
-    // Trigger refetch and verify updated balance
-    const { data } = await result.current.refetch()
-    expect(data).toBeGreaterThan(0n)
-  })
-
-  test('behavior: check different account', async () => {
-    const { quote } = await setupTokenPair()
-
-    const { result } = await renderHook(() =>
-      Hooks.dex.useBalance({ account: account2.address, token: quote }),
-    )
-
-    await vi.waitFor(() => expect(result.current.isSuccess).toBeTruthy())
-
-    // Check account2's balance (should be 0)
-    expect(result.current.data).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 })
-
-    const { result } = await renderHook(() => ({
-      quote: Hooks.dex.useBalance({ account: account.address, token: quote }),
-      base: Hooks.dex.useBalance({ account: account.address, token: base }),
-    }))
-
-    await vi.waitUntil(
-      () => result.current.base.isSuccess && result.current.quote.isSuccess,
-      {
-        timeout: 50_000,
-      },
-    )
-
-    // Check quote balance (should have refunded tokens)
-    expect(result.current.quote.data).toBeGreaterThan(0n)
-    // Check base balance (should still be 0)
-    expect(result.current.base.data).toBe(0n)
-  })
-})
-
-describe('useBuyQuote', () => {
-  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'),
-    })
-
-    const { result } = await renderHook(() =>
-      Hooks.dex.useBuyQuote({
-        tokenIn: quote,
-        tokenOut: base,
-        amountOut: parseUnits('100', 6),
-      }),
-    )
-
-    await vi.waitFor(() => expect(result.current.isSuccess).toBeTruthy())
-
-    expect(result.current.data).toBeGreaterThan(0n)
-    // Should be approximately 100 * 1.001 = 100.1
-    expect(result.current.data).toBeGreaterThan(parseUnits('100', 6))
-  })
-
-  test('behavior: fails with no liquidity', async () => {
-    const { base, quote } = await setupTokenPair()
-
-    // No orders placed - no liquidity
-
-    const { result } = await renderHook(() =>
-      Hooks.dex.useBuyQuote({
-        tokenIn: quote,
-        tokenOut: base,
-        amountOut: parseUnits('100', 6),
-      }),
-    )
-
-    await vi.waitUntil(() => result.current.isError, {
-      timeout: 50_000,
-    })
-
-    expect(result.current.error?.message).toContain('InsufficientLiquidity')
-  })
-})
-
-describe('useOrder', () => {
-  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'),
-    })
-
-    const { result } = await renderHook(() =>
-      Hooks.dex.useOrder({
-        orderId,
-      }),
-    )
-
-    await vi.waitFor(() => expect(result.current.isSuccess).toBeTruthy())
-
-    const order = result.current.data!
-    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'),
-    })
-
-    const { result } = await renderHook(() =>
-      Hooks.dex.useOrder({
-        orderId,
-      }),
-    )
-
-    await vi.waitFor(() => expect(result.current.isSuccess).toBeTruthy())
-
-    const order = result.current.data!
-    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()
-
-    const { result } = await renderHook(() =>
-      Hooks.dex.useOrder({
-        orderId: 999n,
-      }),
-    )
-
-    await vi.waitUntil(() => result.current.isError, {
-      timeout: 50_000,
-    })
-
-    expect(result.current.error?.message).toContain('OrderDoesNotExist')
-  })
-})
-
-describe('useOrderbook', () => {
-  test('default', async () => {
-    const { base, quote } = await setupTokenPair()
-
-    const { result } = await renderHook(() =>
-      Hooks.dex.useOrderbook({
-        base,
-        quote,
-      }),
-    )
-
-    await vi.waitFor(() => expect(result.current.isSuccess).toBeTruthy())
-
-    const book = result.current.data!
-    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,
-    })
-
-    const { result } = await renderHook(() =>
-      Hooks.dex.useOrderbook({
-        base,
-        quote,
-      }),
-    )
-
-    await vi.waitFor(() => expect(result.current.isSuccess).toBeTruthy())
-
-    const book = result.current.data!
-    expect(book.bestBidTick).toBe(bidTick)
-    expect(book.bestAskTick).toBe(askTick)
-  })
-})
-
-describe('usePriceLevel', () => {
-  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,
-    })
-
-    const { result } = await renderHook(() =>
-      Hooks.dex.usePriceLevel({
-        base,
-        tick,
-        isBid: true,
-      }),
-    )
-
-    await vi.waitFor(() => expect(result.current.isSuccess).toBeTruthy())
-
-    const level = result.current.data!
-    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 { result } = await renderHook(() =>
-      Hooks.dex.usePriceLevel({
-        base,
-        tick,
-        isBid: true,
-      }),
-    )
-
-    await vi.waitFor(() => expect(result.current.isSuccess).toBeTruthy())
-
-    const level = result.current.data!
-    expect(level.head).toBe(0n)
-    expect(level.tail).toBe(0n)
-    expect(level.totalLiquidity).toBe(0n)
-  })
-})
-
-describe('useSellQuote', () => {
-  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'),
-    })
-
-    const { result } = await renderHook(() =>
-      Hooks.dex.useSellQuote({
-        tokenIn: base,
-        tokenOut: quote,
-        amountIn: parseUnits('100', 6),
-      }),
-    )
-
-    await vi.waitFor(() => expect(result.current.isSuccess).toBeTruthy())
-
-    expect(result.current.data).toBeGreaterThan(0n)
-    // Should be approximately 100 * 0.999 = 99.9
-    expect(result.current.data).toBeLessThan(parseUnits('100', 6))
-  })
-
-  test('behavior: fails with no liquidity', async () => {
-    const { base, quote } = await setupTokenPair()
-
-    // Quote should fail with no liquidity
-    const { result } = await renderHook(() =>
-      Hooks.dex.useSellQuote({
-        tokenIn: base,
-        tokenOut: quote,
-        amountIn: parseUnits('100', 6),
-      }),
-    )
-
-    await vi.waitUntil(() => result.current.isError, {
-      timeout: 50_000,
-    })
-
-    expect(result.current.error?.message).toContain('InsufficientLiquidity')
-  })
-})
-
-describe('usePlace', () => {
-  test('default', async () => {
-    const { base } = await setupTokenPair()
-
-    const { result } = await renderHook(() => Hooks.dex.usePlaceSync())
-
-    // Place a sell order
-    const { receipt, orderId, token, ...resultData } =
-      await result.current.mutateAsync({
-        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(resultData).toMatchInlineSnapshot(`
-      {
-        "amount": 100000000n,
-        "isBid": false,
-        "maker": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-        "tick": 100,
-      }
-    `)
-
-    await vi.waitFor(() => expect(result.current.isSuccess).toBeTruthy())
-
-    // Place a buy order
-    const {
-      receipt: receipt2,
-      orderId: orderId2,
-      token: token2,
-      ...result2
-    } = await result.current.mutateAsync({
-      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,
-      }
-    `)
-  })
-})
-
-describe('usePlaceFlip', () => {
-  test('default', async () => {
-    const { base } = await setupTokenPair()
-
-    const { result } = await renderHook(() => Hooks.dex.usePlaceFlipSync())
-
-    // Place a flip bid order
-    const { receipt, orderId, token, ...resultData } =
-      await result.current.mutateAsync({
-        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(resultData.flipTick).toBe(Tick.fromPrice('1.002'))
-    expect(resultData).toMatchInlineSnapshot(`
-      {
-        "amount": 100000000n,
-        "flipTick": 200,
-        "isBid": true,
-        "maker": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-        "tick": 100,
-      }
-    `)
-
-    await vi.waitFor(() => expect(result.current.isSuccess).toBeTruthy())
-  })
-})
-
-describe('useSell', () => {
-  test('default', async () => {
-    const { base, quote } = await setupTokenPair()
-
-    const { result } = await renderHook(() => Hooks.dex.useSellSync())
-
-    // 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 result.current.mutateAsync({
-      tokenIn: base,
-      tokenOut: quote,
-      amountIn: parseUnits('100', 6),
-      minAmountOut: parseUnits('50', 6),
-    })
-
-    expect(receipt).toBeDefined()
-    expect(receipt.status).toBe('success')
-
-    await vi.waitFor(() => expect(result.current.isSuccess).toBeTruthy())
-  })
-
-  test('behavior: respects minAmountOut', async () => {
-    const { base, quote } = await setupTokenPair()
-
-    const { result } = await renderHook(() => Hooks.dex.useSellSync())
-
-    // 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(
-      result.current.mutateAsync({
-        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()
-
-    const { result } = await renderHook(() => Hooks.dex.useSellSync())
-
-    // No orders - no liquidity
-
-    // Try to sell - should fail
-    await expect(
-      result.current.mutateAsync({
-        tokenIn: base,
-        tokenOut: quote,
-        amountIn: parseUnits('100', 6),
-        minAmountOut: parseUnits('50', 6),
-      }),
-    ).rejects.toThrow('The contract function "swapExactAmountIn" reverted')
-  })
-})
-
-describe('useWatchFlipOrderPlaced', () => {
-  test('default', async () => {
-    const { base } = await setupTokenPair()
-
-    const { result } = await renderHook(() => Hooks.dex.usePlaceFlipSync())
-
-    const events: any[] = []
-    await renderHook(() =>
-      Hooks.dex.useWatchFlipOrderPlaced({
-        onFlipOrderPlaced(args) {
-          events.push(args)
-        },
-      }),
-    )
-
-    // Place flip order to trigger event
-    await result.current.mutateAsync({
-      token: base,
-      amount: parseUnits('100', 6),
-      type: 'buy',
-      tick: Tick.fromPrice('1.001'),
-      flipTick: Tick.fromPrice('1.002'),
-    })
-
-    await vi.waitUntil(() => events.length >= 1)
-
-    expect(events.length).toBeGreaterThanOrEqual(1)
-    expect(events[0]?.flipTick).toBe(Tick.fromPrice('1.002'))
-    expect(events[0]?.tick).toBe(Tick.fromPrice('1.001'))
-    expect(events[0]?.isBid).toBe(true)
-    expect(events[0]?.amount).toBe(parseUnits('100', 6))
-  })
-})
-
-describe('useWatchOrderCancelled', () => {
-  test('default', async () => {
-    const { base } = await setupTokenPair()
-
-    // Place order first
-    const { orderId } = await Actions.dex.placeSync(config, {
-      token: base,
-      amount: parseUnits('100', 6),
-      type: 'buy',
-      tick: Tick.fromPrice('1.001'),
-    })
-
-    const events: any[] = []
-    await renderHook(() =>
-      Hooks.dex.useWatchOrderCancelled({
-        onOrderCancelled(args) {
-          events.push(args)
-        },
-      }),
-    )
-
-    // Cancel order to trigger event
-    await Actions.dex.cancelSync(config, {
-      orderId,
-    })
-
-    await vi.waitUntil(() => events.length >= 1)
-
-    expect(events.length).toBeGreaterThanOrEqual(1)
-    expect(events[0]?.orderId).toBe(orderId)
-  })
-
-  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 events: any[] = []
-    await renderHook(() =>
-      Hooks.dex.useWatchOrderCancelled({
-        orderId: orderId1, // Filter for only orderId1
-        onOrderCancelled(args) {
-          events.push(args)
-        },
-      }),
-    )
-
-    // Cancel orderId1 (should be captured)
-    await Actions.dex.cancelSync(config, {
-      orderId: orderId1,
-    })
-
-    // Cancel orderId2 (should NOT be captured due to filter)
-    await Actions.dex.cancelSync(config, {
-      orderId: orderId2,
-    })
-
-    await vi.waitUntil(() => events.length >= 1, { timeout: 2000 })
-
-    // Should only receive 1 event (for orderId1)
-    expect(events.length).toBe(1)
-    expect(events[0]?.orderId).toBe(orderId1)
-  })
-})
-
-describe.todo('useWatchOrderFilled')
-
-describe('useWatchOrderPlaced', () => {
-  test('default', async () => {
-    const { base } = await setupTokenPair()
-
-    const events: any[] = []
-    await renderHook(() =>
-      Hooks.dex.useWatchOrderPlaced({
-        onOrderPlaced(args) {
-          events.push(args)
-        },
-      }),
-    )
-
-    // 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'),
-    })
-
-    await vi.waitUntil(() => events.length >= 2)
-
-    expect(events.length).toBeGreaterThanOrEqual(2)
-    expect(events[0]?.isBid).toBe(true)
-    expect(events[0]?.amount).toBe(parseUnits('100', 6))
-    expect(events[1]?.isBid).toBe(false)
-    expect(events[1]?.amount).toBe(parseUnits('50', 6))
-  })
-
-  test('behavior: filter by token', async () => {
-    const { base } = await setupTokenPair()
-    const { base: base2 } = await setupTokenPair()
-
-    const events: any[] = []
-    await renderHook(() =>
-      Hooks.dex.useWatchOrderPlaced({
-        token: base, // Filter for only base token
-        onOrderPlaced(args) {
-          events.push(args)
-        },
-      }),
-    )
-
-    // 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 due to filter)
-    await Actions.dex.placeSync(config, {
-      token: base2,
-      amount: parseUnits('50', 6),
-      type: 'buy',
-      tick: Tick.fromPrice('1.001'),
-    })
-
-    await vi.waitUntil(() => events.length >= 1, { timeout: 2000 })
-
-    // Should only receive 1 event (for base token)
-    expect(events.length).toBe(1)
-    expect(events[0]?.token.toLowerCase()).toBe(base.toLowerCase())
-  })
-})
-
-describe('useWithdraw', () => {
-  test('default', async () => {
-    const { base, quote } = await setupTokenPair()
-
-    const { result } = await renderHook(() => ({
-      place: Hooks.dex.usePlaceSync(),
-      cancel: Hooks.dex.useCancelSync(),
-      withdraw: Hooks.dex.useWithdrawSync(),
-    }))
-
-    // Create internal balance
-    const { orderId } = await result.current.place.mutateAsync({
-      token: base,
-      amount: parseUnits('100', 6),
-      type: 'buy',
-      tick: Tick.fromPrice('1.001'),
-    })
-
-    await result.current.cancel.mutateAsync({ 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 result.current.withdraw.mutateAsync({
-      token: quote,
-      amount: dexBalance,
-    })
-
-    expect(receipt).toBeDefined()
-    expect(receipt.status).toBe('success')
-
-    await vi.waitFor(() =>
-      expect(result.current.withdraw.isSuccess).toBeTruthy(),
-    )
-
-    // 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)
-  })
-})