tapimo 0.15.0 → 0.18.0

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

@@ -1 +1 @@
-{"version":3,"file":"exchanges.d.ts","sourceRoot":"","sources":["../../../../src/apps/data/routes/exchanges.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,OAAO,EAAE,MAAM,MAAM,CAAA;AAWzC,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAE7B,OAAO,KAAK,KAAK,GAAG,MAAM,iBAAiB,CAAA;AAM3C,OAAO,KAAK,QAAQ,MAAM,+BAA+B,CAAA;AACzD,OAAO,KAAK,MAAM,MAAM,6BAA6B,CAAA;AASrD,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AA0J3C,kDAAkD;AAClD,yBAAiB,MAAM,CAAC;IACtB;;;;;OAKG;IACI,MAAM,SAAS;;;;;;;;qBAmDrB,CAAA;IAmBD,yDAAyD;IACzD,UAAiB,WAAW,CAAC;QAI3B,4DAA4D;QACrD,MAAM,MAAM,yBAYlB,CAAA;QAED,sEAAsE;QAC/D,MAAM,OAAO;;;UAE6D,CAAA;QAEjF,oDAAoD;QAC7C,MAAM,YAAY;;;YAGxB,CAAA;QAED,4EAA4E;QACrE,MAAM,KAAK;;;;;;;;;;0BAMsD,CAAA;QAExE,uEAAuE;QAChE,MAAM,OAAO;;;;;;;;;;0BAyCnB,CAAA;QAED,uDAAuD;QAChD,MAAM,IAAI;;;;yBAkBhB,CAAA;QA8BM,MAAM,WAAW;;;;;;;;;;yBAuBvB,CAAA;QAED,gDAAgD;QACzC,MAAM,IAAI;;;;;;yBAahB,CAAA;QAED,0EAA0E;QACnE,MAAM,SAAS;;;;;;;;yBAqErB,CAAA;QA6ID,kEAAkE;QAC3D,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAYpB,CAAA;KACF;IAED,0EAA0E;IAC1E,UAAiB,YAAY,CAAC;QAC5B,mCAAmC;QAC5B,MAAM,OAAO;;;;;0BA8BnB,CAAA;QAED,8BAA8B;QACvB,MAAM,QAAQ;;;;;;;;;;;;;yBAapB,CAAA;KACF;IAED,0CAA0C;IAC1C,UAAiB,QAAQ,CAAC;QACxB;;;;WAIG;QACI,MAAM,OAAO;;;UAMjB,CAAA;QAEH;;;;WAIG;QACI,MAAM,YAAY;;;YAGxB,CAAA;QAED,uDAAuD;QAChD,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;0BAoBf,CAAA;QAEH,mDAAmD;QAC5C,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;yBAoDhB,CAAA;QAED,4EAA4E;QACrE,MAAM,IAAI;;;yBAA8D,CAAA;QAE/E,wEAAwE;QACjE,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAiBpB,CAAA;KACF;IAED,sEAAsE;IACtE,UAAiB,OAAO,CAAC;QACvB;;;;WAIG;QACI,MAAM,MAAM;;yBAMmD,CAAA;QAEtE,qEAAqE;QAC9D,MAAM,OAAO;;UAEqD,CAAA;QAEzE;;;WAGG;QACI,MAAM,YAAY;;YAGxB,CAAA;QAED,iDAAiD;QAC1C,MAAM,KAAK;;;;;;;;0BAKkD,CAAA;QAEpE,+EAA+E;QACxE,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;yBAAgB,CAAA;KACtC;IAED,kFAAkF;IAClF,UAAiB,QAAQ,CAAC;QACxB,sEAAsE;QAC/D,MAAM,OAAO;;;UAEyD,CAAA;QAE7E,oDAAoD;QAC7C,MAAM,YAAY;;;YAGxB,CAAA;QAED,+CAA+C;QACxC,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;0BAuCf,CAAA;QAEH,yEAAyE;QAClE,MAAM,QAAQ;;;;;;;;yBAGpB,CAAA;QAED,oFAAoF;QAC7E,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAuChB,CAAA;QAED;;;;;;WAMG;QACI,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA2EhB,CAAA;QAED;;;;;;WAMG;QACH,uDAAuD;QAChD,MAAM,IAAI;;;;;;yBAchB,CAAA;QAEM,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAWpB,CAAA;KACF;IAED,wEAAwE;IACxE,UAAiB,WAAW,CAAC;QAC3B;;;WAGG;QACI,MAAM,MAAM;;yBAM0D,CAAA;QAE7E,mDAAmD;QAC5C,MAAM,QAAQ;;;;;;;UAEuE,CAAA;QAE5F,+DAA+D;QACxD,MAAM,MAAM;;;;;UAKhB,CAAA;QAEH;;;;WAIG;QACI,MAAM,OAAO;;UAEqD,CAAA;QAEzE;;;WAGG;QACI,MAAM,YAAY;;YAGxB,CAAA;QAED,+CAA+C;QACxC,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;0BAayD,CAAA;QAE3E;;;;;WAKG;QACI,MAAM,MAAM;;;;;;;;;;;;yBAgFlB,CAAA;QAED,6DAA6D;QACtD,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAyBpB,CAAA;KACF;IAED,mEAAmE;IACnE,UAAiB,KAAK,CAAC;QACrB,uEAAuE;QAChE,MAAM,MAAM;;yBAOuD,CAAA;QAE1E,4CAA4C;QACrC,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;yBAUhB,CAAA;KACF;IAED,0CAA0C;IAC1C,UAAiB,QAAQ,CAAC;QACxB,iDAAiD;QAC1C,MAAM,MAAM;;yBAAe,CAAA;QAElC;;;;WAIG;QACI,MAAM,OAAO;;UAEqD,CAAA;QAEzE;;;;WAIG;QACI,MAAM,YAAY;;YAGxB,CAAA;QAED,kDAAkD;QAC3C,MAAM,KAAK;;;;;;;;0BAK2C,CAAA;QAE7D;;;;;;;;;WASG;QACI,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAuFpB,CAAA;KACF;IAED,4FAA4F;IAC5F,UAAiB,SAAS,CAAC;QACzB;;;;WAIG;QACI,MAAM,OAAO;;;UAMjB,CAAA;QAEH;;;WAGG;QACI,MAAM,YAAY;;;YAGxB,CAAA;QAED,wDAAwD;QACjD,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;0BAqC0E,CAAA;QAE5F;;;;;;;WAOG;QACI,MAAM,YAAY;;;;;;;;;;;;;;;;;yBA+ExB,CAAA;QAED,2EAA2E;QACpE,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAQjB,CAAA;QAED,4EAA4E;QACrE,MAAM,IAAI;;;yBAA+D,CAAA;QAEhF,0EAA0E;QACnE,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA2BpB,CAAA;KACF;IAED,+CAA+C;IAC/C,UAAiB,aAAa,CAAC;QAC7B,wEAAwE;QACjE,MAAM,MAAM;;yBAAe,CAAA;QAElC,0DAA0D;QACnD,MAAM,KAAK;;;;;;;;;;;;;;;0BAYf,CAAA;QAEH;;;;WAIG;QACI,MAAM,IAAI;;;;;;;;;;yBAsDhB,CAAA;QAED,4EAA4E;QACrE,MAAM,IAAI;;;yBAAmE,CAAA;QAEpF,6CAA6C;QACtC,MAAM,QAAQ;;;;;;;;;;;;;;;;;yBAWpB,CAAA;KACF;IAED,4EAA4E;IAC5E,UAAiB,YAAY,CAAC;QAC5B;;;WAGG;QACI,MAAM,MAAM;;yBAM6D,CAAA;QAEhF;;;;WAIG;QACI,MAAM,OAAO;;UAEqD,CAAA;QAEzE;;;WAGG;QACI,MAAM,YAAY;;YAGxB,CAAA;QAED,gDAAgD;QACzC,MAAM,KAAK;;;;;;;;;0BAgB4D,CAAA;QAE9E;;;;;;WAMG;QACI,MAAM,KAAK;;;;;;yBAoCjB,CAAA;QAED,4EAA4E;QACrE,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAwBpB,CAAA;KACF;CACF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,OAAO,GAAE,SAAS,CAAC,OAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}
+{"version":3,"file":"exchanges.d.ts","sourceRoot":"","sources":["../../../../src/apps/data/routes/exchanges.ts"],"names":[],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

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

@@ -1785,10 +1785,12 @@ export function exchanges(options = {}) {
         const options = c.req.valid('query');
         const chainId = options.chainId ?? c.get('chainId');
         try {
-            const pairs = await getPairIndex(c, { chainId });
-            const target = pairs.get(base);
+            const target = await getPairByBase(c, { base, chainId });
             if (!target)
-                return pairNotFoundError(c, { base, pairIndex: pairs });
+                return pairNotFoundError(c, {
+                    base,
+                    pairIndex: await getPairIndex(c, { chainId }),
+                });
             // Token metadata is opt-in: resolve both pair tokens once and spread
             // onto the `base`/`quote` PairToken slots.
             let baseToken = { address: target.base };
@@ -2170,10 +2172,12 @@ export function exchanges(options = {}) {
         if (options.interval === '1h' || options.interval === '4h' || options.interval === '1d')
             Cache.setPolicy(c, Cache.policies.state);
         try {
-            const pairs = await getPairIndex(c, { chainId });
-            const target = pairs.get(baseAddress);
+            const target = await getPairByBase(c, { base: baseAddress, chainId });
             if (!target)
-                return pairNotFoundError(c, { base: baseAddress, pairIndex: pairs });
+                return pairNotFoundError(c, {
+                    base: baseAddress,
+                    pairIndex: await getPairIndex(c, { chainId }),
+                });
             const result = await getPairOhlc(c, {
                 chainId,
                 interval: options.interval,
@@ -2265,13 +2269,7 @@ export function exchanges(options = {}) {
         const options = c.req.valid('query');
         const chainId = options.chainId ?? c.get('chainId');
         try {
-            // Pair definitions are immutable after creation, so cache successful
-            // point lookups without making unknown pairs stale.
-            const target = await Store.memoize(async () => (await getPairsByBase(c, { bases: [baseAddress], chainId })).get(baseAddress), {
-                key: `exchange:v1:${chainId}:pair-by-base:${baseAddress}:v1`,
-                store: c.get('store'),
-                ttl: Ttl.minutes(5),
-            });
+            const target = await getPairByBase(c, { base: baseAddress, chainId });
             if (!target)
                 return pairNotFoundError(c, {
                     base: baseAddress,
@@ -2574,6 +2572,33 @@ async function getPairsByBase(c, options) {
         return pairs;
     });
 }
+/**
+ * Resolves one pair by base address without depending on the bounded pair
+ * index. Successful immutable definitions are cached; misses stay fresh.
+ */
+async function getPairByBase(c, options) {
+    const { base, chainId } = options;
+    const tidx = c.get('getTidx')(chainId);
+    return Timing.time(c, 'pair_lookup', () => Store.memoize(async () => {
+        const result = await tidx.fetch({
+            chainId,
+            engine: 'clickhouse',
+            query: `
+            SELECT key, base, quote, tx_hash, block_num, block_timestamp
+            FROM dex_pairs
+            WHERE address = '${stablecoinDex}' AND base = '${base}'
+            ORDER BY block_num ASC, log_idx ASC
+            LIMIT 1
+          `,
+        });
+        const row = result.rows[0];
+        return row ? parsePairRow(row) : undefined;
+    }, {
+        key: `exchange:v1:${chainId}:pair-by-base:${base}:v2`,
+        store: c.get('store'),
+        ttl: Ttl.minutes(5),
+    }));
+}
 /**
  * Resolves one pair by its book key with a targeted `dex_pairs` lookup,
  * covering books the bounded pair index ages out of its newest window.
@@ -3494,11 +3519,9 @@ function parseTickSide(value) {
  * The candles are aggregated **in ClickHouse**: each bucket folds server-side
  * (open/close by fill position, high/low by executed rate, volume sums and
  * fill counts), so the response covers the entire requested window no matter
- * how many fills it contains — the previous implementation shipped the newest
- * raw fills to the app capped at 1,000, which truncated busy pairs' 7d/30d
- * windows to a few hours. The pair filter still resolves through the
- * OrderPlaced-only `dex_orders` table, so fills of flipped orders remain
- * invisible until order state lands at ingest (the `dex_ohlc_1m` plan).
+ * how many fills it contains. Each fill joins to its state-event history and
+ * selects the latest preceding `OrderPlaced`/`OrderFlipped` log because flip
+ * orders retain their id while changing side and tick.
  *
  * `OrderFilled` only carries the base-token `amountFilled`; the quote-side
  * amount is reconstructed per fill from the order's tick using the DEX's
@@ -3517,12 +3540,13 @@ async function getPairOhlc(c, options) {
     // ClickHouse `DateTime64(3, 'UTC')` rejects ISO-Z; normalize to space form.
     const fromTimestamp = formatClickHouseDateTime(new Date(Date.now() - windowMs(window)).toISOString());
     const bucketMs = intervalMs(interval);
+    const pairTopic = `0x${pair.base.slice(2).padStart(64, '0')}`;
     return Timing.time(c, 'pair_ohlc', async () => {
         // Taker-perspective rate used only to *select* the high/low fill; the
         // formatted rate string is recomputed in JS from the winning `(tick,
         // isBid)` so it goes through the exact same formatting as open/close.
         const scale = Tick.priceScale;
-        const rate = `if(p."isBid" = 1, (${scale} + p.tick) / ${scale}, ${scale} / (${scale} + p.tick))`;
+        const rate = `if(r.is_bid_int = 1, (${scale} + r.tick) / ${scale}, ${scale} / (${scale} + r.tick))`;
         // UInt256 sums are forced through `toString` so values past 2^53 survive
         // JSON; the `(tick, isBid)` tuples are small integers and need no forcing.
         const result = await tidx.fetch({
@@ -3530,21 +3554,37 @@ async function getPairOhlc(c, options) {
             engine: 'clickhouse',
             query: `
         SELECT
-          intDiv(toUnixTimestamp64Milli(f.block_timestamp), ${bucketMs}) AS bucket,
+          intDiv(toUnixTimestamp64Milli(r.block_timestamp), ${bucketMs}) AS bucket,
           count() AS fill_count,
-          toString(sum(f."amountFilled")) AS base_volume,
-          toString(sum(intDiv(f."amountFilled" * toUInt256(${scale} + p.tick), ${scale}))) AS quote_volume,
-          argMin(tuple(p.tick, p."isBid"), tuple(f.block_num, f.log_idx)) AS open_t,
-          argMax(tuple(p.tick, p."isBid"), tuple(f.block_num, f.log_idx)) AS close_t,
-          argMax(tuple(p.tick, p."isBid"), ${rate}) AS high_t,
-          argMin(tuple(p.tick, p."isBid"), ${rate}) AS low_t
-        FROM dex_fills f
-        JOIN dex_orders p ON p."orderId" = f."orderId"
-        WHERE f.address = '${stablecoinDex}'
-          AND f.block_timestamp >= '${fromTimestamp}'
-          AND f."orderId" IN (
-            SELECT p2."orderId" FROM dex_orders p2 WHERE p2.token = '${pair.base}'
-          )
+          toString(sum(r.amount_filled)) AS base_volume,
+          toString(sum(intDiv(r.amount_filled * toUInt256(${scale} + r.tick), ${scale}))) AS quote_volume,
+          argMin(tuple(r.tick, r.is_bid_int), tuple(r.block_num, r.log_idx)) AS open_t,
+          argMax(tuple(r.tick, r.is_bid_int), tuple(r.block_num, r.log_idx)) AS close_t,
+          argMax(tuple(r.tick, r.is_bid_int), ${rate}) AS high_t,
+          argMin(tuple(r.tick, r.is_bid_int), ${rate}) AS low_t
+        FROM (
+          SELECT f.block_timestamp, f.block_num, f.log_idx,
+                 f."amountFilled" AS amount_filled,
+                 argMax(s.tick, (s.block_num, s.log_idx)) AS tick,
+                 argMax(s.is_bid_int, (s.block_num, s.log_idx)) AS is_bid_int
+          FROM dex_fills f
+          INNER JOIN (
+            SELECT
+              reinterpretAsUInt256(reverse(unhex(substring(topic1, 3)))) AS order_id,
+              reinterpretAsInt16(reverse(unhex(substring(data, 191, 4)))) AS tick,
+              data != '' AND substring(data, 130, 1) = '1' AS is_bid_int,
+              block_num,
+              log_idx
+            FROM logs
+            WHERE address = '${stablecoinDex}'
+              AND selector IN ('${orderPlacedTopic}', '${orderFlippedTopic}')
+              AND topic3 = '${pairTopic}'
+          ) AS s ON f."orderId" = s.order_id
+          WHERE f.address = '${stablecoinDex}'
+            AND f.block_timestamp >= '${fromTimestamp}'
+            AND (s.block_num < f.block_num OR (s.block_num = f.block_num AND s.log_idx < f.log_idx))
+          GROUP BY f.block_timestamp, f.block_num, f.log_idx, f."amountFilled"
+        ) AS r
         GROUP BY bucket
         ORDER BY bucket ASC
       `,
@@ -3627,11 +3667,10 @@ const orderCursorTickBias = 32768;
  * still applied app-side. ClickHouse aggregates fills per order before the
  * app computes each remaining amount.
  *
- * `remaining = OrderPlaced.amount - sum(OrderFilled.amountFilled)`; orders
- * with an `OrderCancelled` event are excluded outright. Each row is annotated
- * with its pair: the scoped feed reuses the resolved `pair`, the unscoped
- * feed resolves the page's base tokens with one targeted `dex_pairs` lookup
- * (rows whose pair is unknown are dropped).
+ * `remaining` is the latest state event's amount minus subsequent fills;
+ * orders with an `OrderCancelled` event are excluded outright. Each row is
+ * annotated with its pair: the scoped feed reuses the resolved `pair`, the
+ * unscoped feed resolves the page's base tokens with one targeted lookup.
  */
 async function getOrders(c, options) {
     const { chainId, cursor, limit, maker, order, page, pair, side, sort } = options;
@@ -3847,9 +3886,10 @@ function cursorTupleFromOrder(row, sort) {
     return [row.blockNumber, row.logIndex];
 }
 /**
- * Loads every resting maker order for a pair: scan `OrderPlaced` filtered by
- * the pair's base token (and optional `maker`), then subtract fills and drop
- * cancelled orders using batched `WHERE "orderId" IN (...)` joins.
+ * Loads every resting maker order for a pair: scan state events filtered by
+ * the pair's base token (and optional `maker`), resolve each order's latest
+ * `OrderPlaced`/`OrderFlipped` generation, then subtract fills after that
+ * generation and drop cancelled orders.
  *
  * Returns the resting set along with a `truncated` flag set when the
  * `OrderPlaced` scan hit `orderScanCap`. Callers surface the flag so
@@ -3857,69 +3897,22 @@ function cursorTupleFromOrder(row, sort) {
  */
 async function loadRestingOrders(c, options) {
     const { base, chainId, maker, scanCap = orderScanCap } = options;
-    const tidx = c.get('getTidx')(chainId);
-    // Scan window is intentionally newest-first so a `truncated` snapshot still
-    // reflects current market activity rather than ancient placements.
-    const filters = [`address = '${stablecoinDex}'`];
-    if (base !== undefined)
-        filters.push(`token = '${base}'`);
-    if (maker !== undefined)
-        filters.push(`maker = '${maker}'`);
-    const where = `WHERE ${filters.join(' AND ')}`;
-    // ClickHouse OLAP path: bloom-filter index on `topic1` (and the `token`
-    // string column) handles `WHERE token = '<base>'` and the downstream
-    // `"orderId" IN (...)` joins natively, without the per-row decode cost of
-    // the Postgres `abi_uint(topic1)` fallback.
-    //
-    // `"isBid"` is aliased to a name that is *not* in the OrderPlaced event
-    // signature so tidx.ts's signature-driven result decoder skips it. ClickHouse
-    // serializes booleans as `1`/`0`, but tidx.ts validates `bool` columns with a
-    // strict `z.boolean()` derived from the signature and rejects integer
-    // representations. Aliasing dodges that decoder and lets us coerce
-    // numerically in `parsePlacedRow`.
-    const result = await tidx.fetch({
+    const snapshot = await fetchLatestOrderStates(c, { base, chainId, maker, scanCap });
+    if (snapshot.orders.length === 0)
+        return snapshot;
+    const cancelled = await fetchCancelledByIds(c, {
         chainId,
-        engine: 'clickhouse',
-        query: `
-      SELECT "orderId", maker, amount, token, "isBid" AS is_bid_int, tick, tx_hash, block_num, log_idx, block_timestamp
-      FROM dex_orders
-      ${where}
-      ORDER BY block_num DESC, log_idx DESC
-      LIMIT ${scanCap + 1}
-    `,
+        orderIds: snapshot.orders.map((row) => row.orderId),
     });
-    const truncated = result.rows.length > scanCap;
-    const placedRows = result.rows.slice(0, scanCap);
-    // `dex_orders` can carry duplicate rows per placement; keep the first
-    // (newest) copy so pages emit each order once and a duplicate straddling an
-    // IN-batch boundary can't double-count fills.
-    const placed = [];
-    const seen = new Set();
-    for (const row of placedRows) {
-        const parsed = parsePlacedRow(row);
-        if (!parsed || seen.has(parsed.orderId))
-            continue;
-        seen.add(parsed.orderId);
-        placed.push(parsed);
-    }
-    if (placed.length === 0)
-        return { orders: [], truncated };
-    const orderIds = placed.map((row) => row.orderId);
-    const [cancelled, fillSums] = await Promise.all([
-        fetchCancelledByIds(c, { chainId, orderIds }),
-        fetchFillSumsByIds(c, { chainId, orderIds }),
-    ]);
     const orders = [];
-    for (const row of placed) {
+    for (const row of snapshot.orders) {
         if (cancelled.has(row.orderId))
             continue;
-        const filled = fillSums.get(row.orderId) ?? 0n;
-        const remaining = BigInt(row.amount) - filled;
-        if (remaining <= 0n)
+        if (BigInt(row.remaining) <= 0n)
             continue;
-        orders.push({ ...row, remaining: remaining.toString() });
+        orders.push(row);
     }
-    return { orders, truncated };
+    return { orders, truncated: snapshot.truncated };
 }
 /**
  * Base-token chunk size for the multi-book `WHERE token IN (...)` scan in
@@ -4073,6 +4066,183 @@ function parsePlacedRow(row) {
         transactionHash: transactionHash.data,
     };
 }
+/**
+ * Resolves each scanned order's latest generation from raw state logs and
+ * subtracts only fills after that state event. A fully filled flip generation
+ * therefore resets to the counter-order amount emitted by `OrderFlipped`.
+ */
+async function fetchLatestOrderStates(c, options) {
+    const { base, chainId, maker, scanCap } = options;
+    const tidx = c.get('getTidx')(chainId);
+    let truncated = false;
+    const filters = [
+        `address = '${stablecoinDex}'`,
+        `selector IN ('${orderPlacedTopic}', '${orderFlippedTopic}')`,
+    ];
+    if (base !== undefined)
+        filters.push(`topic3 = '0x${base.slice(2).padStart(64, '0')}'`);
+    // Global candidates below already belong to the maker. Keeping topic2 in
+    // that lookup makes the indexer scan a sparse maker instead of indexed IDs.
+    if (base !== undefined && maker !== undefined)
+        filters.push(`topic2 = '0x${maker.slice(2).padStart(64, '0')}'`);
+    let batches = [filters];
+    // The global raw-log aggregate is unbounded on hosted TIDX. Bound it to the
+    // newest state events so old placements with recent flips remain candidates.
+    if (base === undefined) {
+        const candidateFilters = [
+            `address = '${stablecoinDex}'`,
+            `selector IN ('${orderPlacedTopic}', '${orderFlippedTopic}')`,
+        ];
+        const candidates = await tidx.fetch({
+            chainId,
+            engine: 'clickhouse',
+            query: `
+        SELECT topic1, topic2
+        FROM logs
+        WHERE ${candidateFilters.join(' AND ')}
+        ORDER BY block_num DESC, log_idx DESC
+        LIMIT ${scanCap + 1}
+      `,
+        });
+        truncated = candidates.rows.length > scanCap;
+        const topics = new Set();
+        for (const row of candidates.rows.slice(0, scanCap)) {
+            if (maker !== undefined && row['topic2'] !== `0x${maker.slice(2).padStart(64, '0')}`)
+                continue;
+            const topic = Value.toText(row['topic1']);
+            if (topic !== undefined && /^0x[0-9a-fA-F]{64}$/.test(topic))
+                topics.add(topic);
+        }
+        // `logs.topic2` is not a viable hosted-TIDX scan for a sparse maker.
+        // Include its indexed placement window, then resolve current state below.
+        if (maker !== undefined) {
+            const placements = await tidx.fetch({
+                chainId,
+                engine: 'clickhouse',
+                query: `
+          SELECT "orderId"
+          FROM dex_orders
+          WHERE address = '${stablecoinDex}' AND maker = '${maker}'
+          ORDER BY block_num DESC, log_idx DESC
+          LIMIT ${scanCap + 1}
+        `,
+            });
+            truncated ||= placements.rows.length > scanCap;
+            for (const row of placements.rows.slice(0, scanCap)) {
+                const orderId = Value.toIntegerString(row['orderId']);
+                if (orderId !== undefined)
+                    topics.add(`0x${BigInt(orderId).toString(16).padStart(64, '0')}`);
+            }
+        }
+        if (topics.size === 0)
+            return { orders: [], truncated };
+        // Compact hex avoids oversized GET URLs and TIDX's per-cell SQL scanning
+        // cost. Pad in ClickHouse; batching also bounds maximum-width IDs.
+        const ids = [...topics].map((topic) => `'${BigInt(topic).toString(16)}'`);
+        batches = [];
+        for (let i = 0; i < ids.length; i += 512)
+            batches.push([
+                ...filters,
+                `topic1 IN (SELECT concat('0x', leftPad(arrayJoin([${ids.slice(i, i + 512).join(', ')}]), 64, '0')))`,
+            ]);
+    }
+    const rows = [];
+    for (const filters of batches) {
+        const result = await tidx.fetch({
+            chainId,
+            engine: 'clickhouse',
+            // Raw state fields have no signature-backed result schema; every field is validated below.
+            query: `
+      WITH states AS (
+        SELECT topic1,
+               argMax(topic2, (block_num, log_idx)) AS t2,
+               argMax(topic3, (block_num, log_idx)) AS t3,
+               argMax(data, (block_num, log_idx)) AS payload,
+               argMax(tx_hash, (block_num, log_idx)) AS state_tx_hash,
+               argMax(block_num, (block_num, log_idx)) AS state_block_num,
+               argMax(log_idx, (block_num, log_idx)) AS state_log_idx,
+               argMax(block_timestamp, (block_num, log_idx)) AS state_timestamp
+        FROM logs
+        WHERE ${filters.join(' AND ')}
+        GROUP BY topic1
+        ORDER BY state_block_num DESC, state_log_idx DESC
+        LIMIT ${scanCap + 1}
+      )
+      SELECT states.*,
+             toString(sumIf(f."amountFilled",
+               f.block_num > states.state_block_num OR
+               (f.block_num = states.state_block_num AND f.log_idx > states.state_log_idx)
+             )) AS amount_filled
+      FROM states
+      LEFT JOIN dex_fills f
+        ON f.address = '${stablecoinDex}'
+       AND f."orderId" = reinterpretAsUInt256(reverse(unhex(substring(states.topic1, 3))))
+      GROUP BY states.topic1, states.t2, states.t3, states.payload,
+               states.state_tx_hash, states.state_block_num, states.state_log_idx,
+               states.state_timestamp
+      ORDER BY states.state_block_num DESC, states.state_log_idx DESC
+    `,
+        });
+        rows.push(...result.rows);
+    }
+    rows.sort((a, b) => Number(b['state_block_num']) - Number(a['state_block_num']) ||
+        Number(b['state_log_idx']) - Number(a['state_log_idx']));
+    truncated ||= rows.length > scanCap;
+    const orders = [];
+    for (const row of rows.slice(0, scanCap)) {
+        const state = parseLatestOrderStateRow(row);
+        if (state)
+            orders.push(state);
+    }
+    return { orders, truncated };
+}
+/** Decodes one latest-state aggregate into a resting-order snapshot row. */
+function parseLatestOrderStateRow(row) {
+    const topic1 = Value.toText(row['topic1']);
+    const topic2 = Value.toText(row['t2']);
+    const topic3 = Value.toText(row['t3']);
+    const payload = Value.toText(row['payload']);
+    const filled = Value.toIntegerString(row['amount_filled']);
+    const blockNumber = Value.toNumber(row['state_block_num']);
+    const logIndex = Value.toNumber(row['state_log_idx']);
+    const timestamp = Value.toIsoDateTime(row['state_timestamp']);
+    const transactionHash = Schema.Hash.safeParse(row['state_tx_hash']);
+    const maker = Schema.Address.safeParse(topic2 === undefined ? undefined : `0x${topic2.slice(26).toLowerCase()}`);
+    const token = Schema.TokenAddress.safeParse(topic3 === undefined ? undefined : `0x${topic3.slice(26).toLowerCase()}`);
+    if (topic1 === undefined ||
+        !/^0x[0-9a-fA-F]{64}$/.test(topic1) ||
+        topic2 === undefined ||
+        !/^0x[0-9a-fA-F]{64}$/.test(topic2) ||
+        topic3 === undefined ||
+        !/^0x[0-9a-fA-F]{64}$/.test(topic3) ||
+        payload === undefined ||
+        payload.length < 2 + 64 * 3 ||
+        filled === undefined ||
+        blockNumber === undefined ||
+        logIndex === undefined ||
+        timestamp === undefined ||
+        !transactionHash.success ||
+        !maker.success ||
+        !token.success)
+        return undefined;
+    const amount = BigInt(`0x${payload.slice(2, 66)}`);
+    const tickWord = BigInt(`0x${payload.slice(130, 194)}`);
+    const tick = Number(tickWord >= 2n ** 255n ? tickWord - 2n ** 256n : tickWord);
+    const remaining = amount - BigInt(filled);
+    return {
+        amount: amount.toString(),
+        blockNumber,
+        isBid: BigInt(`0x${payload.slice(66, 130)}`) !== 0n,
+        logIndex,
+        maker: maker.data,
+        orderId: BigInt(topic1).toString(),
+        remaining: remaining.toString(),
+        tick,
+        timestamp,
+        token: token.data,
+        transactionHash: transactionHash.data,
+    };
+}
 /**
  * Resolves the set of cancelled `orderId`s in the snapshot window via batched
  * `OrderCancelled WHERE "orderId" IN (...)` queries. Empty input short-circuits