tapimo 0.5.3 → 0.7.0

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

@@ -1 +1 @@
-{"version":3,"file":"addresses.d.ts","sourceRoot":"","sources":["../../../../src/apps/data/routes/addresses.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,GAAG,MAAM,iBAAiB,CAAA;AAI3C;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAIxB"}
+{"version":3,"file":"addresses.d.ts","sourceRoot":"","sources":["../../../../src/apps/data/routes/addresses.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,GAAG,MAAM,iBAAiB,CAAA;AAG3C,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAE3C;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,OAAO,GAAE,SAAS,CAAC,OAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAKxD;AAED,MAAM,CAAC,OAAO,WAAW,SAAS,CAAC;IACjC,qDAAqD;IACrD,KAAK,OAAO,GAAG;QACb,mDAAmD;QACnD,EAAE,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,EAAE,GAAG,SAAS,CAAA;KACxC,CAAA;CACF"}

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

@@ -1,22 +1,24 @@
 import { Hono } from 'hono';
 import * as Activities from './activities.js';
 import * as Balances from './balances.js';
+import * as Valuation from './valuation.js';
 /**
  * Composes the `/v1/addresses/:address/*` route surface from the
  * address-scoped sub-routers exported by each resource module. The handlers,
  * schemas, and paths live with the resource they describe (activities,
- * balances); this composer only aggregates them so docs grouping stays by tag
- * while URLs stay nested under the parent resource.
+ * balances, valuation); this composer only aggregates them so docs grouping
+ * stays by tag while URLs stay nested under the parent resource.
  *
  * Only subject-relative resources live here — rows that cannot be interpreted
- * without the path address (activity classification, held-token balances).
- * Plain filtered views of canonical collections are reached via search params
- * instead (`GET /transactions?address=…`, `GET /transfers?address=…`,
- * `GET /transactions/receipts?address=…`).
+ * without the path address (activity classification, held-token balances,
+ * holdings valuation). Plain filtered views of canonical collections are
+ * reached via search params instead (`GET /transactions?address=…`,
+ * `GET /transfers?address=…`, `GET /transactions/receipts?address=…`).
  */
-export function addresses() {
+export function addresses(options = {}) {
     return new Hono()
-        .route('/', Activities.addresses())
-        .route('/', Balances.addresses());
+        .route('/', Activities.addresses({ fx: options.fx }))
+        .route('/', Balances.addresses({ fx: options.fx }))
+        .route('/', Valuation.addresses({ fx: options.fx }));
 }
 //# sourceMappingURL=addresses.js.map

package/dist/apps/data/routes/addresses.js.map

@@ -1 +1 @@
-{"version":3,"file":"addresses.js","sourceRoot":"","sources":["../../../../src/apps/data/routes/addresses.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAA;AAG3B,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAC7C,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,SAAS;IACvB,OAAO,IAAI,IAAI,EAAmB;SAC/B,KAAK,CAAC,GAAG,EAAE,UAAU,CAAC,SAAS,EAAE,CAAC;SAClC,KAAK,CAAC,GAAG,EAAE,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAA;AACrC,CAAC"}
+{"version":3,"file":"addresses.js","sourceRoot":"","sources":["../../../../src/apps/data/routes/addresses.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAA;AAG3B,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAC7C,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AACzC,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAE3C;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,SAAS,CAAC,OAAO,GAAsB,EAAE;IACvD,OAAO,IAAI,IAAI,EAAmB;SAC/B,KAAK,CAAC,GAAG,EAAE,UAAU,CAAC,SAAS,CAAC,EAAE,EAAE,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC,CAAC;SACpD,KAAK,CAAC,GAAG,EAAE,QAAQ,CAAC,SAAS,CAAC,EAAE,EAAE,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC,CAAC;SAClD,KAAK,CAAC,GAAG,EAAE,SAAS,CAAC,SAAS,CAAC,EAAE,EAAE,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC,CAAC,CAAA;AACxD,CAAC"}

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

@@ -1,6 +1,7 @@
 import * as z from 'zod/mini';
 import type * as App from '../../../App.js';
 import * as Response from '../../../internal/Response.js';
+import * as Valuation from './valuation.js';
 /** Zod schemas owned by the balance handlers. */
 export declare namespace schema {
     /** Schemas for the getAddressBalances operation. */
@@ -17,6 +18,7 @@ export declare namespace schema {
             }>, z.ZodMiniTransform<4217 | 42431, "mainnet" | "testnet">>, z.ZodMiniNumber<unknown>]>, z.ZodMiniNumber<number>>>;
             currency: z.ZodMiniOptional<z.ZodMiniString<string>>;
             cursor: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            denomination: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<string, string>>>;
             feeEligible: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniEnum<{
                 false: "false";
                 true: "true";
@@ -31,17 +33,14 @@ export declare namespace schema {
                 true: "true";
             }>, z.ZodMiniTransform<boolean, "false" | "true">>>;
         }, z.core.$strict>;
-        /**
-         * A TIP-20 token balance held by an address: the held `amount` in the
-         * token's base unit, its `formatted` value, and the trimmed `token`
-         * reference inlined per row. Rows whose token metadata cannot be resolved
-         * are omitted.
-         */
+        /** A TIP-20 balance with raw and formatted amounts. Unresolvable token metadata omits the row. */
         const Balance: z.ZodMiniObject<{
             amount: z.ZodMiniString<string>;
+            currency: z.ZodMiniString<string>;
+            decimals: z.ZodMiniNumber<number>;
+            feeEligible: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
             formatted: z.ZodMiniString<string>;
             id: z.ZodMiniString<string>;
-            feeEligible: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
             token: z.ZodMiniObject<{
                 address: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
                 currency: z.ZodMiniString<string>;
@@ -52,14 +51,30 @@ export declare namespace schema {
                 symbol: z.ZodMiniString<string>;
                 verified: z.ZodMiniBoolean<boolean>;
             }, z.core.$strip>;
+            valuation: z.ZodMiniNullable<z.ZodMiniObject<{
+                amount: z.ZodMiniString<string>;
+                currency: z.ZodMiniString<string>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        /** Page-level resources: opt-in counts plus valuation rate provenance. */
+        const Meta: z.ZodMiniObject<{
+            pricing: z.ZodMiniOptional<z.ZodMiniObject<{
+                asOf: z.ZodMiniISODateTime;
+                basis: z.ZodMiniLiteral<"nominal">;
+                source: z.ZodMiniString<string>;
+            }, z.core.$strip>>;
+            totalCount: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+            totalCountCapped: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
         }, z.core.$strip>;
         /** Page of TIP-20 token balances held by an address, ordered by amount descending. */
         const Response: z.ZodMiniObject<{
             data: z.ZodMiniArray<z.ZodMiniObject<{
                 amount: z.ZodMiniString<string>;
+                currency: z.ZodMiniString<string>;
+                decimals: z.ZodMiniNumber<number>;
+                feeEligible: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
                 formatted: z.ZodMiniString<string>;
                 id: z.ZodMiniString<string>;
-                feeEligible: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
                 token: z.ZodMiniObject<{
                     address: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
                     currency: z.ZodMiniString<string>;
@@ -70,10 +85,19 @@ export declare namespace schema {
                     symbol: z.ZodMiniString<string>;
                     verified: z.ZodMiniBoolean<boolean>;
                 }, z.core.$strip>;
+                valuation: z.ZodMiniNullable<z.ZodMiniObject<{
+                    amount: z.ZodMiniString<string>;
+                    currency: z.ZodMiniString<string>;
+                }, z.core.$strip>>;
             }, z.core.$strip>>;
             meta: z.ZodMiniOptional<z.ZodMiniObject<{
-                totalCountCapped: z.ZodMiniBoolean<boolean>;
-                totalCount: z.ZodMiniNumber<number>;
+                pricing: z.ZodMiniOptional<z.ZodMiniObject<{
+                    asOf: z.ZodMiniISODateTime;
+                    basis: z.ZodMiniLiteral<"nominal">;
+                    source: z.ZodMiniString<string>;
+                }, z.core.$strip>>;
+                totalCount: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+                totalCountCapped: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
             }, z.core.$strip>>;
             nextCursor: z.ZodMiniNullable<z.ZodMiniString<string>>;
         }, z.core.$strip>;
@@ -83,7 +107,7 @@ export declare namespace schema {
  * Creates address-scoped balance handlers, mounted under the `/addresses`
  * composer. Exposes `GET /:address/balances`, the held-balance page.
  */
-export declare function addresses(): import("hono/hono-base").HonoBase<App.Environment, {
+export declare function addresses(options?: addresses.Options): import("hono/hono-base").HonoBase<App.Environment, {
     "/v1/addresses/:address/balances": {
         $get: {
             output: null;
@@ -98,6 +122,7 @@ export declare function addresses(): import("hono/hono-base").HonoBase<App.Envir
                     chainId?: string | string[];
                     currency?: string | string[];
                     cursor?: string | string[];
+                    denomination?: string | string[];
                     feeEligible?: string | string[];
                     include?: string | string[];
                     limit?: string | string[];
@@ -108,14 +133,14 @@ export declare function addresses(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "upstream_error";
+                    code: "api_key_malformed";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 502;
+            status: 400;
             input: {
                 param: {
                     address: `0x${string}`;
@@ -125,6 +150,7 @@ export declare function addresses(): import("hono/hono-base").HonoBase<App.Envir
                     chainId?: string | string[];
                     currency?: string | string[];
                     cursor?: string | string[];
+                    denomination?: string | string[];
                     feeEligible?: string | string[];
                     include?: string | string[];
                     limit?: string | string[];
@@ -135,14 +161,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 Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 401;
             input: {
                 param: {
                     address: `0x${string}`;
@@ -152,6 +178,7 @@ export declare function addresses(): import("hono/hono-base").HonoBase<App.Envir
                     chainId?: string | string[];
                     currency?: string | string[];
                     cursor?: string | string[];
+                    denomination?: string | string[];
                     feeEligible?: string | string[];
                     include?: string | string[];
                     limit?: string | string[];
@@ -162,14 +189,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 Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 401;
+            status: 403;
             input: {
                 param: {
                     address: `0x${string}`;
@@ -179,6 +206,7 @@ export declare function addresses(): import("hono/hono-base").HonoBase<App.Envir
                     chainId?: string | string[];
                     currency?: string | string[];
                     cursor?: string | string[];
+                    denomination?: string | string[];
                     feeEligible?: string | string[];
                     include?: string | string[];
                     limit?: string | string[];
@@ -189,14 +217,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 Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 403;
+            status: 429;
             input: {
                 param: {
                     address: `0x${string}`;
@@ -206,6 +234,7 @@ export declare function addresses(): import("hono/hono-base").HonoBase<App.Envir
                     chainId?: string | string[];
                     currency?: string | string[];
                     cursor?: string | string[];
+                    denomination?: string | string[];
                     feeEligible?: string | string[];
                     include?: string | string[];
                     limit?: string | string[];
@@ -216,14 +245,14 @@ export declare function addresses(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             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: {
                 param: {
                     address: `0x${string}`;
@@ -233,6 +262,7 @@ export declare function addresses(): import("hono/hono-base").HonoBase<App.Envir
                     chainId?: string | string[];
                     currency?: string | string[];
                     cursor?: string | string[];
+                    denomination?: string | string[];
                     feeEligible?: string | string[];
                     include?: string | string[];
                     limit?: string | string[];
@@ -243,14 +273,14 @@ export declare function addresses(): import("hono/hono-base").HonoBase<App.Envir
         } | {
             output: {
                 error: {
-                    code: "query_invalid";
+                    code: "upstream_error";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 502;
             input: {
                 param: {
                     address: `0x${string}`;
@@ -260,6 +290,7 @@ export declare function addresses(): import("hono/hono-base").HonoBase<App.Envir
                     chainId?: string | string[];
                     currency?: string | string[];
                     cursor?: string | string[];
+                    denomination?: string | string[];
                     feeEligible?: string | string[];
                     include?: string | string[];
                     limit?: string | string[];
@@ -287,6 +318,7 @@ export declare function addresses(): import("hono/hono-base").HonoBase<App.Envir
                     chainId?: string | string[];
                     currency?: string | string[];
                     cursor?: string | string[];
+                    denomination?: string | string[];
                     feeEligible?: string | string[];
                     include?: string | string[];
                     limit?: string | string[];
@@ -298,9 +330,11 @@ export declare function addresses(): import("hono/hono-base").HonoBase<App.Envir
             output: {
                 data: {
                     amount: string;
+                    currency: string;
+                    decimals: number;
+                    feeEligible?: boolean | undefined;
                     formatted: string;
                     id: string;
-                    feeEligible?: boolean | undefined;
                     token: {
                         address: `0x${string}`;
                         currency: string;
@@ -311,10 +345,19 @@ export declare function addresses(): import("hono/hono-base").HonoBase<App.Envir
                         symbol: string;
                         verified: boolean;
                     };
+                    valuation: {
+                        amount: string;
+                        currency: string;
+                    } | null;
                 }[];
                 meta?: {
-                    totalCountCapped: boolean;
-                    totalCount: number;
+                    pricing?: {
+                        asOf: string;
+                        basis: "nominal";
+                        source: string;
+                    } | undefined;
+                    totalCount?: number | undefined;
+                    totalCountCapped?: boolean | undefined;
                 } | undefined;
                 nextCursor: string | null;
             };
@@ -329,6 +372,7 @@ export declare function addresses(): import("hono/hono-base").HonoBase<App.Envir
                     chainId?: string | string[];
                     currency?: string | string[];
                     cursor?: string | string[];
+                    denomination?: string | string[];
                     feeEligible?: string | string[];
                     include?: string | string[];
                     limit?: string | string[];
@@ -339,4 +383,11 @@ export declare function addresses(): import("hono/hono-base").HonoBase<App.Envir
         };
     };
 }, "/", "/v1/addresses/:address/balances">;
+export declare namespace addresses {
+    /** Options for the address-scoped balance handlers. */
+    type Options = {
+        /** FX configuration backing per-row valuation. */
+        fx?: Valuation.addresses.Fx | undefined;
+    };
+}
 //# sourceMappingURL=balances.d.ts.map

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;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"}
+{"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;AAOzD,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAQ3C,iDAAiD;AACjD,yBAAiB,MAAM,CAAC;IACtB,oDAAoD;IACpD,UAAiB,kBAAkB,CAAC;QAClC,oDAAoD;QAC7C,MAAM,MAAM;;yBAM6D,CAAA;QAEhF,qDAAqD;QAC9C,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;0BA0Cf,CAAA;QAEH,kGAAkG;QAC3F,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;yBAoEnB,CAAA;QAED,0EAA0E;QACnE,MAAM,IAAI;;;;;;;;yBAasD,CAAA;QAEvE,sFAAsF;QAC/E,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAUwD,CAAA;KAC9E;CACF;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,OAAO,GAAE,SAAS,CAAC,OAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CA0FxD;AAED,MAAM,CAAC,OAAO,WAAW,SAAS,CAAC;IACjC,uDAAuD;IACvD,KAAK,OAAO,GAAG;QACb,kDAAkD;QAClD,EAAE,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,EAAE,GAAG,SAAS,CAAA;KACxC,CAAA;CACF"}

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

@@ -10,8 +10,10 @@ import * as Response from '../../../internal/Response.js';
 import * as Schema from '../../../internal/Schema.js';
 import * as Timing from '../../../internal/Timing.js';
 import * as VerifiedTokens from '../../../internal/VerifiedTokens.js';
+import * as FxOracle from '../FxOracle.js';
 import * as FeeAmm from './fee-amm.js';
 import * as Tokens from './tokens.js';
+import * as Valuation from './valuation.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
 // balance sources include every Transfer-emitting contract, so discovery
@@ -40,6 +42,7 @@ export var schema;
                 'snapshot does not store currency for unverified tokens. ' +
                 'Unknown currency strings are accepted but match no rows.')),
             cursor: Schema.Cursor,
+            denomination: Schema.Denomination,
             feeEligible: z
                 .optional(Schema.booleanQuery())
                 .check(z.describe('When `true`, include only tokens eligible to pay transaction fees on Tempo: ' +
@@ -54,22 +57,17 @@ export var schema;
                 .check(z.describe('When `true`, include only tokens from Tempo’s curated verified token list.'), z.meta({ examples: [true] })),
         })
             .check(...Schema.pageChecks(), z.describe('Query parameters for listing an account’s token balances.'));
-        /**
-         * A TIP-20 token balance held by an address: the held `amount` in the
-         * token's base unit, its `formatted` value, and the trimmed `token`
-         * reference inlined per row. Rows whose token metadata cannot be resolved
-         * are omitted.
-         */
+        /** A TIP-20 balance with raw and formatted amounts. Unresolvable token metadata omits the row. */
         getAddressBalances.Balance = Schema.describe(z.object({
             amount: z
                 .string()
                 .check(z.regex(/^\d+$/), z.describe('A non-negative whole number, given as a decimal string so very large token amounts keep full precision. Expressed in the smallest unit of the token.'), z.meta({ examples: ['1500000'] })),
-            formatted: z
-                .string()
-                .check(z.describe('The same balance in human-readable decimal form, using the token’s `decimals`.'), z.meta({ examples: ['1.5'] })),
-            id: z
+            currency: z
                 .string()
-                .check(z.describe('A stable resource ID for this balance, equal to the token contract address.'), z.meta({ examples: ['0x20c0000000000000000000008f5425160ebe5525'] })),
+                .check(z.describe('The currency label for this balance, such as `USD` for a USD-denominated token.'), z.meta({ examples: ['USD'] })),
+            decimals: z
+                .number()
+                .check(z.int(), z.nonnegative(), z.describe('The number of decimal places used to convert this balance between base units and human-readable form.'), z.meta({ examples: [6] })),
             feeEligible: z
                 .optional(z.boolean())
                 .check(z.describe('Whether this token can be used to pay transaction fees on Tempo: `true` when ' +
@@ -77,8 +75,29 @@ export var schema;
                 '(`pathUSD`). Lets you identify fee-payable holdings without a separate ' +
                 '`/fee-amm/pools` query. Omitted (best-effort) when the fee-token lookup ' +
                 'is unavailable.'), z.meta({ examples: [true] })),
+            formatted: z
+                .string()
+                .check(z.describe('The same balance in human-readable decimal form, using this balance’s `decimals`.'), z.meta({ examples: ['1.5'] })),
+            id: z
+                .string()
+                .check(z.describe('A stable resource ID for this balance, equal to the token contract address.'), z.meta({ examples: ['0x20c0000000000000000000008f5425160ebe5525'] })),
             token: Tokens.schema.Token,
+            valuation: z
+                .nullable(Valuation.schema.Value)
+                .check(z.describe('The holding’s nominal value in the requested `denomination`, or `null` when the ' +
+                'token is unverified, its display currency has no rate, or rates were unavailable.')),
         }), 'One TIP-20 token balance held by this account, with both raw and human-readable amounts.');
+        /** Page-level resources: opt-in counts plus valuation rate provenance. */
+        getAddressBalances.Meta = z
+            .object({
+            pricing: z
+                .optional(Valuation.schema.Pricing)
+                .check(z.describe('Rate provenance for row valuations. Present when conversion rates were ' +
+                'consulted; absent when every value was identity-valued or rates were unavailable.')),
+            totalCount: z.optional(Schema.TotalCount),
+            totalCountCapped: z.optional(Schema.TotalCountCapped),
+        })
+            .check(z.describe('Page-level resources attached to this response.'));
         /** Page of TIP-20 token balances held by an address, ordered by amount descending. */
         getAddressBalances.Response = z
             .object({
@@ -86,8 +105,8 @@ export var schema;
                 .array(getAddressBalances.Balance)
                 .check(z.describe('The balances in this page, ordered from largest to smallest amount.')),
             meta: z
-                .optional(Schema.CountMeta)
-                .check(z.describe('Page-level resources you requested with `include`.')),
+                .optional(getAddressBalances.Meta)
+                .check(z.describe('Page-level resources: opt-in counts and valuation rate provenance.')),
             nextCursor: Schema.NextCursor,
         })
             .check(z.describe('A page of TIP-20 token balances held by this account.'));
@@ -97,7 +116,8 @@ export var schema;
  * Creates address-scoped balance handlers, mounted under the `/addresses`
  * composer. Exposes `GET /:address/balances`, the held-balance page.
  */
-export function addresses() {
+export function addresses(options = {}) {
+    const oracle = options.fx?.oracle ?? FxOracle.ecb();
     return new Hono().get('/v1/addresses/:address/balances', Auth.policy({ apiKey: { scopes: ['data:read'] }, mpp: true, public: true }), OpenApi.validate('param', schema.getAddressBalances.Params, {
         code: 'address_invalid',
         message: 'Invalid account address',
@@ -105,10 +125,10 @@ export function addresses() {
         code: 'query_invalid',
         message: 'Invalid query parameters',
     }), OpenApi.describeRoute({
-        description: 'Lists how much of each TIP-20 token an account holds, ordered from largest to smallest balance. Amounts are returned in raw base units and human-readable form.',
+        description: 'Lists how much of each TIP-20 token an account holds, ordered from largest to smallest balance. Amounts are returned in raw base units and human-readable form, and each verified holding carries its nominal value in the requested denomination.',
         operationId: 'getAddressBalances',
         responses: OpenApi.responses({
-            errors: { 502: 'The upstream indexer could not serve this request.' },
+            errors: { 502: 'Could not read balance or token data from an upstream service.' },
             success: {
                 description: 'A page of token balances for this account.',
                 schema: schema.getAddressBalances.Response,
@@ -158,25 +178,31 @@ export function addresses() {
                 chainId,
                 currency: query.currency,
                 cursor: query.cursor,
+                denomination: query.denomination ?? 'USD',
                 feeEligible,
                 feeTokens,
                 includeTotalCount: query.include.includes('totalCount'),
                 limit: query.limit,
+                oracle,
                 page: query.page,
                 verified,
             });
             return c.json(Response.validated(schema.getAddressBalances.Response, balances), 200);
         }
         catch (cause) {
+            if (cause instanceof Valuation.UnsupportedDenominationError)
+                return Response.error(c, { code: 'query_invalid', message: cause.message, status: 400 });
             return Response.upstream(c, cause);
         }
     });
 }
 async function getAddressBalances(c, options) {
-    const { address, chainId, currency, feeEligible, feeTokens, includeTotalCount, limit, verified } = options;
+    const { address, chainId, currency, denomination, feeEligible, feeTokens, includeTotalCount, limit, oracle, verified, } = options;
     const tidx = c.get('getTidx')(chainId);
     const cursor = options.cursor ? Cursor.decode(options.cursor, ['uint', 'address']) : undefined;
     const offset = options.page !== undefined && options.page > 1 ? (options.page - 1) * limit : 0;
+    // Validate the requested denomination independently of the current page.
+    await Valuation.ratesFor(c, { currencies: [], denomination, oracle });
     // 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
@@ -259,51 +285,66 @@ async function getAddressBalances(c, options) {
                 : {}),
             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
-    // dropped rather than returned with placeholders. Because the TIDX filter
-    // already restricts to TIP-20 (`0x20c0…`) tokens, resolution should succeed
-    // for nearly every row in practice.
-    //
-    // 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(page.rows.map((holding) => Tokens.resolveToken(c, {
-        address: holding.address,
-        chainId,
-        snapshot,
-    })
-        .then((metadata) => ({ amount: holding.amount, metadata }))
-        .catch(() => ({ amount: holding.amount, metadata: undefined })))));
+    const rates = await Valuation.ratesFor(c, {
+        currencies: page.rows.flatMap((row) => {
+            const held = snapshot.byAddress.get(row.address.toLowerCase())?.currency;
+            return held === undefined ? [] : [held];
+        }),
+        denomination,
+        oracle,
+    });
+    // Balance tokens retain their logo and verification metadata by default.
+    const resolved = await Timing.time(c, 'tokens', () => Promise.all(page.rows.map(async (holding) => {
+        try {
+            const token = Schema.Address.parse(holding.address.toLowerCase());
+            const [logoUri, metadata] = await Promise.all([
+                Timing.time(c, 'token_logo', () => Tokens.getTokenLogo(c, { address: token, chainId })).catch(() => undefined),
+                Timing.time(c, 'token_metadata', () => Tokens.getTokenMetadata(c, { address: token, chainId })),
+            ]);
+            return { amount: holding.amount, logoUri, metadata, token };
+        }
+        catch {
+            return undefined;
+        }
+    })));
     const data = [];
     for (const entry of resolved) {
-        if (!entry.metadata)
+        if (!entry)
             continue;
         data.push({
             amount: entry.amount,
-            formatted: core_Value.format(BigInt(entry.amount), entry.metadata.decimals),
-            id: entry.metadata.address,
+            currency: entry.metadata.currency,
+            decimals: entry.metadata.decimals,
             // Best-effort: omit `feeEligible` entirely when the fee-token set was
             // unavailable, rather than reporting a misleading `false`.
-            ...(feeTokens ? { feeEligible: feeTokens.has(entry.metadata.address.toLowerCase()) } : {}),
+            ...(feeTokens ? { feeEligible: feeTokens.has(entry.token.toLowerCase()) } : {}),
+            formatted: core_Value.format(BigInt(entry.amount), entry.metadata.decimals),
+            id: entry.token,
             token: {
-                address: entry.metadata.address,
+                address: entry.token,
                 currency: entry.metadata.currency,
                 decimals: entry.metadata.decimals,
-                id: entry.metadata.id,
-                logoUri: entry.metadata.logoUri,
+                id: entry.token,
+                logoUri: entry.logoUri ?? snapshot.byAddress.get(entry.token)?.logoUri ?? entry.metadata.logoUri,
                 name: entry.metadata.name,
                 symbol: entry.metadata.symbol,
-                verified: entry.metadata.verified,
+                verified: snapshot.byAddress.has(entry.token),
             },
+            valuation: Valuation.valuationFor({
+                amount: BigInt(entry.amount),
+                denomination,
+                rates,
+                token: snapshot.byAddress.get(entry.token),
+            }),
         });
     }
+    const meta = {
+        ...(rates ? { pricing: Valuation.pricing(rates, oracle) } : {}),
+        ...(includeTotalCount ? { totalCount: corrected.length, totalCountCapped: false } : {}),
+    };
     return {
         data,
-        ...(includeTotalCount
-            ? { meta: { totalCount: corrected.length, totalCountCapped: false } }
-            : {}),
+        ...(Object.keys(meta).length > 0 ? { meta } : {}),
         nextCursor: page.nextCursor,
     };
 }
@@ -320,6 +361,8 @@ function allowedTokens(options) {
     const { currency, feeEligible, feeTokens, snapshot, verified } = options;
     let allowed;
     if (verified) {
+        if (!snapshot)
+            throw new Error('Unable to resolve verified token metadata');
         const matching = currency
             ? (snapshot.byCurrency.get(currency.toLowerCase()) ?? [])
             : snapshot.list;