tapimo 0.10.0 → 0.10.2

package/src/analytics/Analytics.test.ts

@@ -5,10 +5,12 @@ import * as RequestEvents from './tables/requestEvents.js'
 const context = { enabled: true, environment: 'test', service: 'api' }
 
 const entry = {
+  chainId: 4217,
   duration: 12.3,
   level: 'info',
   method: 'GET',
   path: '/v1/transactions',
+  query: 'include=receipt&limit=10',
   requestId: 'req-1',
   route: '/v1/transactions',
   status: 200,
@@ -25,6 +27,7 @@ const clickHouse = {
 /** Baseline stored row for insert/queue tests. */
 const row = {
   billing_active: null,
+  chain_id: 4217,
   duration_ms: 12.3,
   environment: 'test',
   error_code: null,
@@ -34,6 +37,7 @@ const row = {
   org_id: null,
   project_id: null,
   principal_type: 'unknown',
+  query: 'include=receipt&limit=10',
   rate_limit_scope: null,
   request_id: 'req-1',
   route: '/v1/transactions',
@@ -183,6 +187,31 @@ describe('migrations', () => {
     const sql = Analytics.migrations.map((migration) => migration.sql).join('\n')
     for (const column of Object.keys(row)) expect(sql).toContain(column)
     expect(sql).toContain('timings Map(String, Float64)')
+    expect(sql).toContain('query String')
+  })
+
+  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')
+  })
+
+  test('the migrations declare the endpoint latency view', () => {
+    const sql = Analytics.migrations.map((migration) => migration.sql).join('\n')
+    const latest = Analytics.migrations[Analytics.migrations.length - 1]!
+    expect(sql).toContain('CREATE OR REPLACE VIEW endpoint_latency_results')
+    expect(sql).toContain("'production' AS source")
+    expect(sql).toContain("'benchmark' AS source")
+    expect(sql).toContain("if(result.metric = 'benchmark', 'request', result.metric) AS metric")
+    expect(sql).toContain("if(status >= 200 AND status < 300, 'success', 'error') AS outcome")
+    expect(sql).toContain("WHERE result.metric != 'request'")
+    expect(sql).toContain('arrayZip(mapKeys(timings), mapValues(timings))')
+    expect(latest.name).toBe('0011_endpoint_latency_query')
+    expect(latest.sql).toContain("environment = 'production' AND service = 'cadent-api'")
+    expect(latest.sql).toContain("coalesce(request_id, '') AS request_id")
+    expect(latest.sql).toContain('query AS variant')
   })
 })
 
