tapimo 0.9.0 → 0.10.1

package/src/analytics/Analytics.test.ts

@@ -184,6 +184,14 @@ describe('migrations', () => {
     for (const column of Object.keys(row)) expect(sql).toContain(column)
     expect(sql).toContain('timings Map(String, Float64)')
   })
+
+  test('the migrations declare query benchmark history', () => {
+    const sql = Analytics.migrations.map((migration) => migration.sql).join('\n')
+    expect(sql).toContain('CREATE TABLE IF NOT EXISTS query_benchmark_results')
+    expect(sql).toContain('ORDER BY (chain_id, query, metric, timestamp, run_id)')
+    expect(sql).toContain('rpc_url String')
+    expect(sql).toContain('tidx_url String')
+  })
 })
 
 describe('get', () => {

package/src/analytics/Analytics.ts

@@ -192,6 +192,32 @@ export const migrations: readonly Migration[] = [
         ADD COLUMN IF NOT EXISTS timings Map(String, Float64)
     `,
   },
+  {
+    name: '0005_query_benchmark_results',
+    sql: `
+      CREATE TABLE IF NOT EXISTS query_benchmark_results (
+        timestamp DateTime64(3, 'UTC'),
+        run_id String,
+        repository LowCardinality(String),
+        git_sha String,
+        git_ref LowCardinality(String),
+        chain_id UInt32,
+        chain LowCardinality(String),
+        query String,
+        metric LowCardinality(String),
+        mean_ms Float64,
+        min_ms Float64,
+        max_ms Float64,
+        samples UInt16,
+        tidx_queries Array(String),
+        rpc_url String,
+        tidx_url String
+      )
+      ENGINE = ReplacingMergeTree
+      PARTITION BY toYYYYMM(timestamp)
+      ORDER BY (chain_id, query, metric, timestamp, run_id)
+    `,
+  },
 ]
 
 /**

package/src/apps/Zones.test.ts

@@ -5,16 +5,34 @@ describe('chains', () => {
     expect(Zones.chains).toMatchObject([
       {
         contracts: {
-          messenger: { address: '0x254356112cCf6f32fAd84F16CC5E0A0cCA17Beb7' },
-          portal: { address: '0x59831A17340EE14FE136d751EfbeA8b630470fD2' },
+          messenger: { address: '0x2fB7Aba18510622cd88F5f45B3AC0E7Dd70606a5' },
+          portal: { address: '0x5765e8B9003054e479df44D12D3dEeaADEfa8b7c' },
+          verifier: { address: '0xfa16b9C6A356a096F0e7ceF0135C393A81d4a355' },
         },
-        id: 421_700_001,
+        id: 1_424_310_001,
+        name: 'zone-moderato-internal',
         rpcUrls: {
-          default: { http: ['https://rpc-zone-e.testnet.tempo.xyz'] },
-          internal: { http: ['https://rpc-zone-e.testnet.tempo.xyz'] },
+          default: { http: ['https://zone-internal-rpc.testnet.tempo.xyz'] },
+          internal: { http: ['https://zone-internal-rpc.testnet.tempo.xyz'] },
+          tidx: { http: ['https://indexer-zone-internal.testnet.tempo.xyz'] },
         },
         sourceId: 42_431,
       },
+      {
+        contracts: {
+          messenger: { address: '0x171699d2B5211414C23E5Cd306d05046b78FdD16' },
+          portal: { address: '0xe5208b9604972CA6a2E1EF656a9d2bDF2e530B9A' },
+          verifier: { address: '0x3E7C1cC9C049052eb061116A4Ee7a7C281fa1F30' },
+        },
+        id: 421_700_001,
+        name: 'zone-mainnet-internal',
+        rpcUrls: {
+          default: { http: ['https://zone-internal-rpc.tempo.xyz'] },
+          internal: { http: ['https://zone-internal-rpc.tempo.xyz'] },
+          tidx: { http: ['https://indexer-zone-internal.tempo.xyz'] },
+        },
+        sourceId: 4_217,
+      },
       {
         contracts: {
           messenger: { address: '0x5A4d000000000000000000000000000000000000' },

package/src/apps/Zones.ts

@@ -1,23 +1,44 @@
 import { defineChain } from 'viem'
-import { tempoDevnet, tempoTestnet } from 'viem/tempo/chains'
+import { tempo, tempoDevnet, tempoTestnet } from 'viem/tempo/chains'
 
-/** Zone E on Tempo testnet. */
-export const zoneE = defineChain({
+/** Internal Moderato Zone on Tempo testnet. */
+export const zoneModeratoInternal = defineChain({
   ...tempoTestnet,
   contracts: {
     ...tempoTestnet.contracts,
-    messenger: { address: '0x254356112cCf6f32fAd84F16CC5E0A0cCA17Beb7' },
-    portal: { address: '0x59831A17340EE14FE136d751EfbeA8b630470fD2' },
+    messenger: { address: '0x2fB7Aba18510622cd88F5f45B3AC0E7Dd70606a5' },
+    portal: { address: '0x5765e8B9003054e479df44D12D3dEeaADEfa8b7c' },
+    verifier: { address: '0xfa16b9C6A356a096F0e7ceF0135C393A81d4a355' },
   },
-  id: 421_700_001,
-  name: 'zone-e',
+  id: 1_424_310_001,
+  name: 'zone-moderato-internal',
   rpcUrls: {
-    default: { http: ['https://rpc-zone-e.testnet.tempo.xyz'] },
-    internal: { http: ['https://rpc-zone-e.testnet.tempo.xyz'] },
+    default: { http: ['https://zone-internal-rpc.testnet.tempo.xyz'] },
+    internal: { http: ['https://zone-internal-rpc.testnet.tempo.xyz'] },
+    tidx: { http: ['https://indexer-zone-internal.testnet.tempo.xyz'] },
   },
   sourceId: tempoTestnet.id,
 })
 
+/** Internal Zone on Tempo mainnet. */
+export const zoneMainnetInternal = defineChain({
+  ...tempo,
+  contracts: {
+    ...tempo.contracts,
+    messenger: { address: '0x171699d2B5211414C23E5Cd306d05046b78FdD16' },
+    portal: { address: '0xe5208b9604972CA6a2E1EF656a9d2bDF2e530B9A' },
+    verifier: { address: '0x3E7C1cC9C049052eb061116A4Ee7a7C281fa1F30' },
+  },
+  id: 421_700_001,
+  name: 'zone-mainnet-internal',
+  rpcUrls: {
+    default: { http: ['https://zone-internal-rpc.tempo.xyz'] },
+    internal: { http: ['https://zone-internal-rpc.tempo.xyz'] },
+    tidx: { http: ['https://indexer-zone-internal.tempo.xyz'] },
+  },
+  sourceId: tempo.id,
+})
+
 /** Stable hosted Zone on Tempo devnet. */
 export const zoneStable = defineChain({
   ...tempoDevnet,
@@ -37,4 +58,4 @@ export const zoneStable = defineChain({
 })
 
 /** Hosted Zone chains served by the API and admin. */
-export const chains = [zoneE, zoneStable] as const
+export const chains = [zoneModeratoInternal, zoneMainnetInternal, zoneStable] as const

package/src/apps/composition.test.ts

@@ -197,6 +197,7 @@ describe('data()', () => {
           42431,
           421700001,
           421700006,
+          1424310001,
         ],
       }
     `)

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

@@ -436,8 +436,8 @@ describe('sandbox chain guard', () => {
 })
 
 async function exhaustPublicQuota(store: Store.Store) {
-  const limit = { perMinute: 60 }
+  const limit = { limit: 60, period: 'minute' } satisfies RateLimit.Limit
   const rateLimit = RateLimit.memory({ store })
-  for (let index = 0; index < limit.perMinute; index++)
+  for (let index = 0; index < limit.limit; index++)
     await rateLimit.consume({ key: 'public:anonymous', limit })
 }

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

@@ -41,6 +41,24 @@ describe('from', () => {
 })
 
 describe('ecb', () => {
+  test('caches the daily feed for one day', () => {
+    expect(FxOracle.ecb({ url: feedUrl('1.25') }).ttl).toMatchInlineSnapshot(`86400000`)
+  })
+
+  test('rotates the cache key after the daily publication window', () => {
+    vi.useFakeTimers()
+    try {
+      const oracle = FxOracle.ecb({ url: feedUrl('1.25') })
+
+      vi.setSystemTime('2026-01-02T15:59:00.000Z')
+      expect(oracle.cacheKey?.()).toMatchInlineSnapshot(`"ecb:2026-01-01"`)
+      vi.setSystemTime('2026-01-02T16:00:00.000Z')
+      expect(oracle.cacheKey?.()).toMatchInlineSnapshot(`"ecb:2026-01-02"`)
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
   test('fetches and parses the daily reference rates', async () => {
     const rates = await FxOracle.ecb({ url: feedUrl('1.25') }).rates()
     expect(rates).toMatchInlineSnapshot(`

package/src/apps/data/FxOracle.ts

@@ -4,6 +4,8 @@ import * as Ttl from '../../internal/Ttl.js'
 
 /** A pluggable fiat FX rate oracle consumed by the valuation endpoint. */
 export type Oracle = {
+  /** Returns the cache-key suffix for the oracle's current publication window. */
+  cacheKey?: (() => string) | undefined
   /** Oracle identifier, surfaced as valuation rate provenance (e.g. `ecb`). */
   name: string
   /** Fetches the oracle's current rate set. */
@@ -34,6 +36,7 @@ export const ecbUrl = 'https://www.ecb.europa.eu/stats/eurofxref/eurofxref-daily
  */
 export function from(oracle: from.Value): Oracle {
   return {
+    ...(oracle.cacheKey ? { cacheKey: oracle.cacheKey } : {}),
     name: oracle.name,
     rates: async () => {
       try {
@@ -48,19 +51,17 @@ export function from(oracle: from.Value): Oracle {
 
 export declare namespace from {
   /** Oracle definition accepted by {@link from}. */
-  type Value = Pick<Oracle, 'name' | 'rates'> & {
+  type Value = Pick<Oracle, 'cacheKey' | 'name' | 'rates'> & {
     /** Cache lifetime for a fetched rate set, in milliseconds. @default `Ttl.hours(1)` */
     ttl?: number | undefined
   }
 }
 
-/**
- * European Central Bank euro reference rates: one EUR-based set covering ~30
- * currencies, published once per working day.
- */
+/** European Central Bank reference rates, cached for one day to match their publication cadence. */
 export function ecb(options: ecb.Options = {}): Oracle {
   const { fetch = globalThis.fetch, url = ecbUrl } = options
   return from({
+    cacheKey: () => `ecb:${ecbPublication(new Date())}`,
     name: 'ecb',
     rates: async () => {
       const response = await fetch(url, {
@@ -90,9 +91,31 @@ export function ecb(options: ecb.Options = {}): Oracle {
       if (!asOf || rates['USD'] === undefined) throw new ParseError()
       return { asOf: `${asOf}T00:00:00.000Z`, base: 'EUR', rates }
     },
+    ttl: Ttl.days(1),
   })
 }
 
+const ecbTime = new Intl.DateTimeFormat('en-CA', {
+  day: '2-digit',
+  hour: '2-digit',
+  hourCycle: 'h23',
+  month: '2-digit',
+  timeZone: 'Europe/Brussels',
+  year: 'numeric',
+})
+
+function ecbPublication(now: Date) {
+  const parts = Object.fromEntries(
+    ecbTime.formatToParts(now).map((part) => [part.type, part.value]),
+  )
+  // Rotate one hour after the ECB's usual 16:00 CET publication time.
+  const date = Number(parts['hour']) >= 17 ? now : new Date(now.getTime() - Ttl.days(1))
+  const publication = Object.fromEntries(
+    ecbTime.formatToParts(date).map((part) => [part.type, part.value]),
+  )
+  return `${publication['year']}-${publication['month']}-${publication['day']}`
+}
+
 export declare namespace ecb {
   /** Options for the ECB oracle. */
   type Options = {

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

@@ -0,0 +1,41 @@
+import * as QueryBench from '../../../../test/QueryBench.js'
+
+const fixtures = {
+  4217: {
+    address: '0xc24357119432595a547cb2c1e41c51d753645519',
+    transactionHash: '0x7f98e4b2bf4d1444b257526f7dd294ac3480d73cd91f723bf0df6062d1ba1c82',
+  },
+  42431: {
+    address: '0x15496d3123afb2cfadc0ac068eadd11d0f8ae799',
+    transactionHash: '0x1c8ccebb169f863b72388cc057fcecee240032eb7d2c64aa6f6fb8e5a60d3f9a',
+  },
+} as const
+
+QueryBench.bench({
+  name: 'getAddressActivities',
+  path: {
+    4217: `/v1/addresses/${fixtures[4217].address}/activities`,
+    42431: `/v1/addresses/${fixtures[42431].address}/activities`,
+  },
+  queries: [
+    'group=true',
+    'include=token.logoUri',
+    'include=token.verified',
+    'logs=true',
+    'valuation.currency=USD',
+  ],
+})
+
+QueryBench.bench({
+  name: 'getTransactionActivities',
+  path: {
+    4217: `/v1/transactions/${fixtures[4217].transactionHash}/activities`,
+    42431: `/v1/transactions/${fixtures[42431].transactionHash}/activities`,
+  },
+  queries: [
+    'include=token.logoUri',
+    'include=token.verified',
+    'logs=true',
+    'valuation.currency=USD',
+  ],
+})

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

@@ -328,6 +328,25 @@ describe('GET /addresses/:address/activities', () => {
     `)
   })
 
+  test.skipIf(runtime.mode !== 'localnet')('omits activity valuations by default', async () => {
+    const response = await client.v1.transactions[':transactionHash'].activities.$get(
+      {
+        param: { transactionHash: runtime.fixtures!.faucetTransactionHashes[0]! },
+        query: {},
+      },
+      TestApp.auth,
+    )
+    const body = await TestApp.json(response, Activities.schema.getTransactionActivities.Response)
+    expect(response.status).toBe(200)
+
+    const amounts = body.data.flatMap((item) =>
+      item.type === 'transfer' || item.type === 'mint' ? [item.data.sourceAmount] : [],
+    )
+    expect(amounts.length).toBeGreaterThan(0)
+    for (const amount of amounts) expect('valuation' in amount).toBe(false)
+    expect(response.headers.get('server-timing')).not.toContain('valuation_rates;dur=')
+  })
+
   test('returns every item at the root by default (no group entries)', async () => {
     const body = await activities(accounts.channel)
     expect(body.data.every((entry) => entry.type !== 'group')).toBe(true)
@@ -680,11 +699,12 @@ describe('Activities.list precompile classification', () => {
     logIdx: number
   }): Activities.Row {
     type Param = { indexed?: boolean; name?: string; type: string }
-    const event = Abis.abis.find((a) => a.type === 'event' && a.name === options.eventName) as {
+    const abi = [...Abis.abis, ...Abis.earnRouter, ...Abis.earnVault]
+    const event = abi.find((a) => a.type === 'event' && a.name === options.eventName) as {
       inputs: readonly Param[]
     }
     const topics = encodeEventTopics({
-      abi: Abis.abis,
+      abi,
       eventName: options.eventName as never,
       args: options.args as never,
     }) as (string | null)[]
@@ -732,6 +752,106 @@ describe('Activities.list precompile classification', () => {
     return items
   }
 
+  test('classifies every Earn vault and private-router event', async () => {
+    const requestId = `0x${'c'.repeat(64)}` as Hex.Hex
+    const cases = [
+      ['Deposited', { assets: 100n, caller: viewer, earnShares: 90n, receiver: viewer }],
+      [
+        'VenueSharesDeposited',
+        {
+          caller: viewer,
+          earnShares: 90n,
+          receivedEngineShares: 95n,
+          receiver: viewer,
+          requestedVenueShares: 100n,
+        },
+      ],
+      ['Redeemed', { assets: 100n, caller: viewer, earnShares: 90n, receiver: viewer }],
+      ['WithdrewExact', { assets: 100n, caller: viewer, earnSharesBurned: 90n, receiver: viewer }],
+      ['RedeemRequested', { earnShares: 90n, receiver: viewer, requestId, requester: viewer }],
+      [
+        'RedeemFinalized',
+        { asset: tokenA, assets: 100n, earnShares: 90n, receiver: viewer, requestId },
+      ],
+      ['RedeemCancelled', { earnShares: 90n, receiver: viewer, requestId }],
+      [
+        'EarnDeposit',
+        {
+          actionId: requestId,
+          earnShares: 90n,
+          earnVault: tokenA,
+          inputAmount: 100n,
+          inputToken: tokenA,
+          vaultAssets: 100n,
+          zoneDepositHash: requestId,
+        },
+      ],
+      [
+        'EarnRedeem',
+        {
+          actionId: requestId,
+          earnShares: 90n,
+          earnVault: tokenA,
+          outputAmount: 100n,
+          outputToken: tokenA,
+          vaultAssets: 100n,
+          zoneDepositHash: requestId,
+        },
+      ],
+    ] as const
+
+    const types = []
+    for (const [eventName, args] of cases) {
+      const items = await classify([logRow({ address: tokenA, args, eventName, logIdx: 0 })])
+      types.push(items[0]?.type)
+    }
+
+    expect(types).toMatchInlineSnapshot(`
+      [
+        "assets-deposited",
+        "shares-deposited",
+        "shares-redeemed",
+        "assets-withdrawn",
+        "shares-redemption-requested",
+        "shares-redemption-finalized",
+        "shares-redemption-cancelled",
+        "private-assets-deposited",
+        "private-shares-redeemed",
+      ]
+    `)
+  })
+
+  test('prefers a private Earn event over its underlying vault event', async () => {
+    const actionId = `0x${'c'.repeat(64)}` as Hex.Hex
+    const items = await classify([
+      logRow({
+        address: tokenA,
+        args: { assets: 100n, caller: viewer, earnShares: 90n, receiver: viewer },
+        eventName: 'Deposited',
+        logIdx: 0,
+      }),
+      logRow({
+        address: tokenA,
+        args: {
+          actionId,
+          earnShares: 90n,
+          earnVault: tokenA,
+          inputAmount: 100n,
+          inputToken: tokenA,
+          vaultAssets: 100n,
+          zoneDepositHash: actionId,
+        },
+        eventName: 'EarnDeposit',
+        logIdx: 1,
+      }),
+    ])
+    expect(items.map((item) => item.type)).toMatchInlineSnapshot(`
+      [
+        "private-assets-deposited",
+      ]
+    `)
+  })
+
   test('classifies ChannelOpened as `channel-opened` with the deposit token', async () => {
     const items = await classify([
       logRow({