tapimo 0.6.0 → 0.7.1

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

@@ -9,6 +9,7 @@ import type * as Log from '../../../internal/Log.js'
 import * as OpenApi from '../../../internal/OpenApi.js'
 import * as Response from '../../../internal/Response.js'
 import * as Schema from '../../../internal/Schema.js'
+import * as Value from '../../../internal/Value.js'
 import * as FundingQuoteProviders from '../FundingQuoteProviders.js'
 
 /** Zod schemas owned by funding quote resources. */
@@ -58,6 +59,12 @@ export namespace schema {
           z.describe('Contract address, mint, or issuer address on the token chain.'),
           z.meta({ examples: ['0x833589fcd6edb6e08f4c7c32d4f71b54bda02913'] }),
         ),
+      currency: z
+        .string()
+        .check(
+          z.describe('Monetary denomination represented by this token.'),
+          z.meta({ examples: ['USD'] }),
+        ),
       decimals: z
         .number()
         .check(
@@ -97,22 +104,10 @@ export namespace schema {
     'A normalized token reference for funding quotes.',
   )
 
-  /** Source amount echoed by a funding quote response. */
+  /** Self-contained source or destination amount in a funding quote. */
   export const TokenAmount = Schema.describe(
-    z.object({
-      amount: Schema.DecimalString.check(
-        z.describe("The requested source amount in the token's smallest unit."),
-      ),
-      formatted: z
-        .string()
-        .check(
-          z.describe(
-            'The same amount in human-readable decimal form, using the source token’s `decimals`.',
-          ),
-          z.meta({ examples: ['1'] }),
-        ),
-    }),
-    'The requested source amount in provider-safe base units and display form.',
+    Schema.TokenAmount,
+    'A funding amount in base units and human-readable form.',
   )
 
   /** Provider summary embedded in a funding quote. */
@@ -171,7 +166,7 @@ export namespace schema {
     'Machine-readable liquidity, fee, and source signals for a successful quote.',
   )
 
-  /** Provider-derived output, limits, and freshness data. */
+  /** Provider quote freshness data. */
   export const QuoteDetails = Schema.describe(
     z.object({
       expiresAt: z
@@ -180,31 +175,6 @@ export namespace schema {
           z.describe('Timestamp after which the provider quote is no longer valid.'),
           z.meta({ examples: ['2026-01-01T00:01:00Z'] }),
         ),
-      inputAmount: Schema.DecimalString.check(
-        z.describe('Source amount sent to the provider in base units.'),
-        z.meta({ examples: ['1000000'] }),
-      ),
-      minimumOutputAmount: z
-        .optional(Schema.DecimalString)
-        .check(
-          z.describe(
-            'Provider-derived minimum destination amount in base units. Symbiosis and Squid quotes use a fixed 1% slippage tolerance.',
-          ),
-          z.meta({ examples: ['988000'] }),
-        ),
-      outputAmount: z
-        .string()
-        .check(z.regex(/^\d+$/))
-        .check(
-          z.describe('Expected destination amount in base units.'),
-          z.meta({ examples: ['989102'] }),
-        ),
-      outputAmountFormatted: z
-        .string()
-        .check(
-          z.describe('Expected destination amount rendered with destination token decimals.'),
-          z.meta({ examples: ['0.989102'] }),
-        ),
       sampledAt: z.iso
         .datetime()
         .check(
@@ -212,12 +182,20 @@ export namespace schema {
           z.meta({ examples: ['2026-01-01T00:00:00Z'] }),
         ),
     }),
-    'Provider-derived output, limits, and freshness data for a funding quote.',
+    'Freshness data for a provider funding quote.',
   )
 
   /** Successful live funding quote. */
   export const FundingQuote = Schema.describe(
     z.object({
+      destinationAmount: TokenAmount.check(z.describe('Expected destination amount.')),
+      destinationAmountMin: z
+        .optional(TokenAmount)
+        .check(
+          z.describe(
+            'Provider-derived minimum destination amount. Symbiosis and Squid quotes use a fixed 1% slippage tolerance.',
+          ),
+        ),
       destinationChain: Chain.check(z.describe('Destination chain, always Tempo mainnet in V1.')),
       destinationToken: Token.check(z.describe('Tempo token expected from this quote.')),
       id: z
@@ -377,7 +355,20 @@ const fundingQuoteResponseExample = (() => {
   return {
     data: [
       {
-        ...candidate,
+        destinationAmount: Value.tokenAmount({
+          baseUnits: '979295',
+          currency: candidate.destinationToken.currency,
+          decimals: candidate.destinationToken.decimals,
+        }),
+        destinationAmountMin: Value.tokenAmount({
+          baseUnits: '939242',
+          currency: candidate.destinationToken.currency,
+          decimals: candidate.destinationToken.decimals,
+        }),
+        destinationChain: candidate.destinationChain,
+        destinationToken: candidate.destinationToken,
+        id: candidate.id,
+        provider: candidate.provider,
         quality: {
           estimatedSeconds: 1,
           liquiditySource: 'providerQuote',
@@ -385,12 +376,15 @@ const fundingQuoteResponseExample = (() => {
           tier: 'liquid',
         },
         quote: {
-          inputAmount: '1000000',
-          minimumOutputAmount: '939242',
-          outputAmount: '979295',
-          outputAmountFormatted: '0.979295',
           sampledAt: '2026-01-01T00:00:00.000Z',
         },
+        sourceAmount: Value.tokenAmount({
+          baseUnits: candidate.sourceAmount.amount,
+          currency: candidate.sourceToken.currency,
+          decimals: candidate.sourceToken.decimals,
+        }),
+        sourceChain: candidate.sourceChain,
+        sourceToken: candidate.sourceToken,
       },
     ],
   }
@@ -508,7 +502,7 @@ export function funding(options: funding.Options = {}) {
       }),
       Cache.response<App.Environment>({
         cacheControl: Cache.policies.stable,
-        name: 'tempo-api:funding-chains:v1',
+        name: 'tempo-api:funding-chains:v2',
         key: (c) => c.req.url,
       }),
       (c) => {

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

@@ -11,7 +11,11 @@ import * as Receipts from './receipts.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' },
+  }),
 })
 
 /** The decoded `type` names a humanized receipt may report. */
@@ -217,7 +221,7 @@ describe('GET /transactions/receipts', () => {
     })
     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/tokenlist.test.ts

@@ -75,4 +75,19 @@ describe('GET /tokenlist', () => {
     expect(body.tokens).toEqual([])
     expect(body.version.patch).toBe(0)
   })
+
+  test('refreshes cached reads after a snapshot publish', async () => {
+    const db = TestApp.database()
+    await VerifiedTokens.replace(db, chainId, seedList)
+    const client = TestApp.client({ auth: { keys: [reader] }, db })
+
+    await client.v1.tokenlist.$get({ query: {} }, as(reader))
+    await VerifiedTokens.replace(db, chainId, seedList.slice(1))
+
+    const response = await client.v1.tokenlist.$get({ query: {} }, as(reader))
+    const body = await TestApp.json(response, Tokenlist.schema.getTokenList.Response)
+    expect(body.tokens.map((token) => token.address)).toEqual(
+      seedList.slice(1).map((token) => token.address),
+    )
+  })
 })

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

@@ -4,6 +4,7 @@ import * as z from 'zod/mini'
 import type * as App from '../../../App.js'
 import * as Auth from '../../../internal/Auth.js'
 import * as Cache from '../../../internal/Cache.js'
+import * as EdgeCache from '../../../internal/EdgeCache.js'
 import * as OpenApi from '../../../internal/OpenApi.js'
 import * as Response from '../../../internal/Response.js'
 import * as Schema from '../../../internal/Schema.js'
@@ -159,11 +160,23 @@ export function tokenlist() {
       summary: 'Get token list',
       tags: ['Verified Tokens'],
     }),
-    Cache.response<App.Environment>({
-      cacheControl: Cache.policies.stable,
-      name: 'tempo-api:tokenlist:v1',
-      key: (c) => Cache.urlKey(c, schema.getTokenList.Query),
-    }),
+    // The shared edge cache is URL-keyed and cannot include the snapshot version.
+    EdgeCache.setEligibility(
+      Cache.response<App.Environment>({
+        cacheControl: Cache.policies.stable,
+        name: 'tempo-api:tokenlist:v1',
+        key: async (c) => {
+          const base = Cache.urlKey(c, schema.getTokenList.Query)
+          const query = schema.getTokenList.Query.parse(
+            Object.fromEntries(new URL(c.req.url).searchParams),
+          )
+          const chainId = query.chainId ?? c.get('chainId')
+          const { version } = await VerifiedTokens.snapshot(c, chainId)
+          return `${base}:v:${version}`
+        },
+      }),
+      () => false,
+    ),
     async (c) => {
       if (Auth.narrowAccess) return Auth.paidAccessError(c)
       if (OpenApi.narrowValidation)

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

@@ -1214,7 +1214,7 @@ declare namespace getTokenMetadata {
 
 /**
  * Resolves a token's curated R2 icon URI, memoized per `(chainId, address)`
- * so page enrichers (balances, holders, transfers `include=token`) don't
+ * so page enrichers (balances, holders, transfers `include=token.logoUri`) don't
  * re-fetch the asset per row on every request. Misses are memoized as `null`
  * too — most tokens have no curated icon, and the negative lookup is exactly
  * what page enrichment would otherwise repeat N times per page.
@@ -1821,6 +1821,8 @@ export async function getTokenCreatedAtByAddress(
   try {
     const result = await tidx.fetch({
       chainId: options.chainId,
+      // TODO: Remove the explicit engine after TIDX 1.0 is released.
+      engine: 'clickhouse',
       query: `
         SELECT token, block_timestamp
         FROM tokencreated
@@ -1916,6 +1918,8 @@ async function getTokenCreatedByAddress(
     // needs no event signature for the `logs` table.
     const result = await tidx.fetch({
       chainId: options.chainId,
+      // TODO: Remove the explicit engine after TIDX 1.0 is released.
+      engine: 'clickhouse',
       query: `
         SELECT topic1, data, block_timestamp
         FROM logs

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

@@ -10,10 +10,28 @@ import * as Transfers from './transfers.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' },
+  }),
 })
 
 describe('GET /transfers', () => {
+  test('parses granular token includes', () => {
+    expect(
+      Transfers.schema.getTransfers.Query.parse({
+        include: 'token.logoUri,token.verified',
+      }).include,
+    ).toMatchInlineSnapshot(`
+      [
+        "token.logoUri",
+        "token.verified",
+      ]
+    `)
+    expect(Transfers.schema.getTransfers.Query.safeParse({ include: 'token' }).success).toBe(false)
+  })
+
   test('degrades unavailable verification data to null valuations', async () => {
     const db = () =>
       Db.postgres({
@@ -29,7 +47,7 @@ describe('GET /transfers', () => {
 
     expect(response.status).toBe(200)
     expect(body.data.length).toBeGreaterThan(0)
-    for (const entry of body.data) expect(entry.sourceToken.valuation).toBeNull()
+    for (const entry of body.data) expect(entry.sourceAmount.valuation).toBeNull()
 
     const emptyResponse = await client.v1.transfers.$get(
       { query: { limit: '5', token: `0x${'11'.repeat(20)}` } },
@@ -57,7 +75,7 @@ describe('GET /transfers', () => {
     expect(unsupported.error.code).toBe('query_invalid')
   })
 
-  test('returns an unscoped transfer page, embedding tokens on demand', async () => {
+  test('returns an unscoped transfer page with token metadata', async () => {
     const client = TestApp.client()
     const baseResponse = await client.v1.transfers.$get({ query: { limit: '5' } }, TestApp.auth)
     const base = await TestApp.json(baseResponse, Transfers.schema.getTransfers.Response)
@@ -74,7 +92,14 @@ describe('GET /transfers', () => {
       base.data.every(
         (entry) =>
           /^0x[0-9a-f]{40}$/.test(entry.sourceToken.address) &&
-          /^\d+$/.test(entry.sourceToken.amount) &&
+          /^\d+$/.test(entry.sourceAmount.baseUnits) &&
+          typeof entry.sourceAmount.currency === 'string' &&
+          Number.isInteger(entry.sourceAmount.decimals) &&
+          typeof entry.sourceAmount.formatted === 'string' &&
+          typeof entry.sourceToken.currency === 'string' &&
+          Number.isInteger(entry.sourceToken.decimals) &&
+          typeof entry.sourceToken.name === 'string' &&
+          typeof entry.sourceToken.symbol === 'string' &&
           Number.isInteger(entry.blockNumber) &&
           /^0x[0-9a-f]{40}$/.test(entry.sender) &&
           /^0x[0-9a-f]{40}$/.test(entry.recipient) &&
@@ -85,28 +110,35 @@ describe('GET /transfers', () => {
     // Transfers default to newest-first (descending block number).
     const blocks = base.data.map((entry) => entry.blockNumber)
     expect(blocks.every((block, index) => index === 0 || blocks[index - 1]! >= block)).toBe(true)
-    // Token metadata is opt-in: the base page's `sourceToken` carries only
-    // `address`/`amount`, with no metadata fields spread in.
-    expect(base.data.every((entry) => entry.sourceToken.symbol === undefined)).toBe(true)
+    // Quantities live beside the token reference; curated fields remain opt-in.
+    expect(
+      base.data.every(
+        (entry) =>
+          !('amount' in entry.sourceToken) &&
+          !('valuation' in entry.sourceToken) &&
+          entry.sourceToken.logoUri === undefined &&
+          entry.sourceToken.verified === undefined,
+      ),
+    ).toBe(true)
 
     const includedResponse = await client.v1.transfers.$get(
-      { query: { limit: '5', include: 'token' } },
+      { query: { limit: '5', include: 'token.logoUri,token.verified' } },
       TestApp.auth,
     )
     const included = await TestApp.json(includedResponse, Transfers.schema.getTransfers.Response)
 
     expect(includedResponse.status).toBe(200)
-    // Each `sourceToken` keeps its `address`/`amount`; when metadata resolves
-    // it is spread alongside. Resolution is best-effort, so a row whose
-    // metadata is unavailable simply omits the metadata fields.
+    // Curated fields remain optional without moving quantities back into the token.
     expect(
       included.data.every(
         (entry) =>
           /^0x[0-9a-f]{40}$/.test(entry.sourceToken.address) &&
-          /^\d+$/.test(entry.sourceToken.amount) &&
-          (entry.sourceToken.symbol === undefined ||
-            (typeof entry.sourceToken.symbol === 'string' &&
-              Number.isInteger(entry.sourceToken.decimals))),
+          /^\d+$/.test(entry.sourceAmount.baseUnits) &&
+          !('amount' in entry.sourceToken) &&
+          !('valuation' in entry.sourceToken) &&
+          typeof entry.sourceToken.symbol === 'string' &&
+          Number.isInteger(entry.sourceToken.decimals) &&
+          typeof entry.sourceToken.verified === 'boolean',
       ),
     ).toBe(true)
   })
@@ -125,24 +157,156 @@ describe('GET /transfers', () => {
 
   test('narrows transfers by address (either side)', async () => {
     const client = TestApp.client()
-    // Seed a real account from a recent transfer.
-    const seedResponse = await client.v1.transfers.$get({ query: { limit: '5' } }, TestApp.auth)
-    const seed = await TestApp.json(seedResponse, Transfers.schema.getTransfers.Response)
-    expect(seedResponse.status).toBe(200)
-    const account = seed.data[0]!.sender
-    expect(account).toMatch(/^0x[0-9a-f]{40}$/)
-
-    const filteredResponse = await client.v1.transfers.$get(
-      { query: { limit: '5', address: account } },
+    const runtime = Runtime.get()
+    const address = Schema.Address.parse(
+      runtime.mode === 'testnet'
+        ? '0xb1f382bd6deed37895528a6387bae4cd9569ac3c'
+        : runtime.fixtures!.fundedAccounts[0]!,
+    )
+    const response = await client.v1.transfers.$get(
+      { query: { address, include: 'totalCount', limit: '10' } },
       TestApp.auth,
     )
-    const filtered = await TestApp.json(filteredResponse, Transfers.schema.getTransfers.Response)
-    expect(filteredResponse.status).toBe(200)
+    const body = await TestApp.json(response, Transfers.schema.getTransfers.Response)
+
+    expect(response.status).toBe(200)
     expect(
-      filtered.data.every((entry) => entry.sender === account || entry.recipient === account),
+      body.data.every((entry) => entry.sender === address || entry.recipient === address),
     ).toBe(true)
+    expect(body.meta!.totalCount).toBeGreaterThanOrEqual(body.data.length)
+    expect(body.meta!.totalCountCapped).toBe(body.meta!.totalCount! >= Schema.countCap)
   })
 
+  test.runIf(Runtime.get().mode === 'testnet')(
+    'merges both address sides before paginating',
+    async () => {
+      const client = TestApp.client()
+      const address = '0xabb0023644c54a20d0fe92becfa764dacaf59ba9'
+      const toBlock = '27608730'
+      const [senderResponse, recipientResponse, addressResponse] = await Promise.all([
+        client.v1.transfers.$get(
+          {
+            query: { 'blockNumber.to': toBlock, limit: '10', order: 'desc', sender: address },
+          },
+          TestApp.auth,
+        ),
+        client.v1.transfers.$get(
+          {
+            query: { 'blockNumber.to': toBlock, limit: '10', order: 'desc', recipient: address },
+          },
+          TestApp.auth,
+        ),
+        client.v1.transfers.$get(
+          {
+            query: { address, 'blockNumber.to': toBlock, limit: '10', order: 'desc' },
+          },
+          TestApp.auth,
+        ),
+      ])
+      const sender = await TestApp.json(senderResponse, Transfers.schema.getTransfers.Response)
+      const recipient = await TestApp.json(
+        recipientResponse,
+        Transfers.schema.getTransfers.Response,
+      )
+      const combined = await TestApp.json(addressResponse, Transfers.schema.getTransfers.Response)
+
+      expect([senderResponse.status, recipientResponse.status, addressResponse.status]).toEqual([
+        200, 200, 200,
+      ])
+      const seen = new Set<string>()
+      const expected = [...sender.data, ...recipient.data]
+        .sort((a, b) => b.blockNumber - a.blockNumber || b.logIndex - a.logIndex)
+        .filter((entry) => {
+          if (seen.has(entry.id)) return false
+          seen.add(entry.id)
+          return true
+        })
+        .slice(0, 10)
+      expect(expected).toHaveLength(10)
+      expect(combined.data.map(({ id }) => id)).toEqual(expected.map(({ id }) => id))
+
+      const firstResponse = await client.v1.transfers.$get(
+        {
+          query: { address, 'blockNumber.to': toBlock, limit: '5', order: 'desc' },
+        },
+        TestApp.auth,
+      )
+      const first = await TestApp.json(firstResponse, Transfers.schema.getTransfers.Response)
+      expect(firstResponse.status).toBe(200)
+      expect(first.nextCursor).not.toBeNull()
+      if (!first.nextCursor) return
+
+      const [cursorResponse, positionalResponse] = await Promise.all([
+        client.v1.transfers.$get(
+          {
+            query: {
+              address,
+              'blockNumber.to': toBlock,
+              cursor: first.nextCursor,
+              limit: '5',
+              order: 'desc',
+            },
+          },
+          TestApp.auth,
+        ),
+        client.v1.transfers.$get(
+          {
+            query: {
+              address,
+              'blockNumber.to': toBlock,
+              limit: '5',
+              order: 'desc',
+              page: '2',
+            },
+          },
+          TestApp.auth,
+        ),
+      ])
+      const cursor = await TestApp.json(cursorResponse, Transfers.schema.getTransfers.Response)
+      const positional = await TestApp.json(
+        positionalResponse,
+        Transfers.schema.getTransfers.Response,
+      )
+      const expectedSecondPage = expected.slice(5, 10).map(({ id }) => id)
+
+      expect([cursorResponse.status, positionalResponse.status]).toEqual([200, 200])
+      expect([...first.data, ...cursor.data].map(({ id }) => id)).toEqual(
+        expected.map(({ id }) => id),
+      )
+      expect(positional.data.map(({ id }) => id)).toEqual(expectedSecondPage)
+    },
+  )
+
+  test.runIf(Runtime.get().mode === 'testnet')(
+    'deduplicates self-transfers in address pages and counts',
+    async () => {
+      const client = TestApp.client()
+      const address = '0xabb0023644c54a20d0fe92becfa764dacaf59ba9'
+      const transactionHash = '0x915a11bcf4b5e667c631f9fb09ac8729f3b436f24eb0b552e54ec13a490ef57f'
+      const response = await client.v1.transfers.$get(
+        {
+          query: {
+            address,
+            'blockNumber.from': '27608730',
+            'blockNumber.to': '27608730',
+            include: 'totalCount',
+            limit: '50',
+            token: '0x20c0000000000000000000000000000000000003',
+          },
+        },
+        TestApp.auth,
+      )
+      const body = await TestApp.json(response, Transfers.schema.getTransfers.Response)
+
+      expect(response.status).toBe(200)
+      expect(body.data.filter(({ id }) => id === `${transactionHash}-233`)).toHaveLength(1)
+      expect(body.meta).toMatchObject({
+        totalCount: body.data.length,
+        totalCountCapped: false,
+      })
+    },
+  )
+
   test('narrows transfers by sender and recipient independently', async () => {
     const client = TestApp.client()
     const seedResponse = await client.v1.transfers.$get({ query: { limit: '5' } }, TestApp.auth)
@@ -208,7 +372,7 @@ describe('GET /transfers', () => {
     // `(txHash, blockNumber)` shortcut is not unique here.
     type Entry = z.output<typeof Transfers.schema.getTransfers.Transfer>
     const keyOf = (entry: Entry) =>
-      `${entry.blockNumber}:${entry.transactionHash}:${entry.sourceToken.address}:${entry.sender}:${entry.recipient}:${entry.sourceToken.amount}`
+      `${entry.blockNumber}:${entry.transactionHash}:${entry.sourceToken.address}:${entry.sender}:${entry.recipient}:${entry.sourceAmount.baseUnits}`
     const firstKeys = new Set(first.data.map(keyOf))
     expect(second.data.every((entry) => !firstKeys.has(keyOf(entry)))).toBe(true)
   })
@@ -256,7 +420,7 @@ describe('GET /transfers', () => {
 
     type Entry = z.output<typeof Transfers.schema.getTransfers.Transfer>
     const keyOf = (entry: Entry) =>
-      `${entry.blockNumber}:${entry.transactionHash}:${entry.sourceToken.address}:${entry.sender}:${entry.recipient}:${entry.sourceToken.amount}`
+      `${entry.blockNumber}:${entry.transactionHash}:${entry.sourceToken.address}:${entry.sender}:${entry.recipient}:${entry.sourceAmount.baseUnits}`
     expect(page.data.map(keyOf)).toEqual(head.data.slice(5, 10).map(keyOf))
     // Offset pages still return a keyset cursor so clients can switch to deep
     // cursor traversal from a positional jump.
@@ -408,6 +572,10 @@ describe('GET /transfers', () => {
       expect(transfer.recipient).toBe(crossToken.recipient)
       expect(transfer.sourceToken.address).toBe(crossToken.sourceToken)
       expect(transfer.destinationToken?.address).toBe(crossToken.destinationToken)
+      expect(transfer.sourceAmount.baseUnits).toMatch(/^\d+$/)
+      expect(transfer.destinationAmount?.baseUnits).toMatch(/^\d+$/)
+      expect('amount' in transfer.sourceToken).toBe(false)
+      expect('amount' in transfer.destinationToken!).toBe(false)
 
       // Without `include=crossToken`, the transaction stays as its raw per-log
       // legs (more than one row) and no row carries `destinationToken`.
@@ -494,8 +662,8 @@ describe('GET /transfers', () => {
     expect(response.status).toBe(200)
     expect(body.data.length).toBeGreaterThan(0)
     for (const entry of body.data)
-      expect(entry.sourceToken.valuation).toEqual({
-        amount: core_Value.format(BigInt(entry.sourceToken.amount), 6),
+      expect(entry.sourceAmount.valuation).toEqual({
+        amount: core_Value.format(BigInt(entry.sourceAmount.baseUnits), 6),
         currency: 'USD',
       })
     expect(body.meta?.pricing).toBeUndefined()
@@ -517,13 +685,13 @@ describe('GET /transfers', () => {
     expect(body.data.length).toBeGreaterThan(0)
     // USD -> AUD at the fixed 1.6 cross rate, floored to 6 dp.
     for (const entry of body.data)
-      expect(entry.sourceToken.valuation).toEqual({
-        amount: core_Value.format((BigInt(entry.sourceToken.amount) * 16n) / 10n, 6),
+      expect(entry.sourceAmount.valuation).toEqual({
+        amount: core_Value.format((BigInt(entry.sourceAmount.baseUnits) * 16n) / 10n, 6),
         currency: 'AUD',
       })
     expect(body.meta?.pricing).toMatchInlineSnapshot(`
       {
-        "asOf": "2026-01-01",
+        "asOf": "2026-01-01T00:00:00.000Z",
         "basis": "nominal",
         "source": "fixed",
       }
@@ -560,7 +728,7 @@ describe('GET /transfers', () => {
 
       expect(response.status).toBe(200)
       expect(body.data.length).toBeGreaterThan(0)
-      for (const entry of body.data) expect(entry.sourceToken.valuation).toBeNull()
+      for (const entry of body.data) expect(entry.sourceAmount.valuation).toBeNull()
     },
   )