tapimo 0.0.0 → 0.0.2

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

@@ -0,0 +1,640 @@
+import { type Context } from 'hono';
+import * as z from 'zod/mini';
+import type * as App from '../App.js';
+import * as Response from '../internal/Response.js';
+import * as Schema from '../internal/Schema.js';
+/** Zod schemas owned by the fee AMM handlers. */
+export declare namespace schema {
+    /**
+     * A token referenced by a fee pool: its contract address plus best-effort
+     * metadata. Mirrors the transfer feed's `sourceToken` technique: `address`
+     * is always present; the metadata fields spread in only when resolution
+     * succeeds, so a token whose metadata is unavailable keeps just the bare
+     * reference. The pools listing extends this shape with the side's reserve
+     * (`getFeeAmmPools.Token`).
+     */
+    const PoolToken: z.ZodMiniObject<{
+        address: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+        currency: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        decimals: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+        logoUri: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        symbol: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        verified: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+    }, z.core.$strip>;
+    /** Schemas for the getFeeAmmPools operation. */
+    namespace getFeeAmmPools {
+        /** Optional related resources that callers opt into via `include`. */
+        const Include: z.ZodMiniEnum<{
+            token: "token";
+        }>;
+        /**
+         * Parses a comma-separated `include` query value into a list of optional
+         * resources to embed. Token metadata resolution is one extra (batched)
+         * `token.getMetadata` round trip, so it runs only when `include=token` is
+         * requested; the base page returns each side's bare `address` plus its
+         * reserve and skips the lookup entirely.
+         */
+        const includeQuery: z.ZodMiniPipe<z.ZodMiniPipe<z.ZodMiniOptional<z.ZodMiniUnknown>, z.ZodMiniTransform<string[], unknown>>, z.ZodMiniArray<z.ZodMiniEnum<{
+            token: "token";
+        }>>>;
+        /** Query parameters for the fee pool list request. */
+        const Query: z.ZodMiniObject<{
+            chainId: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniEnum<{
+                mainnet: "mainnet";
+                testnet: "testnet";
+            }>, z.ZodMiniTransform<4217 | 42431, "mainnet" | "testnet">>, z.ZodMiniNumber<unknown>]>, z.ZodMiniNumber<number>>>;
+            cursor: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            include: z.ZodMiniPipe<z.ZodMiniPipe<z.ZodMiniOptional<z.ZodMiniUnknown>, z.ZodMiniTransform<string[], unknown>>, z.ZodMiniArray<z.ZodMiniEnum<{
+                token: "token";
+            }>>>;
+            limit: z.ZodMiniDefault<z.ZodMiniNumber<unknown>>;
+            page: z.ZodMiniOptional<z.ZodMiniNumber<unknown>>;
+        }, z.core.$strict>;
+        /**
+         * One side of a fee pool: the token reference carrying the side's current
+         * on-chain reserve. `amount`/`formatted` come from `FeeManager.getPool`
+         * and are absent when the read fails (best-effort, like the metadata
+         * fields).
+         */
+        const Token: z.ZodMiniObject<{
+            address: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+            currency: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            decimals: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+            logoUri: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            symbol: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            verified: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+            amount: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            formatted: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        }, z.core.$strip>;
+        /** A fee AMM pool, aggregated from its `Mint` events. */
+        const Pool: z.ZodMiniObject<{
+            createdAt: z.ZodMiniISODateTime;
+            id: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+            lastMintAt: z.ZodMiniISODateTime;
+            mintCount: z.ZodMiniNumber<number>;
+            poolId: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+            userToken: z.ZodMiniObject<{
+                address: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+                currency: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                decimals: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+                logoUri: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                symbol: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                verified: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+                amount: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                formatted: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            }, z.core.$strip>;
+            validatorToken: z.ZodMiniObject<{
+                address: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+                currency: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                decimals: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+                logoUri: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                symbol: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                verified: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+                amount: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                formatted: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        /** Page of fee pools, ordered by mint count (most active first). */
+        const Response: z.ZodMiniObject<{
+            data: z.ZodMiniArray<z.ZodMiniObject<{
+                createdAt: z.ZodMiniISODateTime;
+                id: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+                lastMintAt: z.ZodMiniISODateTime;
+                mintCount: z.ZodMiniNumber<number>;
+                poolId: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+                userToken: z.ZodMiniObject<{
+                    address: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+                    currency: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                    decimals: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+                    logoUri: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                    name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                    symbol: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                    verified: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+                    amount: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                    formatted: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                }, z.core.$strip>;
+                validatorToken: z.ZodMiniObject<{
+                    address: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+                    currency: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                    decimals: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+                    logoUri: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                    name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                    symbol: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                    verified: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+                    amount: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                    formatted: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+            nextCursor: z.ZodMiniNullable<z.ZodMiniString<string>>;
+        }, z.core.$strip>;
+    }
+    /** Schemas for the getFeeAmmMints operation. */
+    namespace getFeeAmmMints {
+        /** Query parameters for the pool mint list request. */
+        const Query: z.ZodMiniObject<{
+            chainId: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniEnum<{
+                mainnet: "mainnet";
+                testnet: "testnet";
+            }>, z.ZodMiniTransform<4217 | 42431, "mainnet" | "testnet">>, z.ZodMiniNumber<unknown>]>, z.ZodMiniNumber<number>>>;
+            cursor: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            include: z.ZodMiniPipe<z.ZodMiniPipe<z.ZodMiniOptional<z.ZodMiniUnknown>, z.ZodMiniTransform<string[], unknown>>, z.ZodMiniArray<z.ZodMiniEnum<{
+                totalCount: "totalCount";
+            }>>>;
+            limit: z.ZodMiniDefault<z.ZodMiniNumber<unknown>>;
+            order: z.ZodMiniDefault<z.ZodMiniEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+            page: z.ZodMiniOptional<z.ZodMiniNumber<unknown>>;
+            userToken: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
+            validatorToken: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
+        }, z.core.$strict>;
+        /** A single liquidity mint into a fee pool. */
+        const Mint: z.ZodMiniObject<{
+            amountUserToken: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            amountValidatorToken: z.ZodMiniString<string>;
+            blockNumber: z.ZodMiniNumber<number>;
+            id: z.ZodMiniString<string>;
+            liquidity: z.ZodMiniString<string>;
+            logIndex: z.ZodMiniNumber<number>;
+            minter: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+            recipient: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
+            timestamp: z.ZodMiniISODateTime;
+            transactionHash: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+            userToken: z.ZodMiniObject<{
+                address: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+                currency: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                decimals: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+                logoUri: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                symbol: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                verified: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+            }, z.core.$strip>;
+            validatorToken: z.ZodMiniObject<{
+                address: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+                currency: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                decimals: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+                logoUri: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                symbol: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                verified: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        /** Page of fee pool mints, ordered by block then log index. */
+        const Response: z.ZodMiniObject<{
+            data: z.ZodMiniArray<z.ZodMiniObject<{
+                amountUserToken: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                amountValidatorToken: z.ZodMiniString<string>;
+                blockNumber: z.ZodMiniNumber<number>;
+                id: z.ZodMiniString<string>;
+                liquidity: z.ZodMiniString<string>;
+                logIndex: z.ZodMiniNumber<number>;
+                minter: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+                recipient: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
+                timestamp: z.ZodMiniISODateTime;
+                transactionHash: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+                userToken: z.ZodMiniObject<{
+                    address: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+                    currency: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                    decimals: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+                    logoUri: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                    name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                    symbol: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                    verified: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+                }, z.core.$strip>;
+                validatorToken: z.ZodMiniObject<{
+                    address: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+                    currency: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                    decimals: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+                    logoUri: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                    name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                    symbol: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                    verified: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+            meta: z.ZodMiniOptional<z.ZodMiniObject<{
+                totalCountCapped: z.ZodMiniBoolean<boolean>;
+                totalCount: z.ZodMiniNumber<number>;
+            }, z.core.$strip>>;
+            nextCursor: z.ZodMiniNullable<z.ZodMiniString<string>>;
+        }, z.core.$strip>;
+    }
+}
+/** Creates fee AMM handlers. */
+export declare function feeAmm(): import("hono/hono-base").HonoBase<App.Environment, {
+    "/pools": {
+        $get: {
+            output: null;
+            outputFormat: "body";
+            status: 402;
+            input: {
+                query?: {
+                    chainId?: string | string[];
+                    cursor?: string | string[];
+                    include?: string | string[];
+                    limit?: string | string[];
+                    page?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "upstream_error";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 502;
+            input: {
+                query?: {
+                    chainId?: string | string[];
+                    cursor?: string | string[];
+                    include?: string | string[];
+                    limit?: string | string[];
+                    page?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "api_key_malformed";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 400;
+            input: {
+                query?: {
+                    chainId?: string | string[];
+                    cursor?: string | string[];
+                    include?: string | string[];
+                    limit?: string | string[];
+                    page?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "api_key_invalid" | "api_key_missing";
+                    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: {
+                error: {
+                    code: "api_key_forbidden";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 403;
+            input: {
+                query?: {
+                    chainId?: string | string[];
+                    cursor?: string | string[];
+                    include?: string | string[];
+                    limit?: string | string[];
+                    page?: string | string[];
+                } | undefined;
+            };
+        } | {
+            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[];
+                    cursor?: string | string[];
+                    include?: string | string[];
+                    limit?: string | string[];
+                    page?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "query_invalid";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 400;
+            input: {
+                query?: {
+                    chainId?: string | string[];
+                    cursor?: string | string[];
+                    include?: string | string[];
+                    limit?: string | string[];
+                    page?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                data: {
+                    createdAt: string;
+                    id: `0x${string}`;
+                    lastMintAt: string;
+                    mintCount: number;
+                    poolId: `0x${string}`;
+                    userToken: {
+                        address: `0x${string}`;
+                        currency?: string | undefined;
+                        decimals?: number | undefined;
+                        logoUri?: string | undefined;
+                        name?: string | undefined;
+                        symbol?: string | undefined;
+                        verified?: boolean | undefined;
+                        amount?: string | undefined;
+                        formatted?: string | undefined;
+                    };
+                    validatorToken: {
+                        address: `0x${string}`;
+                        currency?: string | undefined;
+                        decimals?: number | undefined;
+                        logoUri?: string | undefined;
+                        name?: string | undefined;
+                        symbol?: string | undefined;
+                        verified?: boolean | undefined;
+                        amount?: string | undefined;
+                        formatted?: string | 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;
+            };
+        };
+    };
+} & {
+    "/mints": {
+        $get: {
+            output: null;
+            outputFormat: "body";
+            status: 402;
+            input: {
+                query?: {
+                    chainId?: string | string[];
+                    cursor?: string | string[];
+                    include?: string | string[];
+                    limit?: string | string[];
+                    order?: string | string[];
+                    page?: string | string[];
+                    userToken?: string | string[];
+                    validatorToken?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "upstream_error";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 502;
+            input: {
+                query?: {
+                    chainId?: string | string[];
+                    cursor?: string | string[];
+                    include?: string | string[];
+                    limit?: string | string[];
+                    order?: string | string[];
+                    page?: string | string[];
+                    userToken?: string | string[];
+                    validatorToken?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "api_key_malformed";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 400;
+            input: {
+                query?: {
+                    chainId?: string | string[];
+                    cursor?: string | string[];
+                    include?: string | string[];
+                    limit?: string | string[];
+                    order?: string | string[];
+                    page?: string | string[];
+                    userToken?: string | string[];
+                    validatorToken?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "api_key_invalid" | "api_key_missing";
+                    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[];
+                    order?: string | string[];
+                    page?: string | string[];
+                    userToken?: string | string[];
+                    validatorToken?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "api_key_forbidden";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 403;
+            input: {
+                query?: {
+                    chainId?: string | string[];
+                    cursor?: string | string[];
+                    include?: string | string[];
+                    limit?: string | string[];
+                    order?: string | string[];
+                    page?: string | string[];
+                    userToken?: string | string[];
+                    validatorToken?: string | string[];
+                } | undefined;
+            };
+        } | {
+            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[];
+                    cursor?: string | string[];
+                    include?: string | string[];
+                    limit?: string | string[];
+                    order?: string | string[];
+                    page?: string | string[];
+                    userToken?: string | string[];
+                    validatorToken?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "query_invalid";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 400;
+            input: {
+                query?: {
+                    chainId?: string | string[];
+                    cursor?: string | string[];
+                    include?: string | string[];
+                    limit?: string | string[];
+                    order?: string | string[];
+                    page?: string | string[];
+                    userToken?: string | string[];
+                    validatorToken?: string | string[];
+                } | undefined;
+            };
+        } | {
+            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}`;
+                    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: 200;
+            input: {
+                query?: {
+                    chainId?: string | string[];
+                    cursor?: string | string[];
+                    include?: string | string[];
+                    limit?: string | string[];
+                    order?: string | string[];
+                    page?: string | string[];
+                    userToken?: string | string[];
+                    validatorToken?: string | string[];
+                } | undefined;
+            };
+        };
+    };
+}, "/", "/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 one-shot 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.
+ */
+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/fee-amm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fee-amm.d.ts","sourceRoot":"","sources":["../../src/apps/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,WAAW,CAAA;AAKrC,OAAO,KAAK,QAAQ,MAAM,yBAAyB,CAAA;AACnD,OAAO,KAAK,MAAM,MAAM,uBAAuB,CAAA;AAmC/C,iDAAiD;AACjD,yBAAiB,MAAM,CAAC;IACtB;;;;;;;OAOG;IACI,MAAM,SAAS;;;;;;;;qBAoCrB,CAAA;IAED,gDAAgD;IAChD,UAAiB,cAAc,CAAC;QAC9B,sEAAsE;QAC/D,MAAM,OAAO;;UAEyD,CAAA;QAE7E;;;;;;WAMG;QACI,MAAM,YAAY;;YAGxB,CAAA;QAED,sDAAsD;QAC/C,MAAM,KAAK;;;;;;;;;;;0BAQyE,CAAA;QAE3F;;;;;WAKG;QACI,MAAM,KAAK;;;;;;;;;;yBAmBjB,CAAA;QAED,yDAAyD;QAClD,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAyCgE,CAAA;QAEjF,oEAAoE;QAC7D,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAOoE,CAAA;KAC1F;IAED,gDAAgD;IAChD,UAAiB,cAAc,CAAC;QAC9B,uDAAuD;QAChD,MAAM,KAAK;;;;;;;;;;;;;;;;;0BAkBf,CAAA;QAEH,+CAA+C;QACxC,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA2D8C,CAAA;QAE/D,+DAA+D;QACxD,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAUqC,CAAA;KAC3D;CACF;AAED,gCAAgC;AAChC,wBAAgB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAiNrB;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,CA6CtB"}