tapimo 0.15.1 → 0.18.0

package/dist/apps/data/routes/fee-amm.d.ts

@@ -239,48 +239,9 @@ export declare namespace schema {
 export declare function feeAmm(): import("hono/hono-base").HonoBase<App.Environment, {
     "/v1/fee-amm/pools": {
         $get: {
-            output: {
-                data: {
-                    createdAt: string;
-                    id: `0x${string}`;
-                    lastMintAt: string;
-                    mintCount: number;
-                    poolId: `0x${string}`;
-                    userAmount?: {
-                        baseUnits: string;
-                        currency: string;
-                        decimals: number;
-                        formatted: string;
-                    } | undefined;
-                    userToken: {
-                        address: `0x${string}`;
-                        currency: string;
-                        decimals: number;
-                        logoUri?: string | undefined;
-                        name: string;
-                        symbol: string;
-                        verified?: boolean | undefined;
-                    };
-                    validatorAmount?: {
-                        baseUnits: string;
-                        currency: string;
-                        decimals: number;
-                        formatted: string;
-                    } | undefined;
-                    validatorToken: {
-                        address: `0x${string}`;
-                        currency: string;
-                        decimals: number;
-                        logoUri?: string | undefined;
-                        name: string;
-                        symbol: string;
-                        verified?: boolean | undefined;
-                    };
-                }[];
-                nextCursor: string | null;
-            };
-            outputFormat: "json";
-            status: 200;
+            output: null;
+            outputFormat: "body";
+            status: 402;
             input: {
                 query?: {
                     chainId?: string | string[];
@@ -313,14 +274,14 @@ export declare function feeAmm(): import("hono/hono-base").HonoBase<App.Environm
         } | {
             output: {
                 error: {
-                    code: "query_invalid";
+                    code: "api_key_invalid" | "api_key_missing";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 401;
             input: {
                 query?: {
                     chainId?: string | string[];
@@ -333,27 +294,14 @@ export declare function feeAmm(): import("hono/hono-base").HonoBase<App.Environm
         } | {
             output: {
                 error: {
-                    code: "api_key_invalid" | "api_key_missing";
+                    code: "api_key_forbidden" | "api_key_ip_forbidden";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 401;
-            input: {
-                query?: {
-                    chainId?: string | string[];
-                    cursor?: string | string[];
-                    include?: string | string[];
-                    limit?: string | string[];
-                    page?: string | string[];
-                } | undefined;
-            };
-        } | {
-            output: null;
-            outputFormat: "body";
-            status: 402;
+            status: 403;
             input: {
                 query?: {
                     chainId?: string | string[];
@@ -366,14 +314,14 @@ export declare function feeAmm(): import("hono/hono-base").HonoBase<App.Environm
         } | {
             output: {
                 error: {
-                    code: "api_key_forbidden" | "api_key_ip_forbidden";
+                    code: "payment_required" | "rate_limit_exceeded";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 403;
+            status: 429;
             input: {
                 query?: {
                     chainId?: string | string[];
@@ -386,14 +334,14 @@ export declare function feeAmm(): import("hono/hono-base").HonoBase<App.Environm
         } | {
             output: {
                 error: {
-                    code: "payment_required" | "rate_limit_exceeded";
+                    code: "query_invalid";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 429;
+            status: 400;
             input: {
                 query?: {
                     chainId?: string | string[];
@@ -423,50 +371,66 @@ export declare function feeAmm(): import("hono/hono-base").HonoBase<App.Environm
                     page?: string | string[];
                 } | undefined;
             };
-        };
-    };
-} & {
-    "/v1/fee-amm/mints": {
-        $get: {
+        } | {
             output: {
                 data: {
-                    amountUserToken?: string | undefined;
-                    amountValidatorToken: string;
-                    blockNumber: number;
-                    id: string;
-                    liquidity: string;
-                    logIndex: number;
-                    minter: `0x${string}`;
-                    recipient?: `0x${string}` | undefined;
-                    timestamp: string;
-                    transactionHash: `0x${string}`;
+                    createdAt: string;
+                    id: `0x${string}`;
+                    lastMintAt: string;
+                    mintCount: number;
+                    poolId: `0x${string}`;
+                    userAmount?: {
+                        baseUnits: string;
+                        currency: string;
+                        decimals: number;
+                        formatted: string;
+                    } | undefined;
                     userToken: {
                         address: `0x${string}`;
-                        currency?: string | undefined;
-                        decimals?: number | undefined;
+                        currency: string;
+                        decimals: number;
                         logoUri?: string | undefined;
-                        name?: string | undefined;
-                        symbol?: string | undefined;
+                        name: string;
+                        symbol: string;
                         verified?: boolean | undefined;
                     };
+                    validatorAmount?: {
+                        baseUnits: string;
+                        currency: string;
+                        decimals: number;
+                        formatted: string;
+                    } | undefined;
                     validatorToken: {
                         address: `0x${string}`;
-                        currency?: string | undefined;
-                        decimals?: number | undefined;
+                        currency: string;
+                        decimals: number;
                         logoUri?: string | undefined;
-                        name?: string | undefined;
-                        symbol?: string | undefined;
+                        name: string;
+                        symbol: string;
                         verified?: boolean | undefined;
                     };
                 }[];
-                meta?: {
-                    totalCountCapped: boolean;
-                    totalCount: number;
-                } | undefined;
                 nextCursor: string | null;
             };
             outputFormat: "json";
             status: 200;
+            input: {
+                query?: {
+                    chainId?: string | string[];
+                    cursor?: string | string[];
+                    include?: string | string[];
+                    limit?: string | string[];
+                    page?: string | string[];
+                } | undefined;
+            };
+        };
+    };
+} & {
+    "/v1/fee-amm/mints": {
+        $get: {
+            output: null;
+            outputFormat: "body";
+            status: 402;
             input: {
                 query?: {
                     chainId?: string | string[];
@@ -505,14 +469,14 @@ export declare function feeAmm(): import("hono/hono-base").HonoBase<App.Environm
         } | {
             output: {
                 error: {
-                    code: "query_invalid";
+                    code: "api_key_invalid" | "api_key_missing";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 401;
             input: {
                 query?: {
                     chainId?: string | string[];
@@ -528,14 +492,14 @@ export declare function feeAmm(): import("hono/hono-base").HonoBase<App.Environm
         } | {
             output: {
                 error: {
-                    code: "api_key_invalid" | "api_key_missing";
+                    code: "api_key_forbidden" | "api_key_ip_forbidden";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 401;
+            status: 403;
             input: {
                 query?: {
                     chainId?: string | string[];
@@ -549,9 +513,16 @@ export declare function feeAmm(): import("hono/hono-base").HonoBase<App.Environm
                 } | undefined;
             };
         } | {
-            output: null;
-            outputFormat: "body";
-            status: 402;
+            output: {
+                error: {
+                    code: "payment_required" | "rate_limit_exceeded";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 429;
             input: {
                 query?: {
                     chainId?: string | string[];
@@ -567,14 +538,14 @@ export declare function feeAmm(): import("hono/hono-base").HonoBase<App.Environm
         } | {
             output: {
                 error: {
-                    code: "api_key_forbidden" | "api_key_ip_forbidden";
+                    code: "query_invalid";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 403;
+            status: 400;
             input: {
                 query?: {
                     chainId?: string | string[];
@@ -590,14 +561,14 @@ export declare function feeAmm(): import("hono/hono-base").HonoBase<App.Environm
         } | {
             output: {
                 error: {
-                    code: "payment_required" | "rate_limit_exceeded";
+                    code: "upstream_error";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 429;
+            status: 502;
             input: {
                 query?: {
                     chainId?: string | string[];
@@ -612,15 +583,44 @@ export declare function feeAmm(): import("hono/hono-base").HonoBase<App.Environm
             };
         } | {
             output: {
-                error: {
-                    code: "upstream_error";
-                    details?: readonly Response.error.Detail[] | undefined;
-                    message: string;
-                };
-                requestId: string;
+                data: {
+                    amountUserToken?: string | undefined;
+                    amountValidatorToken: string;
+                    blockNumber: number;
+                    id: string;
+                    liquidity: string;
+                    logIndex: number;
+                    minter: `0x${string}`;
+                    recipient?: `0x${string}` | undefined;
+                    timestamp: string;
+                    transactionHash: `0x${string}`;
+                    userToken: {
+                        address: `0x${string}`;
+                        currency?: string | undefined;
+                        decimals?: number | undefined;
+                        logoUri?: string | undefined;
+                        name?: string | undefined;
+                        symbol?: string | undefined;
+                        verified?: boolean | undefined;
+                    };
+                    validatorToken: {
+                        address: `0x${string}`;
+                        currency?: string | undefined;
+                        decimals?: number | undefined;
+                        logoUri?: string | undefined;
+                        name?: string | undefined;
+                        symbol?: string | undefined;
+                        verified?: boolean | undefined;
+                    };
+                }[];
+                meta?: {
+                    totalCountCapped: boolean;
+                    totalCount: number;
+                } | undefined;
+                nextCursor: string | null;
             };
             outputFormat: "json";
-            status: 502;
+            status: 200;
             input: {
                 query?: {
                     chainId?: string | string[];
@@ -636,24 +636,6 @@ export declare function feeAmm(): import("hono/hono-base").HonoBase<App.Environm
         };
     };
 }, "/", "/v1/fee-amm/mints">;
-/**
- * The set of token addresses usable to pay transaction fees on a chain: the
- * curated verified tokens that have at least one Fee AMM pool (i.e. appear as a
- * `userToken` / topic2 in the FeeManager's `Mint` logs), plus the protocol
- * default fee token (`pathUSD`), which pays fees without needing a pool.
- * Addresses are lowercased to match the indexer's stored casing.
- *
- * The set is intentionally gated to the verified list rather than every pooled
- * token: anyone can mint a single-mint spam pool, so the raw set of pool
- * `userToken`s is unbounded (tens of thousands on busy chains) and those
- * liquidity-less pools can't actually settle fees. Restricting to verified
- * tokens keeps the set small (a handful of USD stablecoins), bounds the scan
- * (the `topic2 IN (…)` candidate list is the verified list), and matches the
- * tokens fees are realistically paid in.
- *
- * Memoized per chain and verified-snapshot version (the only inputs), so
- * callers — e.g. the address balances endpoint — can flag which holdings are
- * fee-usable without a second `/fee-amm/pools` query.
- */
+/** Returns lowercased verified tokens currently usable for transaction fees. The protocol default (`pathUSD`) is always included. */
 export declare function feeTokenSet(c: Context<App.Environment>, chainId: z.output<typeof Schema.ChainId>): Promise<Set<string>>;
 //# sourceMappingURL=fee-amm.d.ts.map

package/dist/apps/data/routes/fee-amm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fee-amm.d.ts","sourceRoot":"","sources":["../../../../src/apps/data/routes/fee-amm.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,OAAO,EAAE,MAAM,MAAM,CAAA;AAGzC,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAE7B,OAAO,KAAK,KAAK,GAAG,MAAM,iBAAiB,CAAA;AAK3C,OAAO,KAAK,QAAQ,MAAM,+BAA+B,CAAA;AACzD,OAAO,KAAK,MAAM,MAAM,6BAA6B,CAAA;AA4CrD,iDAAiD;AACjD,yBAAiB,MAAM,CAAC;IACtB;;;;OAIG;IACI,MAAM,SAAS;;;;;;;;qBA8CrB,CAAA;IAED,gDAAgD;IAChD,UAAiB,cAAc,CAAC;QAC9B,yEAAyE;QAClE,MAAM,OAAO;;;UAE4D,CAAA;QAEhF;;;WAGG;QACI,MAAM,YAAY;;;YAGxB,CAAA;QAED,sDAAsD;QAC/C,MAAM,KAAK;;;;;;;;;;;;0BAQyE,CAAA;QAE3F,+EAA+E;QACxE,MAAM,KAAK;;;;;;;;yBAMjB,CAAA;QAED,yDAAyD;QAClD,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA4ChB,CAAA;QAED,oEAAoE;QAC7D,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAUpB,CAAA;KACF;IAED,gDAAgD;IAChD,UAAiB,cAAc,CAAC;QAC9B,uDAAuD;QAChD,MAAM,KAAK;;;;;;;;;;;;;;;;;0BAkBf,CAAA;QAEH,+CAA+C;QACxC,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA8DhB,CAAA;QAED,4EAA4E;QACrE,MAAM,IAAI;;;yBAA4D,CAAA;QAE7E,+DAA+D;QACxD,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAapB,CAAA;KACF;CACF;AAED,gCAAgC;AAChC,wBAAgB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAyOrB;AAmJD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,WAAW,CAC/B,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,EAC3B,OAAO,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,MAAM,CAAC,OAAO,CAAC,GACvC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CA4CtB"}
+{"version":3,"file":"fee-amm.d.ts","sourceRoot":"","sources":["../../../../src/apps/data/routes/fee-amm.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,OAAO,EAAE,MAAM,MAAM,CAAA;AAIzC,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;AA4CrD,iDAAiD;AACjD,yBAAiB,MAAM,CAAC;IACtB;;;;OAIG;IACI,MAAM,SAAS;;;;;;;;qBA8CrB,CAAA;IAED,gDAAgD;IAChD,UAAiB,cAAc,CAAC;QAC9B,yEAAyE;QAClE,MAAM,OAAO;;;UAE4D,CAAA;QAEhF;;;WAGG;QACI,MAAM,YAAY;;;YAGxB,CAAA;QAED,sDAAsD;QAC/C,MAAM,KAAK;;;;;;;;;;;;0BAQyE,CAAA;QAE3F,+EAA+E;QACxE,MAAM,KAAK;;;;;;;;yBAMjB,CAAA;QAED,yDAAyD;QAClD,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA4ChB,CAAA;QAED,oEAAoE;QAC7D,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAUpB,CAAA;KACF;IAED,gDAAgD;IAChD,UAAiB,cAAc,CAAC;QAC9B,uDAAuD;QAChD,MAAM,KAAK;;;;;;;;;;;;;;;;;0BAkBf,CAAA;QAEH,+CAA+C;QACxC,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA8DhB,CAAA;QAED,4EAA4E;QACrE,MAAM,IAAI;;;yBAA4D,CAAA;QAE7E,+DAA+D;QACxD,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAapB,CAAA;KACF;CACF;AAED,gCAAgC;AAChC,wBAAgB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAyOrB;AAmJD,qIAAqI;AACrI,wBAAsB,WAAW,CAC/B,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,EAC3B,OAAO,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,MAAM,CAAC,OAAO,CAAC,GACvC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAwEtB"}

package/dist/apps/data/routes/fee-amm.js

@@ -1,5 +1,6 @@
 import { Hono } from 'hono';
 import { AbiEvent, AbiParameters, Hash } from 'ox';
+import { zeroAddress } from 'viem';
 import { Abis, Addresses } from 'viem/tempo';
 import * as z from 'zod/mini';
 import * as Auth from '../../../internal/Auth.js';
@@ -498,32 +499,13 @@ function listPools(c, options) {
         ttl: Ttl.minutes(1),
     }));
 }
-/**
- * The set of token addresses usable to pay transaction fees on a chain: the
- * curated verified tokens that have at least one Fee AMM pool (i.e. appear as a
- * `userToken` / topic2 in the FeeManager's `Mint` logs), plus the protocol
- * default fee token (`pathUSD`), which pays fees without needing a pool.
- * Addresses are lowercased to match the indexer's stored casing.
- *
- * The set is intentionally gated to the verified list rather than every pooled
- * token: anyone can mint a single-mint spam pool, so the raw set of pool
- * `userToken`s is unbounded (tens of thousands on busy chains) and those
- * liquidity-less pools can't actually settle fees. Restricting to verified
- * tokens keeps the set small (a handful of USD stablecoins), bounds the scan
- * (the `topic2 IN (…)` candidate list is the verified list), and matches the
- * tokens fees are realistically paid in.
- *
- * Memoized per chain and verified-snapshot version (the only inputs), so
- * callers — e.g. the address balances endpoint — can flag which holdings are
- * fee-usable without a second `/fee-amm/pools` query.
- */
+/** Returns lowercased verified tokens currently usable for transaction fees. The protocol default (`pathUSD`) is always included. */
 export async function feeTokenSet(c, chainId) {
     const store = c.get('store');
-    const tidx = c.get('getTidx')(chainId);
     const snapshot = await VerifiedTokens.snapshot(c, chainId);
     // pathUSD is always fee-usable; the verified tokens are the only other
     // candidates we probe for a pool. With no verified candidates there is
-    // nothing to query — pathUSD stands alone.
+    // nothing to query, so pathUSD stands alone.
     const candidates = snapshot.list.map((token) => token.address.toLowerCase());
     if (candidates.length === 0)
         return new Set([pathUsd]);
@@ -531,33 +513,77 @@ export async function feeTokenSet(c, chainId) {
     // the `Set` per call (cheap; the list is a handful of stablecoins).
     const addresses = await Timing.time(c, 'fee_token_set', () => Store.memoize(async () => {
         const tokens = new Set([pathUsd]);
-        // PostgreSQL's `topic2` index proves negative lookups without scanning
-        // FeeManager history. Probe serially so an uncapped verified list
-        // cannot fan out indexer load.
-        for (const address of candidates) {
-            const topic = padTopic(address);
-            const result = await tidx.fetch({
+        const validatorTokens = await getValidatorTokens(c, { chainId });
+        // Verified candidates prevent permissionless spam pools from expanding
+        // the lookup. Small batches also bound RPC fan-out for Zone clients.
+        const probes = candidates
+            .filter((address) => {
+            if (!validatorTokens.includes(address))
+                return true;
+            tokens.add(address);
+            return false;
+        })
+            .flatMap((userToken) => validatorTokens.map((validatorToken) => ({ userToken, validatorToken })));
+        const unresolved = new Map();
+        for (let index = 0; index < probes.length; index += 8) {
+            const group = probes.slice(index, index + 8);
+            const results = await Promise.allSettled(group.map(({ userToken, validatorToken }) => readPoolReserves(c, {
                 chainId,
-                engine: 'postgres',
-                query: `
-              SELECT 1 AS present
-              FROM logs
-              WHERE address = '${feeManager}' AND selector IN ('${mintTopic}', '${legacyMintTopic}')
-                AND topic2 = '${topic}'
-              LIMIT 1
-            `,
-            });
-            if (result.rows.length > 0)
-                tokens.add(address);
+                userToken: userToken,
+                validatorToken: validatorToken,
+            })));
+            for (const [offset, result] of results.entries()) {
+                const userToken = group[offset].userToken;
+                if (result.status === 'rejected') {
+                    unresolved.set(userToken, result.reason);
+                    continue;
+                }
+                if (BigInt(result.value.userToken) > 0n && BigInt(result.value.validatorToken) > 0n) {
+                    tokens.add(userToken);
+                    unresolved.delete(userToken);
+                }
+            }
         }
+        const failure = Array.from(unresolved).find(([address]) => !tokens.has(address));
+        if (failure)
+            throw failure[1];
         return Array.from(tokens);
     }, {
-        key: `feeamm:v2:${chainId}:fee-token-set:v:${snapshot.version}`,
+        key: `feeamm:v3:${chainId}:fee-token-set:v:${snapshot.version}`,
         store,
-        ttl: Ttl.minutes(5),
-    }));
+        ttl: Ttl.seconds(30),
+    })).catch((cause) => {
+        const failure = {
+            chainId,
+            failure: 'unknown',
+            id: 'rpc',
+            operation: 'feeTokenSet',
+        };
+        c.set('providerFailures', [...(c.get('providerFailures') ?? []), failure]);
+        throw cause;
+    });
     return new Set(addresses);
 }
+/** Resolves the distinct fee tokens preferred by active validators. */
+async function getValidatorTokens(c, options) {
+    const { chainId } = options;
+    const client = c.get('getClient')(chainId);
+    const validators = await client.readContract({
+        abi: Abis.validatorConfig,
+        address: Addresses.validator,
+        functionName: 'getValidators',
+    });
+    const active = validators.filter((validator) => validator.active);
+    if (active.length === 0)
+        return [pathUsd];
+    const preferred = await Promise.all(active.map((validator) => client.readContract({
+        abi: Abis.feeManager,
+        address: Addresses.feeManager,
+        args: [validator.validatorAddress],
+        functionName: 'validatorTokens',
+    })));
+    return Array.from(new Set(preferred.map((address) => address.toLowerCase() === zeroAddress ? pathUsd : address.toLowerCase())));
+}
 /**
  * Reads a pool's current on-chain reserves via `FeeManager.getPool`, memoized
  * briefly per pool. Reserves are best-effort decoration on the pool listing:
@@ -567,25 +593,28 @@ export async function feeTokenSet(c, chainId) {
  */
 function getPoolReserves(c, options) {
     const { chainId, userToken, validatorToken } = options;
-    const client = c.get('getClient')(chainId);
     const store = c.get('store');
-    return Store.memoize(async () => {
-        const pool = await client.readContract({
-            abi: Abis.feeAmm,
-            address: Addresses.feeManager,
-            args: [userToken, validatorToken],
-            functionName: 'getPool',
-        });
-        return {
-            userToken: pool.reserveUserToken.toString(),
-            validatorToken: pool.reserveValidatorToken.toString(),
-        };
-    }, {
+    return Store.memoize(() => readPoolReserves(c, { chainId, userToken, validatorToken }), {
         key: `feeamm:v1:${chainId}:pool:${userToken}:${validatorToken}:reserves`,
         store,
         ttl: Ttl.seconds(30),
     }).catch(() => null);
 }
+/** Reads a pool's current on-chain reserves and propagates RPC failures. */
+async function readPoolReserves(c, options) {
+    const { chainId, userToken, validatorToken } = options;
+    const client = c.get('getClient')(chainId);
+    const pool = await client.readContract({
+        abi: Abis.feeAmm,
+        address: Addresses.feeManager,
+        args: [userToken, validatorToken],
+        functionName: 'getPool',
+    });
+    return {
+        userToken: pool.reserveUserToken.toString(),
+        validatorToken: pool.reserveValidatorToken.toString(),
+    };
+}
 /**
  * Lists `Mint` logs as a keyset-paginated page on `(block_num, log_idx)`,
  * optionally filtered by the pool's tokens. Runs on ClickHouse: the postgres