tapimo 0.7.0 → 0.7.2

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

@@ -55,7 +55,7 @@ const mpp = {
     getClient: () => Tempo.client,
     recipient: Tempo.accounts[2].address,
   },
-} satisfies NonNullable<TestApp.create.Options['mpp']>
+} satisfies NonNullable<Exclude<NonNullable<TestApp.create.Options['auth']>, false>['mpp']>
 
 describe('MPP session management', () => {
   test('keeps generated POST routes private', async () => {
@@ -72,7 +72,7 @@ describe('MPP session management', () => {
 
   test('matches GET scopes for static, parameterized, and hidden resources', async () => {
     const rateLimitStore = Store.memory()
-    const app = TestApp.create({ mpp, rateLimit: { store: rateLimitStore } })
+    const app = TestApp.create({ auth: { mpp }, rateLimit: { store: rateLimitStore } })
     await exhaustPublicQuota(rateLimitStore)
 
     for (const resource of [
@@ -106,7 +106,11 @@ describe('MPP session management', () => {
 
   test('preserves the mounted base path in session scope', async () => {
     const rateLimitStore = Store.memory()
-    const app = TestApp.create({ mpp, path: '/api', rateLimit: { store: rateLimitStore } })
+    const app = TestApp.create({
+      auth: { mpp },
+      path: '/api',
+      rateLimit: { store: rateLimitStore },
+    })
     await exhaustPublicQuota(rateLimitStore)
 
     const resource = new URL(
@@ -129,12 +133,12 @@ describe('MPP session management', () => {
   test('honors endpoint MPP overrides', async () => {
     const app = TestApp.create({
       auth: {
+        mpp,
         overrides: {
           'GET /v1/scopes': { mpp: true },
           'GET /v1/tokens/:token': { mpp: false },
         },
       },
-      mpp,
     })
     const enabled = await app.request('/v1/scopes', { method: 'POST' })
     const disabled = await app.request(`/v1/tokens/${TestApp.token}`, { method: 'POST' })
@@ -151,13 +155,13 @@ describe('zone chain gate', () => {
   /** A consumer-supplied zone chain id (the API never derives these). */
   const zone = 421_700_001
   /** A second zone, isolating per-zone grants. */
-  const zoneB = 421_700_002
+  const zoneB = 4_217_000_002
 
   function zoneOptions(chainId: number) {
-    return {
+    return TestApp.zone({
       chainId,
-      forwardRpcUrl: `https://${chainId}.rpc.test`,
-    }
+      rpcUrl: `https://${chainId}.rpc.test`,
+    })
   }
 
   /** Zone reader: holds the per-zone scope for `zone` (only). */
@@ -168,6 +172,14 @@ describe('zone chain gate', () => {
     token: 'secret_zone',
   } satisfies TestApp.kvStore.Key
 
+  /** Zone writer: broadcasts signed transactions and reads data for `zone`. */
+  const zoneWriter = {
+    id: 'key_zone_writer',
+    orgId: 'org_test',
+    scopes: ['data:read', `zone:${zone}:write`],
+    token: 'secret_zone_writer',
+  } satisfies TestApp.kvStore.Key
+
   /** Full-access key: the wildcard covers every zone. */
   const admin = {
     id: 'key_admin',
@@ -187,7 +199,7 @@ describe('zone chain gate', () => {
   /** A deployment serving two zones. */
   function zoneApp() {
     return TestApp.create({
-      auth: { keys: [admin, outsider, zoneReader] },
+      auth: { keys: [admin, outsider, zoneReader, zoneWriter] },
       zones: [zoneOptions(zone), zoneOptions(zoneB)],
     })
   }
@@ -249,6 +261,11 @@ describe('zone chain gate', () => {
     expect(response.status).toBe(200)
   })
 
+  test('a Zone write scope reads Zone data', async () => {
+    const response = await zoneApp().request(`/v1/tokenlist?chainId=${zone}`, as(zoneWriter))
+    expect(response.status).toBe(200)
+  })
+
   test('zone authorization applies to every data route', async () => {
     const app = TestApp.create({ auth: false, zones: [zoneOptions(zone)] })
     for (const path of [
@@ -370,6 +387,18 @@ describe('zone chain gate', () => {
   })
 
   test('public chains remain edge-cacheable on a Zone deployment', async () => {
+    const store = Store.memory()
+    const app = TestApp.create({ auth: false, cache: { store }, zones: [zoneOptions(zone)] })
+    const path = '/v1/funding/chains'
+
+    const first = await app.request(path)
+    const second = await app.request(path)
+    expect(first.status).toBe(200)
+    expect(second.status).toBe(200)
+    expect(second.headers.get('cache-control')).toContain('public')
+  })
+
+  test('serves anonymous token lists from the edge cache on public chains', async () => {
     const store = Store.memory()
     const app = TestApp.create({ auth: false, cache: { store }, zones: [zoneOptions(zone)] })
     const path = `/v1/tokenlist?chainId=${Viem.chainId.testnet}`

package/src/apps/data/App.ts

@@ -11,15 +11,18 @@ import * as Path from '../../internal/Path.js'
 import * as Response from '../../internal/Response.js'
 import * as Schema from '../../internal/Schema.js'
 import * as Tidx from '../../internal/Tidx.js'
+import * as Timing from '../../internal/Timing.js'
 import * as Viem from '../../internal/Viem.js'
 import * as Scope from '../../Scope.js'
 import * as Metadata from '../metadata.js'
+
 import type * as FxOracle from './FxOracle.js'
 
 import { transactions as transactionActivities } from './routes/activities.js'
 import { addresses } from './routes/addresses.js'
 import { blocks, blocksByTimestampCompat } from './routes/blocks.js'
 import { coingecko } from './routes/coingecko.js'
+import { earn } from './routes/earn.js'
 import { exchanges } from './routes/exchanges.js'
 import { feeAmm } from './routes/fee-amm.js'
 import { funding } from './routes/funding.js'
@@ -32,10 +35,11 @@ import { transactions } from './routes/transactions.js'
 import { transfers } from './routes/transfers.js'
 import { verifiedTokens } from './routes/verified-tokens.js'
 import { schema as webhookSchema, webhooks } from './routes/webhooks.js'
+import { zones } from './routes/zones.js'
 
 /**
- * The chain-data route group extends app context with TIDX, assets, zones,
- * verified tokens, and webhooks, and exposes indexed and RPC-backed reads.
+ * The chain-data route group extends app context with TIDX, assets, verified
+ * tokens, and webhooks, and exposes indexed and RPC-backed reads.
  *
  * ```ts
  * App.create(options).route('/', data())
@@ -43,6 +47,8 @@ import { schema as webhookSchema, webhooks } from './routes/webhooks.js'
  */
 export function data(options: data.Options = {}) {
   const { assets, tidx } = options
+  const configuredChainIds =
+    typeof tidx === 'function' ? [] : Viem.configuredChainIds(tidx?.baseUrl)
   const webhook =
     options.webhook === false
       ? undefined
@@ -50,11 +56,17 @@ export function data(options: data.Options = {}) {
           supportedChainIds: [Viem.chainId.mainnet, Viem.chainId.testnet],
         })
 
-  // Zone endpoints are explicit trust boundaries; the API never derives them.
-  const zones = new Map((options.zones ?? []).map((zone) => [zone.chainId, zone]))
   const dataRouteHandlers = new Set<unknown>()
 
   const getTidx = Tidx.createGetClient({ tidx })
+  const earn_routes = earn({ fx: options.fx })
+  const indexer_routes = indexer()
+  const indexerRouteHandlers = new Set(indexer_routes.routes.map((route) => route.handler))
+  const rpcOnlyRouteHandlers = new Set(
+    earn_routes.routes
+      .filter((route) => route.path === '/v1/earn/vaults/:vaultId/positions/:address')
+      .map((route) => route.handler),
+  )
 
   const app = new Hono<App.Environment>()
     // Publish the chain-data context vars for this group's handlers. Runs after
@@ -65,16 +77,26 @@ export function data(options: data.Options = {}) {
       const supportedChainIds = new Set<number>([
         ...c.get('supportedChainIds'),
         ...Object.keys(Tidx.url).map(Number),
-        ...zones.keys(),
+        ...configuredChainIds,
       ])
       c.set('getAsset', createGetAsset({ assets, basePath: c.get('basePath'), origin: new URL(c.req.url).origin })) // prettier-ignore
       c.set('getClient', (chainId) => getClient(chainId ?? c.get('chainId')))
-      c.set('getTidx', (chainId) => getTidx(chainId ?? c.get('chainId'), Auth.getPrincipal(c)))
+      c.set('getTidx', (chainId) => {
+        const resolved = chainId ?? c.get('chainId')
+        const client = getTidx(resolved, {
+          principal: Auth.getPrincipal(c),
+          zone: c.get('zones').get(resolved),
+        })
+        return Tidx.observe(client, {
+          record: (failure) =>
+            c.set('providerFailure', failure ? { ...failure, chainId: resolved } : undefined),
+          time: (fn) => Timing.time(c, 'tidx', fn),
+        })
+      })
       c.set('supportedChainIds', supportedChainIds)
       c.set('tidx', tidx)
       c.set('verifiedTokens', options.verifiedTokens === false ? undefined : (options.verifiedTokens ?? {})) // prettier-ignore
       c.set('webhook', webhook)
-      c.set('zones', zones)
       await next()
     })
     // Resolve one chain for every data route before auth and handlers use it.
@@ -85,6 +107,8 @@ export function data(options: data.Options = {}) {
         c,
         defaultChainId,
         handlers: dataRouteHandlers,
+        indexerHandlers: indexerRouteHandlers,
+        rpcOnlyHandlers: rpcOnlyRouteHandlers,
       })
       if (!selection.matched) return next()
       if (selection.conflict || selection.invalid)
@@ -93,19 +117,39 @@ export function data(options: data.Options = {}) {
           message: selection.conflict ? 'Conflicting chain ids' : 'Invalid chain id',
           status: 400,
         })
-      if (!supportedChainIds.has(selection.chainId))
-        return Response.unsupportedChainId(c, selection.chainId, supportedChainIds)
+      const principal = Auth.getPrincipal(c)
+      const rpc_config = c.get('rpc')
+      const tidx_config = c.get('tidx')
+      const zones = c.get('zones')
+      // Raw passthroughs and RPC-only reads need only RPC; composed data routes
+      // require both upstreams to avoid falling through to unrelated defaults.
+      const narrowedChainIds = new Set(
+        [...supportedChainIds].filter((chainId) => {
+          const context = { chainId, principal, zone: zones.get(chainId) }
+          const hasRpc = Viem.resolveRpc(rpc_config, context).url !== undefined
+          const hasTidx = Tidx.resolve(tidx_config, context).baseUrl !== undefined
+          if (selection.rpc || selection.rpcOnly) return hasRpc
+          if (selection.indexer) return hasTidx
+          return hasRpc && hasTidx
+        }),
+      )
+      c.set('supportedChainIds', narrowedChainIds)
+      if (!narrowedChainIds.has(selection.chainId))
+        return Response.unsupportedChainId(c, selection.chainId, narrowedChainIds)
       c.set('chainId', selection.chainId)
       return next()
     })
     // Zone data requires an issued scope. Raw RPC may instead forward the
     // caller's Zone token to the node that enforces account scoping.
     .use('*', async (c, next) => {
+      const zones = c.get('zones')
       if (zones.size === 0) return next()
       const selection = resolveChainSelector({
         c,
         defaultChainId: c.get('chainId'),
         handlers: dataRouteHandlers,
+        indexerHandlers: indexerRouteHandlers,
+        rpcOnlyHandlers: rpcOnlyRouteHandlers,
       })
       if (!selection.matched) return next()
       const chainId = c.get('chainId')
@@ -116,13 +160,14 @@ export function data(options: data.Options = {}) {
       const allowed =
         scopes?.includes(Scope.wildcard) ||
         scopes?.includes(`zone:${chainId}:read`) ||
+        scopes?.includes(`zone:${chainId}:write`) ||
         (selection.rpc && Boolean(c.req.header(ZoneRpcAuthentication.headerName)?.trim()))
       if (!allowed)
         return Response.error(c, {
           code: 'api_key_forbidden',
           message: selection.rpc
-            ? `Chain id ${chainId} is a zone. Use an API key granting \`zone:${chainId}:read\`, or pass a Zone token via \`X-Authorization-Token\`.`
-            : `Chain id ${chainId} is a zone. Use an API key granting \`zone:${chainId}:read\`.`,
+            ? `Chain id ${chainId} is a zone. Use an API key granting \`zone:${chainId}:read\` or \`zone:${chainId}:write\`, or pass a Zone token via \`X-Authorization-Token\`.`
+            : `Chain id ${chainId} is a zone. Use an API key granting \`zone:${chainId}:read\` or \`zone:${chainId}:write\`.`,
           status: 403,
         })
 
@@ -143,6 +188,8 @@ export function data(options: data.Options = {}) {
         c,
         defaultChainId: c.get('chainId'),
         handlers: dataRouteHandlers,
+        indexerHandlers: indexerRouteHandlers,
+        rpcOnlyHandlers: rpcOnlyRouteHandlers,
       })
       if (!selection.matched || !Viem.isMainnet(c.get('chainId'))) return next()
 
@@ -167,10 +214,11 @@ export function data(options: data.Options = {}) {
     })
     .route('/', addresses({ fx: options.fx }))
     .route('/', blocks())
+    .route('/', earn_routes)
     .route('/', exchanges({ fx: options.fx }))
     .route('/', feeAmm())
-    .route('/', funding(options.funding))
-    .route('/', indexer())
+    .route('/', funding())
+    .route('/', indexer_routes)
     .route('/', receipts({ fx: options.fx }))
     .route('/', tokenlist())
     .route('/', tokens())
@@ -179,6 +227,7 @@ export function data(options: data.Options = {}) {
     .route('/', transfers({ fx: options.fx }))
     .route('/', verifiedTokens())
     .route('/', webhooks({ enabled: options.webhook !== false }))
+    .route('/', zones())
     .route('/', rpc())
     .route('/', coingecko())
     .route('/', blocksByTimestampCompat())
@@ -187,22 +236,24 @@ export function data(options: data.Options = {}) {
       c,
       defaultChainId: c.get('chainId'),
       handlers: dataRouteHandlers,
+      indexerHandlers: indexerRouteHandlers,
+      rpcOnlyHandlers: rpcOnlyRouteHandlers,
     })
     return (
       selection.matched &&
       !selection.conflict &&
       !selection.invalid &&
-      !zones.has(selection.chainId)
+      !c.get('zones').has(selection.chainId)
     )
   }
   for (const route of app.routes) {
     if (route.method === 'ALL') continue
     dataRouteHandlers.add(route.handler)
-    if (zones.size > 0) EdgeCache.setEligibility(route.handler, edgeCacheEligible)
+    EdgeCache.setEligibility(route.handler, edgeCacheEligible)
   }
   return Metadata.attach(app, {
     ...openapi,
-    supportedChainIds: [...Object.keys(Tidx.url).map(Number), ...zones.keys()],
+    supportedChainIds: [...Object.keys(Tidx.url).map(Number), ...configuredChainIds],
   })
 }
 
@@ -211,8 +262,6 @@ export declare namespace data {
   type Options = {
     /** Static API asset store for the current runtime (e.g. `Assets.cloudflareR2(...)`). Omit to skip static assets — token logo URIs go unresolved. */
     assets?: Assets.Assets | undefined
-    /** Funding quote provider configuration. */
-    funding?: funding.Options | undefined
     /** FX configuration for the valuation endpoint. */
     fx?: Fx | undefined
     /** TIDX query client options. */
@@ -221,11 +270,6 @@ export declare namespace data {
     verifiedTokens?: VerifiedTokens | false | undefined
     /** Webhook feature configuration. Enabled by default (rows live in `db`); pass `false` to disable, leaving `/webhooks` mounted but returning `404` and hidden from the OpenAPI document. */
     webhook?: Webhook | false | undefined
-    /**
-     * Zone chains served by this deployment. REST and TIDX require a
-     * `zone:<chainId>:read` scope; raw RPC may forward a Zone token instead.
-     */
-    zones?: readonly Zone[] | undefined
   }
 
   /** FX configuration for the valuation endpoint. */
@@ -234,14 +278,6 @@ export declare namespace data {
     oracle?: FxOracle.Oracle | undefined
   }
 
-  /** One zone chain served by this deployment. */
-  type Zone = {
-    /** Zone chain id. Consumer-supplied literal; the API never derives zone chain ids. */
-    chainId: number
-    /** Zone RPC used when forwarding a caller-supplied Zone token. */
-    forwardRpcUrl: string
-  }
-
   /** Verified-token feature configuration. */
   type VerifiedTokens = {
     /**
@@ -260,13 +296,19 @@ function resolveChainSelector(options: {
   c: Context<App.Environment>
   defaultChainId: Viem.ChainId
   handlers: ReadonlySet<unknown>
+  indexerHandlers: ReadonlySet<unknown>
+  rpcOnlyHandlers: ReadonlySet<unknown>
 }) {
   let matched = false
   let path: string | undefined
   let rpc = false
+  let rpcOnly = false
+  let indexer = false
   for (const route of matchedRoutes(options.c)) {
     if (!options.handlers.has(route.handler)) continue
     matched = true
+    if (options.indexerHandlers.has(route.handler)) indexer = true
+    if (options.rpcOnlyHandlers.has(route.handler)) rpcOnly = true
     const selector = pathChainSelector(route.path, options.c.req.path)
     if (selector.name === undefined) continue
     path = selector.value
@@ -278,9 +320,11 @@ function resolveChainSelector(options: {
     return {
       chainId: options.defaultChainId,
       conflict: false,
+      indexer: false,
       invalid: false,
       matched: false,
       rpc: false,
+      rpcOnly: false,
     }
 
   const search = new URL(options.c.req.url).searchParams
@@ -294,9 +338,11 @@ function resolveChainSelector(options: {
   return {
     chainId: chainIds[0] ?? options.defaultChainId,
     conflict: chainIds.length > 1,
+    indexer,
     invalid: parsed.some((result) => !result.success),
     matched: true,
     rpc,
+    rpcOnly,
   }
 }
 
@@ -326,14 +372,19 @@ const openapi = {
     { name: 'Activities', description: 'A readable feed of what an account did onchain.' },
     { name: 'Balances', description: 'How much of each token an account holds.' },
     { name: 'Blocks', description: 'The ordered batches of transactions making up the chain.' },
+    { name: 'Earn', description: 'Vaults that earn yield from assets deposited on Tempo.' },
     { name: 'Exchange', description: "Tempo's built-in stablecoin exchange: pairs, swaps, orders, prices." }, // prettier-ignore
     { name: 'Fee AMM', description: 'Pools that convert stablecoins to pay fees.' },
-    { name: 'Funding', description: 'Live quotes and supported inputs for funding Tempo.' },
+    {
+      name: 'Funding',
+      description: 'Quote, transfer, and deposit management for funding Tempo from other chains.',
+    },
     { name: 'Tokens', description: 'TIP-20 token details, supply, and holders.' },
     { name: 'Transactions', description: 'Transactions submitted to Tempo, and their receipts.' },
     { name: 'Transfers', description: 'Token movements from executing transactions.' },
     { name: 'Verified Tokens', description: 'A curated, trusted list of TIP-20 tokens.' },
     { name: 'Webhooks', description: 'Get signed callbacks when onchain events happen.' },
+    { name: 'Zones', description: 'Private chain operations anchored to Tempo.' },
     { name: 'Indexer', description: "Run read-only SQL queries against Tempo's indexed data." },
     { name: 'RPC', description: 'Direct access to the chain over Ethereum JSON-RPC. Not part of the stable API contract; best-effort support only. No compatibility, latency, availability, or data-freshness guarantees. Breaking changes may happen with limited notice.' }, // prettier-ignore
     { name: 'CoinGecko', description: "Exchange data in CoinGecko's GeckoTerminal format." },
@@ -345,6 +396,7 @@ const openapi = {
         'Activities',
         'Balances',
         'Blocks',
+        'Earn',
         'Exchange',
         'Fee AMM',
         'Funding',
@@ -353,6 +405,7 @@ const openapi = {
         'Transfers',
         'Verified Tokens',
         'Webhooks',
+        'Zones',
         'Indexer',
         'RPC',
         'MCP',
@@ -415,7 +468,7 @@ function webhooksBlock() {
 function createGetAsset(options: createGetAsset.Options): App.GetAsset {
   const { assets, basePath, origin } = options
   if (!assets) return () => undefined
-  return async (chainId, path) => {
+  const getAsset: App.GetAsset = async (chainId, path) => {
     const pathname = Path.join(basePath, 'assets', String(chainId), path)
     // `path` may be absolute (`Path.join` returns a leading slash); strip it so
     // the key is `:chainId/:path`, not `:chainId//:path`.
@@ -429,6 +482,16 @@ function createGetAsset(options: createGetAsset.Options): App.GetAsset {
       uri: new URL(pathname, origin).toString(),
     }
   }
+  const list = assets.list
+  if (list)
+    getAsset.list = async (chainId, path) => {
+      const prefix = `${chainId}/${path.replace(/^\/+/, '')}`
+      return (await list(prefix)).map((key) => ({
+        key,
+        uri: new URL(Path.join(basePath, 'assets', key), origin).toString(),
+      }))
+    }
+  return getAsset
 }
 
 declare namespace createGetAsset {

package/src/apps/data/FxOracle.ts

@@ -4,7 +4,7 @@ import * as Ttl from '../../internal/Ttl.js'
 
 /** A pluggable fiat FX rate oracle consumed by the valuation endpoint. */
 export type Oracle = {
-  /** Oracle identifier, surfaced as the valuation's `pricing.source` (e.g. `ecb`). */
+  /** Oracle identifier, surfaced as valuation rate provenance (e.g. `ecb`). */
   name: string
   /** Fetches the oracle's current rate set. */
   rates: () => Promise<RateSet>

package/src/apps/data/index.ts

@@ -1,4 +1,3 @@
 export { data } from './App.js'
-export * as FundingQuoteProviders from './FundingQuoteProviders.js'
 export * as FxOracle from './FxOracle.js'
 export * as Sponsorships from '../relay/Sponsorships.js'

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

@@ -1,13 +1,18 @@
+/** @module-tag localnet */
+
 import { Address, Hex, Value as core_Value } from 'ox'
 import { FxOracle } from 'tapimo/apps'
-import { encodeAbiParameters, encodeEventTopics } from 'viem'
-import { Abis } from 'viem/tempo'
+import { createClient, encodeAbiParameters, encodeEventTopics, http } from 'viem'
+import { sendTransactionSync } from 'viem/actions'
+import { Abis, Actions, Addresses } from 'viem/tempo'
 
 import * as TestApp from '../../../../test/App.js'
 import * as Runtime from '../../../../test/runtime.js'
+import * as Tempo from '../../../../test/Tempo.js'
 import * as Cursor from '../../../internal/Cursor.js'
 import * as Store from '../../../internal/Store.js'
 import * as Activities from './activities.js'
+import * as Transactions from './transactions.js'
 
 // Deterministic EUR-based rate set so conversion math is exact in assertions.
 const fixed = FxOracle.from({
@@ -297,7 +302,7 @@ describe('GET /addresses/:address/activities', () => {
     const hash = runtime.fixtures!.faucetTransactionHashes[0]!
 
     const response = await client.v1.transactions[':transactionHash'].activities.$get(
-      { param: { transactionHash: hash }, query: { denomination: 'AUD' } },
+      { param: { transactionHash: hash }, query: { 'valuation.currency': 'AUD' } },
       TestApp.auth,
     )
     const body = await TestApp.json(response, Activities.schema.getTransactionActivities.Response)
@@ -314,7 +319,7 @@ describe('GET /addresses/:address/activities', () => {
         amount: core_Value.format((BigInt(amount.baseUnits) * 16n) / 10n, 6),
         currency: 'AUD',
       })
-    expect(body.meta?.pricing).toMatchInlineSnapshot(`
+    expect(body.meta?.valuation).toMatchInlineSnapshot(`
       {
         "asOf": "2026-01-01T00:00:00.000Z",
         "basis": "nominal",
@@ -330,15 +335,86 @@ describe('GET /addresses/:address/activities', () => {
 
   test('paginates with an opaque cursor', async () => {
     const first = await activities(accounts.keychain, { limit: '5' })
+    expect(first.nextCursor).toBeTypeOf('string')
     if (!first.nextCursor) return
     const response = await request(accounts.keychain, { limit: '5', cursor: first.nextCursor })
     expect(response.headers.get('cache-control')).toMatchInlineSnapshot(
       `"private, max-age=60, stale-while-revalidate=300"`,
     )
     const second = await TestApp.json(response, Activities.schema.getAddressActivities.Response)
-    expect(Array.isArray(second.data)).toBe(true)
+    const firstHashes = new Set(
+      first.data.flatMap((entry) =>
+        entry.type === 'group'
+          ? entry.data.items.map((item) => item.transactionHash)
+          : [entry.transactionHash],
+      ),
+    )
+    const secondHashes = second.data.flatMap((entry) =>
+      entry.type === 'group'
+        ? entry.data.items.map((item) => item.transactionHash)
+        : [entry.transactionHash],
+    )
+    expect(secondHashes.every((hash) => !firstHashes.has(hash))).toBe(true)
   })
 
+  test.skipIf(runtime.mode !== 'localnet')(
+    'keeps older activity behind a high-log transaction',
+    async () => {
+      const account = Tempo.accounts[3]
+      const wallet = createClient({
+        account,
+        chain: Tempo.chain,
+        transport: http(Tempo.rpcUrl),
+      })
+      await Actions.faucet.fundSync(Tempo.client, { account, timeout: 60_000 })
+      const approval_result = await Actions.token.approveSync(wallet, {
+        amount: 1n,
+        spender: Addresses.stablecoinDex,
+        token: Addresses.pathUsd,
+      })
+      const approval = 'receipt' in approval_result ? approval_result.receipt : approval_result
+      const highLog = await sendTransactionSync(wallet, {
+        account,
+        calls: Array.from({ length: 25 }, (_, index) =>
+          Actions.token.approve.call(wallet, {
+            amount: BigInt(index + 2),
+            spender: Addresses.stablecoinDex,
+            token: Addresses.pathUsd,
+          }),
+        ),
+      })
+      // The legacy `limit * 4` joined-row window stopped inside this transaction
+      // and never exposed the older approval to the activity paginator.
+      expect(highLog.logs.length).toBeGreaterThan(20)
+
+      const pending = new Set(
+        [approval.transactionHash, highLog.transactionHash].map((hash) => hash.toLowerCase()),
+      )
+      const deadline = Date.now() + 60_000
+      while (Date.now() < deadline && pending.size > 0) {
+        const response = await client.v1.transactions.$get(
+          { query: { limit: '200', sender: account.address } },
+          { headers: { 'cache-control': 'no-store', ...TestApp.auth.headers } },
+        )
+        if (response.status === 200) {
+          const body = await TestApp.json(response, Transactions.schema.getTransactions.Response)
+          for (const transaction of body.data) pending.delete(transaction.hash.toLowerCase())
+        }
+        if (pending.size > 0) await new Promise((resolve) => setTimeout(resolve, 250))
+      }
+      expect(pending).toEqual(new Set())
+
+      const body = await activities(account.address, { limit: '5' })
+      expect(
+        body.data.some(
+          (entry) =>
+            entry.type === 'approval' && entry.transactionHash === approval.transactionHash,
+        ),
+      ).toBe(true)
+    },
+    120_000,
+  )
+
   test('validates denominations on empty feeds', async () => {
     const client = TestApp.client({ fx: { oracle: fixed } })
     const cursor = Cursor.encode([0, 0])
@@ -353,7 +429,7 @@ describe('GET /addresses/:address/activities', () => {
     const response = await client.v1.addresses[':address'].activities.$get(
       {
         param: { address: accounts.keychain },
-        query: { cursor, denomination: 'JPY', limit: '5' },
+        query: { cursor, limit: '5', 'valuation.currency': 'JPY' },
       },
       TestApp.auth,
     )