tapimo 0.7.1 → 0.8.0

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

@@ -14,7 +14,7 @@ import * as Schema from '../../../internal/Schema.js'
 import * as Timing from '../../../internal/Timing.js'
 import * as Value from '../../../internal/Value.js'
 import { resolveBookQuotes, resolveBookReserves, resolveOrderStates } from './exchanges.js'
-import { getTokenMetadata } from './tokens.js'
+import { getTokenMetadata, isTokenNotFound } from './tokens.js'
 
 // Stablecoin DEX precompile. Pairs are announced by `PairCreated` (pre-decoded
 // into `dex_pairs`); fills land in `dex_fills`. The lowercase form is for inline
@@ -93,6 +93,11 @@ const addressChunkSize = 200
 // every multicall comfortably under the limit while still aggregating per chunk.
 const tokenReadChunkSize = 20
 
+// How many metadata chunks to keep in flight. Each `getMetadata` is a
+// standalone deployless aggregate3 call (never batch-merged), so concurrency
+// cuts wall time without growing any single RPC call.
+const tokenReadConcurrency = 4
+
 /** Zod schemas owned by the CoinGecko/GeckoTerminal compatibility adapter. */
 export namespace schema {
   /**
@@ -565,9 +570,11 @@ export function coingecko() {
         const { address, chainId } = c.req.valid('param')
         try {
           const asset = await resolveAsset(c, chainId, address)
-          if (!asset) return notFound(c, 'Asset not found')
           return c.json(Response.validated(schema.AssetResponse, { asset }), 200)
         } catch (cause) {
+          // Non-TIP-20 addresses (LP pairs, EOAs) fail the metadata read; that
+          // is the documented 404, not an upstream failure.
+          if (isTokenNotFound(cause)) return notFound(c, 'Asset not found')
           return Response.upstream(c, cause)
         }
       },
@@ -838,9 +845,10 @@ async function resolveAsset(
   c: Context<App.Environment>,
   chainId: z.output<typeof Schema.ChainId>,
   address: z.output<typeof Schema.TokenAddress>,
-): Promise<z.output<typeof schema.Asset> | undefined> {
-  const metadata = await getTokenMetadata(c, { address, chainId })
-  if (!metadata) return undefined
+): Promise<z.output<typeof schema.Asset>> {
+  const metadata = await Timing.time(c, 'coingecko_metadata', () =>
+    getTokenMetadata(c, { address, chainId }),
+  )
   return {
     id: Address.checksum(address),
     name: metadata.name,
@@ -979,8 +987,8 @@ type TokenMetadata = Awaited<ReturnType<typeof getTokenMetadata>>
 /**
  * Reads RPC metadata for a set of tokens, returning an `address -> metadata`
  * map. Deduplicates so a quote shared across many books (e.g. pathUSD) is read
- * once per request, and reads in {@link tokenReadChunkSize} chunks so the
- * client's deployless multicall never overflows the RPC's per-call limit. A read
+ * once per request, and reads in {@link tokenReadChunkSize} chunks with at most
+ * {@link tokenReadConcurrency} chunks in flight, bounding the RPC burst. A read
  * failure maps the token to `undefined` and flips `failed` rather than failing
  * the whole response (metadata is best-effort); callers must not cache a
  * degraded page.
@@ -993,22 +1001,24 @@ async function loadTokenMetadata(
   const metadata = new Map<string, TokenMetadata | undefined>()
   const unique = [...new Set(tokens)]
   let failed = false
-  await mapSeries(chunk(unique, tokenReadChunkSize), (group) =>
-    Promise.all(
-      group.map(async (address) => {
-        try {
-          metadata.set(
-            address,
-            await getTokenMetadata(c, {
-              address: address as z.output<typeof Schema.Address>,
-              chainId,
-            }),
-          )
-        } catch {
-          failed = true
-          metadata.set(address, undefined)
-        }
-      }),
+  await Timing.time(c, 'coingecko_metadata', () =>
+    Batch.mapConcurrent(Batch.chunk(unique, tokenReadChunkSize), tokenReadConcurrency, (group) =>
+      Promise.all(
+        group.map(async (address) => {
+          try {
+            metadata.set(
+              address,
+              await getTokenMetadata(c, {
+                address: address as z.output<typeof Schema.Address>,
+                chainId,
+              }),
+            )
+          } catch {
+            failed = true
+            metadata.set(address, undefined)
+          }
+        }),
+      ),
     ),
   )
   return { failed, metadata }
@@ -1035,7 +1045,7 @@ async function loadDexBalances(
   if (unique.length === 0) return { balances, failed }
   const client = c.get('getClient')(chainId)
   await Timing.time(c, 'coingecko_reserves', () =>
-    mapSeries(chunk(unique, tokenReadChunkSize), (group) =>
+    Batch.mapSeries(Batch.chunk(unique, tokenReadChunkSize), (group) =>
       Promise.all(
         group.map(async (token) => {
           try {
@@ -1138,7 +1148,7 @@ async function listEvents(
   const orderIds = [...new Set(fills.map((fill) => fill.orderId))]
   const states: Awaited<ReturnType<typeof resolveOrderStates>> = new Map()
   await Timing.time(c, 'coingecko_states', async () => {
-    const partials = await mapSeries(chunk(orderIds, orderIdChunkSize), (ids) =>
+    const partials = await Batch.mapSeries(Batch.chunk(orderIds, orderIdChunkSize), (ids) =>
       resolveOrderStates(c, {
         chainId,
         maxBlock: toBlock,
@@ -1155,7 +1165,9 @@ async function listEvents(
   const bases = [
     ...new Set([...states.values()].flatMap((events) => events.map((event) => event.token))),
   ]
-  const { keyByBase, quoteByBase } = await resolvePairIndex(c, chainId, bases)
+  const { keyByBase, quoteByBase } = await Timing.time(c, 'coingecko_pair_index', () =>
+    resolvePairIndex(c, chainId, bases),
+  )
 
   // Token decimals (RPC metadata) and best-effort current reserves (RPC
   // `balanceOf`) for every base/quote involved. Loaded in bounded chunks and
@@ -1279,7 +1291,7 @@ async function resolvePairIndex(
   // Chunk the `base IN (...)` lookup for the same GET-URI reason as the order
   // states above; chunks resolve serially and merge.
   const tidx = c.get('getTidx')(chainId)
-  const results = await mapSeries(chunk(bases, addressChunkSize), (group) => {
+  const results = await Batch.mapSeries(Batch.chunk(bases, addressChunkSize), (group) => {
     const list = group.map((base) => `'${base}'`).join(', ')
     return tidx.fetch({
       chainId,
@@ -1323,28 +1335,52 @@ function latestStateBefore(
   return undefined
 }
 
-/** Splits `items` into consecutive groups of at most `size`. */
-function chunk<item>(items: readonly item[], size: number): item[][] {
-  const groups: item[][] = []
-  for (let i = 0; i < items.length; i += size) groups.push(items.slice(i, i + size))
-  return groups
-}
+namespace Batch {
+  /** Splits `items` into consecutive groups of at most `size`. */
+  export function chunk<item>(items: readonly item[], size: number): item[][] {
+    const groups: item[][] = []
+    for (let i = 0; i < items.length; i += size) groups.push(items.slice(i, i + size))
+    return groups
+  }
 
-/**
- * Maps `fn` over `items` strictly one at a time. ClickHouse chunk queries are
- * issued serially on purpose: the managed indexer rejects bursts of concurrent
- * queries with a fast HTTP 422 (verified: heavy baseline scans 422 at 2-3 in
- * flight), and each chunk is individually fast (~2 s), so serial execution
- * trades a little latency for reliability. Real GeckoTerminal polling windows
- * are small and cached, so the latency is rarely on the hot path.
- */
-async function mapSeries<item, result>(
-  items: readonly item[],
-  fn: (item: item) => Promise<result>,
-): Promise<result[]> {
-  const results: result[] = []
-  for (const item of items) results.push(await fn(item))
-  return results
+  /**
+   * Maps `fn` over `items` strictly one at a time. ClickHouse chunk queries are
+   * issued serially on purpose: the managed indexer rejects bursts of concurrent
+   * queries with a fast HTTP 422 (verified: heavy baseline scans 422 at 2-3 in
+   * flight), and each chunk is individually fast (~2 s), so serial execution
+   * trades a little latency for reliability. Real GeckoTerminal polling windows
+   * are small and cached, so the latency is rarely on the hot path.
+   */
+  export async function mapSeries<item, result>(
+    items: readonly item[],
+    fn: (item: item) => Promise<result>,
+  ): Promise<result[]> {
+    const results: result[] = []
+    for (const item of items) results.push(await fn(item))
+    return results
+  }
+
+  /**
+   * Maps `fn` over `items` with at most `concurrency` calls in flight, preserving
+   * result order. For RPC chunk fan-outs only: ClickHouse chunk queries stay
+   * serial through {@link mapSeries}.
+   */
+  export async function mapConcurrent<item, result>(
+    items: readonly item[],
+    concurrency: number,
+    fn: (item: item) => Promise<result>,
+  ): Promise<result[]> {
+    const results: result[] = Array.from({ length: items.length })
+    let next = 0
+    const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+      while (next < items.length) {
+        const index = next++
+        results[index] = await fn(items[index]!)
+      }
+    })
+    await Promise.all(workers)
+    return results
+  }
 }
 
 /** `keccak256(base ++ quote)` — the on-chain order-book key. */