tapimo 0.6.0 → 0.7.0

package/src/analytics/Analytics.test.ts

@@ -36,6 +36,9 @@ const row = {
   rate_limit_scope: null,
   request_id: 'req-1',
   route: '/v1/transactions',
+  rpc_error_code: null,
+  rpc_error_count: 0,
+  rpc_error_data_code: null,
   service: 'api',
   status: 200,
   timestamp: '2026-01-01 00:00:00.000',
@@ -211,6 +214,9 @@ describe('createQueueSink', () => {
       rate_limit_scope: row.rate_limit_scope,
       request_id: row.request_id,
       route: row.route,
+      rpc_error_code: row.rpc_error_code,
+      rpc_error_count: row.rpc_error_count,
+      rpc_error_data_code: row.rpc_error_data_code,
       service: row.service,
       status: row.status,
       timestamp: '<timestamp>',
@@ -229,6 +235,9 @@ describe('createQueueSink', () => {
         "rate_limit_scope": null,
         "request_id": "req-1",
         "route": "/v1/transactions",
+        "rpc_error_code": null,
+        "rpc_error_count": 0,
+        "rpc_error_data_code": null,
         "service": "api",
         "status": 200,
         "timestamp": "<timestamp>",
@@ -272,6 +281,24 @@ describe('createQueueSink', () => {
     })
   })
 
+  test('records JSON-RPC error metadata', async () => {
+    const send = vi.fn<(message: Analytics.Event) => Promise<void>>().mockResolvedValue(undefined)
+    const sink = Analytics.createQueueSink({ send })(context)
+
+    await sink({
+      ...entry,
+      level: 'warn',
+      rpc: { code: -32602, dataCode: 'billing_required', errors: 2 },
+    })
+
+    expect(send.mock.calls[0]![0]).toMatchObject({
+      rpc_error_code: -32602,
+      rpc_error_count: 2,
+      rpc_error_data_code: 'billing_required',
+      status: 200,
+    })
+  })
+
   test('rethrows when the retry also fails', async () => {
     const send = vi
       .fn<(message: Analytics.Event) => Promise<void>>()
@@ -399,6 +426,7 @@ describe('readProjectUsage', () => {
     expect(query).toContain(`key_environment = 'sandbox'`)
     expect(query).not.toContain('key_id IN')
     expect(query).toContain('LIMIT 100')
+    expect(query).toContain('status >= 400 OR rpc_error_count > 0')
     expect(new URL(String(fetch.mock.calls[0]![0])).searchParams.get('query')).toBeNull()
     expect(usage).toMatchObject({
       from: '2026-01-01T00:00:00.000Z',
@@ -408,6 +436,29 @@ describe('readProjectUsage', () => {
     })
   })
 
+  test('includes JSON-RPC failures in the error breakdown', async () => {
+    const fetch = vi.fn<typeof globalThis.fetch>().mockResolvedValue(
+      new Response(JSON.stringify({ data: [{ code: 'billing_required', requests: '2' }] }), {
+        status: 200,
+      }),
+    )
+    vi.stubGlobal('fetch', fetch)
+
+    const breakdown = await RequestEvents.readErrorBreakdown(Analytics.clickhouse(clickHouse), {
+      attributions: [{ projectId: 'prj_1' }],
+      from: '2026-01-01T00:00:00.000Z',
+      interval: 'day',
+      orgId: 'org_1',
+      to: '2026-01-02T00:00:00.000Z',
+    })
+
+    expect(fetch.mock.calls[0]![1]?.body).toEqual(expect.stringContaining('rpc_error_data_code'))
+    expect(fetch.mock.calls[0]![1]?.body).toEqual(
+      expect.stringContaining('status >= 400 OR rpc_error_count > 0'),
+    )
+    expect(breakdown).toEqual([{ code: 'billing_required', requests: 2 }])
+  })
+
   test('keeps legacy rows scoped to project keys without global org filtering', async () => {
     const fetch = vi
       .fn<typeof globalThis.fetch>()
@@ -525,3 +576,35 @@ describe('readProjectUsage', () => {
     })
   })
 })
+
+describe('readLastUsedAt', () => {
+  test('returns the latest request timestamp for each requested key', async () => {
+    const fetch = vi.fn<typeof globalThis.fetch>().mockImplementation(async (_url, init) => {
+      const sql = init?.body
+      if (typeof sql !== 'string') throw new Error('Expected a SQL request body.')
+      expect(sql).toContain("key_id IN ('key_1', 'key_2')")
+      expect(sql).toContain('max(timestamp)')
+      return new Response(
+        JSON.stringify({
+          data: [{ key_id: 'key_1', lastUsedAt: '2026-07-21T12:34:56.000Z' }],
+        }),
+        { status: 200 },
+      )
+    })
+    vi.stubGlobal('fetch', fetch)
+
+    await expect(
+      RequestEvents.readLastUsedAt(Analytics.clickhouse(clickHouse), ['key_1', 'key_2']),
+    ).resolves.toEqual([{ apiKeyId: 'key_1', lastUsedAt: '2026-07-21T12:34:56.000Z' }])
+  })
+
+  test('skips the analytics query when no keys are requested', async () => {
+    const fetch = vi.fn<typeof globalThis.fetch>()
+    vi.stubGlobal('fetch', fetch)
+
+    await expect(
+      RequestEvents.readLastUsedAt(Analytics.clickhouse(clickHouse), []),
+    ).resolves.toEqual([])
+    expect(fetch).not.toHaveBeenCalled()
+  })
+})

package/src/analytics/Analytics.ts

@@ -131,6 +131,9 @@ export const migrations: readonly Migration[] = [
         project_id Nullable(String),
         rate_limit_scope Nullable(String),
         error_code Nullable(String),
+        rpc_error_code Nullable(Int32),
+        rpc_error_data_code Nullable(String),
+        rpc_error_count UInt16 DEFAULT 0,
         request_id Nullable(String),
         billing_active Nullable(UInt8)
       )
@@ -156,6 +159,23 @@ export const migrations: readonly Migration[] = [
         ADD COLUMN IF NOT EXISTS billing_active Nullable(UInt8)
     `,
   },
+  {
+    name: '0003_request_events_rpc_errors',
+    // Patches tables created before RPC columns entered the baseline. Fresh
+    // tables include them, allowing scoped preview users without ALTER to skip.
+    guard: `
+      SELECT toUInt8(count() = 3) FROM system.columns
+      WHERE database = currentDatabase()
+        AND table = 'request_events'
+        AND name IN ('rpc_error_code', 'rpc_error_data_code', 'rpc_error_count')
+    `,
+    sql: `
+      ALTER TABLE request_events
+        ADD COLUMN IF NOT EXISTS rpc_error_code Nullable(Int32),
+        ADD COLUMN IF NOT EXISTS rpc_error_data_code Nullable(String),
+        ADD COLUMN IF NOT EXISTS rpc_error_count UInt16 DEFAULT 0
+    `,
+  },
 ]
 
 /**

package/src/analytics/tables/requestEvents.ts

@@ -30,6 +30,12 @@ export type Table = {
   principal_type: 'api_key' | 'public' | 'session' | 'super_admin' | 'unknown'
   /** Rate-limit bucket scope, when a rate limit was applied. */
   rate_limit_scope: string | null
+  /** Numeric JSON-RPC error code when every failed response shares one code. */
+  rpc_error_code: number | null
+  /** Stable application error code from JSON-RPC `error.data.code`. */
+  rpc_error_data_code: string | null
+  /** Number of failed JSON-RPC responses in the request. */
+  rpc_error_count: number
   /** Stable per-request id (`entry.requestId`); dedups the billing count via `uniqExact`. */
   request_id: string | null
   /** Bounded matched route pattern. */
@@ -79,6 +85,14 @@ export type KeyBreakdown = {
   requests: number
 }
 
+/** Latest authenticated request timestamp for one API key. */
+export type LastUsedAt = {
+  /** API key id (`key_…`). */
+  apiKeyId: string
+  /** Latest request completion timestamp (ISO 8601). */
+  lastUsedAt: string
+}
+
 /** Time bucket size for the usage series. */
 export type Interval = 'day' | 'hour'
 
@@ -227,6 +241,32 @@ export declare namespace insertMessages {
   }
 }
 
+/**
+ * Reads the latest authenticated request timestamp for each requested API key.
+ * Keys with no request events are omitted.
+ */
+export async function readLastUsedAt(
+  analytics: Analytics.Analytics,
+  apiKeyIds: readonly string[],
+): Promise<LastUsedAt[]> {
+  if (apiKeyIds.length === 0) return []
+  const rows = await analytics.query<LastUsedAtRow>(
+    `
+      SELECT
+        key_id,
+        formatDateTime(max(timestamp), '%Y-%m-%dT%H:%i:%S.000Z', 'UTC') AS lastUsedAt
+      FROM ${table}
+      WHERE principal_type = 'api_key'
+        AND key_id IN (${apiKeyIds.map(literal).join(', ')})
+      GROUP BY key_id
+    `,
+  )
+  return rows.map((row) => ({
+    apiKeyId: String(row.key_id),
+    lastUsedAt: String(row.lastUsedAt),
+  }))
+}
+
 /**
  * Reads request usage for one project from the `request_events` table.
  *
@@ -247,7 +287,7 @@ export async function readProjectUsage(
         SELECT
           key_id,
           count() AS requests,
-          countIf(status >= 400) AS errors,
+          countIf(status >= 400 OR rpc_error_count > 0) AS errors,
           ${average} AS averageDurationMs
         FROM ${table}
         WHERE ${where} AND key_id IS NOT NULL
@@ -261,7 +301,7 @@ export async function readProjectUsage(
         SELECT
           route,
           count() AS requests,
-          countIf(status >= 400) AS errors,
+          countIf(status >= 400 OR rpc_error_count > 0) AS errors,
           ${average} AS averageDurationMs
         FROM ${table}
         WHERE ${where}
@@ -286,7 +326,7 @@ export async function readProjectUsage(
         SELECT
           formatDateTime(${bucket}, '%Y-%m-%dT%H:%i:%S.000Z', 'UTC') AS time,
           count() AS requests,
-          countIf(status >= 400) AS errors
+          countIf(status >= 400 OR rpc_error_count > 0) AS errors
         FROM ${table}
         WHERE ${where}
         GROUP BY ${bucket}
@@ -297,7 +337,7 @@ export async function readProjectUsage(
       `
         SELECT
           count() AS requests,
-          countIf(status >= 400) AS errors,
+          countIf(status >= 400 OR rpc_error_count > 0) AS errors,
           ${average} AS averageDurationMs
         FROM ${table}
         WHERE ${where}
@@ -347,11 +387,16 @@ export async function readErrorBreakdown(
   const rows = await analytics.query<ErrorRow>(
     `
       SELECT
-        coalesce(error_code, 'unknown') AS code,
+        coalesce(
+          error_code,
+          rpc_error_data_code,
+          if(rpc_error_count > 0 AND rpc_error_code IS NOT NULL, concat('rpc_', toString(rpc_error_code)), NULL),
+          if(rpc_error_count > 0, 'rpc_multiple', 'unknown')
+        ) AS code,
         count() AS requests
       FROM ${table}
-      WHERE ${usageWhere(options)} AND status >= 400
-      GROUP BY error_code
+      WHERE ${usageWhere(options)} AND (status >= 400 OR rpc_error_count > 0)
+      GROUP BY code
       ORDER BY requests DESC, code ASC
       LIMIT 25
     `,
@@ -434,6 +479,11 @@ type KeyRow = {
   requests: number | string
 }
 
+type LastUsedAtRow = {
+  key_id: string
+  lastUsedAt: string
+}
+
 type ErrorRow = {
   code: string
   requests: number | string
@@ -480,6 +530,9 @@ function event(entry: Log.Entry, context: Metrics.cloudflare.Context): Table {
     rate_limit_scope: entry.rateLimit?.scope ?? null,
     request_id: entry.requestId ?? null,
     route: entry.route,
+    rpc_error_code: entry.rpc?.code ?? null,
+    rpc_error_count: entry.rpc?.errors ?? 0,
+    rpc_error_data_code: entry.rpc?.dataCode ?? null,
     service: context.service ?? 'unknown',
     status: entry.status,
     timestamp: timestamp(),

package/src/apps/composition.test.ts

@@ -1,5 +1,5 @@
 import { App, Store } from 'tapimo'
-import { data, management, relay } from 'tapimo/apps'
+import { data, management, mpp, relay } from 'tapimo/apps'
 import { Hono } from 'hono'
 import { describeRoute } from 'hono-openapi'
 import * as TestApp from '../../test/App.js'
@@ -190,7 +190,7 @@ describe('data()', () => {
 })
 
 describe('relay()', () => {
-  test('mounts the relay after data() and stays out of the document', async () => {
+  test('mounts the relay after data() without documenting RPC routes', async () => {
     const composed = App.create({ db: TestApp.database() }).route('/', data()).route('/', relay())
 
     // Mounted but default-closed and hidden: unauthenticated requests are
@@ -209,6 +209,15 @@ describe('relay()', () => {
   })
 })
 
+describe('mpp()', () => {
+  test('mounts documented MPP routes independently', async () => {
+    const app = App.create({ db: TestApp.database() }).route('/', mpp())
+
+    expect((await paths(app)).some((path) => path.startsWith('/v1/mpp'))).toBe(true)
+    expect((await app.request('/rpc/relay')).status).toBe(404)
+  })
+})
+
 describe('management()', () => {
   test('mounts management routes and omits data routes', async () => {
     const app = App.create({

package/src/apps/data/App.test.ts

@@ -254,7 +254,7 @@ describe('zone chain gate', () => {
     for (const path of [
       `/v1/tokens?chainId=${zone}`,
       `/v1/addresses/0x0000000000000000000000000000000000000001/activities?chainId=${zone}`,
-      `/v1/transfers?chainId=${zone}&include=token`,
+      `/v1/transfers?chainId=${zone}&include=token.verified`,
     ]) {
       const response = await app.request(path)
       const body = (await response.json()) as { error: { code: string; message: string } }

package/src/apps/data/FundingQuoteProviders.test.ts

@@ -84,7 +84,6 @@ describe('FundingQuoteProviders', () => {
       expiresAt: '2026-01-01T00:01:00.000Z',
       minimumOutputAmount: '988000',
       outputAmount: '990000',
-      outputAmountFormatted: '0.99',
       quality: {
         estimatedSeconds: 2,
         liquiditySource: 'providerQuote',
@@ -185,7 +184,6 @@ describe('FundingQuoteProviders', () => {
     expect(result).toMatchObject({
       minimumOutputAmount: '980000',
       outputAmount: '990000',
-      outputAmountFormatted: '0.99',
       quality: {
         estimatedSeconds: 15,
         liquiditySource: 'providerQuote',
@@ -230,7 +228,6 @@ describe('FundingQuoteProviders', () => {
     expect(result).toEqual({
       minimumOutputAmount: '989622',
       outputAmount: '999620',
-      outputAmountFormatted: '0.99962',
       quality: {
         estimatedSeconds: 10,
         liquiditySource: 'providerQuote',
@@ -308,7 +305,6 @@ describe('FundingQuoteProviders', () => {
     expect(result).toEqual({
       minimumOutputAmount: '979000',
       outputAmount: '989000',
-      outputAmountFormatted: '0.989',
       quality: {
         estimatedSeconds: 18,
         liquiditySource: 'providerQuote',
@@ -480,7 +476,6 @@ describe('FundingQuoteProviders', () => {
     })
     expect(result).toEqual({
       outputAmount: '983000',
-      outputAmountFormatted: '0.983',
       quality: {
         estimatedSeconds: 2,
         liquiditySource: 'providerQuote',

package/src/apps/data/FundingQuoteProviders.ts

@@ -292,7 +292,7 @@ export function relay(options: relay.Options): FundingQuotes.ProviderAdapter {
           method: 'POST',
           signal,
         })
-        return formatRelayResult(candidate, quote, now())
+        return formatRelayResult(quote, now())
       } catch (cause) {
         const unavailable = providerUnavailable(cause, [
           'NO_QUOTES',
@@ -600,10 +600,6 @@ function formatAcrossResult(
     expiresAt: expiresAt.toISOString(),
     minimumOutputAmount: response.minOutputAmount,
     outputAmount: response.expectedOutputAmount,
-    outputAmountFormatted: decimalFromBaseUnits(
-      response.expectedOutputAmount,
-      candidate.destinationToken.decimals,
-    ),
     quality: {
       estimatedSeconds: response.expectedFillTime,
       liquiditySource: 'providerQuote',
@@ -615,11 +611,7 @@ function formatAcrossResult(
   }
 }
 
-function formatRelayResult(
-  candidate: FundingQuotes.QuoteCandidate,
-  quote: unknown,
-  now: Date,
-): FundingQuotes.QuoteProbeResult {
+function formatRelayResult(quote: unknown, now: Date): FundingQuotes.QuoteProbeResult {
   const details = record(record(quote)['details'])
   const currencyOut = record(details['currencyOut'])
   const outputAmount = decimalString(currencyOut['amount'])
@@ -630,9 +622,6 @@ function formatRelayResult(
   return {
     minimumOutputAmount: decimalString(currencyOut['minimumAmount']),
     outputAmount,
-    outputAmountFormatted: outputAmount
-      ? decimalFromBaseUnits(outputAmount, candidate.destinationToken.decimals)
-      : undefined,
     quality: {
       estimatedSeconds: nonnegativeInteger(details['timeEstimate']),
       liquiditySource: 'providerQuote',
@@ -669,7 +658,6 @@ function formatRhinoResult(
 
   return {
     outputAmount,
-    outputAmountFormatted: decimalFromBaseUnits(outputAmount, candidate.destinationToken.decimals),
     quality: {
       ...(response.estimatedDuration === undefined || response.estimatedDuration === null
         ? {}
@@ -704,10 +692,6 @@ function formatSquidResult(
   return {
     minimumOutputAmount: response.toAmountMin,
     outputAmount: response.toAmount,
-    outputAmountFormatted: decimalFromBaseUnits(
-      response.toAmount,
-      candidate.destinationToken.decimals,
-    ),
     quality: {
       estimatedSeconds: Math.ceil(response.estimatedRouteDuration),
       liquiditySource: 'providerQuote',
@@ -764,10 +748,6 @@ function formatSymbiosisResult(
   return {
     minimumOutputAmount: response.tokenAmountOutMin.amount,
     outputAmount: response.tokenAmountOut.amount,
-    outputAmountFormatted: decimalFromBaseUnits(
-      response.tokenAmountOut.amount,
-      candidate.destinationToken.decimals,
-    ),
     quality: {
       ...(response.estimatedTime === undefined
         ? {}
@@ -1005,13 +985,6 @@ function nonnegativeInteger(input: unknown) {
   return undefined
 }
 
-function decimalFromBaseUnits(baseUnits: string, decimals: number) {
-  const padded = baseUnits.padStart(decimals + 1, '0')
-  const whole = decimals === 0 ? padded : padded.slice(0, -decimals)
-  const fraction = decimals === 0 ? '' : padded.slice(-decimals).replace(/0+$/, '')
-  return fraction ? `${whole}.${fraction}` : whole
-}
-
 function baseUnitsFromDecimal(value: string, decimals: number) {
   if (!/^\d+(\.\d+)?$/.test(value)) return undefined
   const [whole, fraction = ''] = value.split('.')

package/src/apps/data/FxOracle.test.ts

@@ -1,7 +1,7 @@
 import * as FxOracle from './FxOracle.js'
 
 const set = {
-  asOf: '2026-01-01',
+  asOf: '2026-01-01T00:00:00.000Z',
   base: 'EUR',
   rates: { AUD: '1.6', USD: '1.25' },
 } satisfies FxOracle.RateSet
@@ -45,7 +45,7 @@ describe('ecb', () => {
     const rates = await FxOracle.ecb({ url: feedUrl('1.25') }).rates()
     expect(rates).toMatchInlineSnapshot(`
       {
-        "asOf": "2026-01-01",
+        "asOf": "2026-01-01T00:00:00.000Z",
         "base": "EUR",
         "rates": {
           "AUD": "1.6",

package/src/apps/data/FxOracle.ts

@@ -14,7 +14,7 @@ export type Oracle = {
 
 /** One oracle-published set of exchange rates quoted against a base currency. */
 export type RateSet = {
-  /** Publication date of the rate set (e.g. `2026-07-20`). */
+  /** Publication date of the rate set as an ISO 8601 timestamp. */
   asOf: string
   /** Currency the rates are quoted against (e.g. `EUR`). */
   base: string
@@ -88,7 +88,7 @@ export function ecb(options: ecb.Options = {}): Oracle {
         rates[code] = value
       }
       if (!asOf || rates['USD'] === undefined) throw new ParseError()
-      return { asOf, base: 'EUR', rates }
+      return { asOf: `${asOf}T00:00:00.000Z`, base: 'EUR', rates }
     },
   })
 }

package/src/apps/data/routes/activities.test.ts

@@ -12,7 +12,11 @@ import * as Activities from './activities.js'
 // Deterministic EUR-based rate set so conversion math is exact in assertions.
 const fixed = FxOracle.from({
   name: 'fixed',
-  rates: async () => ({ asOf: '2026-01-01', base: 'EUR', rates: { AUD: '1.6', USD: '1.0' } }),
+  rates: async () => ({
+    asOf: '2026-01-01T00:00:00.000Z',
+    base: 'EUR',
+    rates: { AUD: '1.6', USD: '1.0' },
+  }),
 })
 
 /**
@@ -312,7 +316,7 @@ describe('GET /addresses/:address/activities', () => {
       })
     expect(body.meta?.pricing).toMatchInlineSnapshot(`
       {
-        "asOf": "2026-01-01",
+        "asOf": "2026-01-01T00:00:00.000Z",
         "basis": "nominal",
         "source": "fixed",
       }

package/src/apps/data/routes/activities.ts

@@ -1,6 +1,7 @@
 import { Hono, type Context } from 'hono'
 import { Address, Hex } from 'ox'
 import { type Log, parseEventLogs, zeroAddress } from 'viem'
+import { token as viem_Token } from 'viem/actions'
 import { Abis, Addresses } from 'viem/tempo'
 import * as z from 'zod/mini'
 
@@ -28,6 +29,10 @@ const exampleHash = '0x4845ae2098724ab26a5d89370dce5124d044be6a5acc164afc348662d
 
 const tokenFields = ['token.logoUri', 'token.verified'] as const
 
+// TIP-20 tokens live at deterministic `0x20c0…` addresses. Other contracts
+// can emit the same `Transfer` signature but do not expose TIP-20 metadata.
+const tip20AddressPrefix = '0x20c0'
+
 /** Zod schemas owned by the activity handlers. */
 export namespace schema {
   /** A signer: the literal `self`, or the access-key address that signed. */
@@ -3982,6 +3987,39 @@ type ResolvedToken = {
   verified?: boolean | undefined
 }
 
+/** Resolves TIP-20 metadata or the standard ERC-20 subset used by activity transfers. */
+function getActivityTokenMetadata(
+  c: Context<App.Environment>,
+  options: getActivityTokenMetadata.Options,
+): Promise<Omit<ResolvedToken, 'verified'>> {
+  const { address, chainId } = options
+  if (address.startsWith(tip20AddressPrefix))
+    return Tokens.getTokenMetadata(c, { address, chainId })
+
+  return Store.memoize(
+    async () => {
+      const metadata = await viem_Token.getMetadata(c.get('getClient')(chainId), { token: address })
+      // ERC-20 has no currency field; its symbol is the amount's unit label.
+      return {
+        currency: metadata.symbol,
+        decimals: metadata.decimals,
+        name: metadata.name,
+        symbol: metadata.symbol,
+      }
+    },
+    { key: `token:erc20:v1:${chainId}:${address}:metadata`, store: c.get('store'), ttl: Ttl.minutes(1) }, // prettier-ignore
+  )
+}
+
+declare namespace getActivityTokenMetadata {
+  type Options = {
+    /** Token contract address. */
+    address: Address.Address
+    /** Source chain id. */
+    chainId: z.output<typeof Schema.ChainId>
+  }
+}
+
 /** Resolves core metadata into immutable items. Optional logo and verification sources are best-effort. */
 async function enrichTokens(
   c: Context<App.Environment>,
@@ -4018,7 +4056,7 @@ async function enrichTokens(
           includeLogoUri
             ? Tokens.getTokenLogo(c, { address, chainId }).catch(() => undefined)
             : undefined,
-          Tokens.getTokenMetadata(c, { address, chainId }),
+          getActivityTokenMetadata(c, { address, chainId }),
         ])
         return [
           address.toLowerCase(),

package/src/apps/data/routes/balances.test.ts

@@ -12,7 +12,11 @@ import * as Tokens from './tokens.js'
 // Deterministic EUR-based rate set so conversion math is exact in assertions.
 const fixed = FxOracle.from({
   name: 'fixed',
-  rates: async () => ({ asOf: '2026-01-01', base: 'EUR', rates: { AUD: '1.6', USD: '1.0' } }),
+  rates: async () => ({
+    asOf: '2026-01-01T00:00:00.000Z',
+    base: 'EUR',
+    rates: { AUD: '1.6', USD: '1.0' },
+  }),
 })
 
 // Verified enrichment is store-backed now that the build-time bundle is gone, so
@@ -381,7 +385,7 @@ describe('GET /addresses/:address/balances', () => {
     // Consulted rates surface their provenance response-wide.
     expect(body.meta?.pricing).toMatchInlineSnapshot(`
       {
-        "asOf": "2026-01-01",
+        "asOf": "2026-01-01T00:00:00.000Z",
         "basis": "nominal",
         "source": "fixed",
       }

package/src/apps/data/routes/exchanges.test.ts

@@ -33,7 +33,11 @@ type PairsResponse = z.output<typeof Exchanges.schema.getPairs.Response>
 // Deterministic EUR-based rate set so conversion math is exact in assertions.
 const fixed = FxOracle.from({
   name: 'fixed',
-  rates: async () => ({ asOf: '2026-01-01', base: 'EUR', rates: { AUD: '1.6', USD: '1.0' } }),
+  rates: async () => ({
+    asOf: '2026-01-01T00:00:00.000Z',
+    base: 'EUR',
+    rates: { AUD: '1.6', USD: '1.0' },
+  }),
 })
 
 type Client = ReturnType<typeof TestApp.client>
@@ -652,7 +656,7 @@ describe('GET /exchange/swaps', () => {
         })
       expect(body.meta?.pricing).toMatchInlineSnapshot(`
         {
-          "asOf": "2026-01-01",
+          "asOf": "2026-01-01T00:00:00.000Z",
           "basis": "nominal",
           "source": "fixed",
         }
@@ -1165,7 +1169,7 @@ describe('POST /exchange/quotes', () => {
       })
       expect(body.meta?.pricing).toMatchInlineSnapshot(`
         {
-          "asOf": "2026-01-01",
+          "asOf": "2026-01-01T00:00:00.000Z",
           "basis": "nominal",
           "source": "fixed",
         }