tapimo 0.15.1 → 0.18.1

package/src/apps/data/routes/exchanges.bench.ts

@@ -4,7 +4,7 @@ const fixtures = {
   4217: {
     base: '0x20c0000000000000000000001a47bebe936d00d7',
     filledOrderId: '3881',
-    orderId: '3312',
+    orderId: '4581',
   },
   42431: {
     base: '0x20c000000000000000000000746cbc54ce86a3cb',
@@ -38,6 +38,8 @@ QueryBench.bench({
   name: 'getOrders',
   path: '/v1/exchange/orders',
   queries: ['include=tokens', 'include=totalCount'],
+  // TODO: Re-enable after batching order IDs or using POST; the global query exceeds TIDX's URL limit (HTTP 414).
+  skip: true,
 })
 
 QueryBench.bench({

package/src/apps/data/routes/exchanges.test.ts

@@ -3,9 +3,9 @@
 import type * as z from 'zod/mini'
 import { Address, Value as core_Value } from 'ox'
 import { FxOracle } from 'tapimo/apps'
-import { Db, Schema } from 'tapimo/server'
+import { Db, Schema, Store } from 'tapimo/server'
 import { decodeFunctionData, zeroHash } from 'viem'
-import { Abis, Actions, Addresses } from 'viem/tempo'
+import { Abis, Actions, Addresses, Tick } from 'viem/tempo'
 
 import * as TestApp from '../../../../test/App.js'
 import * as Relay from '../../../../test/Relay.js'
@@ -948,6 +948,42 @@ describe('GET /exchange/pairs', () => {
 })
 
 describe('GET /exchange/pairs/:base', () => {
+  test.skipIf(Runtime.get().mode !== 'localnet')(
+    'finds a pair created after the bounded index was cached',
+    async () => {
+      const client = TestApp.client({ cache: { store: Store.memory() } })
+      const unknown = `0x${'1'.repeat(40)}` as const
+      const initial = await client.v1.exchange.pairs[':base'].$get(
+        { param: { base: unknown }, query: {} },
+        TestApp.auth,
+      )
+      expect(initial.status).toBe(404)
+
+      const rpc = Relay.getClient({ account: Relay.accounts[2]! })
+      const created = await Actions.token.createSync(rpc, {
+        currency: 'USD',
+        name: 'Late Pair Base',
+        symbol: 'LATE',
+      })
+      const base = Schema.TokenAddress.parse(created.token)
+      await Actions.dex.createPairSync(rpc, { base })
+
+      await expect
+        .poll(
+          async () => {
+            const response = await client.v1.exchange.pairs[':base'].$get(
+              { param: { base }, query: {} },
+              TestApp.auth,
+            )
+            return response.status
+          },
+          { interval: 250, timeout: 30_000 },
+        )
+        .toBe(200)
+    },
+    60_000,
+  )
+
   test('returns the pair identified by its base token', async () => {
     const client = TestApp.client()
     const pairsResponse = await client.v1.exchange.pairs.$get(
@@ -2111,6 +2147,36 @@ describe('GET /exchange/orders', () => {
     for (const order of body.data) expect(order.maker).toBe(row.maker)
   }, 60000)
 
+  // These placement windows overflowed the GET URL limit or the query deadline.
+  test
+    .runIf(Runtime.get().mode === 'testnet')
+    .each([
+      '0x5c1902cf6fed586a1a5166d764e2aea2959f3c4a',
+      '0xca05d37d8e93f1220ef8c64b30c1d6220826ad77',
+    ])(
+    'bounds indexer requests for a maker with a large placement history: %s',
+    async (maker) => {
+      const errors: Error[] = []
+      const client = TestApp.client({
+        logger: (_, error) => {
+          if (error) errors.push(error)
+        },
+      })
+      const response = await client.v1.exchange.orders.$get(
+        { query: { limit: '100', maker, order: 'desc', sort: 'time' } },
+        TestApp.auth,
+      )
+      expect(response.status, errors.map((error) => error.message).join('\n')).toBe(200)
+      const body = await TestApp.json(response, Exchanges.schema.getOrders.Response)
+      expect(body.data.length).toBeGreaterThan(0)
+      expect(body.truncated).toBe(true)
+      for (const order of body.data) expect(order.maker).toBe(maker)
+      const times = body.data.map((order) => Date.parse(order.placedAt))
+      expect(times).toEqual([...times].sort((a, b) => b - a))
+    },
+    60000,
+  )
+
   test('embeds pair token metadata when requested via `include=tokens`', async () => {
     const client = TestApp.client()
     const response = await client.v1.exchange.orders.$get(
@@ -2272,6 +2338,104 @@ describe('GET /exchange/orders/:orderId/fills', () => {
   }, 60000)
 })
 
+describe.skipIf(Runtime.get().mode !== 'localnet')('flip-order state', () => {
+  test('uses the current flip generation for orders and OHLC', async () => {
+    const maker = Relay.accounts[0]!
+    const taker = Relay.accounts[1]!
+    const makerRpc = Relay.getClient({ account: maker })
+    const takerRpc = Relay.getClient({ account: taker })
+    const created = await Actions.token.createSync(makerRpc, {
+      currency: 'USD',
+      name: 'Flip State Base',
+      symbol: 'FLIP',
+    })
+    const base = Schema.TokenAddress.parse(created.token)
+    await Actions.token.grantRolesSync(makerRpc, {
+      roles: ['issuer'],
+      to: maker.address,
+      token: base,
+    })
+    await Actions.token.mintSync(makerRpc, {
+      amount: 400_000_000n,
+      to: maker.address,
+      token: base,
+    })
+    await Actions.token.approveSync(makerRpc, {
+      amount: 400_000_000n,
+      spender: Addresses.stablecoinDex,
+      token: base,
+    })
+    await Actions.token.approveSync(takerRpc, {
+      amount: 400_000_000n,
+      spender: Addresses.stablecoinDex,
+      token: Addresses.pathUsd,
+    })
+    await Actions.dex.createPairSync(makerRpc, { base })
+    const placed = await Actions.dex.placeFlipSync(makerRpc, {
+      amount: 200_000_000n,
+      flipTick: -100,
+      tick: 0,
+      token: base,
+      type: 'sell',
+    })
+    await Actions.dex.buySync(takerRpc, {
+      amountOut: 200_000_000n,
+      maxAmountIn: 200_000_000n,
+      tokenIn: Addresses.pathUsd,
+      tokenOut: base,
+    })
+    await Actions.token.approveSync(takerRpc, {
+      amount: 100_000_000n,
+      spender: Addresses.stablecoinDex,
+      token: base,
+    })
+    await Actions.dex.sellSync(takerRpc, {
+      amountIn: 100_000_000n,
+      feeToken: Addresses.pathUsd,
+      minAmountOut: 0n,
+      tokenIn: base,
+      tokenOut: Addresses.pathUsd,
+    })
+
+    const client = TestApp.client()
+    const auth = {
+      headers: { ...TestApp.auth.headers, 'cache-control': 'no-store' },
+    }
+    const deadline = Date.now() + 45_000
+    let order: OrdersResponse['data'][number] | undefined
+    while (Date.now() < deadline) {
+      const response = await client.v1.exchange.orders.$get(
+        { query: { base, limit: '10', maker: maker.address } },
+        auth,
+      )
+      if (response.status === 200) {
+        const body = await TestApp.json(response, Exchanges.schema.getOrders.Response)
+        order = body.data.find((row) => row.orderId === placed.orderId.toString())
+        if (
+          order &&
+          order.side === 'bid' &&
+          order.tick === -100 &&
+          order.remaining !== order.amount
+        )
+          break
+      }
+      await new Promise((resolve) => setTimeout(resolve, 500))
+    }
+
+    expect(order).toMatchObject({ side: 'bid', tick: -100 })
+    expect(BigInt(order!.remaining)).toBeGreaterThan(0n)
+    expect(BigInt(order!.remaining)).toBeLessThan(BigInt(order!.amount))
+
+    const response = await client.v1.exchange.pairs[':base'].ohlc.$get(
+      { param: { base }, query: { interval: '1h', window: '24h' } },
+      auth,
+    )
+    expect(response.status).toBe(200)
+    const ohlc = await TestApp.json(response, Exchanges.schema.getPairOhlc.Response)
+    expect(ohlc.data.at(-1)?.close).toBe(Tick.toPrice(-100))
+  }, 120_000)
+})
+
 /**
  * Discovers a real order id from the recent global swap feed so the
  * order-fills test can run against live testnet data without hard-coding