tapimo 0.4.4 → 0.5.1

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

@@ -31,30 +31,6 @@ export declare function addresses(): import("hono/hono-base").HonoBase<App.Envir
                     logs?: string | string[];
                 } | undefined;
             };
-        } | {
-            output: {
-                error: {
-                    code: "upstream_error";
-                    details?: readonly import("../../../internal/Response.js").error.Detail[] | undefined;
-                    message: string;
-                };
-                requestId: string;
-            };
-            outputFormat: "json";
-            status: 502;
-            input: {
-                param: {
-                    address: `0x${string}`;
-                };
-            } & {
-                query?: {
-                    chainId?: string | string[];
-                    cursor?: string | string[];
-                    group?: string | string[];
-                    limit?: string | string[];
-                    logs?: string | string[];
-                } | undefined;
-            };
         } | {
             output: {
                 error: {
@@ -154,7 +130,7 @@ export declare function addresses(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "query_invalid";
+                    code: "address_invalid";
                     details?: readonly import("../../../internal/Response.js").error.Detail[] | undefined;
                     message: string;
                 };
@@ -178,7 +154,7 @@ export declare function addresses(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "address_invalid";
+                    code: "query_invalid";
                     details?: readonly import("../../../internal/Response.js").error.Detail[] | undefined;
                     message: string;
                 };
@@ -3401,6 +3377,30 @@ export declare function addresses(): import("hono/hono-base").HonoBase<App.Envir
                     logs?: string | string[];
                 } | undefined;
             };
+        } | {
+            output: {
+                error: {
+                    code: "upstream_error";
+                    details?: readonly import("../../../internal/Response.js").error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 502;
+            input: {
+                param: {
+                    address: `0x${string}`;
+                };
+            } & {
+                query?: {
+                    chainId?: string | string[];
+                    cursor?: string | string[];
+                    group?: string | string[];
+                    limit?: string | string[];
+                    logs?: string | string[];
+                } | undefined;
+            };
         };
     };
 }, "/"> | import("hono/types").MergeSchemaPath<{
@@ -3428,14 +3428,14 @@ export declare function addresses(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "upstream_error";
+                    code: "api_key_malformed";
                     details?: readonly import("../../../internal/Response.js").error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 502;
+            status: 400;
             input: {
                 param: {
                     address: `0x${string}`;
@@ -3455,14 +3455,14 @@ export declare function addresses(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "api_key_malformed";
+                    code: "api_key_invalid" | "api_key_missing";
                     details?: readonly import("../../../internal/Response.js").error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 401;
             input: {
                 param: {
                     address: `0x${string}`;
@@ -3482,14 +3482,14 @@ export declare function addresses(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "api_key_invalid" | "api_key_missing";
+                    code: "api_key_forbidden";
                     details?: readonly import("../../../internal/Response.js").error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 401;
+            status: 403;
             input: {
                 param: {
                     address: `0x${string}`;
@@ -3509,14 +3509,14 @@ export declare function addresses(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "api_key_forbidden";
+                    code: "payment_required" | "rate_limit_exceeded";
                     details?: readonly import("../../../internal/Response.js").error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 403;
+            status: 429;
             input: {
                 param: {
                     address: `0x${string}`;
@@ -3536,14 +3536,14 @@ export declare function addresses(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "payment_required" | "rate_limit_exceeded";
+                    code: "address_invalid";
                     details?: readonly import("../../../internal/Response.js").error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 429;
+            status: 400;
             input: {
                 param: {
                     address: `0x${string}`;
@@ -3590,14 +3590,14 @@ export declare function addresses(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "address_invalid";
+                    code: "upstream_error";
                     details?: readonly import("../../../internal/Response.js").error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 502;
             input: {
                 param: {
                     address: `0x${string}`;

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

@@ -86,9 +86,31 @@ export declare namespace schema {
 export declare function addresses(): import("hono/hono-base").HonoBase<App.Environment, {
     "/v1/addresses/:address/balances": {
         $get: {
-            output: null;
-            outputFormat: "body";
-            status: 402;
+            output: {
+                data: {
+                    amount: string;
+                    formatted: string;
+                    id: string;
+                    feeEligible?: boolean | undefined;
+                    token: {
+                        address: `0x${string}`;
+                        currency: string;
+                        decimals: number;
+                        id: string;
+                        logoUri?: string | undefined;
+                        name: string;
+                        symbol: string;
+                        verified: boolean;
+                    };
+                }[];
+                meta?: {
+                    totalCountCapped: boolean;
+                    totalCount: number;
+                } | undefined;
+                nextCursor: string | null;
+            };
+            outputFormat: "json";
+            status: 200;
             input: {
                 param: {
                     address: `0x${string}`;
@@ -135,14 +157,14 @@ export declare function addresses(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "api_key_invalid" | "api_key_missing";
+                    code: "query_invalid";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 401;
+            status: 400;
             input: {
                 param: {
                     address: `0x${string}`;
@@ -162,14 +184,14 @@ export declare function addresses(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "api_key_forbidden";
+                    code: "address_invalid";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 403;
+            status: 400;
             input: {
                 param: {
                     address: `0x${string}`;
@@ -189,14 +211,14 @@ export declare function addresses(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "payment_required" | "rate_limit_exceeded";
+                    code: "api_key_invalid" | "api_key_missing";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 429;
+            status: 401;
             input: {
                 param: {
                     address: `0x${string}`;
@@ -214,16 +236,9 @@ export declare function addresses(): import("hono/hono-base").HonoBase<App.Envir
                 } | undefined;
             };
         } | {
-            output: {
-                error: {
-                    code: "query_invalid";
-                    details?: readonly Response.error.Detail[] | undefined;
-                    message: string;
-                };
-                requestId: string;
-            };
-            outputFormat: "json";
-            status: 400;
+            output: null;
+            outputFormat: "body";
+            status: 402;
             input: {
                 param: {
                     address: `0x${string}`;
@@ -243,14 +258,14 @@ export declare function addresses(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "upstream_error";
+                    code: "api_key_forbidden";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 502;
+            status: 403;
             input: {
                 param: {
                     address: `0x${string}`;
@@ -270,14 +285,14 @@ export declare function addresses(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "address_invalid";
+                    code: "payment_required" | "rate_limit_exceeded";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 429;
             input: {
                 param: {
                     address: `0x${string}`;
@@ -296,30 +311,15 @@ export declare function addresses(): import("hono/hono-base").HonoBase<App.Envir
             };
         } | {
             output: {
-                data: {
-                    amount: string;
-                    formatted: string;
-                    id: string;
-                    feeEligible?: boolean | undefined;
-                    token: {
-                        address: `0x${string}`;
-                        currency: string;
-                        decimals: number;
-                        id: string;
-                        logoUri?: string | undefined;
-                        name: string;
-                        symbol: string;
-                        verified: boolean;
-                    };
-                }[];
-                meta?: {
-                    totalCountCapped: boolean;
-                    totalCount: number;
-                } | undefined;
-                nextCursor: string | null;
+                error: {
+                    code: "upstream_error";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
             };
             outputFormat: "json";
-            status: 200;
+            status: 502;
             input: {
                 param: {
                     address: `0x${string}`;

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

@@ -1 +1 @@
-{"version":3,"file":"balances.d.ts","sourceRoot":"","sources":["../../../../src/apps/data/routes/balances.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAE7B,OAAO,KAAK,KAAK,GAAG,MAAM,iBAAiB,CAAA;AAK3C,OAAO,KAAK,QAAQ,MAAM,+BAA+B,CAAA;AAezD,iDAAiD;AACjD,yBAAiB,MAAM,CAAC;IACtB,oDAAoD;IACpD,UAAiB,kBAAkB,CAAC;QAClC,oDAAoD;QAC7C,MAAM,MAAM;;yBAM6D,CAAA;QAEhF,qDAAqD;QAC9C,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;0BAyCf,CAAA;QAEH;;;;;WAKG;QACI,MAAM,OAAO;;;;;;;;;;;;;;;yBA0CnB,CAAA;QAED,sFAAsF;QAC/E,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;yBAUwD,CAAA;KAC9E;CACF;AAED;;;GAGG;AACH,wBAAgB,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CA0GxB"}
+{"version":3,"file":"balances.d.ts","sourceRoot":"","sources":["../../../../src/apps/data/routes/balances.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAE7B,OAAO,KAAK,KAAK,GAAG,MAAM,iBAAiB,CAAA;AAK3C,OAAO,KAAK,QAAQ,MAAM,+BAA+B,CAAA;AAazD,iDAAiD;AACjD,yBAAiB,MAAM,CAAC;IACtB,oDAAoD;IACpD,UAAiB,kBAAkB,CAAC;QAClC,oDAAoD;QAC7C,MAAM,MAAM;;yBAM6D,CAAA;QAEhF,qDAAqD;QAC9C,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;0BAyCf,CAAA;QAEH;;;;;WAKG;QACI,MAAM,OAAO;;;;;;;;;;;;;;;yBA0CnB,CAAA;QAED,sFAAsF;QAC/E,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;yBAUwD,CAAA;KAC9E;CACF;AAED;;;GAGG;AACH,wBAAgB,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CAqFxB"}

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

@@ -1,5 +1,5 @@
 import { Hono } from 'hono';
-import { Hex, Value as core_Value } from 'ox';
+import { Value as core_Value } from 'ox';
 import { Actions } from 'viem/tempo';
 import * as z from 'zod/mini';
 import * as Auth from '../../../internal/Auth.js';
@@ -9,15 +9,13 @@ import * as OpenApi from '../../../internal/OpenApi.js';
 import * as Response from '../../../internal/Response.js';
 import * as Schema from '../../../internal/Schema.js';
 import * as Timing from '../../../internal/Timing.js';
-import * as Value from '../../../internal/Value.js';
 import * as VerifiedTokens from '../../../internal/VerifiedTokens.js';
 import * as FeeAmm from './fee-amm.js';
 import * as Tokens from './tokens.js';
 // TIP-20 tokens are minted by the TIP-20 factory and live at deterministic
 // `0x20c0…`-prefixed addresses (e.g. pathUSD `0x20c0…0000`). The indexer's
-// `token_balances_snapshot` view, by contrast, records balances for every
-// Transfer-emitting contract, so balance queries filter on this prefix to keep
-// non-TIP-20 tokens (which have no resolvable TIP-20 metadata) out of results.
+// balance sources include every Transfer-emitting contract, so discovery
+// filters on this prefix to keep non-TIP-20 tokens out of results.
 const tip20AddressPrefix = '0x20c0';
 /** Zod schemas owned by the balance handlers. */
 export var schema;
@@ -155,19 +153,6 @@ export function addresses() {
                     throw cause;
                 return undefined;
             });
-            // `totalCount` (the number of matching holdings) is opt-in and shares
-            // the page's filters; run it concurrently with the page. Best-effort: a
-            // count failure omits `meta` rather than failing the page.
-            const countPromise = query.include.includes('totalCount')
-                ? countAddressBalances(c, {
-                    address,
-                    chainId,
-                    currency: query.currency,
-                    feeEligible,
-                    feeTokens,
-                    verified,
-                }).catch(() => undefined)
-                : undefined;
             const balances = await getAddressBalances(c, {
                 address,
                 chainId,
@@ -175,15 +160,12 @@ export function addresses() {
                 cursor: query.cursor,
                 feeEligible,
                 feeTokens,
+                includeTotalCount: query.include.includes('totalCount'),
                 limit: query.limit,
                 page: query.page,
                 verified,
             });
-            const meta = countPromise ? await countPromise : undefined;
-            return c.json(Response.validated(schema.getAddressBalances.Response, {
-                ...balances,
-                ...(meta ? { meta } : {}),
-            }), 200);
+            return c.json(Response.validated(schema.getAddressBalances.Response, balances), 200);
         }
         catch (cause) {
             return Response.upstream(c, cause);
@@ -191,17 +173,10 @@ export function addresses() {
     });
 }
 async function getAddressBalances(c, options) {
-    const { address, chainId, currency, feeEligible, feeTokens, limit, verified } = options;
+    const { address, chainId, currency, feeEligible, feeTokens, includeTotalCount, limit, verified } = options;
     const tidx = c.get('getTidx')(chainId);
-    // Keyset pagination on `(balance, token)`: balance is descending and `token`
-    // is a stable tiebreaker for the many holdings sharing a balance. A malformed
-    // cursor falls back to the head page. Note: because `balance` is mutable, this
-    // is best-effort across balance changes (the inherent limit of ranking feeds).
     const cursor = options.cursor ? Cursor.decode(options.cursor, ['uint', 'address']) : undefined;
-    // Bounded positional lane (exclusive with `cursor` at the schema): page 1 is
-    // the head page, so it shares the head's SQL and cache entries; deeper pages
-    // translate to a SQL OFFSET of `(page - 1) * limit` rows.
-    const offset = options.page !== undefined && options.page > 1 ? (options.page - 1) * limit : undefined;
+    const offset = options.page !== undefined && options.page > 1 ? (options.page - 1) * limit : 0;
     // Build the optional `token IN (…)` restriction before hitting TIDX. The
     // verified/`currency` filter and the `feeEligible` filter each contribute a set
     // of allowed addresses (`currency` matched case-insensitively so callers can
@@ -213,90 +188,48 @@ async function getAddressBalances(c, options) {
     const allowed = allowedTokens({ currency, feeEligible, feeTokens, snapshot, verified });
     const tokenFilter = allowed?.map((address) => `'${address}'`);
     if (tokenFilter?.length === 0)
-        return { data: [], nextCursor: null };
-    const holdings = await Timing.time(c, 'address_balances', async () => {
-        // A held token is one this address holds a positive amount of. Read the
-        // live `address_balances` view (`holder`-keyed: one row per
-        // `(holder, token, balance)`), which aggregates `address_holder_deltas`
-        // directly so balances reflect the indexer's chain head (no periodic
-        // snapshot refresh — see the indexer's `address_holder_deltas` MV). The
-        // `holder` equality prunes the view by its leading sort key, so this stays
-        // a bounded read per request. Fetch one extra row to detect `hasMore`
-        // without a separate count query. `startsWith` restricts results to TIP-20
-        // tokens (see `tip20AddressPrefix`) before pagination, so `hasMore`/page
-        // sizes stay correct and every returned token has resolvable metadata. The
-        // inline query is cast to `string` so TIDX treats it as a dynamic
-        // ClickHouse query that needs no event signature for the
-        // `address_balances` view.
-        //
-        // Let upstream failures propagate: this is a dedicated endpoint, so a
-        // failure should surface as the declared `502` rather than masquerade as
-        // an address holding zero tokens.
-        const keyset = cursor !== undefined
-            ? ` AND ${Cursor.keyset([
-                { literal: Cursor.literal(cursor[0], 'uint'), name: 'balance', order: 'desc' },
-                { literal: Cursor.literal(cursor[1], 'address'), name: 'token', order: 'asc' },
-            ])}`
-            : '';
+        return {
+            data: [],
+            ...(includeTotalCount ? { meta: { totalCount: 0, totalCountCapped: false } } : {}),
+            nextCursor: null,
+        };
+    const holdings = await Timing.time(c, 'balances_discovery', async () => {
         const tokenIn = tokenFilter ? ` AND token IN (${tokenFilter.join(', ')})` : '';
         const result = await tidx.fetch({
             chainId,
             engine: 'clickhouse',
-            // `balance` is UInt256; SELECT it as a string so values > 2^53
-            // survive JSON without precision loss. The keyset cursor encodes the
-            // row's exact balance, so any rounding would re-include the cursor
-            // row on the next page. Alias is `balance_str` (not `balance`)
-            // because TIDX rejects expression aliases that shadow the source
-            // column (422).
+            // Discovery tolerates stale and reorged rows: RPC removes candidates
+            // with no current balance, so avoid the cost of `FINAL` and aggregation.
             query: `
-        SELECT token, toString(balance) AS balance_str
-        FROM address_balances
-        WHERE holder = '${address}' AND startsWith(token, '${tip20AddressPrefix}') AND balance > 0${tokenIn}${keyset}
-        ORDER BY balance DESC, token ASC
-        LIMIT ${limit + 1}${offset !== undefined ? ` OFFSET ${offset}` : ''}
+        SELECT DISTINCT token
+        FROM address_holder_deltas
+        WHERE holder = '${address}' AND startsWith(token, '${tip20AddressPrefix}')${tokenIn}
       `,
         });
-        // The next page anchors below the last fetched row's `(balance, token)`.
-        const page = Cursor.paginate({
-            rows: result.rows,
-            limit,
-            key: (row) => {
-                const balance = Value.toIntegerString(row['balance_str']);
-                const token = Schema.Address.safeParse(row['token']);
-                return balance !== undefined && token.success ? [balance, token.data] : undefined;
-            },
-        });
-        const data = [];
-        for (const row of page.rows) {
+        return result.rows.flatMap((row) => {
             const token = Schema.Address.safeParse(row['token']);
-            const amount = Value.toIntegerString(row['balance_str']);
-            if (token.success && amount !== undefined)
-                data.push({ address: token.data, amount });
-        }
-        return { data, nextCursor: page.nextCursor };
+            return token.success ? [{ address: token.data }] : [];
+        });
     });
-    if (holdings.data.length === 0)
-        return { data: [], nextCursor: holdings.nextCursor };
+    if (holdings.length === 0)
+        return {
+            data: [],
+            ...(includeTotalCount ? { meta: { totalCount: 0, totalCountCapped: false } } : {}),
+            nextCursor: null,
+        };
     const client = c.get('getClient')(chainId);
-    // TODO: remove once https://github.com/tempoxyz/tidx/commit/2f37b44172d381fd00234ef23f79ed1e1d69c470 deployed.
     const corrected = await Timing.time(c, 'balances_rpc', async () => {
-        const results = await client
-            .multicall({
-            allowFailure: true,
-            contracts: holdings.data.map((holding) => Actions.token.getBalance.call(client, { account: address, token: holding.address })),
-        })
-            .catch(() => undefined);
-        const rows = [];
-        for (const [index, holding] of holdings.data.entries()) {
-            const result = results?.[index];
-            if (!result || result.status !== 'success' || typeof result.result !== 'bigint') {
-                rows.push(holding);
-                continue;
-            }
-            if (result.result === 0n)
-                continue;
-            rows.push({ address: holding.address, amount: result.result.toString() });
-        }
+        // Concurrent reads enter viem's shared batch window and become one
+        // deployless multicall. A failed read fails the request rather than serving
+        // a stale or partial balance page.
+        const results = await Promise.all(holdings.map(async (holding) => {
+            const { amount } = await Actions.token.getBalance(client, {
+                account: address,
+                token: holding.address,
+            });
+            return amount === 0n ? undefined : { address: holding.address, amount: amount.toString() };
+        }));
+        const rows = results.filter((holding) => holding !== undefined);
         rows.sort((a, b) => {
             const delta = BigInt(b.amount) - BigInt(a.amount);
             if (delta !== 0n)
@@ -305,8 +238,27 @@ async function getAddressBalances(c, options) {
         });
         return rows;
     });
-    if (corrected.length === 0)
-        return { data: [], nextCursor: holdings.nextCursor };
+    const positioned = (() => {
+        if (!cursor)
+            return corrected.slice(offset);
+        const amount = BigInt(cursor[0]);
+        const address = String(cursor[1]);
+        return corrected.filter((holding) => BigInt(holding.amount) < amount ||
+            (BigInt(holding.amount) === amount && holding.address > address));
+    })();
+    const page = Cursor.paginate({
+        rows: positioned,
+        limit,
+        key: (holding) => [holding.amount, holding.address],
+    });
+    if (page.rows.length === 0)
+        return {
+            data: [],
+            ...(includeTotalCount
+                ? { meta: { totalCount: corrected.length, totalCountCapped: false } }
+                : {}),
+            nextCursor: page.nextCursor,
+        };
     // Resolve token metadata for each balance. The endpoint's contract is a
     // balance with its `token` reference inlined per row (and `formatted` needs
     // the token `decimals`), so a row whose metadata cannot be resolved is
@@ -317,7 +269,7 @@ async function getAddressBalances(c, options) {
     // The verified `snapshot` fetched above is reused across the page instead of
     // re-resolved per row. `createdAt` is not part of this endpoint's response,
     // so it is never fetched here.
-    const resolved = await Timing.time(c, 'tokens', () => Promise.all(corrected.map((holding) => Tokens.resolveToken(c, {
+    const resolved = await Timing.time(c, 'tokens', () => Promise.all(page.rows.map((holding) => Tokens.resolveToken(c, {
         address: holding.address,
         chainId,
         snapshot,
@@ -347,7 +299,13 @@ async function getAddressBalances(c, options) {
             },
         });
     }
-    return { data, nextCursor: holdings.nextCursor };
+    return {
+        data,
+        ...(includeTotalCount
+            ? { meta: { totalCount: corrected.length, totalCountCapped: false } }
+            : {}),
+        nextCursor: page.nextCursor,
+    };
 }
 /**
  * Computes the optional set of allowed token addresses for the page's
@@ -381,44 +339,4 @@ function allowedTokens(options) {
     }
     return allowed;
 }
-/**
- * Exact count of an address's matching TIP-20 holdings, sharing
- * {@link getAddressBalances}'s `holder`/`verified`/`currency` filters (minus
- * pagination) so the count matches the page it annotates. The `holder` equality
- * prunes the `token_balances_snapshot` view by its sort key, so ClickHouse
- * counts via the sparse primary index without a row scan — the count is exact
- * and cheap with no cap (`totalCountCapped` is always `false`), verified at
- * ~370k holdings in <1s. Feeds the opt-in `meta.totalCount`.
- */
-async function countAddressBalances(c, options) {
-    const { address, chainId, currency, feeEligible, feeTokens, verified } = options;
-    const tidx = c.get('getTidx')(chainId);
-    // Same verified/currency/feeEligible `token IN (…)` restriction as the page; an
-    // empty filter means nothing matches, so the count is zero without a round
-    // trip.
-    const snapshot = await VerifiedTokens.snapshot(c, chainId);
-    const allowed = allowedTokens({ currency, feeEligible, feeTokens, snapshot, verified });
-    const tokenFilter = allowed?.map((address) => `'${address}'`);
-    if (tokenFilter?.length === 0)
-        return { totalCountCapped: false, totalCount: 0 };
-    const tokenIn = tokenFilter ? ` AND token IN (${tokenFilter.join(', ')})` : '';
-    return Timing.time(c, 'address_balances_count', async () => {
-        // Exact count over the holder-pruned `address_balances` rows (mirrors the
-        // page's WHERE, minus the keyset cursor). The `holder` sort-key prune lets
-        // ClickHouse count via the sparse index, so no cap is needed. The inline
-        // query is cast to `string` so TIDX treats it as a dynamic ClickHouse
-        // query needing no signature.
-        const result = await tidx.fetch({
-            chainId,
-            engine: 'clickhouse',
-            query: `
-        SELECT count(*) AS total
-        FROM address_balances
-        WHERE holder = '${address}' AND startsWith(token, '${tip20AddressPrefix}') AND balance > 0${tokenIn}
-      `,
-        });
-        const totalCount = Value.toNumber(result.rows[0]?.['total']) ?? 0;
-        return { totalCountCapped: false, totalCount };
-    });
-}
 //# sourceMappingURL=balances.js.map