tapimo 0.10.0 → 0.10.2

package/src/apps/data/routes/earn.ts

@@ -154,7 +154,7 @@ export namespace schema {
     .strictObject({
       chainId: Schema.ChainId.check(
         z.describe('Private Zone chain id.'),
-        z.meta({ examples: [421700001] }),
+        z.meta({ examples: [1424310001] }),
       ),
       inputTokens: z
         .array(Schema.Address)
@@ -164,7 +164,7 @@ export namespace schema {
         ),
       name: z
         .string()
-        .check(z.describe('Private Zone name.'), z.meta({ examples: ['zone-moderato'] })),
+        .check(z.describe('Private Zone name.'), z.meta({ examples: ['zone-moderato-internal'] })),
       outputTokens: z
         .array(Schema.Address)
         .check(
@@ -2034,6 +2034,8 @@ export async function listVaults(c: Context<App.Environment>, options: listVault
     core_EarnVaults.list(db, { chainId: options.chainId }),
     VerifiedTokens.snapshot(c, options.chainId),
   ])
+  const include = vaultInclude(options)
+  const apyByVault = new Map<string, EarnRates.Apy | null>()
   const registry = new Map(records.map((record) => [record.vaultAddress.toLowerCase(), record]))
   const decoded = options.cursor ? Cursor.decode(options.cursor, ['int', 'int']) : undefined
   let position = decoded
@@ -2062,22 +2064,44 @@ export async function listVaults(c: Context<App.Environment>, options: listVault
     }
     scanned += page.items.length
 
-    const discovered = await Promise.all(
-      page.items.map(async (item) => {
-        const record = registry.get(item.vaultAddress.toLowerCase())
-        try {
-          const discovery = await resolveVaultDiscovery(c, {
+    const apyVaults =
+      apyByVault.size === 0 &&
+      include.includes('apy') &&
+      options.capability.length === 0 &&
+      options['engine.type'] === undefined
+        ? page.items
+            .slice(0, options.limit - matches.length)
+            .map(({ vaultAddress }) => vaultAddress)
+        : []
+    // Rate boundaries and historical quotes depend only on candidate addresses,
+    // so the unfiltered page can resolve them alongside live vault discovery.
+    const [discovered, prefetchedApy] = await Promise.all([
+      Promise.all(
+        page.items.map(async (item) => {
+          const record = registry.get(item.vaultAddress.toLowerCase())
+          try {
+            const discovery = await resolveVaultDiscovery(c, {
+              chainId: options.chainId,
+              include: discoveryInclude(options),
+              vaultAddress: item.vaultAddress,
+            })
+            return { discovery, position: item.position, record }
+          } catch (cause) {
+            if (!record && isIncompatible(cause)) return undefined
+            throw cause
+          }
+        }),
+      ),
+      apyVaults.length > 0
+        ? resolvePageApy(c, {
             chainId: options.chainId,
-            include: discoveryInclude(options),
-            vaultAddress: item.vaultAddress,
+            include,
+            vaults: apyVaults,
+            window: options['apy.window'],
           })
-          return { discovery, position: item.position, record }
-        } catch (cause) {
-          if (!record && isIncompatible(cause)) return undefined
-          throw cause
-        }
-      }),
-    )
+        : undefined,
+    ])
+    for (const [vault, apy] of prefetchedApy ?? []) apyByVault.set(vault, apy)
     for (const match of discovered) {
       if (!match || !matchesVaultFilters(match.discovery, options)) continue
       matches.push(match)
@@ -2089,17 +2113,25 @@ export async function listVaults(c: Context<App.Environment>, options: listVault
 
   const page = matches.slice(0, options.limit)
   const discoveries = page.map(({ discovery }) => discovery)
-  const include = vaultInclude(options)
-  const [apy, rates, tokens] = await Promise.all([
-    resolvePageApy(c, {
-      chainId: options.chainId,
-      discoveries,
-      include,
-      window: options['apy.window'],
-    }),
+  const missingApyVaults = include.includes('apy')
+    ? discoveries.flatMap(({ vaultAddress }) =>
+        apyByVault.has(vaultAddress.toLowerCase()) ? [] : [vaultAddress],
+      )
+    : []
+  const [missingApy, rates, tokens] = await Promise.all([
+    missingApyVaults.length > 0
+      ? resolvePageApy(c, {
+          chainId: options.chainId,
+          include,
+          vaults: missingApyVaults,
+          window: options['apy.window'],
+        })
+      : undefined,
     resolvePageRates(c, { discoveries, include, oracle: options.oracle, snapshot }),
     resolvePageTokens(c, { chainId: options.chainId, discoveries, include, snapshot }),
   ])
+  for (const [vault, apy] of missingApy ?? []) apyByVault.set(vault, apy)
+  const apy = include.includes('apy') ? apyByVault : undefined
   const data = page.map((match) =>
     resolveVault(c, { ...match, apy, include, rates, snapshot, tokens }),
   )
@@ -2181,8 +2213,8 @@ export async function listVerifiedVaults(
   const [apy, rates, tokens] = await Promise.all([
     resolvePageApy(c, {
       chainId: options.chainId,
-      discoveries,
       include,
+      vaults: discoveries.map(({ vaultAddress }) => vaultAddress),
       window: options['apy.window'],
     }),
     resolvePageRates(c, { discoveries, include, oracle: options.oracle, snapshot }),
@@ -2503,8 +2535,8 @@ export async function getVault(c: Context<App.Environment>, options: getVault.Op
     const [apy, rates, tokens] = await Promise.all([
       resolvePageApy(c, {
         chainId: options.chainId,
-        discoveries,
         include,
+        vaults: discoveries.map(({ vaultAddress }) => vaultAddress),
         window: options['apy.window'],
       }),
       resolvePageRates(c, { discoveries, include, oracle: options.oracle, snapshot }),
@@ -2616,7 +2648,7 @@ function resolvePageApy(c: Context<App.Environment>, options: resolvePageApy.Opt
       getClient: c.get('getClient'),
       getTidx: c.get('getTidx'),
       store: c.get('store'),
-      vaults: options.discoveries.map(({ vaultAddress }) => vaultAddress),
+      vaults: options.vaults,
       window: options.window,
     }),
   )
@@ -2625,8 +2657,8 @@ function resolvePageApy(c: Context<App.Environment>, options: resolvePageApy.Opt
 declare namespace resolvePageApy {
   type Options = {
     chainId: z.output<typeof Schema.ChainId>
-    discoveries: readonly EarnVaults.Discovery[]
     include: z.output<typeof schema.getEarnVault.Query>['include']
+    vaults: readonly z.output<typeof Schema.Address>[]
     window: z.output<typeof schema.getEarnVault.Query>['apy.window']
   }
 }
@@ -2837,7 +2869,7 @@ async function queryDeployments(
   c: Context<App.Environment>,
   options: queryDeployments.Options,
 ): Promise<queryDeployments.Result> {
-  const filters = ['deployment_rank = 1']
+  const filters: string[] = []
   if (options.asset) filters.push(`lower(asset) = '${options.asset.toLowerCase()}'`)
   if (options.cursor)
     filters.push(
@@ -2855,7 +2887,7 @@ async function queryDeployments(
       ]),
     )
 
-  // ClickHouse supports ordering and windowing over decoded event CTEs.
+  // Deduplicate before outer filters so every vault is filtered by its latest deployment.
   const result = await c
     .get('getTidx')(options.chainId)
     .fetch({
@@ -2868,14 +2900,12 @@ async function queryDeployments(
           "earnVault",
           asset,
           block_num,
-          log_idx,
-          row_number() OVER (
-            PARTITION BY lower("earnVault")
-            ORDER BY block_num DESC, log_idx DESC
-          ) AS deployment_rank
+          log_idx
         FROM EarnStackDeployed
+        ORDER BY block_num DESC, log_idx DESC
+        LIMIT 1 BY lower("earnVault")
       )
-      WHERE ${filters.join(' AND ')}
+      ${filters.length > 0 ? `WHERE ${filters.join(' AND ')}` : ''}
       ORDER BY block_num DESC, log_idx DESC
       LIMIT ${options.limit + 1}
     ` as string,

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

@@ -0,0 +1,85 @@
+import * as QueryBench from '../../../../test/QueryBench.js'
+
+const fixtures = {
+  4217: {
+    base: '0x20c0000000000000000000001a47bebe936d00d7',
+    filledOrderId: '3881',
+    orderId: '3312',
+  },
+  42431: {
+    base: '0x20c000000000000000000000746cbc54ce86a3cb',
+    filledOrderId: '18047908',
+    orderId: '18048313',
+  },
+} as const
+
+QueryBench.bench({
+  name: 'getSwaps',
+  path: '/v1/exchange/swaps',
+  queries: ['include=token.logoUri', 'include=token.verified', 'valuation.currency=USD'],
+})
+
+QueryBench.bench({
+  name: 'getPairs',
+  path: '/v1/exchange/pairs',
+  queries: ['include=tokens', 'include=totalCount', 'sort=liquidity'],
+})
+
+QueryBench.bench({
+  name: 'getPair',
+  path: {
+    4217: `/v1/exchange/pairs/${fixtures[4217].base}`,
+    42431: `/v1/exchange/pairs/${fixtures[42431].base}`,
+  },
+  queries: ['include=tokens'],
+})
+
+QueryBench.bench({
+  name: 'getOrders',
+  path: '/v1/exchange/orders',
+  queries: ['include=tokens', 'include=totalCount'],
+})
+
+QueryBench.bench({
+  name: 'getOrders?base',
+  path: {
+    4217: `/v1/exchange/orders?base=${fixtures[4217].base}`,
+    42431: `/v1/exchange/orders?base=${fixtures[42431].base}`,
+  },
+})
+
+QueryBench.bench({
+  name: 'getOrder',
+  path: {
+    4217: `/v1/exchange/orders/${fixtures[4217].orderId}`,
+    42431: `/v1/exchange/orders/${fixtures[42431].orderId}`,
+  },
+  queries: ['include=tokens'],
+})
+
+QueryBench.bench({
+  name: 'getOrderFills',
+  path: {
+    4217: `/v1/exchange/orders/${fixtures[4217].filledOrderId}/fills`,
+    42431: `/v1/exchange/orders/${fixtures[42431].filledOrderId}/fills`,
+  },
+  queries: ['include=totalCount'],
+})
+
+QueryBench.bench({
+  name: 'getPairOhlc',
+  path: {
+    4217: `/v1/exchange/pairs/${fixtures[4217].base}/ohlc`,
+    42431: `/v1/exchange/pairs/${fixtures[42431].base}/ohlc`,
+  },
+  queries: ['include=tokens'],
+})
+
+QueryBench.bench({
+  name: 'getPairDepth',
+  path: {
+    4217: `/v1/exchange/pairs/${fixtures[4217].base}/depth`,
+    42431: `/v1/exchange/pairs/${fixtures[42431].base}/depth`,
+  },
+  queries: ['include=tokens'],
+})

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

@@ -531,7 +531,7 @@ describe('GET /exchange/orders?base=… (pair-scoped orders)', () => {
 })
 
 describe('GET /exchange/pairs/:base/depth', () => {
-  test('returns orderbook depth for a real pair', async () => {
+  test('returns orderbook depth when token metadata is requested', async () => {
     const client = TestApp.client()
     const pairsResponse = await client.v1.exchange.pairs.$get(
       { query: { limit: '5' } },
@@ -547,21 +547,25 @@ describe('GET /exchange/pairs/:base/depth', () => {
     // throttles the multicall response.
     let body: z.output<typeof Exchanges.schema.getPairDepth.Response> | null = null
     let pair: (typeof pairs.data)[number] | null = null
+    let timing: string | null = null
     for (const candidate of pairs.data) {
       const response = await client.v1.exchange.pairs[':base'].depth.$get(
-        { param: { base: candidate.base.address }, query: {} },
+        { param: { base: candidate.base.address }, query: { include: 'tokens' } },
         TestApp.auth,
       )
       if (response.status === 502) return
       expect(response.status).toBe(200)
       body = await TestApp.json(response, Exchanges.schema.getPairDepth.Response)
       pair = candidate
+      timing = response.headers.get('server-timing')
       if (body.bids.length > 0 || body.asks.length > 0) break
     }
     if (!body || !pair) return
 
     expect(body.base.address).toBe(pair.base.address)
     expect(body.quote.address).toBe(pair.quote.address)
+    expect(timing).toContain('pair_lookup;dur=')
+    expect(timing).not.toContain('pair_index;dur=')
 
     // Asks are emitted lowest-tick first (best ask outward); bids are
     // emitted highest-tick first (best bid outward). Per-row `cumulativeSize`
@@ -689,9 +693,9 @@ describe('GET /exchange/swaps', () => {
     const response = await client.v1.exchange.swaps.$get({ query: { limit: '10' } }, TestApp.auth)
     expect(response.status).toBe(200)
     const body = await TestApp.json(response, Exchanges.schema.getSwaps.Response)
+    expect(body.data.length).toBeGreaterThan(0)
     expect(body.data.length).toBeLessThanOrEqual(10)
     expect(response.headers.get('server-timing')).not.toContain('valuation_rates;dur=')
-    if (body.data.length === 0) return
 
     for (const swap of body.data) {
       expect(swap.taker).toMatch(/^0x[0-9a-f]{40}$/)
@@ -827,6 +831,7 @@ describe('GET /exchange/swaps', () => {
       TestApp.auth,
     )
     expect(response.status).toBe(200)
+    expect(response.headers.get('server-timing')).not.toContain('token_logo_uri;dur=')
     const body = await TestApp.json(response, Exchanges.schema.getSwaps.Response)
     if (body.data.length === 0) return