@@ -205,6 +234,7 @@ describe('createQueueSink', () => {
     const row = send.mock.calls[0]![0]
     expect({
       billing_active: row.billing_active,
+      chain_id: row.chain_id,
       duration_ms: row.duration_ms,
       environment: row.environment,
       error_code: row.error_code,
@@ -214,6 +244,7 @@ describe('createQueueSink', () => {
       org_id: row.org_id,
       principal_type: row.principal_type,
       project_id: row.project_id,
+      query: row.query,
       rate_limit_scope: row.rate_limit_scope,
       request_id: row.request_id,
       route: row.route,
@@ -227,6 +258,7 @@ describe('createQueueSink', () => {
     }).toMatchInlineSnapshot(`
       {
         "billing_active": null,
+        "chain_id": 4217,
         "duration_ms": 12.3,
         "environment": "test",
         "error_code": null,
@@ -236,6 +268,7 @@ describe('createQueueSink', () => {
         "org_id": null,
         "principal_type": "unknown",
         "project_id": null,
+        "query": "include=receipt&limit=10",
         "rate_limit_scope": null,
         "request_id": "req-1",
         "route": "/v1/transactions",
@@ -262,6 +295,15 @@ describe('createQueueSink', () => {
     expect(send.mock.calls[0]![0].timings).toMatchInlineSnapshot(`{}`)
   })
 
+  test('stores an empty query when the request has no query string', async () => {
+    const send = vi.fn<(message: Analytics.Event) => Promise<void>>().mockResolvedValue(undefined)
+    const sink = Analytics.createQueueSink({ send })(context)
+
+    await sink({ ...entry, query: undefined })
+
+    expect(send.mock.calls[0]![0].query).toMatchInlineSnapshot(`""`)
+  })
+
   test('retries a failed send once with the same row', async () => {
     const send = vi
       .fn<(message: Analytics.Event) => Promise<void>>()

package/src/analytics/Analytics.ts

@@ -120,6 +120,7 @@ export const migrations: readonly Migration[] = [
         timestamp DateTime64(3, 'UTC'),
         service LowCardinality(String),
         environment LowCardinality(String),
+        chain_id Nullable(UInt32),
         method LowCardinality(String),
         route LowCardinality(String),
         status UInt16,
@@ -129,6 +130,7 @@ export const migrations: readonly Migration[] = [
         key_environment Nullable(String),
         org_id Nullable(String),
         project_id Nullable(String),
+        query String,
         rate_limit_scope Nullable(String),
         error_code Nullable(String),
         rpc_error_code Nullable(Int32),
@@ -192,6 +194,236 @@ 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),
+        method LowCardinality(String),
+        route 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)
+    `,
+  },
+  {
+    name: '0006_endpoint_latency_dimensions',
+    // Patches production while fresh preview tables skip the unavailable ALTER.
+    guard: `
+      SELECT toUInt8(count() = 1) FROM system.columns
+      WHERE database = currentDatabase()
+        AND table = 'request_events'
+        AND name = 'chain_id'
+    `,
+    sql: `
+      ALTER TABLE request_events
+        ADD COLUMN IF NOT EXISTS chain_id Nullable(UInt32) AFTER environment
+    `,
+  },
+  {
+    name: '0007_query_benchmark_dimensions',
+    // Patches production while fresh preview tables skip the unavailable ALTER.
+    guard: `
+      SELECT toUInt8(count() = 2) FROM system.columns
+      WHERE database = currentDatabase()
+        AND table = 'query_benchmark_results'
+        AND name IN ('method', 'route')
+    `,
+    sql: `
+      ALTER TABLE query_benchmark_results
+        ADD COLUMN IF NOT EXISTS method LowCardinality(String) AFTER chain,
+        ADD COLUMN IF NOT EXISTS route LowCardinality(String) AFTER method
+    `,
+  },
+  {
+    name: '0008_endpoint_latency_results',
+    sql: `
+      CREATE OR REPLACE VIEW endpoint_latency_results AS
+      SELECT
+        timestamp,
+        'production' AS source,
+        chain_id,
+        method,
+        route AS endpoint,
+        '' AS variant,
+        toNullable(status) AS status,
+        if(status >= 200 AND status < 300, 'success', 'error') AS outcome,
+        measurement.1 AS metric,
+        measurement.2 AS mean_ms,
+        measurement.2 AS min_ms,
+        measurement.2 AS max_ms,
+        toUInt64(1) AS samples,
+        '' AS run_id,
+        '' AS git_sha
+      FROM request_events
+      ARRAY JOIN arrayConcat(
+        [('request', duration_ms)],
+        arrayFilter(
+          measurement -> measurement.1 != 'request',
+          arrayZip(mapKeys(timings), mapValues(timings))
+        )
+      ) AS measurement
+      WHERE environment = 'production' AND service = 'api'
+
+      UNION ALL
+
+      SELECT
+        timestamp,
+        'benchmark' AS source,
+        toNullable(chain_id) AS chain_id,
+        method,
+        if(route = '', query, route) AS endpoint,
+        query AS variant,
+        CAST(NULL, 'Nullable(UInt16)') AS status,
+        'success' AS outcome,
+        if(result.metric = 'benchmark', 'request', result.metric) AS metric,
+        mean_ms,
+        min_ms,
+        max_ms,
+        toUInt64(samples) AS samples,
+        run_id,
+        git_sha
+      FROM query_benchmark_results AS result
+      WHERE result.metric != 'request'
+    `,
+  },
+  {
+    name: '0009_endpoint_latency_production_service',
+    sql: `
+      CREATE OR REPLACE VIEW endpoint_latency_results AS
+      SELECT
+        timestamp,
+        'production' AS source,
+        chain_id,
+        method,
+        route AS endpoint,
+        '' AS variant,
+        toNullable(status) AS status,
+        if(status >= 200 AND status < 300, 'success', 'error') AS outcome,
+        measurement.1 AS metric,
+        measurement.2 AS mean_ms,
+        measurement.2 AS min_ms,
+        measurement.2 AS max_ms,
+        toUInt64(1) AS samples,
+        '' AS run_id,
+        '' AS git_sha
+      FROM request_events
+      ARRAY JOIN arrayConcat(
+        [('request', duration_ms)],
+        arrayFilter(
+          measurement -> measurement.1 != 'request',
+          arrayZip(mapKeys(timings), mapValues(timings))
+        )
+      ) AS measurement
+      WHERE environment = 'production' AND service = 'cadent-api'
+
+      UNION ALL
+
+      SELECT
+        timestamp,
+        'benchmark' AS source,
+        toNullable(chain_id) AS chain_id,
+        method,
+        if(route = '', query, route) AS endpoint,
+        query AS variant,
+        CAST(NULL, 'Nullable(UInt16)') AS status,
+        'success' AS outcome,
+        if(result.metric = 'benchmark', 'request', result.metric) AS metric,
+        mean_ms,
+        min_ms,
+        max_ms,
+        toUInt64(samples) AS samples,
+        run_id,
+        git_sha
+      FROM query_benchmark_results AS result
+      WHERE result.metric != 'request'
+    `,
+  },
+  {
+    name: '0010_request_events_query',
+    // Patches tables created before redacted request queries entered the baseline.
+    // Fresh tables skip this ALTER, allowing scoped preview users to migrate.
+    guard: `
+      SELECT toUInt8(count() = 1) FROM system.columns
+      WHERE database = currentDatabase()
+        AND table = 'request_events'
+        AND name = 'query'
+    `,
+    sql: `
+      ALTER TABLE request_events
+        ADD COLUMN IF NOT EXISTS query String AFTER project_id
+    `,
+  },
+  {
+    name: '0011_endpoint_latency_query',
+    sql: `
+      CREATE OR REPLACE VIEW endpoint_latency_results AS
+      SELECT
+        timestamp,
+        'production' AS source,
+        chain_id,
+        method,
+        route AS endpoint,
+        query AS variant,
+        toNullable(status) AS status,
+        if(status >= 200 AND status < 300, 'success', 'error') AS outcome,
+        measurement.1 AS metric,
+        measurement.2 AS mean_ms,
+        measurement.2 AS min_ms,
+        measurement.2 AS max_ms,
+        toUInt64(1) AS samples,
+        coalesce(request_id, '') AS request_id,
+        '' AS run_id,
+        '' AS git_sha
+      FROM request_events
+      ARRAY JOIN arrayConcat(
+        [('request', duration_ms)],
+        arrayFilter(
+          measurement -> measurement.1 != 'request',
+          arrayZip(mapKeys(timings), mapValues(timings))
+        )
+      ) AS measurement
+      WHERE environment = 'production' AND service = 'cadent-api'
+
+      UNION ALL
+
+      SELECT
+        timestamp,
+        'benchmark' AS source,
+        toNullable(chain_id) AS chain_id,
+        method,
+        if(route = '', query, route) AS endpoint,
+        query AS variant,
+        CAST(NULL, 'Nullable(UInt16)') AS status,
+        'success' AS outcome,
+        if(result.metric = 'benchmark', 'request', result.metric) AS metric,
+        mean_ms,
+        min_ms,
+        max_ms,
+        toUInt64(samples) AS samples,
+        '' AS request_id,
+        run_id,
+        git_sha
+      FROM query_benchmark_results AS result
+      WHERE result.metric != 'request'
+    `,
+  },
 ]
 
 /**

package/src/analytics/tables/requestEvents.ts

@@ -10,6 +10,8 @@ export type Table = {
    * billing gate for sandbox: only `1` rows bill.
    */
   billing_active: number | null
+  /** Tempo chain selected for the request. */
+  chain_id: number | null
   /** Total request duration in milliseconds. */
   duration_ms: number
   /** Deployment environment that served the request. */
@@ -28,6 +30,8 @@ export type Table = {
   project_id: string | null
   /** Caller principal kind. */
   principal_type: 'api_key' | 'public' | 'session' | 'super_admin' | 'unknown'
+  /** Redacted request query string, without a leading `?`. */
+  query: string
   /** 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. */
@@ -557,6 +561,7 @@ function event(entry: Log.Entry, context: Metrics.cloudflare.Context): Table {
   const principal = entry.principal
   return {
     billing_active: principal?.type === 'api_key' ? Number(principal.billingActive === true) : null,
+    chain_id: entry.chainId ?? null,
     duration_ms: entry.duration,
     environment: context.environment ?? 'unknown',
     error_code: entry.errorCode ?? null,
@@ -566,6 +571,7 @@ function event(entry: Log.Entry, context: Metrics.cloudflare.Context): Table {
     org_id: principal?.type === 'api_key' ? (principal.orgId ?? null) : null,
     project_id: principal?.type === 'api_key' ? (principal.projectId ?? null) : null,
     principal_type: principal?.type ?? 'unknown',
+    query: entry.query ?? '',
     rate_limit_scope: entry.rateLimit?.scope ?? null,
     request_id: entry.requestId ?? null,
     route: entry.route,

package/src/apps/Zones.test.ts

@@ -5,10 +5,12 @@ describe('chains', () => {
     expect(Zones.chains).toMatchObject([
       {
         contracts: {
-          messenger: { address: '0xc9C88278eA934A03CE8c90793F0B903e1C63B735' },
-          portal: { address: '0xd8fDA2e3f421F272C56752cBCf5Ae0782c8B9ed2' },
+          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://zone-internal-rpc.testnet.tempo.xyz'] },
           internal: { http: ['https://zone-internal-rpc.testnet.tempo.xyz'] },
@@ -16,6 +18,21 @@ describe('chains', () => {
         },
         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,16 +1,17 @@
 import { defineChain } from 'viem'
-import { tempoDevnet, tempoTestnet } from 'viem/tempo/chains'
+import { tempo, tempoDevnet, tempoTestnet } from 'viem/tempo/chains'
 
-/** Moderato Zone on Tempo testnet. */
-export const zoneModerato = defineChain({
+/** Internal Moderato Zone on Tempo testnet. */
+export const zoneModeratoInternal = defineChain({
   ...tempoTestnet,
   contracts: {
     ...tempoTestnet.contracts,
-    messenger: { address: '0xc9C88278eA934A03CE8c90793F0B903e1C63B735' },
-    portal: { address: '0xd8fDA2e3f421F272C56752cBCf5Ae0782c8B9ed2' },
+    messenger: { address: '0x2fB7Aba18510622cd88F5f45B3AC0E7Dd70606a5' },
+    portal: { address: '0x5765e8B9003054e479df44D12D3dEeaADEfa8b7c' },
+    verifier: { address: '0xfa16b9C6A356a096F0e7ceF0135C393A81d4a355' },
   },
-  id: 421_700_001,
-  name: 'zone-moderato',
+  id: 1_424_310_001,
+  name: 'zone-moderato-internal',
   rpcUrls: {
     default: { http: ['https://zone-internal-rpc.testnet.tempo.xyz'] },
     internal: { http: ['https://zone-internal-rpc.testnet.tempo.xyz'] },
@@ -19,6 +20,25 @@ export const zoneModerato = defineChain({
   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,
@@ -38,4 +58,4 @@ export const zoneStable = defineChain({
 })
 
 /** Hosted Zone chains served by the API and admin. */
-export const chains = [zoneModerato, 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,
         ],
       }
     `)
@@ -325,6 +326,7 @@ describe('funding()', () => {
         ),
       ),
     ).toEqual([
+      'listFundingDepositAddresses',
       'createFundingDepositAddress',
       'reconcileFundingDepositAddress',
       'getFundingDepositAddress',

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/App.ts

@@ -237,6 +237,8 @@ export function data(options: data.Options = {}) {
       indexerHandlers: indexerRouteHandlers,
       rpcOnlyHandlers: rpcOnlyRouteHandlers,
     })
+    if (selection.matched && !selection.conflict && !selection.invalid)
+      c.set('chainId', selection.chainId)
     return (
       selection.matched &&
       !selection.conflict &&

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

@@ -699,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)[]
@@ -751,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({