tapimo 0.7.1 → 0.8.0

package/dist/apps/data/routes/coingecko.d.ts

@@ -228,14 +228,14 @@ export declare function coingecko(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "api_key_malformed";
+                    code: "upstream_error";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 502;
             input: {
                 param: {
                     chainId: string;
@@ -244,14 +244,14 @@ export declare function coingecko(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "api_key_invalid" | "api_key_missing";
+                    code: "api_key_malformed";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 401;
+            status: 400;
             input: {
                 param: {
                     chainId: string;
@@ -260,14 +260,14 @@ export declare function coingecko(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "api_key_forbidden";
+                    code: "api_key_invalid" | "api_key_missing";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 403;
+            status: 401;
             input: {
                 param: {
                     chainId: string;
@@ -276,14 +276,14 @@ export declare function coingecko(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "payment_required" | "rate_limit_exceeded";
+                    code: "api_key_forbidden" | "api_key_ip_forbidden";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 429;
+            status: 403;
             input: {
                 param: {
                     chainId: string;
@@ -292,14 +292,14 @@ export declare function coingecko(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "upstream_error";
+                    code: "payment_required" | "rate_limit_exceeded";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 502;
+            status: 429;
             input: {
                 param: {
                     chainId: string;
@@ -368,14 +368,14 @@ export declare function coingecko(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "api_key_malformed";
+                    code: "upstream_error";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 502;
             input: {
                 param: {
                     chainId: string;
@@ -385,14 +385,14 @@ export declare function coingecko(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "api_key_invalid" | "api_key_missing";
+                    code: "api_key_malformed";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 401;
+            status: 400;
             input: {
                 param: {
                     chainId: string;
@@ -402,14 +402,14 @@ export declare function coingecko(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "api_key_forbidden";
+                    code: "api_key_invalid" | "api_key_missing";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 403;
+            status: 401;
             input: {
                 param: {
                     chainId: string;
@@ -419,14 +419,14 @@ export declare function coingecko(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "payment_required" | "rate_limit_exceeded";
+                    code: "api_key_forbidden" | "api_key_ip_forbidden";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 429;
+            status: 403;
             input: {
                 param: {
                     chainId: string;
@@ -436,14 +436,14 @@ export declare function coingecko(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "upstream_error";
+                    code: "payment_required" | "rate_limit_exceeded";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 502;
+            status: 429;
             input: {
                 param: {
                     chainId: string;
@@ -522,14 +522,14 @@ export declare function coingecko(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "api_key_malformed";
+                    code: "upstream_error";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 502;
             input: {
                 param: {
                     chainId: string;
@@ -542,14 +542,14 @@ export declare function coingecko(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "api_key_invalid" | "api_key_missing";
+                    code: "api_key_malformed";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 401;
+            status: 400;
             input: {
                 param: {
                     chainId: string;
@@ -562,14 +562,14 @@ export declare function coingecko(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "api_key_forbidden";
+                    code: "api_key_invalid" | "api_key_missing";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 403;
+            status: 401;
             input: {
                 param: {
                     chainId: string;
@@ -582,14 +582,14 @@ export declare function coingecko(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "payment_required" | "rate_limit_exceeded";
+                    code: "api_key_forbidden" | "api_key_ip_forbidden";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 429;
+            status: 403;
             input: {
                 param: {
                     chainId: string;
@@ -602,14 +602,14 @@ export declare function coingecko(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "query_invalid";
+                    code: "payment_required" | "rate_limit_exceeded";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 429;
             input: {
                 param: {
                     chainId: string;
@@ -622,14 +622,14 @@ export declare function coingecko(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "upstream_error";
+                    code: "query_invalid";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 502;
+            status: 400;
             input: {
                 param: {
                     chainId: string;
@@ -695,14 +695,14 @@ export declare function coingecko(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "api_key_malformed";
+                    code: "upstream_error";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 502;
             input: {
                 param: {
                     chainId: string;
@@ -712,14 +712,14 @@ export declare function coingecko(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "api_key_invalid" | "api_key_missing";
+                    code: "api_key_malformed";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 401;
+            status: 400;
             input: {
                 param: {
                     chainId: string;
@@ -729,14 +729,14 @@ export declare function coingecko(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "api_key_forbidden";
+                    code: "api_key_invalid" | "api_key_missing";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 403;
+            status: 401;
             input: {
                 param: {
                     chainId: string;
@@ -746,14 +746,14 @@ export declare function coingecko(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "payment_required" | "rate_limit_exceeded";
+                    code: "api_key_forbidden" | "api_key_ip_forbidden";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 429;
+            status: 403;
             input: {
                 param: {
                     chainId: string;
@@ -763,14 +763,14 @@ export declare function coingecko(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "upstream_error";
+                    code: "payment_required" | "rate_limit_exceeded";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 502;
+            status: 429;
             input: {
                 param: {
                     chainId: string;
@@ -868,14 +868,14 @@ export declare function coingecko(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "api_key_malformed";
+                    code: "upstream_error";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 502;
             input: {
                 param: {
                     chainId: string;
@@ -889,14 +889,14 @@ export declare function coingecko(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "api_key_invalid" | "api_key_missing";
+                    code: "api_key_malformed";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 401;
+            status: 400;
             input: {
                 param: {
                     chainId: string;
@@ -910,14 +910,14 @@ export declare function coingecko(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "api_key_forbidden";
+                    code: "api_key_invalid" | "api_key_missing";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 403;
+            status: 401;
             input: {
                 param: {
                     chainId: string;
@@ -931,14 +931,14 @@ export declare function coingecko(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "payment_required" | "rate_limit_exceeded";
+                    code: "api_key_forbidden" | "api_key_ip_forbidden";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 429;
+            status: 403;
             input: {
                 param: {
                     chainId: string;
@@ -952,14 +952,14 @@ export declare function coingecko(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "query_invalid";
+                    code: "payment_required" | "rate_limit_exceeded";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 429;
             input: {
                 param: {
                     chainId: string;
@@ -973,14 +973,14 @@ export declare function coingecko(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "upstream_error";
+                    code: "query_invalid";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 502;
+            status: 400;
             input: {
                 param: {
                     chainId: string;

package/dist/apps/data/routes/coingecko.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coingecko.d.ts","sourceRoot":"","sources":["../../../../src/apps/data/routes/coingecko.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAE7B,OAAO,KAAK,KAAK,GAAG,MAAM,iBAAiB,CAAA;AAI3C,OAAO,KAAK,QAAQ,MAAM,+BAA+B,CAAA;AAoFzD,8EAA8E;AAC9E,yBAAiB,MAAM,CAAC;IACtB;;;;;OAKG;IACI,MAAM,kBAAkB,yBAK5B,CAAA;IAEH;;;;OAIG;IACI,MAAM,YAAY;;;;;qBAQtB,CAAA;IAEH,kDAAkD;IAC3C,MAAM,KAAK;;;qBAoBjB,CAAA;IAED,6CAA6C;IACtC,MAAM,mBAAmB;;;;;qBAG/B,CAAA;IAED,iDAAiD;IAC1C,MAAM,WAAW;;;;;;qBAO0D,CAAA;IAElF,6CAA6C;IACtC,MAAM,KAAK;;;;;;qBA+BjB,CAAA;IAED,gDAAgD;IACzC,MAAM,aAAa;;;;;;;;qBAGzB,CAAA;IAED,0DAA0D;IACnD,MAAM,SAAS;;;;;;qBA+BrB,CAAA;IAED,oCAAoC;IAC7B,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;qBAgEhB,CAAA;IAED,sCAAsC;IAC/B,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;qBAKzB,CAAA;IAED,8CAA8C;IACvC,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;qBAGxB,CAAA;IAED,gDAAgD;IACzC,MAAM,UAAU;;;;;;qBAU+D,CAAA;IAEtF,8CAA8C;IACvC,MAAM,UAAU;;qBAc+C,CAAA;IAEtE,+CAA+C;IACxC,MAAM,WAAW;;;qBAe8D,CAAA;IAEtF,0DAA0D;IACnD,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;qBAoFrB,CAAA;IAED,uCAAuC;IAChC,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;qBAS1B,CAAA;CACF;AAaD,kFAAkF;AAClF,wBAAgB,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAuTxB"}
+{"version":3,"file":"coingecko.d.ts","sourceRoot":"","sources":["../../../../src/apps/data/routes/coingecko.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAE7B,OAAO,KAAK,KAAK,GAAG,MAAM,iBAAiB,CAAA;AAI3C,OAAO,KAAK,QAAQ,MAAM,+BAA+B,CAAA;AAyFzD,8EAA8E;AAC9E,yBAAiB,MAAM,CAAC;IACtB;;;;;OAKG;IACI,MAAM,kBAAkB,yBAK5B,CAAA;IAEH;;;;OAIG;IACI,MAAM,YAAY;;;;;qBAQtB,CAAA;IAEH,kDAAkD;IAC3C,MAAM,KAAK;;;qBAoBjB,CAAA;IAED,6CAA6C;IACtC,MAAM,mBAAmB;;;;;qBAG/B,CAAA;IAED,iDAAiD;IAC1C,MAAM,WAAW;;;;;;qBAO0D,CAAA;IAElF,6CAA6C;IACtC,MAAM,KAAK;;;;;;qBA+BjB,CAAA;IAED,gDAAgD;IACzC,MAAM,aAAa;;;;;;;;qBAGzB,CAAA;IAED,0DAA0D;IACnD,MAAM,SAAS;;;;;;qBA+BrB,CAAA;IAED,oCAAoC;IAC7B,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;qBAgEhB,CAAA;IAED,sCAAsC;IAC/B,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;qBAKzB,CAAA;IAED,8CAA8C;IACvC,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;qBAGxB,CAAA;IAED,gDAAgD;IACzC,MAAM,UAAU;;;;;;qBAU+D,CAAA;IAEtF,8CAA8C;IACvC,MAAM,UAAU;;qBAc+C,CAAA;IAEtE,+CAA+C;IACxC,MAAM,WAAW;;;qBAe8D,CAAA;IAEtF,0DAA0D;IACnD,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;qBAoFrB,CAAA;IAED,uCAAuC;IAChC,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;qBAS1B,CAAA;CACF;AAaD,kFAAkF;AAClF,wBAAgB,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAyTxB"}

package/dist/apps/data/routes/coingecko.js

@@ -12,7 +12,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
 // SQL; `dexAccount` keeps the checksummed address for on-chain reads.
@@ -78,6 +78,10 @@ const addressChunkSize = 200;
 // chunks — with an `await` between groups so each chunk is its own batch — keeps
 // 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 var schema;
 (function (schema) {
@@ -355,11 +359,13 @@ 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);
         }
     })
@@ -584,9 +590,7 @@ async function getLatestBlock(c, chainId) {
 }
 /** Reads TIP-20 metadata and shapes it into the GeckoTerminal asset object. */
 async function resolveAsset(c, chainId, address) {
-    const metadata = await getTokenMetadata(c, { address, chainId });
-    if (!metadata)
-        return undefined;
+    const metadata = await Timing.time(c, 'coingecko_metadata', () => getTokenMetadata(c, { address, chainId }));
     return {
         id: Address.checksum(address),
         name: metadata.name,
@@ -692,8 +696,8 @@ function resolvePairDetails(row, reserves, metadata) {
 /**
  * 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.
@@ -702,7 +706,7 @@ async function loadTokenMetadata(c, chainId, tokens) {
     const metadata = new Map();
     const unique = [...new Set(tokens)];
     let failed = false;
-    await mapSeries(chunk(unique, tokenReadChunkSize), (group) => Promise.all(group.map(async (address) => {
+    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,
@@ -713,7 +717,7 @@ async function loadTokenMetadata(c, chainId, tokens) {
             failed = true;
             metadata.set(address, undefined);
         }
-    })));
+    }))));
     return { failed, metadata };
 }
 /**
@@ -733,7 +737,7 @@ async function loadDexBalances(c, chainId, tokens) {
     if (unique.length === 0)
         return { balances, failed };
     const client = c.get('getClient')(chainId);
-    await Timing.time(c, 'coingecko_reserves', () => mapSeries(chunk(unique, tokenReadChunkSize), (group) => Promise.all(group.map(async (token) => {
+    await Timing.time(c, 'coingecko_reserves', () => Batch.mapSeries(Batch.chunk(unique, tokenReadChunkSize), (group) => Promise.all(group.map(async (token) => {
         try {
             const balance = await client.token.getBalance({
                 account: dexAccount,
@@ -807,7 +811,7 @@ async function listEvents(c, chainId, fromBlock, toBlock) {
     const orderIds = [...new Set(fills.map((fill) => fill.orderId))];
     const states = new Map();
     await Timing.time(c, 'coingecko_states', async () => {
-        const partials = await mapSeries(chunk(orderIds, orderIdChunkSize), (ids) => resolveOrderStates(c, {
+        const partials = await Batch.mapSeries(Batch.chunk(orderIds, orderIdChunkSize), (ids) => resolveOrderStates(c, {
             chainId,
             maxBlock: toBlock,
             minBlock: fromBlock,
@@ -823,7 +827,7 @@ async function listEvents(c, chainId, fromBlock, toBlock) {
     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
     // sequentially (not `Promise.all`) so the two read kinds don't merge into the
@@ -929,7 +933,7 @@ async function resolvePairIndex(c, chainId, bases) {
     // 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,
@@ -963,27 +967,50 @@ function latestStateBefore(events, blockNumber, logIndex) {
     }
     return undefined;
 }
-/** Splits `items` into consecutive groups of at most `size`. */
-function chunk(items, size) {
-    const groups = [];
-    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(items, fn) {
-    const results = [];
-    for (const item of items)
-        results.push(await fn(item));
-    return results;
-}
+var Batch;
+(function (Batch) {
+    /** Splits `items` into consecutive groups of at most `size`. */
+    function chunk(items, size) {
+        const groups = [];
+        for (let i = 0; i < items.length; i += size)
+            groups.push(items.slice(i, i + size));
+        return groups;
+    }
+    Batch.chunk = chunk;
+    /**
+     * 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(items, fn) {
+        const results = [];
+        for (const item of items)
+            results.push(await fn(item));
+        return results;
+    }
+    Batch.mapSeries = mapSeries;
+    /**
+     * 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}.
+     */
+    async function mapConcurrent(items, concurrency, fn) {
+        const results = 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;
+    }
+    Batch.mapConcurrent = mapConcurrent;
+})(Batch || (Batch = {}));
 /** `keccak256(base ++ quote)` — the on-chain order-book key. */
 function deriveBookKey(base, quote) {
     return Hash.keccak256(`0x${base.slice(2)}${quote.slice(2)}`);